目录
1. Spring整合Mybatis底层源码
Mybatis框架可以单独使用，需要用到Mybatis所提供的一些类构造出对应的Mapper对象，然后就能使用Mybatis框架提供的功能，我们先看一个Demo：
@Test
public void testMybatis() throws IOException {
// 读取配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
// 解析配置文件，得到SqlSession工厂类
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 从工厂中获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 然后从SqlSession中获取Mapper的代理对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
String result = mapper.selectById();
sqlSession.commit();
sqlSession.flushStatements();
sqlSession.close();
}这是一段很普通的Mybatis的代码，我们点进去看一下getMapper()方法，看一下Mybatis如何生成UserMapper代理对象，这个方法是SqlSession接口的方法，这个接口里面有很多我们平常使用的CRUD方法：
public interface SqlSession extends Closeable {
<T> T selectOne(String var1);
<T> T selectOne(String var1, Object var2);
<E> List<E> selectList(String var1);
<E> List<E> selectList(String var1, Object var2);
<E> List<E> selectList(String var1, Object var2, RowBounds var3);
<K, V> Map<K, V> selectMap(String var1, String var2);
<K, V> Map<K, V> selectMap(String var1, Object var2, String var3);
<K, V> Map<K, V> selectMap(String var1, Object var2, String var3, RowBounds var4);
<T> Cursor<T> selectCursor(String var1);
<T> Cursor<T> selectCursor(String var1, Object var2);
<T> Cursor<T> selectCursor(String var1, Object var2, RowBounds var3);
void select(String var1, Object var2, ResultHandler var3);
void select(String var1, ResultHandler var2);
void select(String var1, Object var2, RowBounds var3, ResultHandler var4);
int insert(String var1);
int insert(String var1, Object var2);
int update(String var1);
int update(String var1, Object var2);
int delete(String var1);
int delete(String var1, Object var2);
void commit();
void commit(boolean var1);
void rollback();
void rollback(boolean var1);
List<BatchResult> flushStatements();
void close();
void clearCache();
Configuration getConfiguration();
<T> T getMapper(Class<T> var1);
Connection getConnection();
}主要看它默认的实现类DefaultSqlSession的方法：
所属类：org.apache.ibatis.session.defaults.DefaultSqlSession
public <T> T getMapper(Class<T> type) {
return this.configuration.getMapper(type, this);
}所属类：org.apache.ibatis.session.Configuration
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return this.mapperRegistry.getMapper(type, sqlSession);
}所属类：org.apache.ibatis.binding.MapperRegistry
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
} else {
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception var5) {
throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
}
}
}mapperProxyFactory.newInstance(sqlSession)就会返回代理对象：
所属类：org.apache.ibatis.binding.MapperProxyFactory
public class MapperProxyFactory<T> {
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap();
public MapperProxyFactory(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
public Class<T> getMapperInterface() {
return this.mapperInterface;
}
public Map<Method, MapperMethod> getMethodCache() {
return this.methodCache;
}
protected T newInstance(MapperProxy<T> mapperProxy) {
return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
return this.newInstance(mapperProxy);
}
}把mapper传进去，通过JDK的动态代理生成代理对象。我们可以看一下MapperProxy类，它实现了InvocationHandler接口。
public class MapperProxy<T> implements InvocationHandler, Serializable {
private static final long serialVersionUID = -6424540398559729838L;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache;
public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
}
if (this.isDefaultMethod(method)) {
return this.invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
MapperMethod mapperMethod = this.cachedMapperMethod(method);
return mapperMethod.execute(this.sqlSession, args);
}
private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = (MapperMethod)this.methodCache.get(method);
if (mapperMethod == null) {
mapperMethod = new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration());
this.methodCache.put(method, mapperMethod);
}
return mapperMethod;
}当我们得到代理对象，去执行Mapper接口里面的方法时，Mybatis就会进入MapperProxy类的invoke()方法，得到方法上面的注解（如：@Select("select 'user'"))，然后去执行目标方法。
所有MapperProxy类很重要，上面这些生成代理逻辑，都是Mybatis提供的。
回到Spring，如果Mybatis要和Spring整合，除了Mybatis自带的jar包之外，还需整合的jar包：
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>为什么呢？举个例子：
@Component
public class UserService {
@Autowired
private UserMapper userMapper;
public void test() {
System.out.println(userMapper.selectById());
}
}上面的代码貌似没问题，但是如果没有整合jar包，就会报找不到userMapper这个Bean的错误。
我们知道，Spring在Bean的实例化中进行属性注入时，找不到userMapper，因为在过程中需要把Mybatis生成的UserMapper代理对象注入到这里，赋值该属性，才能进行后续的操作，Spring和其他框架整合亦如此。会把Mybatis创建的类（或代理对象）注册到Spring容器，Spring在用的时候才能找到。
这个章节要说的就是如何把Mybatis生成userMapper变成Spring所需的Bean，但是UserMapper是接口，所以不能用固有的思路通过Spring上下文去getBean()，接口是无法实例化的。
答案就是利用FactoryBean接口，例如：
/**
* @author Kieasar
*/
@Component
public class BaecFactoryBean implements FactoryBean {
@Override
public Object getObject() {
// 参数中把类加载器传进去，然后new一个UserMapper，生成代理对象
Object newInstance = Proxy.newProxyInstance(BaecFactoryBean.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
System.out.println("执行代理对象的方法");
return null;
}
});
return newInstance;
}
// 把生成的代理对象的类型返回
@Override
public Class<?> getObjectType() {
return UserMapper.class;
}
}此时，这个Bean对象所对应的Bean就是getObject()方法返回的代理对象（newInstance），接下来，单元测试一下：
@Test
public void main() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(AppConfig.class);
context.refresh();
UserService userService = (UserService) context.getBean("userService");
userService.test();
}执行结果没有报错，说明属性被赋值了，很明显，因为通过属性去找，能找到上面BaecFactoryBean生成的代理对象。
但是test()方法打印结果却为null，因为此时执行的是代理对象的invoke()方法。
上面的例子，貌似我们实现了Mybatis的功能，但是有个问题，此时只有一个UserMapper，如果再有OrderMapper或其他很多的类需要注入，难道我们要写很多个FactoryBean吗？所以，当当前的思路是不行滴~
于是，又想到，代码不要写死，这样不就可以了嘛：
/**
* @author Kieasar
*/
@Component
public class BaecFactoryBean implements FactoryBean {
private Class mapperInterface;
public BaecFactoryBean(Class mapperInterface) {
this.mapperInterface = mapperInterface;
}
@Autowired
public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
sqlSessionFactory.getConfiguration().addMapper(mapperInterface);
this.sqlSession = sqlSessionFactory.openSession();
}
@Override
public Object getObject() {
Object newInstance = Proxy.newProxyInstance(BaecFactoryBean.class.getClassLoader(), new Class[]{mapperInterface}, new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
System.out.println("执行代理对象的方法");
return null;
}
});
return newInstance;
}
// 把生成的代理对象的类型返回
@Override
public Class<?> getObjectType() {
return mapperInterface;
}
}但是，@Component注解修饰的类，注入的时候是单例的，支持生成一个代理对象，不能生成我们需要的若干个Bean，但是，这样可以呀~
@Test
public void main() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(AppConfig.class);
context.refresh();
AbstractBeanDefinition userMapperBeanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
userMapperBeanDefinition.setBeanClass(BaecFactoryBean.class);
userMapperBeanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);
// 得到一个userMapper代理对象
context.registerBeanDefinition("userMapper",userMapperBeanDefinition);
AbstractBeanDefinition orederMapperBeanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
orederMapperBeanDefinition.setBeanClass(BaecFactoryBean.class);
orederMapperBeanDefinition.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);
// 得到一个orderMapper代理对象
context.registerBeanDefinition("orderMapper",orederMapperBeanDefinition);
UserService userServcie = (UserService) context.getBean("userServcie");
userServcie.test();
}确实可以，但是如果有很多的类需要注入呢……
用扫描的方式，则需要一个扫描器，继承ClassPathBeanDefinitionScanner类，就有了扫描器的功能。
public class BaecBeanDefinitionScanner extends ClassPathBeanDefinitionScanner {
public BaecBeanDefinitionScanner(BeanDefinitionRegistry registry) {
super(registry);
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
// 往构造方法的入参中传值的话，传的就是这个mapper解析之后的BeanDefinition的名称
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
beanDefinition.setBeanClassName(BaecFactoryBean.class.getName());
}
return beanDefinitionHolders;
}
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return beanDefinition.getMetadata().isInterface();
}
}但是Spring不关心接口，Mybatis只关心接口，所以，还需要加工一下，重写isCandidateComponent()方法，如果是接口，返回true，只拦截接口，不拦截类，如上。
扫描哪儿呢？还是注解方便，自定义一个注解：
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(BaecBeanDefinitionRegistrar.class)
public @interface BaecMapperScan {
String value();
}
并且需要把BaecBeanDefinitionRegistrar类导入进来，这个类用来注册BeanDefinition：
public class BaecBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
// 参数AnnotationMetadata就是注解的元数据信息
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
// 获取注解信息
Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(BaecMapperScan.class.getName());
// 获取扫描路径
String path = (String) annotationAttributes.get("value");
// 引入扫描器
BaecBeanDefinitionScanner scanner = new BaecBeanDefinitionScanner(registry);
// ClassPathBeanDefinitionScanner扫描器默认只扫描@Component注解的类
// 所以，重写IncludeFilter()方法，让它扫描所有的类
scanner.addIncludeFilter(new TypeFilter() {
@Override
public boolean match(@NotNull MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory){
return true;
}
});
// 扫描路径
scanner.scan(path);
}
}我们定义的BaecBeanDefinitionScanner继承自ClassPathBeanDefinitionScanner扫描器，默认只扫描@Component注解的类，可以看一下ClassPathBeanDefinitionScanner的扫描过程，doScan()方法主要会调到这里：
所属类：springframework.context.annotation.ClassPathScanningCandidateComponentProvider
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 获取basePackage下所以的文件资源
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 根据路径获取资源，class文件的file对象
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
// 元数据读取器
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// excludeFilters includeFilters过滤器判断
if (isCandidateComponent(metadataReader)) {
// 构造BeanDefiniiton
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(resource);
// 又判断一次，符合条件才加入
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
----省略无关代码----
这个方法isCandidateComponent()就是用来判断有没有@Component注解：
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
// 排除过滤器，返回false
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
// 符合includeFilters的才会进行条件匹配，通过了才是Bean，也就是先看有没有@Component，再看是否符合@Conditianal
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return isConditionMatch(metadataReader);
}
}
return false;
}
所以，UserMapper和OrderMapper要想被扫描到，就重写IncludeFilter()方法，让它扫描所有的类。
scanner.addIncludeFilter(new TypeFilter() {
@Override
public boolean match(@NotNull MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory){
return true;
}
});但是自定义的BaecFactoryBean是自己实现代理对象，要整合Mybatis，就需要Mybatis生成得代理对象，顺着这个思路，换成MyBatis的。
@Component
public class BaecFactoryBean implements FactoryBean {
private Class mapperInterface;
private SqlSession sqlSession;
public BaecFactoryBean(Class mapperInterface) {
this.mapperInterface = mapperInterface;
}
// 通过注入SqlSessionFactory拿到SqlSession
@Autowired
public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
sqlSessionFactory.getConfiguration().addMapper(mapperInterface);
this.sqlSession = sqlSessionFactory.openSession();
}
@Override
public Object getObject() {
return sqlSession.getMapper(mapperInterface);
}
// 把生成的代理对象的类型返回
@Override
public Class<?> getObjectType() {
return mapperInterface;
}
}那么，只要Spring能拿到SqlSessionFactory这个Bean，就能取到SqlSession对象，如何拿呢？这就需要程序员自己实现了：
@ComponentScan("com.baec")
@BaecMapperScan("com.baec.mapper")
public class AppConfig {
@Bean
public SqlSessionFactory sqlSessionFactory() throws IOException {
InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
return sqlSessionFactory;
}
}当然，也需要提前把Mybatis的配置文件mybatis.xml准备好。
另外，如果不使用Spring的注解，有什么办法注入SqlSession呢？
public class BaecBeanDefinitionScanner extends ClassPathBeanDefinitionScanner {
public BaecBeanDefinitionScanner(BeanDefinitionRegistry registry) {
super(registry);
}
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
GenericBeanDefinition beanDefinition = (GenericBeanDefinition) beanDefinitionHolder.getBeanDefinition();
// 往构造方法的入参中传值的话，传的就是这个mapper解析之后的BeanDefinition的名称
beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
beanDefinition.setBeanClassName(BaecFactoryBean.class.getName());
// 自动找到BaecFactoryBean类里面的set方法，然后根据类型去找Bean
beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
}
return beanDefinitionHolders;
}
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return beanDefinition.getMetadata().isInterface();
}
}把BeanDefinition强转成GenericBeanDefinition，位置AutowiredMode属性为按类型注入，Spring会自动找到BaecFactoryBean类里面的set方法，然后根据类型去找Bean。
然后，上面的BaecFactoryBean就可以修改为：
public class BaecFactoryBean implements FactoryBean {
private Class mapperInterface;
private SqlSession sqlSession;
public BaecFactoryBean(Class mapperInterface) {
this.mapperInterface = mapperInterface;
}
public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
sqlSessionFactory.getConfiguration().addMapper(mapperInterface);
this.sqlSession = sqlSessionFactory.openSession();
}
@Override
public Object getObject() {
return sqlSession.getMapper(mapperInterface);
}
@Override
public Class<?> getObjectType() {
return mapperInterface;
}
}没有使用Spring的注解，但是实现了注入。
接下来，我们看一下Mybatis的原理，从@MapperScan注解入手：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MapperScannerRegistrar.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;
}它也是导入了MapperScannerRegistrar类，该类也是实现了ImportBeanDefinitionRegistrar接口：
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
private ResourceLoader resourceLoader;
public MapperScannerRegistrar() {
}
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
if (this.resourceLoader != null) {
scanner.setResourceLoader(this.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((BeanNameGenerator)BeanUtils.instantiateClass(generatorClass));
}
Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
scanner.setMapperFactoryBean((MapperFactoryBean)BeanUtils.instantiateClass(mapperFactoryBeanClass));
}
scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
List<String> basePackages = new ArrayList();
String[] var10 = annoAttrs.getStringArray("value");
int var11 = var10.length;
int var12;
String pkg;
for(var12 = 0; var12 < var11; ++var12) {
pkg = var10[var12];
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
var10 = annoAttrs.getStringArray("basePackages");
var11 = var10.length;
for(var12 = 0; var12 < var11; ++var12) {
pkg = var10[var12];
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
Class[] var14 = annoAttrs.getClassArray("basePackageClasses");
var11 = var14.length;
for(var12 = 0; var12 < var11; ++var12) {
Class<?> clazz = var14[var12];
basePackages.add(ClassUtils.getPackageName(clazz));
}
scanner.registerFilters();
scanner.doScan(StringUtils.toStringArray(basePackages));
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
}
在这里面，Mybatis同样创建了一个扫描器ClassPathMapperScanner，扫描@MapperScan注解，毋庸置疑，该类也是继承自Spring的扫描器——ClassPathBeanDefinitionScanner类，在它的doScan方法中的processBeanDefinitions()中，同样也设置了AutowireMode属性为：
beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);接下来，再看一下ClassPathMapperScanner中创建的MapperFactoryBean，是把Mybatis生成代理对象转化为Bean最关键的一环，这个类也实现了FactoryBean接口：
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
private Class<T> mapperInterface;
private boolean addToConfig = true;
public MapperFactoryBean() {
}
public MapperFactoryBean(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
protected void checkDaoConfig() {
super.checkDaoConfig();
Assert.notNull(this.mapperInterface, "Property 'mapperInterface' is required");
Configuration configuration = this.getSqlSession().getConfiguration();
if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
try {
configuration.addMapper(this.mapperInterface);
} catch (Exception var6) {
this.logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", var6);
throw new IllegalArgumentException(var6);
} finally {
ErrorContext.instance().reset();
}
}
}
public T getObject() throws Exception {
return this.getSqlSession().getMapper(this.mapperInterface);
}
public Class<T> getObjectType() {
return this.mapperInterface;
}
public boolean isSingleton() {
return true;
}
public void setMapperInterface(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
public Class<T> getMapperInterface() {
return this.mapperInterface;
}
public void setAddToConfig(boolean addToConfig) {
this.addToConfig = addToConfig;
}
public boolean isAddToConfig() {
return this.addToConfig;
}
}getObject()方法中也是通过getSqlSession().getMapper(this.mapperInterface)拿到的，属性mapperInterface也是通过MapperFactoryBean类的构造方法注入的。
而getSqlSession()方法在它的父类SqlSessionDaoSupport中定义了，和上面的例子一样。
我们回到文章一开头的代码，这句代码就相当于开了一个事务。
// 从工厂中获取SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();它与Mybatis的一级缓存和二级缓存有关，但是，如果一级缓存打开了，第二次去执行同样的sql时就不会去请求数据库了，因为SqlSession会缓存第一次执行sql的结果，会执行MapperProxy的invoke()方法：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
}
if (this.isDefaultMethod(method)) {
return this.invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
MapperMethod mapperMethod = this.cachedMapperMethod(method);
// 主要执行这里
return mapperMethod.execute(this.sqlSession, args);
}当执行某个方法时，会判断方法是@Select、@Insert等注解，以@Select为例，最终会调用
public Object execute(SqlSession sqlSession, Object[] args) {
Object param;
Object result;
switch(this.command.getType()) {
case INSERT:
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
break;
case UPDATE:
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
break;
case DELETE:
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
break;
case SELECT:
if (this.method.returnsVoid() && this.method.hasResultHandler()) {
this.executeWithResultHandler(sqlSession, args);
result = null;
} else if (this.method.returnsMany()) {
result = this.executeForMany(sqlSession, args);
} else if (this.method.returnsMap()) {
result = this.executeForMap(sqlSession, args);
} else if (this.method.returnsCursor()) {
result = this.executeForCursor(sqlSession, args);
} else {
param = this.method.convertArgsToSqlCommandParam(args);
// 最终会调用到这里
result = sqlSession.selectOne(this.command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + this.command.getName());
}执行到result = sqlSession.selectOne(this.command.getName(), param);拿到了sql和方法的参数。
2. SqlSessionTemplate类的作用
在MapperFactoryBean的父类SqlSessionDaoSupport中的SqlSession其实是SqlSessionTemplate类：
this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);我们用到的UserMapper是通过SqlSessionTemplate.getMapper()返回的代理对象，那这个SqlSessionTemplate是什么东东呢？
先看它的构造函数：
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
}
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
Assert.notNull(executorType, "Property 'executorType' is required");
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator;
this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
}传入一个SqlSessionFactory ，最终通过JDK的动态代理生成一个SqlSession的代理对象，并赋值给sqlSessionProxy属性。
再看它的getMapper()方法：
public <T> T getMapper(Class<T> type) {
return this.getConfiguration().getMapper(type, this);
}参数传的是类型和this，去生成代理对象。mapper.selectById()调用的就是SqlSessionTemplate.selectOne()方法：
public <T> T selectOne(String statement, Object parameter) {
return this.sqlSessionProxy.selectOne(statement, parameter);
}就是调用的sqlSessionProxy就是构造函数生成的代理对象的selectOne()方法。
此时还没有真正去执行sql，执行sql是DefaultSqlSession对象，执行sql最终会进入SqlSessionInterceptor类，它是构造方法中生成动态代理导进去的，调用到它的invoke()：
private class SqlSessionInterceptor implements InvocationHandler {
private SqlSessionInterceptor() {
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
Object unwrapped;
try {
// 执行sql就是在这
Object result = method.invoke(sqlSession, args);
if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
sqlSession.commit(true);
}
unwrapped = result;
} catch (Throwable var11) {
unwrapped = ExceptionUtil.unwrapThrowable(var11);
if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
sqlSession = null;
Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
if (translated != null) {
unwrapped = translated;
}
}
throw (Throwable)unwrapped;
} finally {
if (sqlSession != null) {
SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
}
}
return unwrapped;
}SqlSessionUtils.getSqlSession()方法就是从Session工厂中得到DefaultSqlSession：
所属类：org.mybatis.spring.SqlSessionUtils
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
Assert.notNull(sessionFactory, "No SqlSessionFactory specified");
Assert.notNull(executorType, "No ExecutorType specified");
// 通过Spring的事务管理器，从ThreadLocal中是否有SqlSession
SqlSessionHolder holder = (SqlSessionHolder)TransactionSynchronizationManager.getResource(sessionFactory);
SqlSession session = sessionHolder(executorType, holder);
// 有则返回
if (session != null) {
return session;
} else {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Creating a new SqlSession");
}
// 没有，则从DefaultSqlSessionFactory工厂类中创建一个新的DefaultSqlSession
session = sessionFactory.openSession(executorType);
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
return session;
}
}总之，调用流程就是SqlSessionTemplate.selectOne()---->SqlSessionProxy.selectOne()--->DefaultSqlSession.selectOne()。这儿抛出两个问题：
SqlSessionTemplate的作用是什么？
因为DefaultSqlSession是线程不安全的，没有锁和同步方法，当不同线程同时调用DefaultSqlSession时，DefaultSqlSession确是同一个，存在并发安全问题。
SqlSessionTemplate就是用来解决线程安全这个问题，但该类里面的方法却没有加锁，所以只要保证每个线程有单独的DefaultSqlSession，一个线程执行sql时是同一个DefaultSqlSession就可以了，如何做的？
通过ThreadLocal，每个线程执行之前，先看ThreadLoca中是否有DefaultSqlSession，有直接拿来用，没有则创建。
上面SqlSessionUtils.getSqlSession()方法中的TransactionSynchronizationManager.getResource()，就是Spring的事务，底层就是ThreadLocal：
private static Object doGetResource(Object actualKey) {
// resources是ThreadLocal包装的Map，用来缓存资源的，比如缓存当前线程中由某个DataSource所创建的数据库连接
Map<Object, Object> map = resources.get();
if (map == null) {
return null;
}
// 获取DataSource对象所对应的数据库连接对象
Object value = map.get(actualKey);
// Transparently remove ResourceHolder that was marked as void...
if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
map.remove(actualKey);
// Remove entire ThreadLocal if empty...
if (map.isEmpty()) {
resources.remove();
}
value = null;
}
return value;
}检查ThreadLocal中是否有SqlSession，返回的是SqlSession的包装类SqlSessionHolder，有则从SqlSessionHolder中取出，没有，则从DefultSqlSession工厂类中创建一个新的：
SqlSessionFactory.openSession(executorType);
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);然后执行registerSessionHolder()方法，把DefultSqlSession包装成SqlSessionHolder，存到ThreadLocal。
private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
Environment environment = sessionFactory.getConfiguration().getEnvironment();
if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Registering transaction synchronization for SqlSession [" + session + "]");
}
SqlSessionHolder holder = new SqlSessionHolder(session, executorType, exceptionTranslator);
// 通过事务管理器，存到ThreadLocal
TransactionSynchronizationManager.bindResource(sessionFactory, holder);
TransactionSynchronizationManager.registerSynchronization(new SqlSessionUtils.SqlSessionSynchronization(holder, sessionFactory));
holder.setSynchronizedWithTransaction(true);
holder.requested();3. Mybatis一级缓存失效问题
为什么Spring和Mybatis整合之后一级缓存会失效？
在上面的源码中，注意有个条件TransactionSynchronizationManager.isSynchronizationActive()，是否开启了Spring事务，如果为true才去执行后面的逻辑。
不符合带来的结果就是，一个线程去执行不同的sql时，发现ThreadLocal中没有SqlSession，于是每次都去创建，导致一级缓存失效，因为一级缓存的运行机制就是同一个SqlSession执行同一个sql时，返回之前缓存的结果。
如何解决？就是方法上加@Transactional注解，就会使用Spring的事务管理器建立的数据库连接，Mybatis如何拿到事务管理器的连接呢？就是prepareStatement()方法：
所属类：org.apache.ibatis.executor.SimpleExecutor
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
// 获取数据库连接
Connection connection = this.getConnection(statementLog);
Statement stmt = handler.prepare(connection, this.transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}进而调用到org.apache.ibatis.executor.BaseExecutor.getConnection()方法：
protected Connection getConnection(Log statementLog) throws SQLException {
Connection connection = this.transaction.getConnection();
return statementLog.isDebugEnabled() ? ConnectionLogger.newInstance(connection, statementLog, this.queryStack) : connection;
}这个Transaction是Mybatis的事务管理接口，包括事务的提交、回滚，及数据库连接的获取。
会先在DefaultSqlSessionFactory.openSessionFromDataSource()方法中通过TransactionFactory创建的，进而创建了Executor执行器。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
Environment environment = this.configuration.getEnvironment();
TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
Executor executor = this.configuration.newExecutor(tx, execType);
return new DefaultSqlSession(this.configuration, executor, autoCommit);
----省略无关代码----
}Spring整合Mybatis后得到的是SpringManagedTransaction类，它继承自Transaction接口：
public class SpringManagedTransaction implements Transaction {
private static final Log LOGGER = LogFactory.getLog(SpringManagedTransaction.class);
private final DataSource dataSource;
private Connection connection;
private boolean isConnectionTransactional;
private boolean autoCommit;
public SpringManagedTransaction(DataSource dataSource) {
Assert.notNull(dataSource, "No DataSource specified");
this.dataSource = dataSource;
}
public Connection getConnection() throws SQLException {
if (this.connection == null) {
this.openConnection();
}
return this.connection;
}
private void openConnection() throws SQLException {
this.connection = DataSourceUtils.getConnection(this.dataSource);
this.autoCommit = this.connection.getAutoCommit();
this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
}
public void commit() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
this.connection.commit();
}
}
public void rollback() throws SQLException {
if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {
this.connection.rollback();
}
}
public void close() throws SQLException {
DataSourceUtils.releaseConnection(this.connection, this.dataSource);
}
public Integer getTimeout() throws SQLException {
ConnectionHolder holder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.dataSource);
return holder != null && holder.hasTimeout() ? holder.getTimeToLiveInSeconds() : null;
}
}openConnection()中的DataSourceUtils.getConnection(this.dataSource)就可以拿到由Spring事务管理器创建的数据库连接。
如果方法没有开启事务，那么在执行sql时候，每个sql有自己的SqlSession对象来执行。
如果开启了Spring事务，就是多个sql属于同一个事务，那应该用一个SqlSession来执行多个sql。所以，在没有开启Spring事务的时候，SqlSession的一级缓存并不是失效了，而是存在的生命周期太短了（执行完一个sql后就被销毁了，下一个sql执行时又是一个新的SqlSession）。
Spring为什么要这样设计？解决线程安全问题，一般情况下不建议使用Mybatis的一级缓存，如果使用，就会涉及到事务的隔离级别，假如设置的隔离级别是读未提交，那么同一条sql查到的结果可能是一样的（从缓存中拿的），把隔离界别忽略了。那数据库的隔离级别重要还是Mybatis的一级缓存重要？肯定是数据库的隔离级别重要。
如果非要使用Mybatis的一级缓存，提供另外一种方法，用@Bean创建一个SqlSession的Bean：
@ComponentScan("com.baec")
@BaecMapperScan("com.baec.mapper")
public class AppConfig {
@Autowired
public SqlSessionFactory sqlSessionFactory() throws IOException {
InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
return sqlSessionFactory;
}
@Bean
public SqlSession sqlSession() throws IOException {
return sqlSessionFactory().openSession();
}这样，在Service中就可以直接使用了：
@Component
public class UserService {
@Autowired
private UserMapper userMapper;
@Autowired
private SqlSession sqlSession;
public void test() {
sqlSession.selectOne("cn.kieasar.mybatis.mapper.UserMapper.selectById");
sqlSession.selectOne("cn.kieasar.mybatis.mapper.UserMapper.selectById");
sqlSession.selectOne("cn.kieasar.mybatis.mapper.UserMapper.selectById");
}
}这样一来，这三个Sql执行使用的SqlSession 就是同一个了，而且是同一个线程。
如果加了@MapperScan注解，会扫描、注入BeanDefinition，Mapper的代理对象Bean，即MapperFactoryBean<T>，MapperFactoryBean继承了SqlSessionDaoSupport，SqlSessionDaoSupport又继承了DaoSupport，而DaoSupport类实现了InitializingBean接口，所以各种Mapper创建时会执行afterPropertiesSet()方法：
public abstract class DaoSupport implements InitializingBean {
/** Logger available to subclasses. */
protected final Log logger = LogFactory.getLog(getClass());
@Override
public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {
// Let abstract subclasses check their configuration.
checkDaoConfig();
// Let concrete implementations initialize themselves.
try {
initDao();
}
catch (Exception ex) {
throw new BeanInitializationException("Initialization of DAO failed", ex);
}
}初始化的时候首先会调用checkDaoConfig()，检查SqlSession是否为空，会调到这里：
public abstract class SqlSessionDaoSupport extends DaoSupport {
private SqlSession sqlSession;
private boolean externalSqlSession;
public SqlSessionDaoSupport() {
}
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;
}
protected void checkDaoConfig() {
Assert.notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");
}
}
接下来，会进入到子类MapperFactoryBean.checkDaoConfig()：
protected void checkDaoConfig() {
super.checkDaoConfig();
Assert.notNull(this.mapperInterface, "Property 'mapperInterface' is required");
Configuration configuration = this.getSqlSession().getConfiguration();
if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
try {
// 把泛型Class<T>的mapperInterface添加到Mapper中
configuration.addMapper(this.mapperInterface);
} catch (Exception var6) {
this.logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", var6);
throw new IllegalArgumentException(var6);
} finally {
ErrorContext.instance().reset();
}
}
}把泛型Class<T>的mapperInterface添加到Mapper中。
另外，如果不想写@MapperScan注解，还有一种方式可以扫描注入Mybatis生成的代理对象Bean，整合Mybatis：
@ComponentScan("com.baec")
public class AppConfig {
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer configurer = new MapperScannerConfigurer();
// 指定扫描路径
configurer.setBasePackage("com.baec.mapper");
return configurer;
}
@Bean
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(dataSource());
}
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/tuling?characterEncoding=utf-8&useSSL=false");
dataSource.setUsername("root");
dataSource.setPassword("Zhouyu123456***");
return dataSource;
}
@Bean
public SqlSessionFactory sqlSessionFactory() throws Exception {
SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
sessionFactoryBean.setDataSource(dataSource());
return sessionFactoryBean.getObject();
}
}SqlSessionFactory类实现了InitializingBean和FactoryBean接口，它的getObject()方法调用了afterPropertiesSet()方法：
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
this.afterPropertiesSet();
}
return this.sqlSessionFactory;
} public void afterPropertiesSet() throws Exception {
this.sqlSessionFactory = this.buildSqlSessionFactory();
}buildSqlSessionFactory()方法中会构建出Mybatis的核心配置类Configuration，在这里面创建了Spring的事务管理器SpringManagedTransactionFactory工厂，通过该类可以拿到SpringManagedTransaction。
MapperScannerConfigurer实现了BenDefinitionRegistryPostProcessor接口，在postProcessBeanDefinitionRegistry()方法中创建了扫描器，实现了扫描BeanDefiniiton的功能：
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"));
}最后，我们总结一下Spring整合Mybatis底层源码执行流程：
- 通过@MapperScan导入了MapperScannerRegistrar类；
- MapperScannerRegistrar类实现了ImportBeanDefinitionRegistrar接口，Spring在启动时会调用MapperScannerRegistrar类中的registerBeanDefinitions()方法；
- registerBeanDefinitions()方法中定义了ClassPathMapperScanner对象，用来扫描Mapper；
- 设置ClassPathMapperScanner对象可以扫描到接口，因为在Spring中不会扫描接口（因为ClassPathMapperScanner中重写了isCandidateComponent方法，导致isCandidateComponent只会扫描@Component注解的类）；
- 扫描接口并且得到对应的BeanDefinition；
- 把扫描得到的BeanDefinition进行修改，把BeanClass修改为MapperFactoryBean，把AutowireMode修改为byType；
- 扫描完成后，Spring就会基于BeanDefinition去创建Bean，相当于每个Mapper对应一个FactoryBean；
- 在MapperFactoryBean中的getObject()方法中，调用了getSqlSession()去得到一个sqlSession对象，然后根据对应的Mapper接口生成一个Mapper接口代理对象，这个代理对象就成为Spring容器中的Bean；
- SqlSession对象属于Mybatis，SqlSession对象需要SqlSessionFactory来产生；
- MapperFactoryBean的AutowireMode为byType，所以Spring会自动调用set方法，有两个set方法，一个setSqlSessionFactory()，一个setSqlSessionTemplate()，而这两个方法执行的前提是根据方法参数类型能找到对应的bean，所以Spring容器中要存在SqlSessionFactory类型的Bean或者SqlSessionTemplate类型的Bean；
- 如果你定义的是一个SqlSessionFactory类型的Bean，那么最终也会被包装为一个SqlSessionTemplate对象，并且赋值给sqlSession属性；
- 而在SqlSessionTemplate类中就存在一个getMapper()方法，这个方法会产生一个Mapper接口代理对象；
- 当执行该代理对象的某个方法时，就会进入到Mybatis框架的底层执行流程，执行流程看下图：
