wen 深入源码理解Spring整合MyBatis原理
写在前面
聊一聊MyBatis的核心概念、Spring相关的核心内容，主要结合源码理解Spring是如何整合MyBatis的。（结合右侧目录了解吧）
MyBatis相关核心概念粗略回顾
SqlSessionFactory
创建SqlSession的工厂
SqlSession
sql请求的会话，通过SqlSessionFactory获取。
String resource = "mybatis-config.xml";
InputStream resourceAsStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream); // 通过Builder获取构建SqlSessionFactory（读取mybatis-config.xml文件配置）
SqlSession sqlSession = sqlSessionFactory.openSession(); // 开启Session
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.findByUserId(1);
上述代码就是单独使用MyBatis的时候的API例子。读取mybatis-config.xml构建出SqlSessionFactory，通过Factory开启SqlSession，使用SqlSession获取Mapper的代理实例。
Mapper
public interface UserMapper {
User findByUserId(Integer userId);
}
<mapper namepsace = "com.deepz.mybatis.user.UserMapper">
<select id = "findByUserId" resultType="User">
...
</select>
</mapper>
以上就是咱们熟悉的MyBatis使用代码了，一个Mapper接口对应的就有一个XML文件。
Spring相关核心概念粗略回顾
FactoryBean接口
是一种特殊的SpringBean，对应的真实实例是FactoryBean接口中getObject()方法的返回值，用于自定义复杂的Bean生成。
FactoryBean类型的Bean的获取
AbstractBeanFactory#doGetBean
Object sharedInstance = getSingleton(beanName); // 从三级缓存中根据beanName获取SpringBean
if (sharedInstance != null && args == null) { // 如果SpringBean不为空则说明命中缓存，直接获取SpringBean实例即可
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean "" + beanName +
"" that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean "" + beanName + """);
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); // 获取SpringBean真实实例（针对FactoryBean）
}
AbstractBeanFactory#getObjectForBeanInstance
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it"s a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { // 如果不是FactoryBean类型则直接返回
return beanInstance;
}
// 后续代码针对FactoryBean类型的SpringBean处理
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName); // 从缓存中获取
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic); // 获取FactoryBean真实实例
}
return object;
FactoryBeanRegistrySupport#doGetObjectFromFactoryBean
FactoryBeanRegistrySupport#getObjectFromFactoryBean最终会调到如下方法，通过FactoryBean的getObject()获取FactoryBean的真实实例
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject(); // 显示调用FactoryBean#getObject
}
}
InitializingBean接口
在SpringBean的生命周期中，Bean的初始化环节Spring会调用AbstractAutowireCapableBeanFactory#invokeInitMethods() 回调实现了InitializingBean接口的Bean的InitializingBean#afterPropertiesSet()
关于SpringBean生命周期欢迎移步笔者的相关总结随笔《深入源码理解SpringBean生命周期》
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean); // Bean实现了InitializingBean接口
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name "" + beanName + """);
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
((InitializingBean) bean).afterPropertiesSet();
return null;
}
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet(); // 显式回调InitializingBean的afterPropertiesSet()方法
}
}
if (mbd != null) {
String initMethodName = mbd.getInitMethodName();
if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
BeanDefinitionRegistryPostProcessor接口
可以看到BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，那么该接口的实现类一定会在Spring应用上下文生命周期中回调相关接口方法。
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
/**
* Modify the application context"s internal bean definition registry after its
* standard initialization. All regular bean definitions will have been loaded,
* but no beans will have been instantiated yet. This allows for adding further
* bean definitions before the next post-processing phase kicks in.
* @param registry the bean definition registry used by the application context
* @throws org.springframework.beans.BeansException in case of errors
*/
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
BeanFactoryPostProcessor接口
这个接口是干什么的？它有自己的抽象方法，在Spring应用上下文生命周期的”invokeBeanFactoryPostProcessors”环节会回调相关方法。(这里不是重点不过多聊）
我们这次关注的重点是它的子接口-BeanDefinitionRegistryPostProcessor，Spring在上述环节中对该接口做了特殊处理，回调了它的独有方法。（如上面的代码段所示）
BeanDefinitionRegistryPostProcessor接口回调
AbstractApplicationContext#refresh()方法即为Spring应用上下文的生命周期的刷新入口，可以看到在比较前置的环节就会先处理BeanFactoryProcessor类型的Bean。
追进源码后发现最后会在PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()方法中循环处理所有BeanFactoryProcessor，其中如果是BeanDefinitionRegistryPostProcessor则会回调BeanDefinitionRegistryPostProcessor的独有方法,值得注意的是该方法的入参是一个BeanDefinitionRegistry。
(关于BeanDefinitionRegistry有必要在单独段落做介绍，所以请先移步下一段落吧）
在了解了这几个接口后，我们汇总一下就明白了BeanDefinitionRegistryPostProcessor的能力了。它可以在Spring应用上下文前期先被实例化且回调相关接口方法，向Spring容器注册或移除BeanDefinition甚至可以在get出一个BeanDefinition后直接修改内部属性，让Bean变成你想要的模样。
BeanDefinitionRegistry接口
BeanDefinition是什么？
BeanDefinition是Spring实例化一个Bean的依据，它的内部维护了一个Bean的各种属性，如BeanClass、BeanName、lazyInit(是否懒加载)、primary、scope等等。
而Spring在实例化一个Bean的时候需要先从一个Map中根据beanName获取到对应的BeanDefinition才能去按需实例化SpringBean，如下。
DefaultListableBeanFactory#getBeanDefinition()
看看这个Map的定义
相信大家也猜到了，上面提到的就是维护这个Map的。
BeanDefinitionRegistry接口的方法如下：
可以看到该接口的能力就是维护Spring容器中的BeanDefinition。
Spring整合MyBatis正片
有了上面的回顾后，关于Spring整合MyBatis的秘密就很容易揭晓了。
在跟进源码前，我们先思考下如果是你，你会怎么将MyBatis整合进来？达到效果：通过@Autowired将Mapper注入进来便可以直接使用。
首先，我们有了Spring，第一个要干掉的就是SqlSessionFactory的维护了，我们要想办法读取”mybatis-config.xml“配置后，将SqlSessionFactory作为一个SpringBean交给SpringIOC管理。
其次，同样的，我们不可能每次都通过sqlSession.getMapper()来获取我们需要的Mapper代理实例，所以第二个要干掉的就是Mapper的维护，我们同样要想办法将所有的Mapper处理成SpringBean交给SpringIOC，这样我们就能够将SpringBean依赖注入到任何地方了。
思考过后，我们来看看Spring是怎么做的吧。当我们需要结合Spring使用MyBatis的时候，第一步便是添加一个mybatis-spring的Jar到项目里来，那么秘密都在这里了。
MyBatis-Spring
如下便是MyBatis-Spring这个Jar的项目结构了，应该能看到大家使用的时候熟悉的组件吧。如MapperScan注解。眼尖的伙伴应该能看到几个类：SqlSessionFactoryBean、MapperFactoryBean、MapperScannerConfigurer、SpringManagedTransaction，这几个类将会是接下来探讨的重点。
SqlSessionFactoryBean
刚刚我们聊到了，首先需要干掉的就是SqlSessionFactory的低端维护方式。我们先看看SqlSessionFactory这个类的继承树。
可以看到它实现了FactoryBean，这就意味着它一定有一个getObject()方法，用于返回交给Spring管理的实例；
它还实现了InitializingBean，这就意味着在这个Bean的初始化时，Spring会回调它的afterPropertiesSet()方法。（Spring事件本次不讨论）
将SqlSessionFactory交给Spring管理-FactoryBean#getObject()
我们先看看，这个SqlSessionFactoryBean交给Spring管理的对象是怎样构建的。
/**
* {@inheritDoc}
*/
@Override
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) { // 如果sqlSessionFactory为空，则显式调用afterPropertiesSet()方法
afterPropertiesSet();
}
return this.sqlSessionFactory; // 返回sqlSessionFactory
}
@Override
public Class<? extends SqlSessionFactory> getObjectType() {
return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
}
可以看到源码中首先是判空，如果为空则显式调用afterPropertiesSet()方法，最后将sqlSessionFactory返回。那么可以猜出，afterPropertiesSet()方法大概率是构造sqlSessionFactory的了。
SqlSessionFactory的构建
首先看看afterPropertiesSet()方法
/**
* {@inheritDoc}
*/
@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(); // 核心逻辑在buildSqlSessionFactory()中。
}
跟进看看buildSqlSessionFactory()方法，请重点看标了注释的，其他的可以不用太关注细节，主要是一些配置的初始化工作。
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
Configuration configuration;
XMLConfigBuilder xmlConfigBuilder = null;
// 初始化Configuration全局配置对象。
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);
}
// 如下将是对MyBatis的基础配置做初始化，如扫描注册别名、注册Plugins、注册TypeHandler、配置缓存、配置数据源等等。
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();
}
}
// 配置事务管理类，将不再由MyBatis管理（之前配置为“JDBC”对应的MyBatis的JdbcTransactionFactory)。
if (this.transactionFactory == null) {
this.transactionFactory = new SpringManagedTransactionFactory();
}
configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));
// 扫描Mapper.xml以及对应的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);
}
总体就是读取MyBatis的配置，初始化Configuration全局配置对象，根据整合的配置创建出SqlSessionFactory。
经过了上述步骤，SqlSessionFactory就可以被交给Spring管理了，解决了第一个问题，可以从Spring上下文中获取到SqlSessionFactory这个Bean了。
ClassPathXmlApplication applicationContext = new ClassPathXmlApplicationContext("spring.xml");
SqlSessionFactory sqlSessionFactory = applicationContext.getBean(SqlSessionFactory.class);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 省略后续MyBatis代码 -.-
......
Mapper的代理对象-MapperFactoryBean
接下来讨论Spring如何实现通过@Autowired将Mapper注入进来后就能直接使用的问题。
首先思考一下，如何将一个类交给Spring管理？@Component系列注解？而MyBatis是一个个Interface而不是Class，在上面加注解是没用的，我们需要的是将MyBatis对Mapper生成的代理对象交给Spring管理。那该怎么做呢？Spring的做法是将Mapper一对一地包装成了MapperFactoryBean，而MapperFactoryBean维护了Mapper的类型，通过该类型获取Mapper代理实例。
可以看到这个MapperFactoryBean同样实现了FactoryBean接口，那么按照惯例我们看看它的getObject()做了什么。
// Mapper接口类型
private Class<T> mapperInterface;
/**
* {@inheritDoc}
*/
@Override
public T getObject() throws Exception {
// 与MyBatis单独使用类似，都是通过sqlSession调用getMapper()方法获取对应的Mapper。
// 需要注意的是入参是一个接口类型，而出参是MyBatis生成的代理对象
return getSqlSession().getMapper(this.mapperInterface);
}
/**
* {@inheritDoc}
*/
@Override
public Class<T> getObjectType() {
return this.mapperInterface; // Object的类型
}
可以看出Spring将Mapper包装成了MapperFactoryBean，其中的mapperInterface字段就是Mapper的类型，在交给Spring管理的时候依旧是通过sqlSession.getMapper(Class type)返回Mapper的代理对象的。
那么Mapper对应的模型有了，是不是还缺点什么？是的，我们需要扫描所有的Mapper，将他们包装成MapperFactoryBean（如UserMapper，就需要有一个MapperFactoryBean，其中mapperInterface字段是UserMapper.class）。这个重要的任务，Spring交给了我们接下来要聊的MapperScannerConfigurer了，通过类名就能感知到关键字：[Mapper、扫描、配置]。
Mapper的扫描与配置-MapperScannerConfigurer
老规矩，看看几个核心接口的方法都做了什么。
afterPropertiesSet()
/**
* {@inheritDoc}
*/
@Override
public void afterPropertiesSet() throws Exception {
// 几乎啥也没干，就断言了个扫描包路径不为空。 下一个！
notNull(this.basePackage, "Property "basePackage" is required");
}
扫描Mapper并注册BeanDefinition
可以看到MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口，文章开头的Spring技术回顾聊到该接口的postProcessBeanDefinitionRegistry()方法会在Spring容器启动的时候在较早的时机被回调。
private String basePackage;
private boolean addToConfig = true;
private SqlSessionFactory sqlSessionFactory;
private SqlSessionTemplate sqlSessionTemplate;
private String sqlSessionFactoryBeanName;
private String sqlSessionTemplateBeanName;
private Class<? extends Annotation> annotationClass;
private Class<?> markerInterface;
private ApplicationContext applicationContext;
private String beanName;
private boolean processPropertyPlaceHolders;
private BeanNameGenerator nameGenerator;
/**
* {@inheritDoc}
*
* @since 1.0.2
*/
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
if (this.processPropertyPlaceHolders) {
// 解析并更新Spring配置文件中MapperScannerConfigurer相关的配置
processPropertyPlaceHolders();
}
//创建类路径Mapper扫描器，并配置基本信息如扫描的注解（过滤条件）等。
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();
//根据配置好的信息去扫描basePackage字段中指定的包及其子包
scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
我们来看看processPropertyPlaceHolders()做了什么。[可以跳过，不重要]
/*
* BeanDefinitionRegistries are called early in application startup, before
* BeanFactoryPostProcessors. This means that PropertyResourceConfigurers will not have been
* loaded and any property substitution of this class" properties will fail. To avoid this, find
* any PropertyResourceConfigurers defined in the context and run them on this class" bean
* definition. Then update the values.
*/
// 上面Spring官方的注释的意思如下：BeanDefinitionRegistriy在Spring启动的时候回调地太早了，在BeanFactoryPostProcessors之后（PropertyResourceConfigurer实现了BeanFactoryProcessor）
// 方法调用到此处的时候，相关的配置信息还没被载入进来，都是空，会有问题。所以我们要提前主动触发(getBeanOfType与getBean逻辑一致，都是先拿，拿不到就实例化再存入三级缓存)PropertyResourceConfigurer的实例化，这样相关的配置就能够被载入进来了。
private void processPropertyPlaceHolders() {
// 先主动触发该类型的Bean的实例化。
Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);
if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) {
BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext)
.getBeanFactory().getBeanDefinition(beanName);
// PropertyResourceConfigurer does not expose any methods to explicitly perform
// property placeholder substitution. Instead, create a BeanFactory that just
// contains this mapper scanner and post process the factory.
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition(beanName, mapperScannerBean);
for (PropertyResourceConfigurer prc : prcs.values()) {
prc.postProcessBeanFactory(factory);
}
PropertyValues values = mapperScannerBean.getPropertyValues();
// 更新相关重要字段信息
this.basePackage = updatePropertyValue("basePackage", values);
this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
}
}
根据条件扫描Mapper并整合成BeanDefintions注册进Spring
回到ClassPathMapperScanner#scan()，该方法内部会继续调用doScan()方法。
/**
* Calls the parent search that will search and register all the candidates.
* Then the registered objects are post processed to set them as
* MapperFactoryBeans
*/
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
//先调用父类ClassPathBeanDefinitionScanner#doScan()方法
//扫描并将Bean信息整合成BeanDefinition注册进Spring容器，且包装成BeanDefinitionHolder返回
Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
if (beanDefinitions.isEmpty()) {
logger.warn("No MyBatis mapper was found in "" + Arrays.toString(basePackages) + "" package. Please check your configuration.");
} else {
// 重要！！！ 将BeanDefinition的定义适配成MapperFactoryBean。（当前BeanDefinition的beanClass是Mapper Interface，是无法实例化的。）
processBeanDefinitions(beanDefinitions);
}
return beanDefinitions;
}
加工Mapper的BeanDefinition-适配成MapperFactoryBean
如下是processBeanDefinitions()的核心代码片段
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
for (BeanDefinitionHolder holder : beanDefinitions) {
definition = (GenericBeanDefinition) holder.getBeanDefinition();
// 省略代码
......
// the mapper interface is the original class of the bean
// but, the actual class of the bean is MapperFactoryBean
// 添加构造函数参数值，当前Mapper的Class。
definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
// 将Bean的类型定义修改为MapperFactoryBean，这样实例化出来的就是一个MapperFactoryBean了
definition.setBeanClass(this.mapperFactoryBean.getClass());
definition.getPropertyValues().add("addToConfig", this.addToConfig);
// 省略代码
......
}
}
这段代码非常关键！首先，它对Bean的构造函数参数值做了干预，将当前的BeanClassName设置进去了（如UserMapper.class)，而从第二行代码中也能知道该Bean的Class被修改成了MapperFactoryBean，所以我们去看看MapperFactoryBean的构造函数就行了。
public MapperFactoryBean(Class<T> mapperInterface) {
// Mapper Interface。（如UserMapper.class）
this.mapperInterface = mapperInterface;
}
/**
* {@inheritDoc}
*/
@Override
public T getObject() throws Exception {
return getSqlSession().getMapper(this.mapperInterface); // 等同于如：sqlSession.getMapper(UserMapper.class)
}
其次它将Bean的实例化类型从无法实例化的Mapper Interface修改成了可以实例化的MapperFactoryBean类型。
以上操作后，就将一个Mapper Bean包装成了MapperFactoryBean，而交给Spring管理的是Mapper对应的代理实例（通过mapperInterface字段绑定关系），所以我们就能通过@Autowired将Mapper(MapperFactoryBean#getObject())依赖注入进来直接使用了。
到此，Spring整合MyBatis的内容就结束了。
Spring事务管理器-SpringManagedTransaction
再顺便聊一下其中的变动-事务管理器，因为Spring整合了MyBatis所以后续的事务就应该由Spring来管理了。
之前在MyBatis中如果配置的是“JDBC”,则是JdbcTransactionFactory
值得一提的是，SpringManagedTransaction 中除了维护事务关联的数据库连接和数据源之外，还维护了一个 isConnectionTransactional 字段（boolean 类型）用来标识当前事务是否由 Spring 的事务管理器管理，这个标识会控制 commit() 方法和rollback() 方法是否真正提交和回滚事务，相关的代码片段如下：
public void commit() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit){
// 当事务不由Spring事务管理器管理的时候，会立即提交事务，否则由Spring事务管理器管理事务的提交和回滚
this.connection.commit();
}
}
总结
看一眼Xml方式的Spring整合MyBatis，通过两个核心的组件就完成了Spring整合MyBatis。
<!-- 省略 -->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="scannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- name="basePackage":(起始)包名, 从这个包开始扫描-->
<property name="basePackage" value="com.deepz.mapper"/>
</bean>
<!-- 省略 -->
总结下本文的内容吧：
- 回顾了MyBatis的相关概念：SqlSessionFactory、SqlSession、Mapper
- 回顾了Spring的相关概念：FactoryBean、InitializingBean、BeanDefinitionRegistryPostProcessor、BeanFactoryPostProcessor
- 跟进Spring整合MyBatis的两个重要步骤：1. SqlSessionFactory的维护 2. Mapper的维护
- 最后还提了一下事务管理器的变化，毕竟是被Spring整合了，事务自然也得交给Spring管理
SqlSessionFactory的注入：
SqlSessionFactoryBean中的buildSqlSessionFactory()会读取MyBatis的核心配置载入内存，并构建出SqlSessionFactory通过FactoryBean的getObject()交给Spring管理。
而buildSqlSessionFactory()方法的触发时机有两个：1. 在Bean初始化的时候Spring回调InitializingBean的afterProperties()；2. FactoryBean的getObject()方法会前置判断SqlSessionFactory是否为空，是空则会调用。
Mapper的注入：
MapperScannerConfigurer在Spring应用上下文启动的时候，在较早的时机回调BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
通过ClassPathMapperScanner来扫描指定过滤条件(包路径、注解类型…)的类，包装成BeanDefinition注册进容器。
同时将这些BeanDefinition做“加工”处理，就是我们讲的“processBeanDefinitions()”。它主要做的两件事：1. 添加构造函数参数值，将当前BeanDefinition的Class传递进去，作为后续sqlSession.getMapper();的入参。2. 将BeanDefinition中的beanClass替换成MapperFactoryBean.class，使得Spring通过BeanDefinition实例化出来的是MapperFactoryBean，上演了一出狸猫换太子。最后注入进去的又是getObject()中MyBatis根据MapperFactoryBean中的mapperInterface字段创建的代理对象， 完成了将Mapper交给Spring管理的目标。
原创不易，希望对你有帮助。欢迎多多指导和讨论。
