参考文档：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 映射器文件的路径
然后在 applicationContext.xml 配置需要扫描 Mapper 接口的路径
在 Mybatis 里面有3种方式，第一种是配置一个 MapperScannerConfigurer。
第二种是配置一个
第三种就是直接用@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, InitializingBean, ApplicationListener {
...
//它实现了 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 扩展点总结：
创建 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 doScan(String... basePackages) {
Set 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 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 extends SqlSessionDaoSupport implements FactoryBean {
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 extends SqlSessionDaoSupport implements FactoryBean {
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 getMapper(Class 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 getMapper(Class type, SqlSession sqlSession) {
return this.mapperRegistry.getMapper(type, sqlSession);
}
这一步我们很熟悉，跟编程式使用里面的getMapper一样，通过工厂类MapperProxyFactory 获得一个 MapperProxy 代理对象，也就是说，我们注入到 Service 层的接口，实际上还是一个 MapperProxy 代理对象。
所以最后调用 Mapper 接口的方法，也是执行 MapperProxy 的 invoke()方法，后面的流程就跟编程式的里面一模一样了
总结：
——学自咕泡学院