文章目录
我们在Springboot中使用mybatis时只需要简单的几个配置就可以了:
1、在pom文件中引入mybatis的starter
2、配置数据库连接池
3、在Springboot配置文件里配置mybatis相关参数
4、编写自己的dao以及mapper配置文件
那么在我们Spring项目里注入dao并进行CRUD时,mybatis是怎么被Springboot加载以及怎么执行jdbc操作的?这里先贴出配置:
- 配置datasource,比如用druid链接池配置
spring:
datasource:
#druid相关配置
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
#配置数据库连接
druid:
url: jdbc:mysql://localhost:3306/test-db?useUnicode=true&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
username: root
password: 123456
initial-size: 10
max-active: 100
min-idle: 10
max-wait: 60000
pool-prepared-statements: true
max-pool-prepared-statement-per-connection-size: 20
time-between-eviction-runs-millis: 60000
min-evictable-idle-time-millis: 300000
validation-query: SELECT 1 FROM DUAL
test-while-idle: true
test-on-borrow: false
test-on-return: false
connectionInitSqls: set names utf8mb4
- 配置mybatis参数,指定mapper文件路径
mybatis:
mapper-locations: classpath:mapper/*.xml
- 按业务需要定义dao接口,并加上
@Mapper
注解
@Mapper
public interface UserInfoDao {
int insert(UserInfoDO userInfoDO)
UserInfoDO getById(long id);
int update(UserInfoDO userInfoDO);
int delete(long id);
}
- 配置mapper文件,写好sql与dao接口的映射关系,其中
namespace
是对应的dao接口完整类名
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.hj.dao.UserInfoDao">
<resultMap id="BaseResultMap" type="com.hj.DO.UserInfoDO">
<id column="id" property="id"/>
<result column="userId" property="userId"/>
<result column="name" property="name"/>
</resultMap>
<insert id="insert" parameterType="com.hhdd.DO.UserInfoDO">
insert ...
</insert>
<select id="getById" resultMap="BaseResultMap" parameterType="java.lang.Long">
select ...
</select>
<update id="update" parameterType="com.hj.DO.UserInfoDO">
update ...
</update>
<delete id="delete">
delete ...
</delete>
</mapper>
加载过程
1、读取META-INF/spring.factories
配置文件里需要自动装载的类
mybatis-spring-boot-starter
依赖的作用实际是提供一个pom文件,该pom文件内有mybatis
需要的所有依赖,其中比较重要的有mybatis-spring-boot-autoconfigure
,如下图:
在mybatis-spring-boot-autoconfigure
这个包内包含META-INF/spring.factories
配置文件,Springboot就是通过该配置文件内定义的启动类来拉起mybatis的,如下图:
而Springboot触发读取这个配置文件的逻辑在@EnableAutoConfiguration
注解上@Import
注解引入的AutoConfigurationImportSelector.class
类的selectImports
方法里,有兴趣的可以在这个方法里打个断点debug下流程。
2、解析MybatisAutoConfiguration
类里的注解信息,将需要管理的Bean注册到Spring容器
在《Springboot之Bean的加载过程》中讲到将类解析成BeanDefinition
并最终实例化成Bean的过程,这里会向Spring容器注册几个重要的类:
2.1 注册SqlSessionFactory
,并根据mapper配置文件解析出dao与具体jdbc操作、resultMap与实体类等的映射关系
代码如下:
@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
factory.setDataSource(dataSource);
factory.setVfs(SpringBootVFS.class);
if (StringUtils.hasText(this.properties.getConfigLocation())) {
factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
}
Configuration configuration = this.properties.getConfiguration();
if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
configuration = new Configuration();
}
if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
customizer.customize(configuration);
}
}
factory.setConfiguration(configuration);
...
if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
factory.setMapperLocations(this.properties.resolveMapperLocations());
}
return factory.getObject();
}
SqlSessionFactory
的实例化是通过SqlSessionFactoryBean.getObject()
实现的,该类会被注入DataSource
对象(负责管理数据库连接池,Session指的是一次会话,而这个会话是在DataSource
提供的Connection
上进行的),SqlSessionFactory.getObject()
方法里会根据我们mybatis相关配置(比如上面的mybatis.mapper-locations配置)找到并解析我们的mapper文件,解析出sql与dao方法里的映射、ResultMap与具体实体类的映射等,并放到SqlSessionFactory
的Configuration
中缓存下来,在后续调用过程中会通过这些信息来匹配jdbc操作。
2.2 注册实现了CRUD操作的SqlSessionTemplate
类
该类实现了我们常用的CRUD操作,在执行CRUD时,会通过SqlSessionFactory
对象获取Session来操作,所以会持有SqlSessionFactory
对象
@Bean
@ConditionalOnMissingBean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
ExecutorType executorType = this.properties.getExecutorType();
if (executorType != null) {
return new SqlSessionTemplate(sqlSessionFactory, executorType);
} else {
return new SqlSessionTemplate(sqlSessionFactory);
}
}
2.3 注册AutoConfiguredMapperScannerRegistrar
类来扫描被@Mapper
标注的类
该类负责遍历被@Mapper标注的类,并将这些扫描到的类解析成BeanDefinition
注册到Spring容器中,核心逻辑在registerBeanDefinitions
中,需要注意的一点是,在扫描到被@Mapper标注的类时,会将这些类解析成beanClass为MapperFactoryBean
的BeanDefinition,同时会告知Spring容器在将这个BeanDefinition
实例化成Bean时,需要注入SqlSessionFactory
和SqlSessionTemplate
对象,截图如下:
从这里可以看出我们在代码中注入的dao实际上是一个动态代理类,由MapperFactoryBean
这个FactoryBean
的getObject()
方法生成
3 在注入dao时,触发该dao对应的MapperFactoryBean.getObject()
方法来注入动态代理类
MapperFactoryBean.getObject()
逻辑由BeanFactory的getBean(string beanName)
触发,getObject()
代码如下:
public T getObject() throws Exception {
return this.getSqlSession().getMapper(this.mapperInterface);
}
getSqlSession()
获取的是SqlSessionTemplate
对象,this.mapperInterface
就是我们的dao层接口,比如开头demo里的被@Mapper
标注的UserInfoDao
,最终会通过MapperProxyFactory
来生成动态代理类,代码如下:
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
这里的参数SqlSession
就是SqlSessionTemplate
对象,可以看出是通过基于接口的JDK的Proxy来生成动态代理,在我们代码中进行CRUD时候,最后都会通过MapperProxy
类(该类实现了InvocationHandler接口)的invoke(Object proxy, Method method, Object[] args)
方法来处理.
调用过程
通过上面的加载过程,我们了解到最后注入到业务代码的是一个动态代理类,我们再看下这个动态代理类的调用过程,主要逻辑在MapperProxy
类(该类实现了InvocationHandler接口)的invoke(Object proxy, Method method, Object[] args)
方法,我这里以select请求为例,代码如下:
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
SqlSessionTemplate
在加载阶段会根据配置的mapper文件解析出对应的映射关系,并封装好元数据信息(包括需要执行的sql、返回类型等),而MapperMethod
的构造器被调用时会通过SqlSessionTemplate
里的映射关系拿到这些元数据信息并封装成SqlCommand
对象,在执行jdbc操作时会通过SqlCommand
来获取jdbc信息来执行后续逻辑,debug截图如下:
最终通过SqlSessionTemplate
类来实现jdbc操作,debug图如下:
而sqlSession.selectOne
方法会调用到SqlSessionTemplate
的内部类SqlSessionInterceptor.invoke(Object proxy, Method method, Object[] args)
方法里,主要逻辑如下:
-
通过
SqlSessionFactory
从DataSource
连接池中获取sqlSession
,这里会先从一个ThreadLocal
中获取,因为开启了事务的话,sqlSession
会通过ThreadLocal
来传递,如果没有开启事务,则从连接池中获取新的Session -
通过反射来调用获取到的
sqlSession
对象(这里获取到的是DefaultSqlSession
)的selectList
方法 -
以dao的接口名+方法名为key获取之前解析到的元数据信息,包括对应的sql、返回类型等,debug截图如下:
-
通过四大组件之一的Executor的实现类
CachingExecutor
类(因为mybatis默认开启缓存,所以会使用这个实现类)来执行jdbc操作,该类封装了cache相关操作,先解析出该方法需要执行的sql,debug图如下:
这里会首先去查询是否开启了二级缓存(需要在mapper文件里家在<cache/>配置,二级缓存是namespace粒度的),如果开启了缓存,则会直接从缓存中查询,debug图如下:
然后会查询一级缓存(session粒度),如果没有命中缓存则继续后续操作,debug图如下:
-
通过四大组件之一的statementHandler的实现类
RoutingStatementHandler
类来执行CRUD操作,这个类主要是封装类,不提供具体的实现,只是根据Executor的类型,创建不同的类型StatementHandler,默认创建带有预编译功能的PreparedStatementHandler
类,debug图如下:
-
通过四大组件之一的ParameterHandler来拼接sql中的参数,debug图如下:
-
通过四大组件之一的ResultSetHandler来处理返回值,将数据库返回值绑定到对应的实体类,debug图如下:
-
处理缓存信息、释放资源等逻辑