mybatis之依赖于spring初始化过程分析

叁歲伎倆 2022-09-09 13:49 149阅读 0赞

## 写在前面 ##

通过[这里][Link 1]文章我们分析了mybatis自身的初始化等相关内容，其中有[加载全局配置文件][Link 2]`->`[加载全局配置文件中的mappers信息][mappers]`->`[加载mapper文件中的stament][mapper_stament]等初始化相关流程，对应的主要类的初始化为“通过全局配置文件创建SqlSessionFactory`->`通过openSesion创建SqlSession”，之后就可以通过SqlSession创建Mapper进行数据库操作了，当和spring整合之后，初始化依然是这些内容，创建的也依然是这些类，只不过配置的方式稍有改变，加载的流程稍有改变，`但核心不变`,spring有很多的方式让我们定制spring bean的初始化过程，如，[自定义标签][Link 3]，[各种后置bean处理器][bean].[各种aware][bean],[InitializingBean][bean]等，而spring整合mybaits选择是[InitializingBean][bean]的方式，因为这种方式是在spring bean的属性都设置完毕后才会调用的，而初始化mybatis依赖于这些属性值信息，因此选择了这种方式，对应的类是`org.mybatis.spring.SqlSessionFactoryBean`,好的，我们就从这个类开始吧。

## 1：SqlSessionFactoryBean ##

签名如下：

org.mybatis.spring.SqlSessionFactoryBean
    public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>,
     InitializingBean, ApplicationListener<ApplicationEvent> { }

接口说明如下：

FactoryBean：spring会通过调用getObject()方法获取SqlSessionFactory对象，并存储到容器中
    InitializingBean：spring会在设置完bean的属性后调用afterPropertiesSet方法
    ApplicationListener：应用程序监听器，初始化后调用onApplicationEvent方法

关于FactoryBean可以参考[这篇文章][Link 4]。  
关于InitializingBean可以参考[这篇文章][bean]。  
方法调用的顺序是`afterPropertiesSet->getObject->onApplicationEvent`，我们就按照这个顺序来看下具体的源码。`afterPropertiesSet`参考`1.1：afterPropertiesSet`。`getObject`参考`1.2：getObject`。`onApplicationEvent`参考`1.3：onApplicationEvent`。

### 1.1：afterPropertiesSet ###

源码如下：

org.mybatis.spring.SqlSessionFactoryBean#afterPropertiesSet
    @Override
    public void afterPropertiesSet() throws Exception { 
      // 强制要求配置数据源对象，是通过<proeperty/>标签配置的，如下可能配置：
      /* <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> ...snip... <property name="dataSource" ref="myDataSource"/> ...snip... </bean> */
      notNull(dataSource, "Property 'dataSource' is required");
      // 这里不会为null，因为是直接new的
      // private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
      // 全局配置文件对象和全局配置文件为值，必须配置一个，且只能配置一个，一般我们都是配置位置，因为
      // 全局配置文件对应的org.apache.ibatis.session.Configruation对象创建非常复杂，一般不会自己来做
      // 可能如下配置：
      /* <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> ...snip... <property name="configLocation" value="classpath:mybatis/mybatis-config-1.xml"/> ...snip... </bean> */
      state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
                "Property 'configuration' and 'configLocation' can not specified with together");
      // 创建SqlSessionFactory对象
      // 2021-09-01 18:00:01
      this.sqlSessionFactory = buildSqlSessionFactory();
    }

`2021-09-01 18:00:01`处是创建`org.apache.ibatis.session.SqlSessionFactory`对象，具体参考`1.1.1：buildSqlSessionFactory`。

#### 1.1.1：buildSqlSessionFactory ####

源码如下：

org.mybatis.spring.SqlSessionFactoryBean#buildSqlSessionFactory
    protected SqlSessionFactory buildSqlSessionFactory() throws IOException { 
      // 全局配置文件对应的org.apache.ibatis.session.Configuration对象
      Configuration configuration;
      // 用于创建Configuration的对象
      XMLConfigBuilder xmlConfigBuilder = null;
      // 这里一般为false，可以忽略这里
      if (this.configuration != null) { 
        ...snip...
      // 这里一般为true，重点来看这里
      } else if (this.configLocation != null) { 
        // 创建XMLConfigBuilder对象
        xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
        // 通过XMLConfigBudiler创建org.apache.ibatis.session.Configuration对象
        configuration = xmlConfigBuilder.getConfiguration();
      } else { 
        ...snip...
      }
      // 设置objectFactory，一般为false
      // 2021-09-01 18:15:53
      if (this.objectFactory != null) { 
        configuration.setObjectFactory(this.objectFactory);
      }
      // 设置objectWrapperFactory到configuration中
      if (this.objectWrapperFactory != null) { 
        configuration.setObjectWrapperFactory(this.objectWrapperFactory);
      }
      // 设置VFS，这是mybatis在IO包中提供的通用的文件系统API
      if (this.vfs != null) { 
        configuration.setVfsImpl(this.vfs);
      }
      // 如果配置了类型别名扫描包，如下可能配置：
      /* <beanid="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> ...snip... <property name="typeAliasesPackage" value="yudaosourcecode.huohuo,yudaosourcecode.ignoredependencyinterface"/> </bean> */
      // 对标的是mybatis配置中的<typeAliases>标签，可能如下：
      /* <typeAliases> <package name="yudaosourcecode.mybatis"/> </typeAliases> */
      if (hasLength(this.typeAliasesPackage)) { 
        // 以”,;\t\n“分割为数组
        String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        // 依次加载
        for (String packageToScan : typeAliasPackageArray) { 
          // 扫描包中的类，加载别名信息
          // 2021-09-02 13:26:27
          configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                  typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
          }
        }
      }
      // 如果配置了别名设置
      if (!isEmpty(this.typeAliases)) { 
        for (Class<?> typeAlias : this.typeAliases) { 
          configuration.getTypeAliasRegistry().registerAlias(typeAlias);
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Registered type alias: '" + typeAlias + "'");
          }
        }
      }
      // 如果是配置了插件
      // 2021-09-02 13:38:18
      if (!isEmpty(this.plugins)) { 
        for (Interceptor plugin : this.plugins) { 
          configuration.addInterceptor(plugin);
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Registered plugin: '" + plugin + "'");
          }
        }
      }
      // 如果是配置了类型处理器(通过包方式)
      // 2021-09-02 13:51:00
      if (hasLength(this.typeHandlersPackage)) { 
        String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        for (String packageToScan : typeHandlersPackageArray) { 
          configuration.getTypeHandlerRegistry().register(packageToScan);
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
          }
        }
      }
      // 如果是配置了类型处理器(通过类名称方式)
      // 2021-09-02 13:51:01
      if (!isEmpty(this.typeHandlers)) { 
        for (TypeHandler<?> typeHandler : this.typeHandlers) { 
          configuration.getTypeHandlerRegistry().register(typeHandler);
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Registered type handler: '" + typeHandler + "'");
          }
        }
      }
      // 设置databseIdProvider，用于设置数据厂商别名
      // 2021-09-02 14:00:47
      if (this.databaseIdProvider != null) { 
        try { 
          configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
        } catch (SQLException e) { 
          throw new NestedIOException("Failed getting a databaseId", e);
        }
      }
      // 如果是配置了cache缓存
      if (this.cache != null) { 
        configuration.addCache(this.cache);
      }
      // 正常会执行这里的逻辑，即解析mybatis的全局配置文件
      if (xmlConfigBuilder != null) { 
        try { 
          // 解析全局配置文件
          // 2021-09-02 14:11:01
          xmlConfigBuilder.parse();
    
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
          }
        } catch (Exception ex) { 
          throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
        } finally { 
          ErrorContext.instance().reset();
        }
      }
      // 初始化TransactionFactory对象
      if (this.transactionFactory == null) { 
        this.transactionFactory = new SpringManagedTransactionFactory();
      }
      // 设置environment信息
      configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));
      // 如果是单独配置了mapper的位置信息
      if (!isEmpty(this.mapperLocations)) { 
        for (Resource mapperLocation : this.mapperLocations) { 
          if (mapperLocation == null) { 
            continue;
          }
    
          try { 
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                configuration, mapperLocation.toString(), configuration.getSqlFragments());
            xmlMapperBuilder.parse();
          } catch (Exception e) { 
            throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
          } finally { 
            ErrorContext.instance().reset();
          }
    
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
          }
        }
      } else { 
        if (LOGGER.isDebugEnabled()) { 
          LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
        }
      }
      // 构造SqlSessionFactory并返回
      return this.sqlSessionFactoryBuilder.build(configuration);
    }

`2021-09-01 18:15:53`处是设置ObjectFactory到Configuration中，具体可以参考[这里][Link 5]。`2021-09-02 13:26:27`处是扫描指定包中类，加载别名信息，具体参考[这篇文章][Link 2]，搜索`202107091115`。`2021-09-02 13:38:18`处是处理可能配置的插件，关于插件可以参考[这篇文章][Link 6]和[这篇文章][Link 7]。`2021-09-02 13:51:00`处和`2021-09-02 13:51:01`处都是处理类型处理器，关于类型处理器可以参考[这篇文章][Link 2]，搜索`5.1.9：typeHandlers`,[这篇文章][Link 8]。`2021-09-02 14:00:47`处是用于设置数据库厂商别名，如果需要的话可以在statement中通过databseId属性设置当前使用的数据库厂商，不过一般不需要配置，具体可以参考[这篇文章][Link 9]。`2021-09-02 14:11:01`处是解析mybatis的全局config配置文件，关于这个过程具体参考[这篇文章][Link 2]。

### 1.2：getObject ###

源码如下：

org.mybatis.spring.SqlSessionFactoryBean#getObject
    @Override
    publicSqlSessionFactory getObject() throws Exception { 
      // 保证SqlSessionFactor已经初始化
      if (this.sqlSessionFactory == null) { 
        afterPropertiesSet();
      }
      return this.sqlSessionFactory;
    }

### 1.3：onApplicationEvent ###

源码如下：

org.mybatis.spring.SqlSessionFactoryBean#onApplicationEvent
    @Override
    public void onApplicationEvent(ApplicationEvent event) { 
      if (failFast && event instanceof ContextRefreshedEvent) { 
        this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
      }
    }

接着我们来看下mybatis-spring提供的配置mapper xml的几种方式，以及加载的过程。`mapperLocations`方式参考`2：mapperLocations`。`MapperFactoryBean`参考`4：MapperFactoryBean`，其他的的配置方式还有`@org.mybatis.spring.annotation.MapperScan`注解，`<mybatis:scan>`自定义标签。

## 2：mapperLocations ##

如下可能配置：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
            <property name="url" value="jdbc:mysql://127.0.0.1:3366/ssmdemo" />
            <property name="username" value="root" />
            <property name="password" value="root" />
            <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        </bean>
        <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="myDataSource"/>
            <property name="mapperLocations" value="classpath*:yudaosourcecode/mybatis/mapper/TestResultmapAndParametermapMapper.xml"/>
        </bean>
         <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="sqlSessionFactoryBeanName" value="SqlSessionFactory"/>
            <property name="basePackage" value="yudaosourcecode.mybatis.mapper"/>
        </bean>
    </beans>

其中的`org.mybatis.spring.SqlSessionFactoryBean`在`1：SqlSessionFactoryBean`中已经进行了分析，`org.mybatis.spring.mapper.MapperScannerConfigurer`具体参考`3：MapperScannerConfigurer`。

## 3：MapperScannerConfigurer ##

该类用于从指定的路径加载mapper接口信息，生成代理类，并作为spring bean，方法签名如下：

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware { }

接口`BeanDefinitionRegistryPostProcessor`是在生成对应的BeanDefinition之后调用`postProcessBeanDefinitionRegistry`方法，在此处修改bean的属性值等信息，具体参考`3.1：postProcessBeanDefinitionRegistry`。接口`InitializingBean`会调用对应的`afterPropertiesSet`方法，具体参考`3.2：afterPropertiesSet`。

### 3.1：postProcessBeanDefinitionRegistry ###

源码如下：

org.mybatis.spring.mapper.MapperScannerConfigurer#postProcessBeanDefinitionRegistry
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
      // 替换占位符，如果是需要的话
      if (this.processPropertyPlaceHolders) { 
        processPropertyPlaceHolders();
      }
      // 创建扫描器对象
      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
      scanner.setAddToConfig(this.addToConfig);
      scanner.setAnnotationClass(this.annotationClass);
      scanner.setMarkerInterface(this.markerInterface);
      scanner.setSqlSessionFactory(this.sqlSessionFactory);
      scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
      scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
      scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
      scanner.setResourceLoader(this.applicationContext);
      scanner.setBeanNameGenerator(this.nameGenerator);
      scanner.registerFilters();
      // 扫描，将扫描到的信息创建对应的BeanDefinition，注册到BeanFactory，后续就可以
      // 通过这些bean定义创建对应的spring bean了
      scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
    }

### 3.2：afterPropertiesSet ###

源码如下：

org.mybatis.spring.mapper.MapperScannerConfigurer#afterPropertiesSet
    public void afterPropertiesSet() throws Exception { 
      // 判断basePackage属性值必须配置，如下可能配置：
      /* <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> ...snip... <property name="basePackage" value="yudaosourcecode.mybatis.mapper"/> </bean> */
      notNull(this.basePackage, "Property 'basePackage' is required");
    }

## 4：MapperFactoryBean ##

[Link 1]: https://blog.csdn.net/wang0907/article/details/118675622
[Link 2]: https://blog.csdn.net/wang0907/article/details/118521697
[mappers]: https://blog.csdn.net/wang0907/article/details/118765131
[mapper_stament]: https://blog.csdn.net/wang0907/article/details/119248871
[Link 3]: https://blog.csdn.net/wang0907/article/details/114435126
[bean]: https://blog.csdn.net/wang0907/article/details/115429599
[Link 4]: https://blog.csdn.net/wang0907/article/details/114641214
[Link 5]: https://blog.csdn.net/wang0907/article/details/118482256#t11
[Link 6]: https://blog.csdn.net/wang0907/article/details/120001462
[Link 7]: https://blog.csdn.net/wang0907/article/details/120021924
[Link 8]: https://blog.csdn.net/wang0907/article/details/118482256#t4
[Link 9]: https://blog.csdn.net/wang0907/article/details/118482256#t16