spring源码学习之整合Mybatis原理分析

清疚 2022-04-17 01:15 234阅读 0赞

本文主要解析spring是如何与mybatis进行整合，整合的过程中需要哪些组件的支持。以前面提到过的配置例子《spring源码学习之aop事物标签解析》

整合的过程中需要使用以下这个依赖包：

<dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.2.2</version>
    </dependency>

spring启动的时候需要使用一个bean.xml配置文件，

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

bean.xml文件中就涉及到整合的配置信息，整合使用到以下的配置：

# 创建MapperScannerConfigurer #

首先我们分析一下，这个MapperScannerConfigurer类在实例化过程中做了什么主要的事情。首先看看它的类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70][]

这个类中主要的方法就是这个postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)方法，看看具体内容：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        if (this.processPropertyPlaceHolders) {
            this.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();
        scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
    }

这个方法中创建了一个spring-mybatis.jar包中的ClassPathMapperScanner扫描器，这个扫描器继承了spring的ClassPathBeanDefinitionScanner。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 1][]

ClassPathMapperScanner这个扫描器的主要的作用有以下几个：

*  第一扫描basePackage包下面所有的class类
 *  第二将所有的class类封装成为spring的ScannedGenericBeanDefinition sbd对象![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 2][] 
 *  第三过滤sbd对象，只接受接口类，从下面的代码中可以看出。

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }

*  第四完成sbd对象属性的设置，比如设置sqlSessionFactory、BeanClass等，这个sqlSessionFactory是本文接下来要解析的SqlSessionFactoryBean

sbd.getPropertyValues().add("mapperInterface", definition.getBeanClassName());
    sbd.setBeanClass(MapperFactoryBean.class);
    sbd.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);

*  第五将过滤出来的sbd对象通过这个BeanDefinitionRegistry registry注册器注册到DefaultListableBeanFactory中，这个registry就是方法postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)中的参数。

以上就是实例化MapperScannerConfigurer类的主要工作，总结起来就是扫描basePackage包下所有的mapper接口类，并将mapper接口类封装成为BeanDefinition对象，注册到spring的BeanFactory容器中。以下时序图不代表实际过程。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 3][]

mapper接口注册之后，在什么地方实例化和使用呢？后面在分析。

接着看看spring和mybatis整合的另外一个标签。

# 创建SqlSessionFactoryBean #

这个sqlSessionFactory的实现类中做了什么事情。首先看看这个类的声明：

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
        //省略代码
    }

从配置来看，这个Bean至少提供了两个方法，一个是和dataSource有关，一个和mapperLocations有关，

public void setDataSource(DataSource dataSource) {
        if (dataSource instanceof TransactionAwareDataSourceProxy) {
            this.dataSource = ((TransactionAwareDataSourceProxy)dataSource).getTargetDataSource();
        } else {
            this.dataSource = dataSource;
        }
    
    }
    public void setMapperLocations(Resource[] mapperLocations) {
        this.mapperLocations = mapperLocations;
    }

这个两个方法，啥也没干，就是做了一次赋值操作。在来一张Bean的类图，实现了几个接口，那就必须实现这几个接口的方法。那就继续看看实现的方法中，都干了什么事情。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 4][]

## 执行afterPropertiesSet方法 ##

在这个bean被创建的过程中，首先被调用的方法是afterPropertiesSet，这个方法是接口InitializingBean中的方法。

public void afterPropertiesSet() throws Exception {
        Assert.notNull(this.dataSource, "Property 'dataSource' is required");
        Assert.notNull(this.sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        this.sqlSessionFactory = this.buildSqlSessionFactory();
    }

在这个buildSqlSessionFactory()方法中，做了很多事情，但是有些不是必须做的，为了简化分析，我们只关心必须要做的事情。

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
        XMLConfigBuilder xmlConfigBuilder = null;
        Configuration configuration;
        configuration = new Configuration();
            configuration.setVariables(this.configurationProperties);
        //省略代码
        if (this.transactionFactory == null) {
            this.transactionFactory = new SpringManagedTransactionFactory();
        }
    
        Environment environment = new Environment(this.environment, this.transactionFactory, this.dataSource);
        configuration.setEnvironment(environment);
        
        if (!ObjectUtils.isEmpty(this.mapperLocations)) {
            Resource[] arr$ = this.mapperLocations;
            len$ = arr$.length;
            for(i$ = 0; i$ < len$; ++i$) {
                Resource mapperLocation = arr$[i$];
                if (mapperLocation != null) {
                    try {
                        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(), configuration, mapperLocation.toString(), configuration.getSqlFragments());
                        xmlMapperBuilder.parse();
                    } catch (Exception var20) {
                        throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", var20);
                    } finally {
                        ErrorContext.instance().reset();
                    }
                }
            }
        }
    
        return this.sqlSessionFactoryBuilder.build(configuration);
    }

首先通过一个关键字new创建了对象Configuration，这个对象是mybatis框架的一个核心类，在这里我们不做详细介绍，以后再剖析。接着又创建了new SpringManagedTransactionFactory()，后面介绍这个类的作用，此处略过。接着继续创建new Environment(this.environment, this.transactionFactory, this.dataSource)，这个Environment类中持有事物工厂和数据源的引用。接下来就是创建XMLMapperBuilder对象，并且调用了xmlMapperBuilder.parse()方法，这个方法的详细，不在此分析，也不是我们这篇文章要记录的重点，否则会偏离我们的主题，parse()这个方法就是在解析mapperLocation变量所代表的就是mybatis的一个xml配置文件，mapperLocation-->AuthUserMapper.xml，AuthUserMapper.xml的部分代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.test.bean.AuthUserMapper" >
      <resultMap id="BaseResultMap" type="com.test.bean.AuthUser" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="user_account" property="userAccount" jdbcType="VARCHAR" />
        <result column="password" property="password" jdbcType="VARCHAR" />
        <result column="create_time" property="createTime" jdbcType="TIMESTAMP" />
        <result column="update_time" property="updateTime" jdbcType="TIMESTAMP" />
        <result column="is_delete" property="isDelete" jdbcType="TINYINT" />
      </resultMap>
      //此处代码有省略
      <update id="updateByPrimaryKey" parameterType="com.test.bean.AuthUser" >
        update t_auth_user
        set user_account = #{userAccount,jdbcType=VARCHAR},
          password = #{password,jdbcType=VARCHAR},
          create_time = #{createTime,jdbcType=TIMESTAMP},
          update_time = #{updateTime,jdbcType=TIMESTAMP},
          is_delete = #{isDelete,jdbcType=TINYINT}
        where id = #{id,jdbcType=BIGINT}
      </update>
    </mapper>

解析这个xml文件内容，然后将解析的结果封装成不同的对象，存放到Configuration对象中。

xmlMapperBuilder.parse()方法执行完成之后，调用this.sqlSessionFactoryBuilder.build(configuration)，这个sqlSessionFactoryBuilder 构造器在哪儿创建的呢？其他它就是SqlSessionFactoryBean的一个私有类变量，初始化SqlSessionFactoryBean的时候，就实例化了这个sqlSessionFactoryBuilder。

private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

看看这个build()方法做什么了。

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

构造器做的事情很简单，直接创建了DefaultSqlSessionFactory，其中还持有Configuration对象的引用。到此afterPropertiesSet()方法做的做的事情就结束了。

总结起来，就是创建了几个对象，依次是mybatis的核心类Configuration、spring和mybatis集成的事物工厂类SpringManagedTransactionFactory、mybatis的Environment类、mybatis的DefaultSqlSessionFactory类，同时还完成了对mybatis的xml文件解析，并将解析结果封装在Configuration类中。以下时序图不代表实际的过程。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 5][]

## 执行onApplicationEvent方法 ##

调用完上面的afterPropertiesSet方法之后，第二个被调用的就是onApplicationEvent方法，这个方法的调用时机是，spring容器初始化完成之后，该方法是接口ApplicationListener<ApplicationEvent>中的方法。

public void onApplicationEvent(ApplicationEvent event) {
        if (this.failFast && event instanceof ContextRefreshedEvent) {
            this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
        }
    }

调试发现this.failFast这个变量的值是false，所以这个方法不会执行，在此就不做重点分析了。

## 执行getObject方法 ##

调用完上面的onApplicationEvent方法之后，第三个被调用的就是getObject方法，该方法是接口FactoryBean<SqlSessionFactory>中的方法。这个方法的调用时机是？首先需要简单介绍一下这个FactoryBean的作用。

一般情况下，Spring通过反射机制利用<bean>标签的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照反射机制的方式，则需要在<bean>标签中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.beans.factory.FactoryBean<T>的工厂类接口，我们可以通过实现该接口定制实例化Bean的逻辑。

实现了FactoryBean<T>接口的Bean，不同于普通Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，请在id前面加一个&符号来获取。

通过这段对FactoryBean的简短介绍就知道，getObject()方法被调用时机是在spring实例化SqlSessionFactoryBean的过程中。那么调用的getObject()方法返回的是什么对象呢，看看方法内容：

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

从内容上看，是直接返回了一个SqlSessionFactory类的实例，这个sqlSessionFactory对象是在什么时候创建的呢？其实就是本文上面介绍的afterPropertiesSet()方法中，sqlSessionFactory引用的对象就是mybatis的DefaultSqlSessionFactory类的实例。至于这个类是什么作用，在哪儿用的，后面在作介绍。

上面两个标签的解析过程分析完成，现在有两个问题没有答案，第一个是basePackage基础包下面扫描出来的mapper接口怎么实例化的？第二个是这两个标签创建出来的对象怎么配合使用的？

# 整合之后实例化过程 #

在本系列的例子中，spring容器在启动的过程中，需要去实例化AuthUserServiceImpl服务类，

@Service
    public class AuthUserServiceImpl implements IAuthUserService {
    	@Resource
    	private AuthUserMapper authUserMapper;
    
    	public AuthUserServiceImpl(){
    		logger.info("创建 com.test.bean.AuthUserServiceImpl");
    	}
    }

这个类依赖了AuthUserMapper接口，在实例化AuthUserServiceImpl的过程中需要，首先去实例化这个AuthUserMapper接口，但是接口是不能被实例化的，接下来分析这个接口实现类的创建过程。以下时序图不代表实际执行过程。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 6][]

对上面的图做一个简单的说明，spring在初始化的过程中，会去创建AuthUserServiceImpl类，创建完成之后，会进行属性赋值，AuthUserMapper这个mybatis接口就是AuthUserServiceImpl的一个属性，

首先根据这个mapper的名字从spring的BeanFactory中获取它的BeanDefinition，再从BeanDefinition中获取BeanClass，AuthUserMapper对应的BeanClass就是MapperFactoryBean，这是为什么呢？在上面分析的内容中提到过，也就是在创建MapperScannerConfigurer对象的时候设置的。

接着就是创建MapperFactoryBean对象了，创建完成之后，就需要对属性进行赋值，他有哪些属性需要赋值呢？这是在创建AuthUserMapper所对应BeanDefinition对象的时候决定的，回顾上面创建MapperScannerConfigurer对象的那部分内容就知道。其中有一个属性就是SqlSessionFactoryBean，要实例化这个对象，这个就需要用到下面这个标签了

上面的内容也已经分析过这个SqlSessionFactoryBean的创建过程。

MapperFactoryBean对象的属性设置完成之后，就调用它的getObject()方法，来获取authUserMapper对应的实现类，从上面图中可以看出来，最后返回的就是一个代理类，这个代理类使用jdk的动态代理创建出来的。

return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(),
     new Class[]{this.mapperInterface}, mapperProxy);

这个MapperProxy类就是InvocationHandler的实现类：

public class MapperProxy<T> implements InvocationHandler, Serializable {
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, args);
            } else {
                MapperMethod mapperMethod = this.cachedMapperMethod(method);
                return mapperMethod.execute(this.sqlSession, args);
            }
        }
    }

程序在调用authUserMapper对象的某个方法的时候，就会调用到MapperProxy对象的invoke()方法，去完成对数据库的操作。

最后附上一张类图，spring和mybatis整合过程中创建的类：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 7][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70]: /images/20220417/241230fc76804180a5e6127549daee3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 1]: /images/20220417/103cee24bbc948acb601f59e17dee5b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 2]: /images/20220417/67e31e205ef0472b8d5ab5e0dc3b5389.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 3]: /images/20220417/76fd9677ac434597a0480913bbdac830.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 4]: /images/20220417/aa06c67251774e8fb7f37d15c532bd5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 5]: /images/20220417/f93a285b689142f78e0c5a965a0316fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 6]: /images/20220417/0c77ea2da13f4f5b953a9ff2b53794d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpaHVheW9uZw_size_16_color_FFFFFF_t_70 7]: /images/20220417/22348c8f079e4fac8f424bf78c5778f6.png