mybatis源码分析6 - mybatis-spring容器初始化

1 引言

使用 MyBatis-Spring 模块,我们可以在Spring中使用mybatis,让Spring容器来管理sqlSessionFactory单例的创建。如以下代码

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <!--指定数据源,不用再在mybatis的XML配置文件中指定environment了-->
  <property name="dataSource" ref="dataSource" />
  <!--指定configuration对象,它是创建sqlSessionFactory的核心,包含mybatis几乎全部的配置信息-->
  <property name="configuration">
    <bean class="org.apache.ibatis.session.Configuration">
      <property name="mapUnderscoreToCamelCase" value="true"/>
    </bean>
  </property>
  <!--数据库映射mapper文件的位置-->
  <property  name="mapperLocations"  value="classpath*:com/xxt/ibatis/dbcp/**/*.xml"/>
  <!--或指定指定sqlMapConfig总配置文件位置configLocation,建议采用这种mybatis配置单独放在另一个XML中的方式-->
  <property  name="configLocation"  value="classpath:sqlMapConfig.xml"/> 
</bean>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

我们只需要指定两个属性即可,一是dataSource数据库源,二是configuration对象或configLocation配置文件所在位置。那么有这两个属性是如何创建sqlSessionFactory对象的呢,这一节我们详细分析。

2 sqlSessionFactory对象注入的流程

创建sqlSessionFactory bean时,指定的实现类是SqlSessionFactoryBean类,它是一个FactoryBean。我们知道,对于FactoryBean,Spring为我们创建的不是FactoryBean本身的对象,二是它的getObject()方法返回的对象。故我们从SqlSessionFactoryBean的getObject()方法来分析。

// 工厂bean,它返回的不是FactoryBean本身,而是它的getObject方法返回的bean
public SqlSessionFactory getObject() throws Exception {
  if (this.sqlSessionFactory == null) {
    afterPropertiesSet();
  }

  // getObject最终返回的还是一个SqlSessionFactory对象
  return this.sqlSessionFactory;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

上面是典型的单例模式,我们到afterPropertiesSet()方法中去看。

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

  // 创建sqlSessionFactory
  this.sqlSessionFactory = buildSqlSessionFactory();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

afterPropertiesSet先做dataSource等属性值的校验,注入sqlSessionFactory的时候,必须传入dataSource属性的。然后调用buildSqlSessionFactory()方法来创建sqlSessionFactory,它是一个关键方法,我们详细分析。

// 创建SqlSessionFactory实例
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
  // 包含了几乎所有mybatis配置信息,创建sqlSessionFactory最重要的变量,之前分析mybatis初始化的时候讲到过
  Configuration configuration;

  // 先读取sqlSessionFactory bean注入时,用来设置mybatis配置信息Configuration的属性
  // 有configuration属性或者configLocation属性两种。
  XMLConfigBuilder xmlConfigBuilder = null;

  if (this.configuration != null) {
    // 注入的是configuration属性时,它是一个bean
    configuration = this.configuration;
    // 合并configurationProperties变量到configuration的variables成员中。mybatis初始化的章节讲到过这个合并
    // configurationProperties包含的是一些动态化常量,比如数据库的username和password等信息
    // configurationProperties属性同样在sqlSessionFactory bean注入时设置进来
    if (configuration.getVariables() == null) {
      configuration.setVariables(this.configurationProperties);
    } else if (this.configurationProperties != null) {
      configuration.getVariables().putAll(this.configurationProperties);
    }

  } else if (this.configLocation != null) {
    // 注入的是configLocation属性时,它是一个String,描述了mybatis xml配置文件的位置
    // 此时使用mybatis的配置文件来配置其他属性,利用配置文件生成Configuration对象
    // 和原生mybatis一样,也是先创建XMLConfigBuilder对象,然后利用它来解析mybatis配置文件,然后将配置文件中的属性设置到configuration的相关成员变量中去
    // 此处只是创建XMLConfigBuilder和configuration对象,还没有做解析
    xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
    configuration = xmlConfigBuilder.getConfiguration();

  } else {
    // configuration属性和configLocation属性都没有注入时,只能直接构造mybatis默认的Configuration对象了
    LOGGER.debug(() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
    configuration = new Configuration();
    // 同样合并configurationProperties属性到configuration变量的variables变量中
    if (this.configurationProperties != null) {
      configuration.setVariables(this.configurationProperties);
    }
  }

  // 注入了objectFactory属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (this.objectFactory != null) {
    configuration.setObjectFactory(this.objectFactory);
  }

  // 注入了objectWrapperFactory属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (this.objectWrapperFactory != null) {
    configuration.setObjectWrapperFactory(this.objectWrapperFactory);
  }

  // 注入了vfs属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (this.vfs != null) {
    configuration.setVfsImpl(this.vfs);
  }

  // 注入了typeAliasesPackage属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  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);
      LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for aliases");
    }
  }

  // 注入了typeAliases属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (!isEmpty(this.typeAliases)) {
    for (Class<?> typeAlias : this.typeAliases) {
      configuration.getTypeAliasRegistry().registerAlias(typeAlias);
      LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
    }
  }

  // 注入了plugins属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (!isEmpty(this.plugins)) {
    for (Interceptor plugin : this.plugins) {
      configuration.addInterceptor(plugin);
      LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
    }
  }

  // 注入了typeHandlersPackage属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (hasLength(this.typeHandlersPackage)) {
    String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
        ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    for (String packageToScan : typeHandlersPackageArray) {
      configuration.getTypeHandlerRegistry().register(packageToScan);
      LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for type handlers");
    }
  }

  // 注入了typeHandlers属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (!isEmpty(this.typeHandlers)) {
    for (TypeHandler<?> typeHandler : this.typeHandlers) {
      configuration.getTypeHandlerRegistry().register(typeHandler);
      LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
    }
  }

  // 注入了databaseIdProvider属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  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);
    }
  }

  // 注入了cache属性时,添加到configuration变量的cache map中
  if (this.cache != null) {
    configuration.addCache(this.cache);
  }

  // 使用configLocation属性时,解析mybatis xml配置文件,和直接使用原生mybatis的new SqlSessionFactoryBuild().build()方式几乎相同
  if (xmlConfigBuilder != null) {
    try {
      // 利用前面创建的xmlConfigBuilder来解析XML配置文件,并将解析后的键值对设置到configuration变量中
      xmlConfigBuilder.parse();
      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,用来创建transaction事务,Spring使用AOP来创建事务
  if (this.transactionFactory == null) {
    this.transactionFactory = new SpringManagedTransactionFactory();
  }

  // 设置configuration的environment变量,
  // 采用Spring注入方式时,直接指定了sqlSessionFactory下的dataSource数据库源,一般不需要在mybaits配置文件中设置environments了
  configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

  // 注入了mapperLocations属性时,一般不建议在sqlSessionFactory中注入,而是放到mybatis配置文件中。
  if (!isEmpty(this.mapperLocations)) {
    for (Resource mapperLocation : this.mapperLocations) {
      if (mapperLocation == null) {
        continue;
      }

      try {
        // 读取mapper配置文件,并解析
        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();
      }
      LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
    }
  } else {
    LOGGER.debug(() -> "Property 'mapperLocations' was not specified or no matching resources found");
  }

  // configuration变量创建并初始化好之后,就可以创建sqlSessionFactory对象了
  // sqlSessionFactoryBuilder的build创建DefaultSqlSessionFactory对象,默认的SqlSessionFactory
  // 这个过程之前讲解mybatis初始化的章节时,讲过了的
  return this.sqlSessionFactoryBuilder.build(configuration);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163

这个方法比较长,详细内容读者可以逐行看上面代码和注释,注释应该已经十分详尽了。我们总结下这个方法的流程。

  1. 先读取mybatis配置信息,它通过sqlSessionFactory注入时,传入的configuration对象或者configLocation String来分析配置信息。

    1)传入的是configuration属性时,合并configurationProperties属性到configuration对象中去即可。

    2)传入的是configLocation属性时,它是一个String,描述了mybatis xml配置文件的位置。先创建XMLConfigBuilder对象和configuration对象,后面几步会解析mybatis配置文件,然后将配置文件中的属性设置到configuration的相关成员变量中去(这个过程和原生mybatis相同)

    3)configuration属性和configLocation属性都没有注入时,只能直接构造mybatis默认的Configuration对象了

  2. 再读取创建sqlSessionFactory bean时,传入的其他属性,如objectFactory objectWrapperFactory vfs typeAliasesPackage typeAliases plugins typeHandlersPackage typeHandlers databaseIdProvider等。如果我们使用配置文件位置信息configLocation来解析mybatis配置信息的话,这些属性均不需要传入。如果采用configuration对象的方式,或者configLocation和configuration都没有传入的话,则需要这些属性了。一般建议采用configLocation的方式,将mybatis的配置信息和Spring配置信息相分离。

  3. 使用configLocation属性时,解析mybatis xml配置文件,和直接使用原生mybatis的new SqlSessionFactoryBuild().build()方式几乎相同。

  4. 创建transactionFactory,用来创建transaction事务,Spring使用AOP来创建事务

  5. 设置configuration的environment变量,利用传入的dataSource属性

  6. 读取创建sqlSessionFactory bean时,传入的mapperLocations属性。如果采用configLocation指定mybatis配置文件位置的方式,则一般不需要在Spring中配置mapperLocations

  7. sqlSessionFactoryBuilder的build创建DefaultSqlSessionFactory对象

这个方法很关键,且流程很长。大家最重要的是要知道,创建sqlSessionFactory时指定mybatis配置信息,有三种方式。一是直接configuration对象,包含了配置信息各项参数。二是configLocation字符串,指定了配置文件的位置。三是configuration和configLocation均没有配置,完全依靠Spring配置文件中指定objectFactory typeHandlers 等属性。明白了这一点,上面的代码就会比较清晰了。

为了将Spring配置信息和mybatis配置信息相分离,从而让各个XML各司其职,也避免Spring配置文件过于膨胀,我们一般采用configLocation的方式。这种方式和原生mybatis创建sqlSessionFactory的过程极其类似,都是通过XMLConfigBuilder解析XML配置文件,并将解析到的键值对设置到Configuration对象的相关变量中去。这一过程我们在前面讲解mybatis初始化的章节中已经详细介绍了,故此处不详细讲解了。最后我们看sqlSessionFactoryBuilder.build()方法。

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}
  • 1
  • 2
  • 3

这个方法十分简单,构造sqlSessionFactory的默认实现类DefaultSqlSessionFactory,并传入前面创建并解析好的configuration对象即可。configuration包含了几乎所有的mybatis配置信息,十分重要。

3 总结

Spring容器中sqlSessionFactory的创建其实是十分简单的,特别是采用了configLocation方式的时候。创建过程基本是依赖原生mybatis的执行流程的。从这儿也可以看出代码分层有利于代码适配。这也是我们平时自己设计框架时要要注意的地方,尽量让层次分明,模块解耦,这样才能简易的适配不同的环境,从而提高可移植性。

下一节我们分析mybatis-spring中,sqlSession是如何操作数据库的

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页