Mybatis中自定义实例化SqlSessionFactoryBean问题

spring:
  #数据库配置
  datasource:
    druid:
      type: com.alibaba.druid.pool.DruidDataSource
      url: jdbc:Mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=round&serverTimezone=GMT%2B8
      username: test
      passWord: test
      driver-class-name: com.mysql.jdbc.Driver
#     获取连接时最大等待时间，单位毫秒
      max-wait: 60000
#      最大连接池数量
      max-active: 80
#      初始化时建立物理连接的个数
      initial-size: 20
#      最小连接池数量
      min-idle: 40
#Destory线程中如果检测到当前连接的最后活跃时间和当前时间的差值大于minEvictableIdleTimeMillis，则关闭当前连接。
      min-evictable-idle-time-millis: 600000
#      testWhileIdle的判断依据，详细看testWhileIdle属性的说明
      time-between-eviction-runs-millis: 2000
#用来检测连接是否有效的sql，要求是一个查询语句。
      validation-query: select 1
#      申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      test-while-idle: true
#      申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
      test-on-borrow: false
#      归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      test-on-return: false
#      属性类型是字符串，通过别名的方式配置扩展插件
      filters: stat,wall
#      开启慢sql，并设置时间
      filter:
        stat.log-slow-sql: true
        stat.slow-sql-millis: 2000
      WEB-stat-filter:
        enabled: true
        url-pattern: 
@Configuration
public class MybatisConfig {
    private Logger logger = LoggerFactory.getLogger(MybatisConfig.class);
 
    @Value("${mybatis.mapper-locations}")
    private String mapperLocation;
 
    @Value("${common-mybatis.mapper-locations}")
    private String commonMapperLocation;
 
    @Value("${spring.datasource.druid.username}")
    private String username;
 
    @Value("${spring.datasource.druid.password}")
    private String password;
 
    @Value("${spring.datasource.druid.url}")
    private String dbUrl;
 
    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;
 
    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;
 
    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;
 
    @Value("${spring.datasource.druid.max-wait}")
    private long maxWait;
 
    @Value("${spring.datasource.druid.driver-class-name}")
    private String driverClassName;
 
    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private long minEvictableIdleTimeMillis;
 
    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private long timeBetweenEvictionRunsMillis;
 
    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;
 
    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;
 
    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;
 
    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;
 
    @Value("${spring.datasource.druid.filter.stat.log-slow-sql}")
    private boolean logSlowSql;
 
    @Value("${spring.datasource.druid.filter.stat.slow-sql-millis}")
    private long slowSqlMillis;
 
    @Bean
    public DruidDataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        try {
            druidDataSource.setUsername(username);
            druidDataSource.setPassword(password);
            druidDataSource.setUrl(dbUrl);
            druidDataSource.setFilters("stat,wall");
            druidDataSource.setInitialSize(initialSize);
            druidDataSource.setMinIdle(minIdle);
            druidDataSource.setMaxActive(maxActive);
            druidDataSource.setMaxWait(maxWait);
            druidDataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            druidDataSource.setUseGlobalDataSourceStat(true);
            druidDataSource.setDriverClassName(driverClassName);
            druidDataSource.setValidationQuery(validationQuery);
            druidDataSource.setTestWhileIdle(testWhileIdle);
            druidDataSource.setTestOnBorrow(testOnBorrow);
            druidDataSource.setTestOnReturn(testOnReturn);
            // 设置需要的过滤
            List<Filter> statFilters =new ArrayList<>();
            StatFilter statFilter = new StatFilter();
            statFilter.setLogSlowSql(logSlowSql);
            statFilter.setSlowSqlMillis(slowSqlMillis);
            statFilters.add(statFilter);
            // 设置慢SQL
            druidDataSource.setProxyFilters(statFilters);
         } catch (Exception e) {
            e.printStackTrace();
        }
        return druidDataSource;
    }
 
    @Bean
    public SqlSessionFactoryBean mysqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources1 = resolver.getResources(mapperLocation);
        Resource[] resources2 = resolver.getResources(commonMapperLocation);
        Resource[] resources = new Resource[resources1.length+resources2.length];
        for (int i=0;i<resources1.length;i++) {
            resources[i] = resources1[i];
        }
        int initSize = resources1.length;
        for (int i=0;i<resources2.length;i++) {
            resources[initSize+i] = resources2[i];
        }
        sqlSessionFactoryBean.setMapperLocations(resources);
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{new CatMybatisInterceptor(dbUrl)});
        return sqlSessionFactoryBean;
    }
}

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
 
}

public interface FactoryBean<T> {
    @Nullable
    T getObject() throws Exception;
    
    @Nullable
    Class<?> getObjectType();
    
    default boolean isSingleton() {
        return true;
    }
}