MyBatis源码系列--6.Mybatis与 Spring 整合分析

参考文档：http://www.mybatis.org/spring/zh/index.html
这里我们以传统的 Spring 为例，因为配置更直观，在 Spring 中使用配置类注解是一样的。

基于之前源码分析的两篇文章，用编程式的方式已经弄清楚了 MyBatis 的工作流程、核
心模块和底层原理。编程式的方式，也就是 MyBatis 的原生 API 里面有三个核心对象：
SqlSessionFactory、SqlSession、MapperProxy。

大部分时候我们不会在项目中单独使用 MyBatis 的工程，而是集成到 Spring 里面使用，但是却没有看到这三个对象在代码里面的出现。我们直接注入了一个 Mapper 接口，调用它的方法。

比如之前是

        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      
        SqlSession session = sqlSessionFactory.openSession(); 

        BlogMapper mapper = session.getMapper(BlogMapper.class);
         
        Blog blog = mapper.selectBlogById(1);

而我们实际使用的是这样的

    @Autowired
    BlogMapper blogMapper;

直接注入就可以使用了，所以有几个关键的问题，我们要弄清楚：
1、 SqlSessionFactory 是什么时候创建的？
2、 SqlSession 去哪里了？为什么不用它来 getMapper？
3、 为什么@Autowired 注入一个接口，在使用的时候却变成了代理对象？
在 IOC的容器里面我们注入的是什么？ 注入的时候发生了什么事情？

关键配置

在 Spring 的 applicationContext.xml 里面配置 SqlSessionFactoryBean，它
是用来帮助我们创建会话的，其中还要指定全局配置文件和 mapper 映射器文件的路径

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="configLocation" value="classpath:mybatis-config.xml"></property>
  <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
  <property name="dataSource" ref="dataSource"/>
</bean>

然后在 applicationContext.xml 配置需要扫描 Mapper 接口的路径
在 Mybatis 里面有3种方式，第一种是配置一个 MapperScannerConfigurer。

 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wei.dal.mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

第二种是配置一个<scan>标签：
<mybatis-spring:scan base-package="com.wei.dal.mapper"/>

第三种就是直接用@MapperScan 注解，比如我们在 Spring Boot 的启动类上加上一个注解

@SpringBootApplication
@MapperScan("com.wei.dal.mapper")
public class MybaitsApp {
  public static void main(String[] args) {
    SpringApplication.run(MybaitsApp.class, args);
  }
}

创建会话工厂

Spring 对 MyBatis 的对象进行了管理，但是并不会替换 MyBatis 的核心对象。也就意味着：MyBatis jar 包中的 SqlSessionFactory、SqlSession、MapperProxy 这些都会用到。而 mybatis-spring.jar 里面的类只是做了一些包装或者桥梁的工作。

所以第一步，我们看一下在 Spring 里面，工厂类是怎么创建的。
我们在 Spring 的配置文件中配置了一个 SqlSessionFactoryBean，我们来看一下这个类

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
    ...

     //它实现了 InitializingBean 接口，所以要实现 afterPropertiesSet()方法，
    //这个方法会在 bean 的属性值设置完的时候被调用
     public void afterPropertiesSet() throws Exception {
        ...
        this.sqlSessionFactory = this.buildSqlSessionFactory();
    }

    //它实现了 FactoryBean 接口，所以它初始化的时候，实际上是调用 getObject()方法，
   //它里面调用的也是 afterPropertiesSet()方法
    public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            this.afterPropertiesSet();
        }
        return this.sqlSessionFactory;
    }

}

从上面注释可知，最终还是会调用buildSqlSessionFactory方法来创建会话工厂，我们跟进看看

 protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
        //这里的XMLConfigBuilder 就是mybatis jar包中的对象
        XMLConfigBuilder xmlConfigBuilder = null;
        //这里的Configuration对象就是mybatis jar包中的对象
        Configuration targetConfiguration;
        if (this.configuration != null) {
            targetConfiguration = this.configuration;
            if (targetConfiguration.getVariables() == null) {
                targetConfiguration.setVariables(this.configurationProperties);
            } else if (this.configurationProperties != null) {
                targetConfiguration.getVariables().putAll(this.configurationProperties);
            }
        } else if (this.configLocation != null) {
            xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), (String)null, this.configurationProperties);
            targetConfiguration = xmlConfigBuilder.getConfiguration();
        } else {
            LOGGER.debug(() -> {
                return "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration";
            });
            targetConfiguration = new Configuration();
            Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
        }

       ...
 
        //最终还是调用mybatis jar包中的SqlSessionFactoryBuilder.build方法，返回DefaultSqlSessionFactory
        return this.sqlSessionFactoryBuilder.build(targetConfiguration);
    }

从以上代码可知，还是会调用我们之前在mybatis源码分析中的几个对象，比如用XMLConfigBuilder对象解析好配置文件，封装到Configuration对象中，最终调用SqlSessionFactoryBuilder.build方法，返回DefaultSqlSessionFactory

这里用到的 Spring 扩展点总结：


image.png

创建 SqlSession

我们现在已经有一个 DefaultSqlSessionFactory，按照编程式的开发过程，我们接下来就会创建一个 SqlSession 的实现类，但是在 Spring 里面，我们不是直接使用DefaultSqlSession 的，而是对它进行了一个封装，这个 SqlSession 的实现类就是SqlSessionTemplate。这个跟 Spring 封装其他的组件是一样的，比如 JdbcTemplate，RedisTemplate 等等，也是 Spring 跟 MyBatis 整合的最关键的一个类

为什么不用 DefaultSqlSession？它是线程不安全的，注意看类上的注解

*Note that this class is not Thread-Safe

而 SqlSessionTemplate 是线程安全的

* Thread safe, Spring managed, {@code SqlSession} that works with Spring

在编程式的开发中，SqlSession 我们会在每次请求的时候创建一个，但是 Spring 里面只有一个 SqlSessionTemplate（默认是单例的），多个线程同时调用的时候怎么保证线程安全？

SqlSessionTemplate 里面有 DefaultSqlSession 的所有的方法：selectOne()、
selectList()、insert()、update()、delete()，不过它都是通过一个代理对象实现的。
这个代理对象在构造方法里面通过一个代理类创建：

public class SqlSessionTemplate implements SqlSession, DisposableBean {
    private final SqlSessionFactory sqlSessionFactory;
    private final ExecutorType executorType;
    private final SqlSession sqlSessionProxy;
    private final PersistenceExceptionTranslator exceptionTranslator;

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
        ...
        this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
    }

由此可知，所有的方法都会先走到内部代理类 SqlSessionInterceptor 的 invoke()方法

private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
          //根据Spring的事物上下文来获取事物范围内的sqlSession
        SqlSession sqlSession = getSqlSession(
                SqlSessionTemplate.this.sqlSessionFactory,
                SqlSessionTemplate.this.executorType,
                SqlSessionTemplate.this.exceptionTranslator);
        try {
            //调用从Spring的事物上下文获取事物范围内的sqlSession对象
            Object result = method.invoke(sqlSession, args);
            //然后判断一下当前的sqlSession是否被Spring托管 如果未被Spring托管则自动commit
            if (!isSqlSessionTransactional(sqlSession, 
                    SqlSessionTemplate.this.sqlSessionFactory)) {
                // force commit even on non-dirty sessions because some databases require
                // a commit/rollback before calling close()
                sqlSession.commit(true);
            }
            return result;
        } catch (Throwable t) {
            //如果出现异常则根据情况转换后抛出
            Throwable unwrapped = unwrapThrowable(t);
            if (SqlSessionTemplate.this.exceptionTranslator != null && 
                    unwrapped instanceof PersistenceException) {
                // release the connection to avoid a deadlock if the 
                // translator is no loaded. See issue #22
                closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                sqlSession = null;
                Throwable translated = SqlSessionTemplate.this.exceptionTranslator.
                        translateExceptionIfPossible((PersistenceException) unwrapped);
                if (translated != null) {
                    unwrapped = translated;
                }
            }
            throw unwrapped;
        } finally {
            if (sqlSession != null) {
                //关闭sqlSession，它会根据当前的sqlSession是否在Spring的事物上下文当中来执行具体的关闭动作
                //如果sqlSession被Spring管理 则调用holder.released();
                //使计数器-1，否则才真正的关闭sqlSession
                closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
            }
        }
    }
}

SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
我们跟进这个代码可知，最终还是会生成一个 DefaultSqlSession

Mapper接口的扫描注册

在 Service 层可以使用@Autowired 自动注入的 Mapper 接口，需要保存在 BeanFactory（比如 XmlWebApplicationContext）中。也就是说接口肯定是在 Spring 启动的时候被扫描了，注册过的
1、 什么时候扫描的？
2、 注册的时候，注册的是什么？这个决定了我们拿到的是什么实际对象
我们在applicationContext.xml中配置了 MapperScannerConfigurer，MapperScannerConfigurer 实现了 BeanDefinitionRegistryPostProcessor 接口，BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子类，可以通过编码的方式修改、新增或者删除某些 Bean 的定义，我们只需要重写 postProcessBeanDefinitionRegistry()方法，在这里面操作 Bean就可以了

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
  ...
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        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"));
    }
  ...
}

跟进scan 方法

public int scan(String... basePackages) {
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        //scanner.scan() 方 法 是 ClassPathBeanDefinitionScanner 中 的 ， 而 它 的 子 类
ClassPathMapperScanner 覆 盖 了 doScan() 方 法
        this.doScan(basePackages);
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }

        return this.registry.getBeanDefinitionCount() - beanCountAtScanStart;
    }

/scanner.scan() 方 法 是 ClassPathBeanDefinitionScanner 中 的 ， 而 它 的 子 类ClassPathMapperScanner 覆 盖 了 doScan() 方 法

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
   public Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
        if (beanDefinitions.isEmpty()) {
            LOGGER.warn(() -> {
                return "No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.";
            });
        } else {
            this.processBeanDefinitions(beanDefinitions);
        }

        return beanDefinitions;
    }
}

跟进processBeanDefinitions方法

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
        Iterator var3 = beanDefinitions.iterator();

        while(var3.hasNext()) {
            BeanDefinitionHolder holder = (BeanDefinitionHolder)var3.next();
            GenericBeanDefinition definition = (GenericBeanDefinition)holder.getBeanDefinition();
            String beanClassName = definition.getBeanClassName();
            LOGGER.debug(() -> {
                return "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName + "' mapperInterface";
            });
             //mapper接口是bean的原始类，但bean的实际类是MapperFactoryBean
            definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
            //最终把BeanClass 修改成 MapperFactoryBean
            definition.setBeanClass(this.mapperFactoryBean.getClass());
            definition.getPropertyValues().add("addToConfig", this.addToConfig);
            boolean explicitFactoryUsed = false;
            if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
                definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
                explicitFactoryUsed = true;
            } else if (this.sqlSessionFactory != null) {
                definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
                explicitFactoryUsed = true;
            }

            if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
                if (explicitFactoryUsed) {
                    LOGGER.warn(() -> {
                        return "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.";
                    });
                }

                definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
                explicitFactoryUsed = true;
            } else if (this.sqlSessionTemplate != null) {
                if (explicitFactoryUsed) {
                    LOGGER.warn(() -> {
                        return "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.";
                    });
                }

                definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
                explicitFactoryUsed = true;
            }

            if (!explicitFactoryUsed) {
                LOGGER.debug(() -> {
                    return "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.";
                });
                definition.setAutowireMode(2);
            }
        }

    }

我们主要关注这两行代码
//mapper接口是bean的原始类，但bean的实际类是MapperFactoryBean
definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
//最终把BeanClass 修改成 MapperFactoryBean
definition.setBeanClass(this.mapperFactoryBean.getClass());
我们打开MapperFactoryBean可知

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

MapperFactoryBean 继 承 了 SqlSessionDaoSupport ，可以拿到SqlSessionTemplate

接口注入使用

我们使用 Mapper 的时候，只需要在加了 Service 注解的类里面使用@Autowired 注入 Mapper 接口就好了

@Service
public class  BlogService {
    @Autowired
    BlogMapper  blogMapper;

    public List< Blog> getAll() {
      return blogMapper.selectAll();
    }
}

我们从spring源码解析那篇文章知道，spring在启动的时候需要去实例化BlogService ,BlogService 依赖了BlogMapper 接口，Spring 会根据 Mapper 的名字从 BeanFactory 中获取它的 BeanDefination，再从BeanDefination 中 获 取 BeanClass ， BlogMapper 对 应 的 BeanClass 是
MapperFactoryBean（上一步已经分析过）
接下来就是创建 MapperFactoryBean，它实现了 FactoryBean 接口，同样是调用 getObject()方法

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
    public T getObject() throws Exception {
        return this.getSqlSession().getMapper(this.mapperInterface);
    }
}

因 为 MapperFactoryBean 继 承 了 SqlSessionDaoSupport ， 所 以getSqlSession()就是调用父类的方法，返回 SqlSessionTemplate

public abstract class SqlSessionDaoSupport extends DaoSupport {
   public SqlSession getSqlSession() {
        return this.sqlSessionTemplate;
    }
}

SqlSessionTemplate 的 getMapper()方法，里面又有两个方法：

public class SqlSessionTemplate implements SqlSession, DisposableBean {
     public <T> T getMapper(Class<T> type) {
        return this.getConfiguration().getMapper(type, this);
    }
}

getConfiguration方法通过 DefaultSqlSessionFactory，返回全部配置 Configuration

  public Configuration getConfiguration() {
        return this.sqlSessionFactory.getConfiguration();
    }

public class DefaultSqlSessionFactory implements SqlSessionFactory {
      public Configuration getConfiguration() {
        return this.configuration;
    }
}

回到getMapper方法，

 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return this.mapperRegistry.getMapper(type, sqlSession);
    }

这一步我们很熟悉，跟编程式使用里面的getMapper一样，通过工厂类MapperProxyFactory 获得一个 MapperProxy 代理对象，也就是说，我们注入到 Service 层的接口，实际上还是一个 MapperProxy 代理对象。
所以最后调用 Mapper 接口的方法，也是执行 MapperProxy 的 invoke()方法，后面的流程就跟编程式的里面一模一样了

总结：


image.png

——学自咕泡学院

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,456评论 5赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,370评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,337评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,583评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,596评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,572评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,936评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,595评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,850评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,601评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,685评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,371评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,951评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,934评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,167评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,636评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,411评论 2赞 342

推荐阅读更多精彩内容