本文将结合示例并阅读源码，分析mybatis与spring的集成原理，将重点分析@MapperScan注解扫描、插件注册等内容。
系列文档：
- mybatis源码之创建SqlSessionFactory代码分析
- mybatis源码之创建SqlSessionFactory代码分析 - mapper xml解析
- mybatis源码之执行查询SQL代码分析
- mybatis源码之执行insert代码分析
- mybatis源码之mapper接口扫描原理分析
- mybatis源码之集成spring原理
- mybatis源码之集成springboot原理
- mybatis源码之集成mybatis-plus源码
- mybatis源码之mybatis-plus执行查询(基础篇完结)
- MybatisPlusAutoConfiguration源码分析
- Autowired注入Service变成了biaomidou的Mapper代理
示例代码
Configuration配置类
@MapperScan(basePackages = {"org.net5ijy.mybatis.test.mapper"})
@Configuration
public class MybatisConfig {
// bean config
}
数据源配置
使用的是Druid数据源。
@Bean
public DataSource druidDataSource()
throws IOException, InvocationTargetException,
IllegalAccessException, IntrospectionException,
InstantiationException, ClassNotFoundException {
DruidDataSource dataSource = new DruidDataSource();
// 读取数据源配置文件
Properties properties = new Properties();
properties.load(
MybatisConfig.class.getClassLoader().getResourceAsStream("jdbc.properties"));
// 设置数据源核心参数
dataSource.setUsername(properties.getProperty("username"));
dataSource.setPassword(properties.getProperty("password"));
dataSource.setDriverClassName(properties.getProperty("driver"));
dataSource.setUrl(properties.getProperty("url"));
Set<Object> keys = properties.keySet();
for (Object key : keys) {
String k = (String) key;
if (k.startsWith("druid.")) {
String propertyName = k.substring(6);
String propertyValue = properties.getProperty(k);
if (propertyName.equals("proxyFilters")) {
dataSource.setProxyFilters(createFilters(propertyValue));
} else {
PropertyDescriptor propertyDescriptor =
new PropertyDescriptor(propertyName, DruidDataSource.class);
Method writeMethod = propertyDescriptor.getWriteMethod();
Class<?> type = writeMethod.getParameterTypes()[0];
Object v = transferValue(type, propertyValue);
writeMethod.invoke(dataSource, v);
}
}
}
return dataSource;
}
SqlSessionFactory配置
SqlSessionFactoryBean实现了FactoryBean接口。
@Bean
public SqlSessionFactoryBean sessionFactory(@Autowired DataSource dataSource) {
SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
// 设置数据源
sessionFactoryBean.setDataSource(dataSource);
// 设置mapper xml配置文件路径
sessionFactoryBean.setMapperLocations(new ClassPathResource("mapper/BlogMapper.xml"));
return sessionFactoryBean;
}
SqlSessionTemplate配置(可选)
@Bean
public SqlSession session(@Autowired SqlSessionFactory sessionFactory) {
return new SqlSessionTemplate(sessionFactory);
}
Mapper接口
正常编写。
Mapper xml配置文件
正常编写。
jdbc参数配置
jdbc.properties配置文件：
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis_source_analysis
username=root
password=123456
druid.proxyFilters=stat
druid.maxActive=20
druid.initialSize=1
druid.maxWait=60000
druid.minIdle=1
druid.timeBetweenEvictionRunsMillis=60000
druid.minEvictableIdleTimeMillis=300000
druid.validationQuery=SELECT 1 FROM DUAL
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
druid.poolPreparedStatements=true
druid.maxOpenPreparedStatements=20
druid.defaultAutoCommit=false
测试代码
public class BlogMapper3Test {
private BlogMapper blogMapper;
@Before
public void before() {
// 创建ApplicationContext
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(MybatisConfig.class);
// 获取mapper对象
this.blogMapper = applicationContext.getBean(BlogMapper.class);
}
@Test
public void testInsertBlog() {
Blog blog = new Blog();
blog.setTitle("spring学习");
blog.setContent("spring深入 - 源码分析");
int rows = this.blogMapper.insertBlog(blog);
System.out.println(rows);
System.out.println(blog.getId());
}
@Test
public void testSelectBlogById() {
Blog blog = this.blogMapper.selectBlogById(1);
System.out.println(blog);
}
@Test
public void testSelectBlogByBlogSearchParameter() throws ParseException {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
List<Integer> ids = new ArrayList<>();
ids.add(1);
ids.add(2);
Blog blog = new Blog();
blog.setContent("mybatis源码分析");
blog.setTitle("mybatis");
BlogSearchParameter parameter = new BlogSearchParameter();
parameter.setId(1);
parameter.setIds(ids);
parameter.setCreateTime(format.parse("2020-01-01 00:00:00"));
parameter.setBlog(blog);
List<Blog> list = this.blogMapper.selectBlogByParameter(parameter);
for (Blog b : list) {
System.out.println(b);
}
}
}
重点分析的内容
- @MapperScan注解扫描Mapper接口的原理
- 插件注册的原理
- 与独立运行时的不同点
SqlSessionFactoryBean类
这个类实现了FactoryBean接口，是spring工厂模式获取bean的方式，使用getObject()方法获取bean并放入bean factory中。
FactoryBean接口：
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}
SqlSessionFactoryBean类提供了绝大多数mybatis配置的入口。
可以配置数据源：
sessionFactoryBean.setDataSource(dataSource);
可以配置mapper xml配置路径：
sessionFactoryBean.setMapperLocations(new ClassPathResource("mapper/BlogMapper.xml"));
可以配置主配置文件路径：
void setConfigLocation(Resource configLocation);
可以配置枚举类型处理器：
void setDefaultEnumTypeHandler(Class<? extends TypeHandler> defaultEnumTypeHandler);
可以配置插件：
void setPlugins(Interceptor... plugins);
可以配置事务管理器：
void setTransactionFactory(TransactionFactory transactionFactory);
可以配置别名：
void setTypeAliases(Class<?>... typeAliases);
void setTypeAliasesPackage(String typeAliasesPackage);
可以配置类型处理器：
void setTypeHandlers(TypeHandler<?>... typeHandlers);
SqlSessionTemplate类
实现SqlSession接口，内部维护着一个SqlSessionFactory对象和一个SqlSession的代理对象，所有的SQL执行都是使用这个SqlSession代理对象来做的。
构造方法
看一下构造方法：
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) {
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator;
// 这里创建了一个SqlSession的代理
// 代理逻辑在SqlSessionInterceptor中
// SqlSessionInterceptor是SqlSessionTemplate的内部类，可以访问SqlSessionTemplate的所有成员
this.sqlSessionProxy = (SqlSession) newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class }, new SqlSessionInterceptor());
}
SqlSessionInterceptor类
前面已经说明，SqlSessionInterceptor实现了SqlSessionTemplate的sqlSessionProxy的代理逻辑，看一下invoke代码：
private class SqlSessionInterceptor implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 为了解决DefaultSqlSession的非线程安全问题
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 #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) {
closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
}
}
}
}
// Checks if SqlSession passed as an argument is managed by Spring TransactionSynchronizationManager
// If it is not, it closes it, otherwise it just updates the reference counter and lets Spring call
// the close callback when the managed transaction ends
public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
if ((holder != null) && (holder.getSqlSession() == session)) {
holder.released();
} else {
session.close();
}
}
// SqlSessionUtils.getSqlSession(SqlSessionFactory, ExecutorType, PersistenceExceptionTranslator)
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory,
ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator) {
// TransactionSynchronizationManager类:
// Central delegate that manages resources and transaction synchronizations per thread.
// To be used by resource management code but not by typical application code.
// 这是spring-tx提供的一个工具类，用于管理资源和事务的同步
// 底层使用ThreadLocal实现
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
// 获取当前线程上的SqlSession
// 第一次执行是没有的
SqlSession session = sessionHolder(executorType, holder);
if (session != null) {
return session;
}
// 如果没有就open一个，内部代码已经分析过
// 返回的是一个DefaultSqlSession对象
session = sessionFactory.openSession(executorType);
// 注册到当前线程上
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
return session;
}
// 这里记录一下openSession方法，因为此时使用的事务管理器和之前不同，其余内容都一样
private SqlSession openSessionFromDataSource(
ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
// 这里使用的是SpringManagedTransactionFactory类型
// 此处涉及到spring的事务管理，后续深入分析补充
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
final Executor executor = configuration.newExecutor(tx, execType);
return new DefaultSqlSession(configuration, executor, autoCommit);
} catch (Exception e) {
closeTransaction(tx); // may have fetched a connection so lets call close()
throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
@MapperScan注解扫描原理
之前的 Autowired注入Service变成了biaomidou的Mapper代理 一文的 MapperScan注解 章节对此问题做过详细分析，此处不再做分析。
https://blog.csdn.net/xuguofeng2016/article/details/120515536
执行SQL查询的流程
MapperFactoryBean类和FactoryBean接口
FactoryBean接口是spring工厂模式创建bean的方式，spring在创建完FactoryBean的实现类对象后，会调用getObject()方法来获取真正的bean对象，然后将这个对象放入factory中：
public interface FactoryBean<T> {
// 使用这个方法获取bean对象
T getObject() throws Exception;
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}
看一下MapperFactoryBean的getObject()方法：
public T getObject() throws Exception {
// 获取到SqlSession成员变量，用他来getMapper
// this.mapperInterface也是成员变量，就是我们的mapper接口
return getSqlSession().getMapper(this.mapperInterface);
}
getSqlSession()获取到的是MapperFactoryBean持有的sqlSessionTemplate对象，这个是spring帮忙注入进来的。
getMapper(Class)流程
入口在SqlSessionTemplate.getMapper(Class)中：
public <T> T getMapper(Class<T> type) {
return getConfiguration().getMapper(type, this);
}
进入到Configuration.getMapper()方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
进入到MapperRegistry.getMapper()方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
这段代码在 mybatis源码分析_mapper接口源码分析 一文中看到过，内部的逻辑不再分析，不过这里有一个问题，knownMappers是什么时候put元素的？
knownMappers的初始化
在 mybatis源码分析_mapper接口源码分析 一文中，我们了解到XMLMapperBuilder.parse方法调用bindMapperForNamespace()方法，最后会调用MapperRegistry的addMapper(Class)方法将mapper接口的方法转为Statement保存到Configuration中。
在spring环境中是如何处理的？
还是要回到SqlSessionFactoryBean的getObject()方法，我们之前分析过这个类，但是没有展开分析getObject()方法，此处看一下这个方法：
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
afterPropertiesSet();
}
return this.sqlSessionFactory;
}
public void afterPropertiesSet() throws Exception {
this.sqlSessionFactory = buildSqlSessionFactory();
}
protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
final Configuration targetConfiguration;
XMLConfigBuilder xmlConfigBuilder = null;
// 读取configuration配置，是null分支进不来
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) {
// 从配置的主配置文件路径解析配置，是null分支进不来
xmlConfigBuilder =
new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
targetConfiguration = xmlConfigBuilder.getConfiguration();
} else {
targetConfiguration = new Configuration();
Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
}
Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);
// 别名包配置解析，略
if (hasLength(this.typeAliasesPackage)) {
scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()
.filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())
.filter(clazz -> !clazz.isMemberClass())
.forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
}
// 类型别名配置解析，略
if (!isEmpty(this.typeAliases)) {
Stream.of(this.typeAliases).forEach(typeAlias -> {
targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
});
}
// 插件在这里，代码比较熟悉
if (!isEmpty(this.plugins)) {
Stream.of(this.plugins).forEach(plugin -> {
targetConfiguration.addInterceptor(plugin);
});
}
// 解析类型处理器
if (hasLength(this.typeHandlersPackage)) {
scanClasses(this.typeHandlersPackage, TypeHandler.class)
.stream().filter(clazz -> !clazz.isAnonymousClass())
.filter(clazz -> !clazz.isInterface())
.filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))
.forEach(targetConfiguration.getTypeHandlerRegistry()::register);
}
// 解析类型处理器
if (!isEmpty(this.typeHandlers)) {
Stream.of(this.typeHandlers).forEach(typeHandler -> {
targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
});
}
// 默认的枚举类型处理器
targetConfiguration.setDefaultEnumTypeHandler(defaultEnumTypeHandler);
// 脚本
if (!isEmpty(this.scriptingLanguageDrivers)) {
Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {
targetConfiguration.getLanguageRegistry().register(languageDriver);
});
}
Optional.ofNullable(this.defaultScriptingLanguageDriver)
.ifPresent(targetConfiguration::setDefaultScriptingLanguage);
if (this.databaseIdProvider != null) {
try {
targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
} catch (SQLException e) {
throw new NestedIOException("Failed getting a databaseId", e);
}
}
Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);
// 分支进不来
if (xmlConfigBuilder != null) {
try {
xmlConfigBuilder.parse();
} catch (Exception ex) {
throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
} finally {
ErrorContext.instance().reset();
}
}
targetConfiguration.setEnvironment(new Environment(this.environment,
this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,
this.dataSource));
// 这里是重点
// 这里在解析mapper xml配置文件
// 就是之前使用setMapperLocations(...)方法配置的
if (this.mapperLocations != null) {
if (this.mapperLocations.length == 0) {
// ...
} else {
for (Resource mapperLocation : this.mapperLocations) {
try {
// 这里就比较熟悉了
XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
// 这里调用parse()方法
// 这样就和之前的分析连上了
// OK
xmlMapperBuilder.parse();
} catch (Exception e) {
throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
} finally {
ErrorContext.instance().reset();
}
}
}
} else {
// ...
}
return this.sqlSessionFactoryBuilder.build(targetConfiguration);
}
查询流程
和 mybatis源码分析_mapper接口源码分析 一文中的分析基本一致，只是最后使用的是SqlSessionTemplate的方法，而不是DefaultSqlSession的方法，而SqlSessionTemplate内部又是使用一个SqlSession代理做的，代理的实现逻辑在SqlSessionInterceptor类中，前文做过分析，此处不再记录。
3194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
