# 切换到pgsql用户
su -postgres
# 进入到bash
psql

#修改密码：  (注意最后的分号)
alter user postgres with password '密码';  
#退出pgsql
\q
#退出bash
exit
#登录数据库
psql -U user_name -d database_name -h serverhost -p port -W password
#切换数据库
\c jx_test
#查看当前数据库所有表
\d
#执行sql  (pgsql命令行是严重区分大小写的，即关键字必须写成大写。且尾部必须加;)
SELECT * FROM document ;

# 切换到postgres用户(系统用户)
sudo su -postgres  
# 创建数据库  create db_name
create 1234;
#直接访问数据库(默认进入本地postgres数据库)
psql  
# 查看数据库列表
\l  
# 退出列表页面
:q  
# 退出客户端
\q
# 删除数据库 	dropdb db_name  
dropdb 1234

# 登录客户端
sudo -u postgres psql  
# 创建数据库     (命令行 CREATE TABLE,跨行时直接按 ENTER 键或者 \ 表示换行)
create database admin;
# 删除数据库
drop database admin;

$JENKINS_HOME/jobs/[JOB_NAME]/builds 目录存储了该Jenkins job的全部构建记录（目录名为Build Number）。
$JENKINS_HOME/jobs/[JOB_NAME]/builds/BUILD_NUMBER/artifacts 目录存储了该次构建的artifact。

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("xn_meeting")
public class Meeting implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 会议名称
     */
    private String name;

    /**
     * 会议创建人
     */
    private Long createUserId;

    /**
     * 会议资料集合
     */
    @TableField(exist = false)
    private List<FileEntity> fileList;

    /**
     * 参会人员详细信息
     */
    @TableField(exist = false)
    private List<MeetingUsersEntity> userList;

}

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("xn_file")
public class FileEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    private String uuid;

    /**
     * 资料名称
     */
    private String fileName;

    /**
     * 文件大小
     */
    private Long fileSize;

    /**
     * 文件类型
     */
    private String fileType;

}

@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
public class MeetingUsersEntity extends User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 参会人员是否参会标识   0:参会 1：不参会
     */
    private Integer meetingStatus;

    /**
     * 会议室名称
     */
    private String roomName;

}

Dimension one = this.getOne(Wrappers.<Dimension>lambdaQuery()
    .and(e -> e.eq(Dimension::getCreateTime, "官方还让他让他人员同意"))
    .and(e -> {e.eq(Dimension::getDimName, "名称").or().eq(Dimension::getId, "111");})
);

//        if (StringUtils.isNotBlank(keyword)) {
//            query.and(e->{
//                e.like(Case::getName, keyword)
//                        .or().like(Case::getSerialNumber, keyword)
//                        .or().like(Case::getBmsah, keyword)
//                        .or().like(Case::getApplicant, keyword)
//                        .or().like(Case::getCaseFrom, keyword)
//                        .or().like(Case::getRespondent, keyword)
//                        .or().like(Case::getUndertaker, keyword);
//            });
//        }
//        if(StringUtils.isNotBlank(currentUser)){
//            query.and(e->e.eq(Case::getCreateUser,currentUser));
//        }

@Override
public InputStream download(String bucket, String objectName) throws FileDownloadException, FileNotExistException {
    InputStream stream;
    try {
        exist(bucket, objectName);
        stream = minioClient.getObject(bucket, objectName);
        return stream;
    } catch (MinioException | NoSuchAlgorithmException | IOException | InvalidKeyException | XmlPullParserException | FileServerAccessException e) {
        throw new FileDownloadException(bucket, objectName, e);
    }
}

@Override
public boolean exist(String bucket, String objectName) throws FileServerAccessException, FileNotExistException {
    try {
        minioClient.statObject(bucket, objectName);
        return true;
    } catch (ErrorResponseException e) { //不存在是会抛出异常的
        ErrorCode errorCode = e.errorResponse().errorCode();
        if (errorCode == ErrorCode.NO_SUCH_KEY || errorCode == ErrorCode.NO_SUCH_OBJECT) {
                log.error("文件{}在存储桶{}中不存在！", objectName, bucket);
                return false;
        }
        log.error("查询文件是否存在报错：", e);
        throw new FileNotExistException(bucket, objectName, e);
    } catch (MinioException | IOException | InvalidKeyException | NoSuchAlgorithmException | XmlPullParserException e) {
        log.error("访问文件服务器出错，文件：{}，文件桶：{}，错误：{}", objectName, bucket, e);
        throw new FileServerAccessException("", e);
    }
}

URL image = new URL("http://172.16.16.222:9000/mxzf/public/image/20200429/1588144931194000854/test.jpg");
BufferedReader in = new BufferedReader(new InputStreamReader(image.openStream()));

public class MeetPageVo extends PageRequest {
    @ApiModelProperty("排序规则，默认为创建时间降序排序")
    private LinkedHashSet<Sort> sorts;

    @ApiModel("排序")
    @Setter
    @Getter
    public static class Sort {
        @ApiModelProperty("排序字段：创建时间：CREATE_TIME,开始时间：START_TIME")
        private SortField field = SortField.CREATE_TIME;
        @ApiModelProperty("排序方向：升序ASC,降序DESC")
        private Direction direction = Direction.DESC;

        public Sort() {
        }

        public Sort(SortField field, Direction direction) {
            this.field = field;
            this.direction = direction;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Sort sort = (Sort) o;
            return field == sort.field && direction == sort.direction;
        }

        @Override
        public int hashCode() {
            return Objects.hash(field, direction);
        }
    }

    public enum SortField {
        /**  创建时间 */
        CREATE_TIME,
        /** 开始时间 */
        START_TIME;
    }

    public enum Direction {
        DESC, ASC;
    }

}

LinkedHashSet<MeetPageVo.Sort> sorts = meetPageVo.getSorts();
LinkedHashSet<MeetPageVo.Sort> querySorts = new LinkedHashSet<>();

if (CollectionUtils.isEmpty(sorts)) {//如果排序容器中没有元素，就设置默认排序方式：创建时间倒序排序
    querySorts.add(new MeetPageVo.Sort(MeetPageVo.SortField.CREATE_TIME, MeetPageVo.Direction.DESC));
} else {
    MeetPageVo.Sort querySort;
    // 遍历容器中的排序字段 以及对应的排序方式
    for (MeetPageVo.Sort sort : sorts) {
        querySort = new MeetPageVo.Sort();
        MeetPageVo.SortField field = sort.getField();
        querySort.setField(Objects.isNull(field) ? MeetPageVo.SortField.CREATE_TIME : field);

        MeetPageVo.Direction direction = sort.getDirection();
        querySort.setDirection(Objects.isNull(direction) ? MeetPageVo.Direction.DESC : direction);

        querySorts.add(querySort);
	}
}
meetQueryVo.setSorts(querySorts);

@Configuration把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
@Scope注解 作用域
@Lazy(true) 表示延迟初始化
@Service用于标注业务层组件、
@Controller用于标注控制层组件（如struts中的action）
@Repository用于标注数据访问组件，即DAO组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Scope用于指定scope作用域的（用在类上）
@PostConstruct用于指定初始化方法（用在方法上）
@PreDestory用于指定销毁方法（用在方法上）
@Resource 默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
@DependsOn：定义Bean初始化及销毁时的顺序
@Primary：自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
@Autowired 默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用
@Autowired @Qualifier(“personDaoBean”) 存在多个实例配合使用

public interface Singer {
    String sing(String lyrics);
}

@Component // 加注解，让spring识别
public class MetalSinger implements Singer{

    @Override
    public String sing(String lyrics) {
        return "I am singing with DIO voice: "+lyrics;
    }
}

public class OperaSinger implements Singer {
    @Override
    public String sing(String lyrics) {
        return "I am singing in Bocelli voice: "+lyrics;
    }
}

@Autowired
private Singer singer;

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [main.service.Singer] is defined: expected single matching bean but found 2: metalSinger,operaSinger

@Primary
@Component
public class OperaSinger implements Singer{

    @Override
    public String sing(String lyrics) {
        return "I am singing in Bocelli voice: "+lyrics;
    }
}

@Component // 加注解，让spring识别
@Qualifier("metalSinger")
public class MetalSinger implements Singer{

    @Override
    public String sing(String lyrics) {
        return "I am singing with DIO voice: "+lyrics;
    }
}

@Component
@Qualifier("opreaSinger")
public class OperaSinger implements Singer {
    @Override
    public String sing(String lyrics) {
        return "I am singing in Bocelli voice: "+lyrics;
    }
}

@Component
public class SingerService {
    private static final Logger logger = LoggerFactory.getLogger(SingerService.class);

    @Autowired
    private Singer singer;

    @Qualifier("opreaSinger")
    public String sing(){
        return singer.sing("song lyrics");
    }
}

@Bean
@ConditionalOnBean(WxConfig.class)
public WxAuthService wxBindService(WxService wxService) {
	return new WxAuthServiceAdapter(wxService);
}

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "casic.filestore.minio")
public class MinioProperties {
    private String url;
    private String accessKey;
    private String secretKey;

    public MinioProperties() {

    }
		//设置set、get方法

import io.minio.MinioClient;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidPortException;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

import javax.crypto.KeyGenerator;
import java.security.NoSuchAlgorithmException;

@Configuration
@EnableConfigurationProperties(MinioProperties.class)
public class FileStoreConfig {

	@Bean
	@Lazy
	public MinioClient minioClient(MinioProperties minioProperties) throws InvalidPortException, InvalidEndpointException {
		MinioClient minioClient = new MinioClient(minioProperties.getUrl(),minioProperties.getAccessKey(),minioProperties.getSecretKey());
		return minioClient;
	}
}

@ApiImplicitParams：用在请求的方法上，表示一组参数说明
@ApiImplicitParam：用在@ApiImplicitParams注解中，指定一个请求参数的各个方面
    name：参数名
    value：参数的汉字说明、解释
    required：参数是否必须传
    paramType：参数放在哪个地方
    	· header --> 请求参数的获取：@RequestHeader
    	· query --> 请求参数的获取：@RequestParam
    	· path（用于restful接口）--> 请求参数的获取：@PathVariable
    	· body（不常用）
    	· form（不常用）
    dataType：参数类型，默认String，其它值dataType="Integer"
    defaultValue：参数的默认值

@ApiResponses：用在请求的方法上，表示一组响应
  @ApiResponse：用在@ApiResponses中，一般用于表达一个错误的响应信息
    code：数字，例如400
    message：信息，例如"请求参数没填好"
    response：抛出异常的类

@Validated:用于校验请求中的数据是否正常。即修饰实体类时，通过在实体类中的字段上添加类似
@NotNull、 @Size(max=32,message="code is null")
  等标签，如果在请求时数据异常则会统一抛出异常，方便异常中心统一处理。
@PathVariable：带占位符的 URL 是 Spring3.0 新增的功能；
  通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中：
  URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx“) 绑定到操作方法的入参中;
@TableLogic：在字段上加上这个注解再执行BaseMapper的删除方法时，删除方法会变成修改
@TableField：@TableField(exist = false)注解加载bean属性上，表示当前属性不是数据库的字段，但在项目中必须使用，
  这样在新增等使用bean的时候，mybatis-plus就会忽略这个，不会报错
@NotBlank(message = "密码不能为空！")
  设置字段的验证规则，不需要再业务层再进行单独判断

@TableLogic：注解表示逻辑删除，在字段上加上这个注解再执行BaseMapper的删除方法时，删除方法会变成修改
  没有@TableLogic注解调用deleteById/removeById,直接删除数据。
     SQL:delete from table where id = 1
  有注解走Update方法
     SQL：Update table set isDelete = 1 where id = 1

Swagger:
  @JsonIgnore:不让前端或文档显示某字段注解

Lombok：
  @EqualsAndHashCode(callSuper = true)：
    a.这个注解会生成equals(Object other) 和 hashCode()方法。 
    b.它默认使用非静态，非瞬态的属性 
    c.可通过参数exclude排除一些属性 
    d.可通过参数of指定仅使用哪些属性 
    e.它默认仅使用该类中定义的属性且不调用父类的方法 
    f.可通过callSuper=true解决e问题。让其生成的方法中可以调用父类的方法。

spring:
  # MySQL connection config
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/yq_mysql?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false
    username: root
    password: admin
    # Druid 数据源专用配置
    # 初始化大小，最小，最大
    initialSize: 3
    minIdle: 5
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 30000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 900000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙，使用的日志组件为log4j2
    filters: stat,wall,log4j2
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录.合并多个DruidDataSource的监控数据
    #useGlobalDataSourceStat: true
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=10000
  # Thymeleaf configurations
  thymeleaf:
    mode: HTML
    cache: false
    servlet.content-type: text/html
    encoding: UTF-8
  # jpa configurations
  jpa:
    #配置指明在程序启动的时候要删除并且创建实体类对应的表。这个参数很危险，因为他会把对应的表删除掉然后重建。所以千万不要在生成环境中使用。只有在测试环境中，一开始初始化数据库结构的时候才能使用一次。过后使用update
    #hibernate.ddl-auto: create
    hibernate.ddl-auto: update
    #默认的存储引擎切换为 InnoDB
    database-platform: org.hibernate.dialect.MySQL57InnoDBDialect
    # 配置在日志中打印出执行的 SQL 语句信息。
    show-sql: true
  pgdatasource:
    driver-class-name: org.postgresql.Driver
    url: jdbc:postgresql://localhost:5432/yq_pgsql?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: postgres
    password: admin
  servlet:
    multipart:
    max-file-size: 100MB
    max-request-size: 200MB

/*
 * druid数据源状态监控.
 */
import com.alibaba.druid.support.http.StatViewServlet;

import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;

@WebServlet(urlPatterns = "/druid/*",initParams = {
    //IP白名单 没有配置或者为空则允许所有访问
    @WebInitParam(name="allow",value = "127.0.0.1"),
    // IP黑名单 存在共同时，deny优先于allow
    @WebInitParam(name = "deny", value = "192.168.1.10"),
    // 用户名
    @WebInitParam(name = "loginUsername", value = "root"),
    // 密码
    @WebInitParam(name = "loginPassword", value = "123"),
    // 禁用HTML页面上的“Reset All”功能
    @WebInitParam(name = "resetEnable", value = "false")
})
public class DruidStatViewServlet extends StatViewServlet {
}

/*
 * druid过滤器
 * /**
 * WebStatFilter用于采集web-jdbc关联监控的数据。
 * 属性filterName声明过滤器的名称,可选
 * 属性urlPatterns指定要过滤 的URL模式,也可使用属性value来声明.(指定要过滤的URL模式是必选属性)
 */
import com.alibaba.druid.support.http.WebStatFilter;

import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;

@WebFilter(filterName = "druidWebStatFilter",urlPatterns = "/*",initParams = {
    // 忽略资源
    @WebInitParam(name = "exclusions", value = "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")
})
public class DruidStatFilter extends WebStatFilter {
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
import org.springframework.boot.web.servlet.ServletComponentScan;

//暂时关闭Spring 自带的Security用户认证
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
@ServletComponentScan
public class DruidApplication {

    public static void main(String[] args) {
        SpringApplication.run(DruidApplication.class, args);
    }

}

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootConfiguration
public class DruidMonitorConfig {
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        System.out.println("init Druid Monitor Servlet ...");
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),
                "/druid/*");
        // IP白名单
        servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
        // IP黑名单(共同存在时，deny优先于allow)
        servletRegistrationBean.addInitParameter("deny", "192.168.1.10");
        // 控制台管理用户
        servletRegistrationBean.addInitParameter("loginUsername", "root");
        servletRegistrationBean.addInitParameter("loginPassword", "123");
        // 是否能够重置数据 禁用HTML页面上的“Reset All”功能
        servletRegistrationBean.addInitParameter("resetEnable", "false");
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }
}

# 配置日志输出
spring:
  datasource:
    druid:
      filter:
        slf4j:
          enabled=true
          statement-create-after-log-enabled=false
          statement-close-after-log-enabled=false
          result-set-open-after-log-enabled=false
          result-set-close-after-log-enabled=false

2020-06-18 00:11:15.948  INFO 34916 --- [nio-8081-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2020-06-18 00:11:15.948  INFO 34916 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2020-06-18 00:11:15.957  INFO 34916 --- [nio-8081-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 8 ms
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@68197e8b] was not registered for synchronization because synchronization is not active
2020-06-18 00:11:16.030  INFO 34916 --- [nio-8081-exec-1] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} inited
JDBC Connection [org.postgresql.jdbc.PgConnection@5d7d2a16] will not be managed by Spring
==>  Preparing: select * from yq_user where id = ?
==> Parameters: 1(Long)
<==    Columns: id, name, account, password
<==        Row: 1, 游强, yq, admin
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@68197e8b]
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7f98edcf] was not registered for synchronization because synchronization is not active
2020-06-18 00:11:16.691  INFO 34916 --- [nio-8081-exec-1] com.alibaba.druid.pool.DruidDataSource   : {dataSource-2} inited
JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@12d550e0] will not be managed by Spring
==>  Preparing: select * from yq_user where id = ?
==> Parameters: 2(Long)
<==    Columns: id, name, account, password
<==        Row: 2, 秦音, qy, admin
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7f98edcf]

#格式：java -cp druid.jar com.alibaba.druid.filter.config.ConfigTools you_password
F:\Download>java -cp druid-1.1.9.jar com.alibaba.druid.filter.config.ConfigTools admin
privateKey:MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAwB/rXIuWe5IHbIZOC9+VB4iRuBow0ca3pztVSIYtJjgkCSbWVN4fWzjfeO54DY9GKhkIufCTE/T+Fgci+UjtRQIDAQABAkBh2uAiDubioYoueGmgGozpfWHbB1v+PNylzM6vVcgBQouOqd0T1/tqs1IxCATSt+vvJ5BKsbgRPWO+nJAHqJyBAiEA+M3jVoGlsHA65j1JlqqPuHk7MXNIhwlajNEYq9F2l00CIQDFrmI9XZDZp0wpm6Vy9YGSuqAvLdqcwMh7LY2g3+jh2QIgDIBj5OvcxHHPM9RuhyiI0i8dP03YnhhlOWAkSjXbLJ0CIQCtsscbyMVomrovrVY5p0PNnDL4gcAgEL2YjrRt8ZF+MQIgOjRYMqQxMLKIzS1JBwjxK3X54xVbyLwgm0DNKlrXJ48=
publicKey:MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMAf61yLlnuSB2yGTgvflQeIkbgaMNHGt6c7VUiGLSY4JAkm1lTeH1s433jueA2PRioZCLnwkxP0/hYHIvlI7UUCAwEAAQ==
password:UDwkTJKXPXEIPjlYFnLKNJ5Tq5mWmEV5yLuENS8LqdAsb5QavQoM6jF3gQKgxmTX5GcXz5Ncxw5XknVQyab3kA==

F:\Download>

spring:
  datasource:
    name: MySQL
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/yq_mysql?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false
    username: root
    # 修改密码为密文
    password: UDwkTJKXPXEIPjlYFnLKNJ5Tq5mWmEV5yLuENS8LqdAsb5QavQoM6jF3gQKgxmTX5GcXz5Ncxw5XknVQyab3kA==
    # 公钥
    publickey: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMAf61yLlnuSB2yGTgvflQeIkbgaMNHGt6c7VUiGLSY4JAkm1lTeH1s433jueA2PRioZCLnwkxP0/hYHIvlI7UUCAwEAAQ==
    # 配置 connection-properties，启用ConfigFilter解密密码，以及配置公钥${publickey}
    connection-properties: config.decrypt=true;config.decrypt.key=${spring.datasource.publickey};password=${spring.datasource.password}
    druid:
      filter:
        config:
          # 启动ConfigFilter
          enabled: true
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙,在原来的filters后面添加config，使用逗号分隔
    filters: stat,wall,log4j2,config

try {
    Properties properties = new Properties();
    properties.load(getClass().getResourceAsStream("/application.yml"));
    datasource.setName(properties.getProperty("name"));
    datasource.setUsername(properties.getProperty("username"));
    datasource.setPassword(properties.getProperty("password"));
    datasource.setDriverClassName(properties.getProperty("driverClassName"));
    datasource.setUrl(properties.getProperty("url"));
} catch (IOException e) {
    e.printStackTrace();
}

try {
    Properties properties = new Properties();
    properties.load(getClass().getResourceAsStream("http://127.0.0.1/application.yml"));
    datasource.setName(properties.getProperty("name"));
    datasource.setUsername(properties.getProperty("username"));
    datasource.setPassword(properties.getProperty("password"));
    datasource.setDriverClassName(properties.getProperty("driverClassName"));
    datasource.setUrl(properties.getProperty("url"));
} catch (IOException e) {
    e.printStackTrace();
}

java -Ddruid.filters=./config/application.yml

public static void main(String[] args) throws Exception {
    String password = "admin";
    //使用ConfigTools生成一组公私钥
    String[] keyPair = ConfigTools.genKeyPair(512);
    //获取公钥
    System.out.println("privateKey:" + keyPair[0]);
    //获取私钥
    System.out.println("publicKey:" + keyPair[1]);
    //通过公钥+密码明文，对密码进行加密
    System.out.println("password:" + ConfigTools.encrypt(keyPair[0], password));

    //然后通过上面得到的密码密文+公钥，解密密码获得明文
    String pwd = "n2giOipoUromAsrEUFApiG15LOKwvyp+5tumwlnQz2NiMs/vtqmkzkAb5cQmACqIKTEFhBBu4GuR/ggtdbYxPw==";
    String pub = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANNhfjPiJkaOd07kp0F9ut92rwMWNO6zRkHHCBNiGpIPr6OKG9OvDcnsTyQ4d9hVINIIRwd+NQ4NF76AgijZ7r0CAwEAAQ==";
    String decrypt = ConfigTools.decrypt(pub, pwd);
    System.out.println(decrypt);
}

connection-properties: config.decrypt=true;config.decrypt.key=${publickey}

2020-06-18 14:41:39.925 ERROR 6388 --- [nio-8081-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException:
### Error querying database.  Cause: java.lang.IllegalArgumentException: Failed to decrypt.
### The error may exist in file [D:\work\code\qinyin\druid\target\classes\mapper\MysqlUserMapper.xml]
### The error may involve com.example.druid.mapper.mysqlMapper.MysqlUserMapper.getOne
### The error occurred while executing a query
### Cause: java.lang.IllegalArgumentException: Failed to decrypt.] with root cause

java.lang.IllegalArgumentException: Illegal character $
	at com.alibaba.druid.util.Base64.base64toInt(Base64.java:174) ~[druid-1.1.9.jar:1.1.9]
	at com.alibaba.druid.util.Base64.base64ToByteArray(Base64.java:140) ~[druid-1.1.9.jar:1.1.9]
	at com.alibaba.druid.util.Base64.base64ToByteArray(Base64.java:107) ~[druid-1.1.9.jar:1.1.9]
	at com.alibaba.druid.filter.config.ConfigTools.getPublicKey(ConfigTools.java:94) ~[druid-1.1.9.jar:1.1.9]
	at com.alibaba.druid.filter.config.ConfigFilter.getPublicKey(ConfigFilter.java:223) ~[druid-1.1.9.jar:1.1.9]
	at com.alibaba.druid.filter.config.ConfigFilter.decrypt(ConfigFilter.java:195) ~[druid-1.1.9.jar:1.1.9]

connection-properties: config.decrypt=true;config.decrypt.key=${spring.datasource.publickey};password=${spring.datasource.password}

try {
    Properties properties = new Properties();
    properties.load(getClass().getResourceAsStream("/application.yml"));
    //config.decrypt=true;config.decrypt.key=${spring.datasource.publickey};password=${spring.datasource.password}
    String connectionProperties = "config.decrypt=true;" + "config.decrypt.key=" + publickey + ";" + "password=" + password;
    datasource.setConnectionProperties(connectionProperties);
} catch (IOException e) {
    e.printStackTrace();
}

2020-06-18 14:38:14.990 ERROR 24840 --- [reate-248705782] com.alibaba.druid.pool.DruidDataSource   : create connection SQLException, url: jdbc:mysql://localhost:3306/yq_mysql?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false, errorCode 1045, state 28000

java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES)
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:965) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3978) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3914) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:871) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.MysqlIO.proceedHandshakeWithPluggableAuthentication(MysqlIO.java:1714) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.MysqlIO.doHandshake(MysqlIO.java:1224) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.ConnectionImpl.coreConnect(ConnectionImpl.java:2199) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.ConnectionImpl.connectOneTryOnly(ConnectionImpl.java:2230) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:2025) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.ConnectionImpl.<init>(ConnectionImpl.java:778) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at com.mysql.jdbc.JDBC4Connection.<init>(JDBC4Connection.java:47) ~[mysql-connector-java-5.1.47.jar:5.1.47]
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) ~[na:1.8.0_191]
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) ~[na:1.8.0_191]
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) ~[na:1.8.0_191]
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423) ~[na:1.8.0_191]
	at com.mysql.jdbc.Util.handleNewInstance(Util.java:425) ~[mysql-connector-java-5.1.47.jar:5.1.47]

log4j:WARN No appenders could be found for logger (druid.sql.Connection).
log4j:WARN Please initialize the log4j system properly.

public static void main(String[] args) {
    BasicConfigurator.configure(); //自动快速地使用缺省Log4j环境
    SpringApplication.run(DruidApplication.class, args);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@f91ab56] was not registered for synchronization because synchronization is not active
2020-06-17 22:08:06.988  INFO 32188 --- [nio-8081-exec-6] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} inited
JDBC Connection [org.postgresql.jdbc.PgConnection@136e7f5c] will not be managed by Spring
==>  Preparing: select * from yq_user where id = ?
==> Parameters: 1(Long)
<==    Columns: id, name, account, password
<==        Row: 1, 游强, yq, admin
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@f91ab56]
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1428c0e1] was not registered for synchronization because synchronization is not active
0 [http-nio-8081-exec-6] DEBUG druid.sql.Connection  - {conn-110001} connected
7 [http-nio-8081-exec-6] DEBUG druid.sql.Connection  - {conn-110002} connected
13 [http-nio-8081-exec-6] DEBUG druid.sql.Connection  - {conn-110003} connected
2020-06-17 22:08:07.569  INFO 32188 --- [nio-8081-exec-6] com.alibaba.druid.pool.DruidDataSource   : {dataSource-2} inited
15 [http-nio-8081-exec-6] DEBUG druid.sql.Connection  - {conn-110003} pool-connect
JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@2713ea39] will not be managed by Spring
==>  Preparing: select * from yq_user where id = ?
134 [http-nio-8081-exec-6] DEBUG druid.sql.Statement  - {conn-110003, pstmt-120000} created. select * from yq_user where id = ?
==> Parameters: 2(Long)
143 [http-nio-8081-exec-6] DEBUG druid.sql.Statement  - {conn-110003, pstmt-120000} Parameters : [2]
143 [http-nio-8081-exec-6] DEBUG druid.sql.Statement  - {conn-110003, pstmt-120000} Types : [BIGINT]
143 [http-nio-8081-exec-6] DEBUG druid.sql.Statement  - {conn-110003, pstmt-120000} executed. 5.6849 millis. select * from yq_user where id = ?
148 [http-nio-8081-exec-6] DEBUG druid.sql.ResultSet  - {conn-110003, pstmt-120000, rs-150000} open
149 [http-nio-8081-exec-6] DEBUG druid.sql.ResultSet  - {conn-110003, pstmt-120000, rs-150000} Header: [id, name, account, password]
149 [http-nio-8081-exec-6] DEBUG druid.sql.ResultSet  - {conn-110003, pstmt-120000, rs-150000} Result: [2, 秦音, qy, admin]
<==    Columns: id, name, account, password
<==        Row: 2, 秦音, qy, admin
<==      Total: 1
150 [http-nio-8081-exec-6] DEBUG druid.sql.ResultSet  - {conn-110003, pstmt-120000, rs-150000} closed
150 [http-nio-8081-exec-6] DEBUG druid.sql.Statement  - {conn-110003, pstmt-120000} clearParameters.
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1428c0e1]
151 [http-nio-8081-exec-6] DEBUG druid.sql.Connection  - {conn-110003} pool-recycle
900023 [Druid-ConnectionPool-Destroy-486994287] DEBUG druid.sql.Connection  - {conn-110001} closed
900024 [Druid-ConnectionPool-Destroy-486994287] DEBUG druid.sql.Connection  - {conn-110002} closed
960025 [Druid-ConnectionPool-Destroy-486994287] DEBUG druid.sql.Connection  - {conn-110003} closed

#此句为定义名为stdout的输出端是哪种类型，可以是
#org.apache.log4j.ConsoleAppender（控制台），
#org.apache.log4j.FileAppender（文件），
#org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
#org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
#org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.Target=System.out  
#此句为定义名为stdout的输出端的layout是哪种类型，可以是
#org.apache.log4j.HTMLLayout（以HTML表格形式布局），
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
#org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
#org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
#如果使用pattern布局就要指定的打印信息的具体格式ConversionPattern，打印参数如下：
#%m 输出代码中指定的消息
#%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
#%r 输出自应用启动到输出该log信息耗费的毫秒数
#%c 输出所属的类目，通常就是所在类的全名
#%t 输出产生该日志事件的线程名
#%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”
#%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
#%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。
#[QC]是log信息的开头，可以为任意字符，一般为项目简称。
#比如：输出的信息：#[TS] DEBUG [main] AbstractBeanFactory.getBean(189) | Returning cached instance of singleton bean 'MyAutoProxy'
log4j.appender.stdout.layout.ConversionPattern= [QC] %p [%t] %C.%M(%L) | %m%n  

#定义名为R的输出端的类型为每天产生一个日志文件。
log4j.appender.R=org.apache.log4j.RollingFileAppender  
#此句为定义名为R的输出端的文件名为D:\\Tomcat 5.5\\logs\\qc.log可以自行修改。
log4j.appender.R.File=D:/work/code/qinyin/druid/src/main/resources/druid.log
#log4j.appender.R.File=${catalina.home}/logs/ddoMsg.log
log4j.appender.R.MaxFileSize=1024KB  
log4j.appender.R.MaxBackupIndex=100  
#与log4j.appender.stdout.layout属性相同
log4j.appender.R.layout=org.apache.log4j.PatternLayout  
#与log4j.appender.stdout.layout.ConversionPattern属性相同
log4j.appender.R.layout.ConversionPattern= %d{yyyy-MM-dd HH:mm:ss} %5p %c %t: - %m%n  

#INFO WARN ERROR DEBUG
#此句为将等级为INFO的日志信息输出到stdout和R这两个目的地，stdout和R的定义在下面的代码，可以任意起名。(此文本设置的是：stdout为控制台输出，R为文本输出)
# 等级可分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL，如果配置OFF则不打出任何信息，
# #如果配置为INFO这样只显示INFO, WARN, ERROR的log信息，而DEBUG信息不会被显示，
log4j.rootLogger=OFF, stdout, R  
org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog  

#指定com.example.druid包下的所有类的等级为DEBUG。
log4j.logger.com.example.druid =OFF
#这两句是把这两个包下出现的错误的等级设为ERROR，如果项目中没有配置EHCache，则不需要这两句。
log4j.logger.com.opensymphony.oscache=OFF
log4j.logger.net.sf.navigator=OFF
#这句是displaytag的包。（QC问题列表页面所用）
log4j.logger.org.displaytag=OFF
#此句为Spring的包。
log4j.logger.org.springframework=OFF
#此两句是hibernate的包。
log4j.logger.org.hibernate.ps.PreparedStatementCache=OFF
log4j.logger.org.hibernate=OFF

public ThreadPoolExecutor(int corePoolSize,  
                          int maximumPoolSize,  
                          long keepAliveTime,  
                          TimeUnit unit,  
                          BlockingQueue workQueue,  
                          ThreadFactory threadFactory,  
                          RejectedExecutionHandler handler)

spring:
#主数据源，即默认的数据源，SpringBoot在启动时会加载默认数据源
  datasource:
    driver-class-name: org.postgresql.Driver
    url: jdbc:postgresql://localhost:5432/yq_pgsql?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: postgres
    password: admin
#从数据源
  mysqldatasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/yq_mysql?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false
    username: root
    password: admin
  jpa:
    properties.hibernate.hbm2ddl.auto: update
    properties.hibernate.dialect: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
#设置mybatis扫描包路径
mybatis:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/*
mybatis-plus:
  mapper-locations: classpath*:mapper/*
#设置日志显示配置，即显示sql查询语句与相关参数在控制台上
logging:
  level:
    com.example.qinyin.datasource.mysqlMapper : debug
    com.example.qinyin.datasource.pgsqlMapper : debug

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    /**
     * 设置数据源1
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    DataSource dataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 设置数据源2
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.mysqldatasource")
    DataSource mysqlDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
}

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import javax.annotation.Resource;

/**
 * 指明该类是一个配置类，配置类中要扫描的包是com.example.qinyin.datasource.pgsqlMapper，即该包下的Mapper接口将操作dataSource中的数据；
 * 对应的SqlSessionFactory和SqlSessionTemplate分别是sqlSessionFactory()和sqlSessionTemplate()返回的bean，
 * 在MyBatisConfigPgSql内部，分别对外提供SqlSessionFactory和SqlSessionTemplate两个bean即可，SqlSessionFactory根据dataSource创建，
 * 然后再根据创建好的SqlSessionFactory创建一个SqlSessionTemplate。
 */
@Configuration
@MapperScan(basePackages = "com.example.qinyin.datasource.pgsqlMapper",
        sqlSessionFactoryRef = "sqlSessionFactory",
        sqlSessionTemplateRef = "sqlSessionTemplate")
public class MybatisConfigPgSql {

    //注入DataSourceConfig中的数据源1指定的dataSource配置
    @Resource(name = "dataSource")
    DataSource dataSource;

    @Value("${mybatis.mapper-locations}")
    private String mapperLocations;

    @Value("${mybatis.type-aliases-package}")
    private String typeAliasesPackage;

    @Bean
    SqlSessionFactory sqlSessionFactory() {
        SqlSessionFactory sessionFactory = null;
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        try {
            //这里需要设置扫描mapper的路径，否则容易导致mapper中的方法无法映射到xml中去，导致报：Invalid bound statement (not found) 错误
            //当Mapper文件跟对应的Mapper接口处于同一位置的时候可以不用指定该属性的值。
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            //通过读取配置文件中的值来指定扫描路径
            bean.setMapperLocations(resolver.getResources(mapperLocations));
            //直接写死值来指定扫描路径
            //bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
            // 设置typeAlias（别名） 包扫描路径。可配置可不配置（猜想：可能不同的数据源查询返回的实体类字段有差异，故指定不同的别名包来映射不同的查询结果）
            // bean.setTypeAliasesPackage(typeAliasesPackage);

            //开启驼峰式映射功能
            org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
            configuration.setMapUnderscoreToCamelCase(true);
            configuration.setLogImpl(org.apache.ibatis.logging.stdout.StdOutImpl.class);
            bean.setConfiguration(configuration);

            sessionFactory = bean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sessionFactory;
    }

    @Bean
    SqlSessionTemplate sqlSessionTemplate() {
        return new SqlSessionTemplate(sqlSessionFactory());
    }
}

org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
configuration.setMapUnderscoreToCamelCase(true);
configuration.setLogImpl(org.apache.ibatis.logging.stdout.StdOutImpl.class);

mybatis:
  #扫描mapper包路径
  mapper-locations: classpath:mapper/*
  #别名包路径
  type-aliases-package: com.example.druid.entity
	configuration:
    #是否开启驼峰式命名映射
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.annotation.Resource;
import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.example.qinyin.datasource.mysqlMapper",
        sqlSessionFactoryRef = "sqlSessionFactoryMySql",
        sqlSessionTemplateRef = "sqlSessionTemplateMySql")
public class MybatisConfigMySql {

    //注入DataSourceConfig中的数据源2指定的dataSource配置
    @Resource(name = "mysqlDataSource")
    DataSource mysqlDataSource;

    @Value("${mybatis.mapper-locations}")
    private String mapperLocations;

    @Value("${mybatis.type-aliases-package}")
    private String typeAliasesPackage;

    @Bean
    SqlSessionFactory sqlSessionFactoryMySql() {
        SqlSessionFactory sessionFactory = null;
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(mysqlDataSource);
        try {
            //这里需要设置扫描mapper的路径，否则容易导致mapper中的方法无法映射到xml中去，导致报：Invalid bound statement (not found) 错误
            //当Mapper文件跟对应的Mapper接口处于同一位置的时候可以不用指定该属性的值。
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            //通过读取配置文件中的值来指定扫描路径
            bean.setMapperLocations(resolver.getResources(mapperLocations));
            //直接写死值来指定扫描路径
            // bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
            // 设置typeAlias（别名） 包扫描路径。可配置可不配置（猜想：可能不同的数据源查询返回的实体类字段有差异，故指定不同的别名包来映射不同的查询结果）
            // bean.setTypeAliasesPackage(typeAliasesPackage);

            //开启驼峰式映射功能
            org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
            configuration.setMapUnderscoreToCamelCase(true);
            configuration.setLogImpl(org.apache.ibatis.logging.stdout.StdOutImpl.class);
            bean.setConfiguration(configuration);
            sessionFactory = bean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sessionFactory;
    }

    @Bean
    SqlSessionTemplate sqlSessionTemplateMySql() {
        return new SqlSessionTemplate(sqlSessionFactoryMySql());
    }
}

@Slf4j
@RestController()
@RequestMapping("/user")
@Api(description = "用户")
public class UserController {

    //数据源1
    @Autowired
    private PgsqlUserMapper pgsqlUserMapper;

    //数据源2
    @Autowired
    private MysqlUserMapper mysqlUserMapper;

    @ApiOperation("获取用户")
    @GetMapping("/getUser")
    public List<User> receiveTask() {
        User userpg = pgsqlUserMapper.getOne(1L);
        User usermy = mysqlUserMapper.getOne(2L);
        return Arrays.asList(userpg, usermy);
    }

}