Spring之整合Mybatis底层源码

文章目录

- 一、整体核心思路
- - 1 . 简介
  - 2. 整合思路
- 二、源码分析
- - 1. 环境准备
  - 2. 源码分析

一、整体核心思路

1 . 简介

有很多框架需要与Spring进行整合，而整合的核心思路就是把其他框架所产生的对象放到Spring容器中，让其成为一个bean。比如Mybatis，Mybatis框架本身是可以单独使用的，而单独使用Mybtis框架就需要用到Mybatis所提供的一些类构造出对应的对象，然后使用该对象，就能使用到Mybatis框架给我们提供的功能，和Mybatis整合SPring就是为了将这些对象放入Spring中成为Bean，在我们的Spring项目中就能很方便的使用这些对象了，也就能很方便的使用Mybatis框架提供的功能了。

2. 整合思路

安装

导入jar包：

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

快速上手

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean 来创建 SqlSessionFactory。要配置这个工厂 Bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property>  <property name="url" value="jdbc:mysql://localhost/mysql"></property> <property name="username" value="root"></property> <property name="password" value="1234"></property>   
</bean> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource" />
</bean>

SqlSessionFactory 需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

假设你定义了一个如下的 mapper 接口：

public interface UserMapper {@Select("SELECT * FROM users WHERE id = #{userId}")User getUser(@Param("userId") String userId);
}

那么可以通过 MapperFactoryBean 将接口加入到 Spring 中:

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" /><property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

需要注意的是：所指定的映射器类必须是一个接口，而不是具体的实现类。在这个示例中，通过注解来指定 SQL 语句，但是也可以使用 MyBatis 映射器的 XML 配置文件。

配置好之后，你就可以像 Spring 中普通的 Bean 注入方法那样，将映射器注入到你的业务或服务对象中。MapperFactoryBean 将会负责 SqlSession 的创建和关闭。如果使用了 Spring 的事务功能，那么当事务完成时，Session 将会被提交或回滚。最终任何异常都会被转换成 Spring 的 DataAccessException 异常。

要调用 MyBatis 的数据方法，只需一行代码：

public class FooServiceImpl implements FooService {private final UserMapper userMapper;public FooServiceImpl(UserMapper userMapper) {this.userMapper = userMapper;}public User doSomeBusinessStuff(String userId) {return this.userMapper.getUser(userId);}
}

二、源码分析

1. 环境准备

准备个mapper

public interface UserMapper {@Select("select 'user'")String selectById();
}

准备个UserService

@Component
public class UserService {@AutowiredUserMapper userMapper;public void test(){System.out.println(userMapper.selectById());}
}

测试类代码

	public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();applicationContext.register(AppConfig.class);applicationContext.refresh();UserService aService = (UserService) applicationContext.getBean("userService");aService.test();applicationContext.close();}

允许上面代码我们知道肯定会报错，报错的原因是什么，主要是我们的spring容器中是没有userMapper这个bean的，所以依赖注入这里会失败。那我们分析，userMapper这里要注入的到底是什么对象？由Mybatis的工作原理我们知道，userMapper要注入的应该是mybatis为该接口产生的一个代理对象，一旦我们拿到这个Mybatis产生的代理对象，我们就可以真正的做到操作Mybatis框架了，这也是Spring和Mybatis整合的一个关键点，这也是Spring整合其它框架的思路。而创建这个对象的关键就是，FactoryBean。

@Component
public class JackFactoryBean implements FactoryBean {@Overridepublic Object getObject() throws Exception {//使用jdk动态代理的技术Object ProxyInstance= Proxy.newProxyInstance(JackFactoryBean.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}});return ProxyInstance;}@Overridepublic Class<?> getObjectType() {return UserMapper.class;}
}

在分析Bean的生命周期源码的时候，我们知道FacotryBean底层的beanName为jackFactoryBean，但它所对应的Bean类型为getObject方法所返回的对象。这里我们以jdk动态代理技术为UserMapper生成了一个代理对象，测试一下上面的测试代码。

现在我们就可以成功注入UserMapper对象到UserService中了

在这里插入图片描述
但我们发现一个问题，如果我们每需要一个Mapper我们都去创建一个FactoryBean，这是很不合理的，所以我做一下改进。

@Component
public class JackFactoryBean implements FactoryBean {private Class MapperInterface;@Overridepublic Object getObject() throws Exception {//使用jdk动态代理的技术Object ProxyInstance= Proxy.newProxyInstance(JackFactoryBean.class.getClassLoader(), new Class[]{MapperInterface}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}});return ProxyInstance;}@Overridepublic Class<?> getObjectType() {return MapperInterface;}
}

但新的问题出来了，由于JackFactoryBean上面加了@Component注解，这是一个单例bean，而我们基于上面的改进代码我们知道，我们是要用这个FactoryBean去创建多个mapper的，所以我们不能这么定义bean，这里我们在测试类中改用以前用过的方式来创建bean。

public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();applicationContext.register(AppConfig.class);AbstractBeanDefinition beanDefinition=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(JackFactoryBean.class);beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);applicationContext.registerBeanDefinition("userMapper",beanDefinition);AbstractBeanDefinition beanDefinition1=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition1.setBeanClass(JackFactoryBean.class);beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);applicationContext.registerBeanDefinition("orderMapper",beanDefinition1);applicationContext.refresh();UserService userService = (UserService) applicationContext.getBean("userService");userService.test();applicationContext.close();}

使用上面方法就给JackFactoryBean类型创建了多个bean，注意userMapper和orderMapper所对应的类型都是userMapper和orderMapper的代理对象。但上面这些代码需要程序员在启动Spring之前自己写，这同样是不可取的。现在我们详细我们的根本目的是往容器中注入BeanDefinition，然后生成我们需要的bean，但仔细回顾我们前面学的知识，还有哪些方式可以注册BeanDefinition，这里我们就想到了前一章学到的BeanDefinitionRegistryPostProcessor接口。

@Component
public class JackBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(JackFactoryBean.class);beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);registry.registerBeanDefinition("userMapper",beanDefinition);AbstractBeanDefinition beanDefinition1=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition1.setBeanClass(JackFactoryBean.class);beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);registry.registerBeanDefinition("orderMapper",beanDefinition1);}
}

在这里插入图片描述
但上面代码的灵活性还是不高，因为我们还是把OrderMapper和UserMapper给写死了，所以我们能不能提供一种包扫描的方式，自动拿到所有的Mapper，所以思路有了下面就开始实现。首先我们自定义一个注解：


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface JackMapperScan {String value();
}

这里我们要知道其实是在实现@MapperScan注解

然后在配置类上加上该注解，现在我们就通过注解拿到我们的路径值了


@ComponentScan("com.zhouyu")
@EnableScheduling
@PropertySource("classpath:spring.properties")
@EnableTransactionManagement
@JackMapperScan("com.zhouyu.mapper")
public class AppConfig {}

现在我们采用前面学习过的另一种思路来注入BeanDefinition，即使用ImportBeanDefinitionRegistrar接口，（使用这个类的原因是，我们可以很方便拿到注解信息）

public class JackImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(JackFactoryBean.class);beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);registry.registerBeanDefinition("userMapper",beanDefinition);AbstractBeanDefinition beanDefinition1=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition1.setBeanClass(JackFactoryBean.class);beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);registry.registerBeanDefinition("orderMapper",beanDefinition1);}
}

然后在配置类上导入该类，我们看过源码知道这个类加@Component是没有效果的，所以我们在配置类上导入该类。

@ComponentScan("com.zhouyu")
@EnableScheduling
@PropertySource("classpath:spring.properties")
@EnableTransactionManagement
@JackMapperScan("com.zhouyu.mapper")
@Import(JackImportBeanDefinitionRegistrar.class)
public class AppConfig {}

现在BeanDefinition是可以注入进容器的。

在这里插入图片描述
我们知道，在Spring解析我们的注解，它会解析该注解和注解底层使用的注解，所以现在我们可以把Import注解加入到我们自定义的注解里面。所以现在我们就可以真正的开始解析扫描路径了。

public class JackImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(JackMapperScan.class.getName());//然后拿到扫描路径String value = (String) annotationAttributes.get("value");System.out.println(value);AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(JackFactoryBean.class);beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);registry.registerBeanDefinition("userMapper",beanDefinition);AbstractBeanDefinition beanDefinition1=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition1.setBeanClass(JackFactoryBean.class);beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);registry.registerBeanDefinition("orderMapper",beanDefinition1);}
}

我们就成功拿到了扫描路径
在这里插入图片描述
下面的关键是如何实现扫描逻辑，前面我们说过Spring是提供了一个扫描器的，它在扫描BeanDefinition的时候起了关键作用，即ClassPathBeanDefinitionScanner，下面自定义一个Scanner。

public class JackScanner extends ClassPathBeanDefinitionScanner {public JackScanner(BeanDefinitionRegistry registry) {super(registry);}
}

有了扫描器，现在的问题是我们知道Spring底层的扫描器是不会扫接口的，所以我们要重写isCandidateComponent方法让其支持扫描借口。

public class JackScanner extends ClassPathBeanDefinitionScanner {public JackScanner(BeanDefinitionRegistry registry) {super(registry);}//我们是不能使用Spring提供的扫描逻辑的@Overrideprotected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {//我们只关心接口return beanDefinition.getMetadata().isInterface();}
}

另外一点从源码我们知道，源码中会判断includefilters属性，这是Component的一个属性，即加了Component注解会自动包含在includefilters属性中，所以我们也要把自己定义的这些接口全部加入到includefilters属性中。

public class JackImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(JackMapperScan.class.getName());//然后拿到扫描路径String value = (String) annotationAttributes.get("value");JackScanner scanner=new JackScanner(registry);scanner.addIncludeFilter(new TypeFilter() {@Overridepublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {//这样写扫描路径下的所有类和接口都会反在IncludeFileter属性中return true;}});scanner.scan(value);AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(JackFactoryBean.class);beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);registry.registerBeanDefinition("userMapper",beanDefinition);AbstractBeanDefinition beanDefinition1=BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition1.setBeanClass(JackFactoryBean.class);beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);registry.registerBeanDefinition("orderMapper",beanDefinition1);}
}

我们测试一下，现在能否拿到mapper生成的BeanDefinition，首先完善一下代码：

public class JackScanner extends ClassPathBeanDefinitionScanner {public JackScanner(BeanDefinitionRegistry registry) {super(registry);}//我们是不能使用Spring提供的扫描逻辑的@Overrideprotected Set<BeanDefinitionHolder> doScan(String... basePackages) {Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);System.out.println(beanDefinitionHolders);return beanDefinitionHolders;}@Overrideprotected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {//我们只关心接口return beanDefinition.getMetadata().isInterface();}
}

现在我们通过打破Spring原始扫描的逻辑，确实是拿到了自己需要的mapper的bean

在这里插入图片描述

但现在的问题是，我们需要的不是接口的实际类型，但是我们实际需要的是这些借口的代理对象，所以我们还需要对BeanDefinition做一些处理。

public class JackScanner extends ClassPathBeanDefinitionScanner {public JackScanner(BeanDefinitionRegistry registry) {super(registry);}//我们是不能使用Spring提供的扫描逻辑的@Overrideprotected Set<BeanDefinitionHolder> doScan(String... basePackages) {Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {GenericBeanDefinition beanDefinition= (GenericBeanDefinition) beanDefinitionHolder.getBeanDefinition();beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());beanDefinition.setBeanClassName(JackFactoryBean.class.getName());beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);}return beanDefinitionHolders;}@Overrideprotected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {//我们只关心接口return beanDefinition.getMetadata().isInterface();}
}

再对JackImportBeanDefinitionRegistrar作一些修改：

public class JackImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(JackMapperScan.class.getName());//然后拿到扫描路径String value = (String) annotationAttributes.get("value");JackScanner scanner=new JackScanner(registry);scanner.addIncludeFilter(new TypeFilter() {@Overridepublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {//这样写扫描路径下的所有类和接口都会反在IncludeFileter属性中return true;}});scanner.scan(value);}
}

在这里插入图片描述

现在我们的代码就可以成功运行了

现在还有一个问题，就是现在mapper的代理对象是我们自己使用jdk代理生成的，但是我们现在需要的使用Mybatis来生成我们的代理对象。所以在代理这一块我们需要重新写一下。在使用Mybatis时，我们使用的使用的SqlSession对象来获取代理对象的。

public class JackFactoryBean implements FactoryBean {private Class MapperInterface;private SqlSession sqlSession;public void setSqlSession(SqlSessionFactory sqlSessionFactory) {sqlSessionFactory.getConfiguration().addMapper(MapperInterface);this.sqlSession = sqlSessionFactory.openSession();}public JackFactoryBean(Class mapperInterface) {this.MapperInterface = mapperInterface;}@Overridepublic Object getObject() throws Exception {return sqlSession.getMapper(MapperInterface);}@Overridepublic Class<?> getObjectType() {return MapperInterface;}
}

在注入SqlSession时，我们使用的是Set方法注入，但是我们需要一个SqlSessionFactory对象在Spring容器中，现在的关键是如何向Spring容器中加入SqlSessionFactory的对象。

@ComponentScan("com.zhouyu")
@EnableScheduling
@PropertySource("classpath:spring.properties")
@EnableTransactionManagement
@JackMapperScan("com.zhouyu.mapper")
public class AppConfig {@BeanSqlSessionFactory sqlSessionFactory() throws IOException {InputStream inputStream= Resources.getResourceAsStream("mybatis.xml");SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);return  sqlSessionFactory;}
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><environments default="development"><environment id="development"><!-- 使用jdbc事务管理 --><transactionManager type="JDBC"/><!-- 数据库连接池 --><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url"value="jdbc:mysql://127.0.0.1:3306/mysql_learn?characterEncoding=utf-8&amp;useSSL=false"/><property name="username" value="root"/><property name="password" value="123456"/></dataSource></environment></environments></configuration>

现在就可以成功的输出sql语句的结果了

在这里插入图片描述
现在Spring和Mybatis已经整合完了，关键点是如何将Mybatis的代理对象注入到Spring容器中。

2. 源码分析

上面我们自动动手整合了Spring和Mybatis，其实spring-mybatis包底层原理几乎差不多，只是过程更复杂，现在我们基于spring-mybatis的版本1.3.2来分析一下源码。

首先我们从@MapperScan注解开始

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {String[] value() default {};String[] basePackages() default {};Class<?>[] basePackageClasses() default {};Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;Class<? extends Annotation> annotationClass() default Annotation.class;Class<?> markerInterface() default Class.class;String sqlSessionTemplateRef() default "";String sqlSessionFactoryRef() default "";Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;String lazyInitialization() default "";String defaultScope() default AbstractBeanDefinition.SCOPE_DEFAULT;}

上面就用了@Import(MapperScannerRegistrar.class)注解，这里就对应我们案例中的@Import(JackImportBeanDefinitionRegistrar.class)，我们进去看一下这个类。

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {private ResourceLoader resourceLoader;/*** {@inheritDoc}*/@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);// this check is needed in Spring 3.1if (resourceLoader != null) {scanner.setResourceLoader(resourceLoader);}Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");if (!Annotation.class.equals(annotationClass)) {scanner.setAnnotationClass(annotationClass);}Class<?> markerInterface = annoAttrs.getClass("markerInterface");if (!Class.class.equals(markerInterface)) {scanner.setMarkerInterface(markerInterface);}Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");if (!BeanNameGenerator.class.equals(generatorClass)) {scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));}Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));}scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));List<String> basePackages = new ArrayList<String>();for (String pkg : annoAttrs.getStringArray("value")) {if (StringUtils.hasText(pkg)) {basePackages.add(pkg);}}for (String pkg : annoAttrs.getStringArray("basePackages")) {if (StringUtils.hasText(pkg)) {basePackages.add(pkg);}}for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {basePackages.add(ClassUtils.getPackageName(clazz));}scanner.registerFilters();scanner.doScan(StringUtils.toStringArray(basePackages));}/*** {@inheritDoc}*/@Overridepublic void setResourceLoader(ResourceLoader resourceLoader) {this.resourceLoader = resourceLoader;}}

上面这个类同样实现ImportBeanDefinitionRegistrar接口，重写了registerBeanDefinitions方法。

 AnnotationAttributes mapperScanAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));

上面代码和案例中一样是拿@MapperScan注解的一些信息。

ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

上面就是mybatis自定义的扫描器

 scanner.doScan(StringUtils.toStringArray(basePackages));

然后这里就开始使用子定义的扫描器开始扫描

@Overridepublic Set<BeanDefinitionHolder> doScan(String... basePackages) {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 {processBeanDefinitions(beanDefinitions);}return beanDefinitions;}private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {GenericBeanDefinition definition;for (BeanDefinitionHolder holder : beanDefinitions) {definition = (GenericBeanDefinition) holder.getBeanDefinition();if (logger.isDebugEnabled()) {logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' mapperInterface");}// the mapper interface is the original class of the bean// but, the actual class of the bean is MapperFactoryBeandefinition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59definition.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("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("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");}definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);explicitFactoryUsed = true;}if (!explicitFactoryUsed) {if (logger.isDebugEnabled()) {logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");}definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);}}}

上面就是Mybatis重写了spring框架的doscan方法：

Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

上面代码就是调用Spring的doScan方法拿到BeanDefinition

 processBeanDefinitions(beanDefinitions);

上面代码就是去修改BeanDefinition

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {GenericBeanDefinition definition;for (BeanDefinitionHolder holder : beanDefinitions) {definition = (GenericBeanDefinition) holder.getBeanDefinition();if (logger.isDebugEnabled()) {logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' mapperInterface");}// the mapper interface is the original class of the bean// but, the actual class of the bean is MapperFactoryBeandefinition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59definition.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("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("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");}definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);explicitFactoryUsed = true;}if (!explicitFactoryUsed) {if (logger.isDebugEnabled()) {logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");}definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);}}}

上面代码思路和我们一样同样是遍历并修改BeanDefinition，关键代码就是下面这几行：

definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());definition.setBeanClass(this.mapperFactoryBean.getClass());definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

然后this.mapperFactoryBean就是Mybatis写的一个FactoryBean，我们看一下这个类。

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {//要生成代理对象的接口的类型private Class<T> mapperInterface;private boolean addToConfig = true;public MapperFactoryBean() {//intentionally empty }public MapperFactoryBean(Class<T> mapperInterface) {this.mapperInterface = mapperInterface;}/*** {@inheritDoc}*/@Overrideprotected void checkDaoConfig() {super.checkDaoConfig();notNull(this.mapperInterface, "Property 'mapperInterface' is required");//设置SqlSessionConfiguration configuration = getSqlSession().getConfiguration();if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {try {configuration.addMapper(this.mapperInterface);} catch (Exception e) {logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);throw new IllegalArgumentException(e);} finally {ErrorContext.instance().reset();}}}@Overridepublic T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}/*** {@inheritDoc}*/@Overridepublic Class<T> getObjectType() {return this.mapperInterface;}.......
}

上面代码和我们一样首先定义了要生成代理对象的接口的类型

 private Class<T> mapperInterface;

然后获取SqlSession对象

  @Overridepublic T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}public abstract class SqlSessionDaoSupport extends DaoSupport {private SqlSession sqlSession;private boolean externalSqlSession;public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {if (!this.externalSqlSession) {this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);}}public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {this.sqlSession = sqlSessionTemplate;this.externalSqlSession = true;}public SqlSession getSqlSession() {return this.sqlSession;}@Overrideprotected void checkDaoConfig() {notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");}}

SqlSessionDaoSupport是MapperFactoryBean的父类，主要就是用来处理SqlSession的，包括设置SqlSessionFactory，前面源码在processBeanDefinitions设置了注入形式为Bytype，所以在注入SqlSession时会自动调用该类的所有set方法，这样SqlSession对象就可以被生成了。

这里有个不同点，我们使用openSession来获取SqlSession对象，但是这里是使用sqlSessionTemplate来创建sqlSession的

这里还是挺重要的，这部分源码需要涉及Mybatis源码分析，这部分在分析Mybatis源码分析。我们现在只需要知道有了sqlSessionTemplate，我们就可以使用sqlSessionTemplate.getMapper()来获取代理对象。前面我们的案例中是直接使用openSession来获取SqlSession对象然后执行selectone等底层函数与数据库进行交互。我们看看sqlSessionTemplate在做什么，因为sqlSessionTemplate在上面代码获得后会被直接返回，所以实际在Mybatis中我们操作的是这个对象来与数据库交互的。

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

如果我们现在用SqlSessionTemplate对象去进行查询，例如调用selectOne

  @Overridepublic <T> T selectOne(String statement) {return this.sqlSessionProxy.<T> selectOne(statement);}

我们会发现它会使用内部的一个this.sqlSessionProxy的属性去执行selectone

 public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator) {notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");notNull(executorType, "Property 'executorType' is required");this.sqlSessionFactory = sqlSessionFactory;this.executorType = executorType;this.exceptionTranslator = exceptionTranslator;this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),new Class[] { SqlSession.class },new SqlSessionInterceptor());}

从构造函数中可以发现this.sqlSessionProxy使用jdk代理来SqlSession接口。然后我们进入selectOne方法，可以发现进入了DefaultSqlSession，这就是Mybatis底层sqlSession真正的实现类。Mybatis为上面不直接使用SqlSession而是绕这么大一圈。

我们知道DefaultSqlSession在容器中就这么一个对象，且从其源码看出它是一个线程不安全的类，如果在高并发场景下，多个线程来使用这个DefaultSqlSession那么可能就出现一些难以预料的并非问题。而SqlSessionTemplate却是线程安全的，那么它是如何保证线程安全的？

它的关键点就是使用ThreadLocal，让每个线程都有一份自己的DefaultSqlSession对象。这样就可以保证线程的一个安全性。关键是要理解this.sqlSessionProxy这个对象

 this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),new Class[] { SqlSession.class },new SqlSessionInterceptor());private class SqlSessionInterceptor implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType,SqlSessionTemplate.this.exceptionTranslator);try {Object result = method.invoke(sqlSession, args);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 #22closeSqlSession(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) {closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);}}}}}

invoke方法中首先调用下面代码获取了一个真正的SqlSession对象

 SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType,SqlSessionTemplate.this.exceptionTranslator);public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);SqlSession session = sessionHolder(executorType, holder);if (session != null) {return session;}if (LOGGER.isDebugEnabled()) {LOGGER.debug("Creating a new SqlSession");}session = sessionFactory.openSession(executorType);registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);return session;}

SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);是Spring事务相关的东西，这里我们先不讲Spring事务相关的内容，我们只需要在这句代码中就操作的ThreadLocal对象，然后ThreadLocal中存的对象是SqlSessionHolder，然后就执行下面这段代码：

 SqlSession session = sessionHolder(executorType, holder);if (session != null) {return session;}session = sessionFactory.openSession(executorType);registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

上面代码就是判断当前线程的ThreadLocal中是否有SqlSessionHolder对象，如果有就直接返回当前线程ThreadLocal中存储的SqlSession对象，如果没有就调用sessionFactory.openSession重新创建一个存入到当前的ThreadLocal中（ registerSessionHolder）。

 private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {SqlSessionHolder holder;//判断是否开启了Spring事务if (TransactionSynchronizationManager.isSynchronizationActive()) {Environment environment = sessionFactory.getConfiguration().getEnvironment();if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {if (LOGGER.isDebugEnabled()) {LOGGER.debug("Registering transaction synchronization for SqlSession [" + session + "]");}holder = new SqlSessionHolder(session, executorType, exceptionTranslator);TransactionSynchronizationManager.bindResource(sessionFactory, holder);TransactionSynchronizationManager.registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));holder.setSynchronizedWithTransaction(true);holder.requested();} else {if (TransactionSynchronizationManager.getResource(environment.getDataSource()) == null) {if (LOGGER.isDebugEnabled()) {LOGGER.debug("SqlSession [" + session + "] was not registered for synchronization because DataSource is not transactional");}} else {throw new TransientDataAccessResourceException("SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization");}}} else {if (LOGGER.isDebugEnabled()) {LOGGER.debug("SqlSession [" + session + "] was not registered for synchronization because synchronization is not active");}}
}

if (TransactionSynchronizationManager.isSynchronizationActive())就是判断我们有没有开启Spring事务，如果我们没有开启Spring事务，因为每次在一个方法中执行一条Sql语句（每个Sql都会看成一个独立的整体）都会创建一个新的SqlSession，这就会导致Mysql一级缓存失效，因为一级缓存有效的保证是同一个SqlSession执行多个sql语句。所以要让一级缓存不失效，就开启Spring事务即可，这样在一个方法中的所有sql就会看成一个整体，只需要一个SqlSession处理即可。