Springboot整合mybatis原理

我们在Springboot中使用mybatis时只需要简单的几个配置就可以了：
1、在pom文件中引入mybatis的starter
2、配置数据库连接池
3、在Springboot配置文件里配置mybatis相关参数
4、编写自己的dao以及mapper配置文件

那么在我们Spring项目里注入dao并进行CRUD时，mybatis是怎么被Springboot加载以及怎么执行jdbc操作的？这里先贴出配置：

• 配置datasource，比如用druid链接池配置

spring:
  datasource:
    #druid相关配置
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    #配置数据库连接
    druid:
      url: jdbc:mysql://localhost:3306/test-db?useUnicode=true&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      initial-size: 10
      max-active: 100
      min-idle: 10
      max-wait: 60000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      connectionInitSqls: set names utf8mb4

• 配置mybatis参数，指定mapper文件路径

mybatis:
  mapper-locations: classpath:mapper/*.xml

• 按业务需要定义dao接口，并加上@Mapper注解

@Mapper
public interface UserInfoDao {
    
    int insert(UserInfoDO userInfoDO)
    
    UserInfoDO getById(long id);
    
    int update(UserInfoDO userInfoDO);

    int delete(long id);
}

• 配置mapper文件，写好sql与dao接口的映射关系，其中namespace是对应的dao接口完整类名

<?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.hj.dao.UserInfoDao">
    <resultMap id="BaseResultMap" type="com.hj.DO.UserInfoDO">
        <id column="id" property="id"/>
        <result column="userId" property="userId"/>
        <result column="name" property="name"/>
    </resultMap>
    
    <insert id="insert" parameterType="com.hhdd.DO.UserInfoDO">
      insert ...
    </insert>

    <select id="getById" resultMap="BaseResultMap" parameterType="java.lang.Long">
        select ...
    </select>

    <update id="update" parameterType="com.hj.DO.UserInfoDO">
        update ...
    </update>

    <delete id="delete">
        delete ...
    </delete>

</mapper>

加载过程

1、读取META-INF/spring.factories配置文件里需要自动装载的类

mybatis-spring-boot-starter依赖的作用实际是提供一个pom文件，该pom文件内有mybatis需要的所有依赖，其中比较重要的有mybatis-spring-boot-autoconfigure，如下图：

在mybatis-spring-boot-autoconfigure这个包内包含META-INF/spring.factories配置文件，Springboot就是通过该配置文件内定义的启动类来拉起mybatis的，如下图：

而Springboot触发读取这个配置文件的逻辑在@EnableAutoConfiguration注解上@Import注解引入的AutoConfigurationImportSelector.class类的selectImports方法里，有兴趣的可以在这个方法里打个断点debug下流程。

2、解析MybatisAutoConfiguration类里的注解信息，将需要管理的Bean注册到Spring容器

在《Springboot之Bean的加载过程》中讲到将类解析成BeanDefinition并最终实例化成Bean的过程，这里会向Spring容器注册几个重要的类：

2.1 注册SqlSessionFactory，并根据mapper配置文件解析出dao与具体jdbc操作、resultMap与实体类等的映射关系

代码如下：

  @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 (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

    return factory.getObject();
  }

SqlSessionFactory的实例化是通过SqlSessionFactoryBean.getObject()实现的，该类会被注入DataSource对象（负责管理数据库连接池，Session指的是一次会话，而这个会话是在DataSource提供的Connection上进行的），SqlSessionFactory.getObject()方法里会根据我们mybatis相关配置（比如上面的mybatis.mapper-locations配置）找到并解析我们的mapper文件，解析出sql与dao方法里的映射、ResultMap与具体实体类的映射等，并放到SqlSessionFactory的Configuration中缓存下来，在后续调用过程中会通过这些信息来匹配jdbc操作。

2.2 注册实现了CRUD操作的SqlSessionTemplate类

该类实现了我们常用的CRUD操作，在执行CRUD时，会通过SqlSessionFactory对象获取Session来操作，所以会持有SqlSessionFactory对象

  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }

2.3 注册AutoConfiguredMapperScannerRegistrar类来扫描被@Mapper标注的类

该类负责遍历被@Mapper标注的类，并将这些扫描到的类解析成BeanDefinition注册到Spring容器中，核心逻辑在registerBeanDefinitions中，需要注意的一点是，在扫描到被@Mapper标注的类时，会将这些类解析成beanClass为MapperFactoryBean的BeanDefinition，同时会告知Spring容器在将这个BeanDefinition实例化成Bean时，需要注入SqlSessionFactory和SqlSessionTemplate对象，截图如下：

从这里可以看出我们在代码中注入的dao实际上是一个动态代理类，由MapperFactoryBean这个FactoryBean的getObject()方法生成

3 在注入dao时，触发该dao对应的MapperFactoryBean.getObject()方法来注入动态代理类

MapperFactoryBean.getObject()逻辑由BeanFactory的getBean(string beanName)触发，getObject()代码如下：

    public T getObject() throws Exception {
        return this.getSqlSession().getMapper(this.mapperInterface);
    }

getSqlSession()获取的是SqlSessionTemplate对象，this.mapperInterface就是我们的dao层接口，比如开头demo里的被@Mapper标注的UserInfoDao，最终会通过MapperProxyFactory来生成动态代理类，代码如下：

public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
  
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

这里的参数SqlSession就是SqlSessionTemplate对象，可以看出是通过基于接口的JDK的Proxy来生成动态代理，在我们代码中进行CRUD时候，最后都会通过MapperProxy类（该类实现了InvocationHandler接口）的invoke(Object proxy, Method method, Object[] args)方法来处理.

调用过程

通过上面的加载过程，我们了解到最后注入到业务代码的是一个动态代理类，我们再看下这个动态代理类的调用过程，主要逻辑在MapperProxy类（该类实现了InvocationHandler接口）的invoke(Object proxy, Method method, Object[] args)方法，我这里以select请求为例，代码如下：

@Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

SqlSessionTemplate在加载阶段会根据配置的mapper文件解析出对应的映射关系，并封装好元数据信息（包括需要执行的sql、返回类型等），而MapperMethod的构造器被调用时会通过SqlSessionTemplate里的映射关系拿到这些元数据信息并封装成SqlCommand对象，在执行jdbc操作时会通过SqlCommand来获取jdbc信息来执行后续逻辑，debug截图如下：

最终通过SqlSessionTemplate类来实现jdbc操作，debug图如下：

而sqlSession.selectOne方法会调用到SqlSessionTemplate的内部类SqlSessionInterceptor.invoke(Object proxy, Method method, Object[] args)方法里，主要逻辑如下：

1. 通过SqlSessionFactory从DataSource连接池中获取sqlSession，这里会先从一个ThreadLocal中获取，因为开启了事务的话，sqlSession会通过ThreadLocal来传递，如果没有开启事务，则从连接池中获取新的Session

2. 通过反射来调用获取到的sqlSession对象（这里获取到的是DefaultSqlSession）的selectList方法

3. 以dao的接口名+方法名为key获取之前解析到的元数据信息，包括对应的sql、返回类型等，debug截图如下：
   

4. 通过四大组件之一的Executor的实现类CachingExecutor类（因为mybatis默认开启缓存，所以会使用这个实现类）来执行jdbc操作，该类封装了cache相关操作，先解析出该方法需要执行的sql，debug图如下：
   

这里会首先去查询是否开启了二级缓存（需要在mapper文件里家在<cache/>配置，二级缓存是namespace粒度的），如果开启了缓存，则会直接从缓存中查询，debug图如下：

然后会查询一级缓存（session粒度），如果没有命中缓存则继续后续操作，debug图如下：

5. 通过四大组件之一的statementHandler的实现类RoutingStatementHandler类来执行CRUD操作，这个类主要是封装类，不提供具体的实现，只是根据Executor的类型，创建不同的类型StatementHandler，默认创建带有预编译功能的PreparedStatementHandler类，debug图如下：
   

6. 通过四大组件之一的ParameterHandler来拼接sql中的参数，debug图如下：
   

7. 通过四大组件之一的ResultSetHandler来处理返回值，将数据库返回值绑定到对应的实体类，debug图如下：
   

8. 处理缓存信息、释放资源等逻辑