mybatis第2 章：SqlSessionFactoryBean

分享未结  0  937

李延 LV6 2021-05-30

悬赏：20积分

# 作用

SqlSessionFactoryBean是SqlSessionFactory的工厂类。而SqlSessionFactory是SqlSession的工厂类。我们的Mapper接口最终就是通过SqlSession去执行sql语句的。

在SqlSessionFactoryBean中主要是对于配置文件的解析包括读取xml、注解等内容。

# 初始化

在解析Mapper接口的时候，我们发现在MybatisAutoConfiguration中通过@Bean注解注入了SqlSessionFactory对象。

我们看一下这段代码

```java
 @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    Configuration configuration = this.properties.getConfiguration();
    if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
      configuration = new Configuration();
    }
    if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
      for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
        customizer.customize(configuration);
      }
    }
    factory.setConfiguration(configuration);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

return factory.getObject();
  }

```

代码比较多，但主要是创建SqlSessionFactoryBean，并通过SqlSessionFactoryBean的getObject 方法获取我们需要的SqlSessionFactory对象。

其中根据配置设置具体的参数。这些参数我们在其使用的地方说明。我们直接看SqlSessionFactoryBean类。

#  SqlSessionFactoryBean

这个类虽然继承自InitializingBean、ApplicationListener接口，但刚刚这个对象是我们new出来的。并不是spring来管理，所以其方法不会触发。我们直接看getObject方法

```java

@Override
  public SqlSessionFactory getObject() throws Exception {
    if (this.sqlSessionFactory == null) {
      afterPropertiesSet();
    }

return this.sqlSessionFactory;
  }

```

我们看到这个方法返回的就是成员变量sqlSessionFactory，如果为空则使用afterPropertiesSet进行初始化。

```java

@Override
  public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
    state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
              "Property 'configuration' and 'configLocation' can not specified with together");

this.sqlSessionFactory = buildSqlSessionFactory();
  }

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

Configuration configuration;

XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configuration != null) {
      configuration = this.configuration;
      if (configuration.getVariables() == null) {
        configuration.setVariables(this.configurationProperties);
      } else if (this.configurationProperties != null) {
        configuration.getVariables().putAll(this.configurationProperties);
      }
    } else if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
      }
      configuration = new Configuration();
      if (this.configurationProperties != null) {
        configuration.setVariables(this.configurationProperties);
      }
    }

if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }

if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }

if (this.vfs != null) {
      configuration.setVfsImpl(this.vfs);
    }

if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeAliasPackageArray) {
        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 + "'");
        }
      }
    }

if (!isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins) {
        configuration.addInterceptor(plugin);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered plugin: '" + plugin + "'");
        }
      }
    }

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");
        }
      }
    }

if (!isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers) {
        configuration.getTypeHandlerRegistry().register(typeHandler);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type handler: '" + typeHandler + "'");
        }
      }
    }

if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls
      try {
        configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      } catch (SQLException e) {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }

if (this.cache != null) {
      configuration.addCache(this.cache);
    }

if (xmlConfigBuilder != null) {
      try {
        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();
      }
    }

if (this.transactionFactory == null) {
      this.transactionFactory = new SpringManagedTransactionFactory();
    }

configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

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");
      }
    }

return this.sqlSessionFactoryBuilder.build(configuration);
  }

```

我们先看mapperLocations。我们在配置文件中通过mybatis.type-aliases-package指定mybastis的xml文件路径。在这里就是加载xml的过程。

```java
if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }

```

我们看到方法是循环每个xml文件创建XMLMapperBuilder对象，并用parse方法进行解析。我们看一下这个方法

## XMLMapperBuilder

```java

public void parse() {
    //判断文件是否已经加载过
    if (!configuration.isResourceLoaded(resource)) {
      //解析xml
      configurationElement(parser.evalNode("/mapper"));
      
      //标记已经加载的文件
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }
```

我们依次看一下没个步骤

### configurationElement

```java
 private void configurationElement(XNode context) {
    try {
      //获取namespace。也就是我们平常写的mapper接口
      String namespace = context.getStringAttribute("namespace");
      //判断null情况
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      //设置namespace
      builderAssistant.setCurrentNamespace(namespace);
      //读取二级缓冲相关配置
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      //读取parameterMap
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      //读取resultMap
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //读取sql
      sqlElement(context.evalNodes("/mapper/sql"));
      //读取各种语句
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }

```

整个过程就是对xml的各种标签的解析，结果都保存在了builderAssistant中。过程特别繁琐，读取后面代码如果有需要再详细说明

整个过程太繁琐了，只知道最后将注解和xml的结果保存在了Configuration对象中。

我们直接看this.sqlSessionFactoryBuilder.build(configuration)

### buid

```
 public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

```

我们看到最后创建的是DefaultSqlSessionFactory对象。而且将刚才的解析结果config也传给了它。

回帖

消灭零回复