在之前笔记,我们有介绍到了 MyBatis 的基本使用。接下来我们来介绍一下 MyBatis 中为我们提供的高级功能 ---- MyBatis 插件机制
。凡是使用过 MyBatis 的你,肯定都用到过这个 PageHelper 分页插件,如果你对 PageHelper 还不了解,你可以点击链接进去了解一下哈,很简单的。
此处说到了 MyBatis 的插件,那么我们就从原理来对 MyBatis 的插件机制进行了解。MyBatis 插件原理:是通过 JDK 动态代理来实现的。
1.JDK 动态代理
代理模式,作为一种常用的设计模式如果你对代理模式还不太了解,请跳转博主【Java设计模式-----代理模式】进行了解,此处不作介绍。
2.MyBatis 插件使用步骤
此处以 PageHelper 插件来介绍。你也可以进入 PageHelper官网 来了解,此处做一些简单的介绍。
2.1 Maven 添加 PageHelper 依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>最新版本</version>
</dependency>
2.2 配置拦截器插件
在 mybatis-config.xml 核心配置文件中进行注册。
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<!-- 一些参数配置 -->
</plugin>
</plugins>
2.3 分页插件的使用
通过 PageHelper.startPage() 方法,设置 page 和 pageSize,即可使用。(此处未整合 Spring)
@Test
public void testSelect() throws Exception {
//配置文件所在路径
String resource = "mybatis/mybatis-config.xml";
//读取MyBatis配置文件,转换成InputStream
InputStream readerStream = Resources.getResourceAsStream(resource);
//创建一个SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(readerStream);
//创建一个SqlSession会话
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
//使用 PageHelper 进行物理分页
PageHelper.startPage(2, 2);
//使用getMapper()方法,执行操作。MyBatis 定义了一个 getMapper() 方法,用来解决框架初期的硬编码问题,
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> users = userMapper.selectAllUser();
for (User user : users) {
System.out.println(user);
}
} finally {
sqlSession.close();
}
}
3.MyBatis 插件源码分析
【此处占位 MyBatis笔记(三):MyBatis 源码分析】
3.1 第一步
我们对 MyBatis 源码分析,了解到在创建 sqlSession 会话的过程中,会对 mybatis-config.xml 核心配置中的所有信息进行解析,并将结果存储在一个 Configuration 对象中。
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
//对配置信息进行解析
parseConfiguration(parser.evalNode("/configuration"));
//返回 Configuration 对象
return configuration;
}
//所有标签解析过程
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
typeAliasesElement(root.evalNode("typeAliases"));
pluginElement(root.evalNode("plugins"));
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
typeHandlerElement(root.evalNode("typeHandlers"));
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
3.2 第二步
此处来分析一下<plugins>
的解析过程,我们来进入到 pluginElement()
来进行了解。
private void pluginElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
//1.此处会读取到核心配置文件中配置的interceptor属性对应的类(如 2.2 中)
String interceptor = child.getStringAttribute("interceptor");
//2.获取到<plugin>下配置的参数信息(2.2中未配置参数)
Properties properties = child.getChildrenAsProperties();
//3.将读取到的类,强转成一个 Interceptor(因为MyBatis插件都必须实现预留的 Interceptor 接口,此处强转不会出错)
Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
//4.对属性进行设置
interceptorInstance.setProperties(properties);
//5.最后,将所有配置都存储到 Configuration 这个类中
configuration.addInterceptor(interceptorInstance);
//6.继续对 addInterceptor() 方法进行分析(继续向下走)
}
}
}
addInterceptor()
public void addInterceptor(Interceptor interceptor) {
//接上:会将所有的组件类名,放置到叫做 interceptorChain 的容器中。
//(此处你记住有这个 interceptorChain 就行了,它是一个 List 类型)
interceptorChain.addInterceptor(interceptor);
}
3.3 第三步
前2步,已经成功创建 SqlSessionFactory
,接下来我们就使用
了解一下 插件在创建 session 会话的过程中,又做了哪些操作。sqlSessionFactory.openSession()来创建一个 sqlSession 会话。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//1.在 openSession()阶段,有创建一个 Executor 执行器
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();
}
}
newExecutor()
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Executor executor;
if (ExecutorType.BATCH == executorType) {
executor = new BatchExecutor(this, transaction);
} else if (ExecutorType.REUSE == executorType) {
executor = new ReuseExecutor(this, transaction);
} else {
executor = new SimpleExecutor(this, transaction);
}
if (cacheEnabled) {
executor = new CachingExecutor(executor);
}
//2.在此处,它通过 pluginAll()方法来加载我们放在 interceptorChain 中的所有组件(步骤3.2中)
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
pluginAll()
public Object pluginAll(Object target) {
//3.此处通过遍历的形式,拿到所有实现了 Interceptor 接口的拦截器(即:MyBatis组件)
for (Interceptor interceptor : interceptors) {
//4.此处,我们以 PageInterceptor 为例
target = interceptor.plugin(target);
}
return target;
}
plugin() & wrap() 方法
public Object plugin(Object target) {
//5.此处 Plugin 类,是 MyBatis 为我们提供的一个类。
//方便我们通过 Plugin.wrap() 的方式来创建一个代理类。接下来进入 wrap()方法分析
return Plugin.wrap(target, this);
}
public static Object wrap(Object target, Interceptor interceptor) {
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
Class<?> type = target.getClass();
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
//6.此处便是 JDK 动态代理的一段代码。到此处你便了解到了 MyBatis 组件的精髓
//它的原理:使用的就是 JDK动态代理机制
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
//7.Plugin 类便是被代理对象的委托类,之后想要调用被代理类的方法时,都会委托给这个类的invoke()方法
//Plugin()类有实现InvocationHandler哦。继续【第四步】分析向下看
new Plugin(target, interceptor, signatureMap));
}
return target;
}
3.4 第四步
既然是通过 JDK 动态代理 的方式实现的,接下来就是执行代理类 Plugin 类
中的invoke() 方法,继续向下分析。Go Go Go → →
//1.Plugin 类已实现 InvocationHandler 方法
public class Plugin implements InvocationHandler {
private Object target;
private Interceptor interceptor;
private Map<Class<?>, Set<Method>> signatureMap;
/**
* 省略部分代码,只留了 invoke() 方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
//此处,便会调用我们自定义的intercept()方法(此处以 PageHelper 分析)
//预留:此处 new Invocation(target, method, args) 类的分析
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
3.5 第五步
现在终于走到了 PageHelper 实现的拦截器,完成对 SQL 部分的操作。PageHelper 是我国的以为大神编写,向大神看起 Go Go Go
正常逻辑下:代理模式,仅仅是对方法的增强,在方法前后做一些操作,最终还是会执行到被代理类的原方法中。那么这个被代理类的原方法在哪呢??
在 PageHelper 中的 intercept 方法中,我们也并没有找到那个被代理类的原方法在哪
。因为 PageHelper 中它的实现方式和我们日常中使用到的有点不同。已经走到了 PageHelper 的具体增强实现,此处不再过多分析。注意一下这个:invocation.getTarget();就行了。我们继续向下走【第六步】
/**
* Mybatis - 通用分页拦截器<br/>
* 项目地址 : http://git.oschina.net/free/Mybatis_PageHelper
*
* @author liuzh/abel533/isea533
* @version 5.0.0
*/
@SuppressWarnings({"rawtypes", "unchecked"})
@Intercepts(
{
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
}
)
public class PageInterceptor implements Interceptor {
//缓存count查询的ms
protected Cache<CacheKey, MappedStatement> msCountMap = null;
private Dialect dialect;
private String default_dialect_class = "com.github.pagehelper.PageHelper";
private Field additionalParametersField;
@Override
public Object intercept(Invocation invocation) throws Throwable {
try {
Object[] args = invocation.getArgs();
MappedStatement ms = (MappedStatement) args[0];
Object parameter = args[1];
RowBounds rowBounds = (RowBounds) args[2];
ResultHandler resultHandler = (ResultHandler) args[3];
//注意此处!!!!!!!!
//此处 invocation.getTarget() 可以来获取被代理对象的一些方法等
//这个传过来的 invocation 对象,我们继续向下走【第六步】开始分析
Executor executor = (Executor) invocation.getTarget();
CacheKey cacheKey;
BoundSql boundSql;
//由于逻辑关系,只会进入一次
if(args.length == 4){
//4 个参数时
boundSql = ms.getBoundSql(parameter);
cacheKey = executor.createCacheKey(ms, parameter, rowBounds, boundSql);
} else {
//6 个参数时
cacheKey = (CacheKey) args[4];
boundSql = (BoundSql) args[5];
}
List resultList;
//调用方法判断是否需要进行分页,如果不需要,直接返回结果
if (!dialect.skip(ms, parameter, rowBounds)) {
//反射获取动态参数
Map<String, Object> additionalParameters = (Map<String, Object>) additionalParametersField.get(boundSql);
//判断是否需要进行 count 查询
if (dialect.beforeCount(ms, parameter, rowBounds)) {
//创建 count 查询的缓存 key
CacheKey countKey = executor.createCacheKey(ms, parameter, RowBounds.DEFAULT, boundSql);
countKey.update(MSUtils.COUNT);
MappedStatement countMs = msCountMap.get(countKey);
if (countMs == null) {
//根据当前的 ms 创建一个返回值为 Long 类型的 ms
countMs = MSUtils.newCountMappedStatement(ms);
msCountMap.put(countKey, countMs);
}
//调用方言获取 count sql
String countSql = dialect.getCountSql(ms, boundSql, parameter, rowBounds, countKey);
countKey.update(countSql);
BoundSql countBoundSql = new BoundSql(ms.getConfiguration(), countSql, boundSql.getParameterMappings(), parameter);
//当使用动态 SQL 时,可能会产生临时的参数,这些参数需要手动设置到新的 BoundSql 中
for (String key : additionalParameters.keySet()) {
countBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
}
//执行 count 查询
Object countResultList = executor.query(countMs, parameter, RowBounds.DEFAULT, resultHandler, countKey, countBoundSql);
Long count = (Long) ((List) countResultList).get(0);
//处理查询总数
//返回 true 时继续分页查询,false 时直接返回
if (!dialect.afterCount(count, parameter, rowBounds)) {
//当查询总数为 0 时,直接返回空的结果
return dialect.afterPage(new ArrayList(), parameter, rowBounds);
}
}
//判断是否需要进行分页查询
if (dialect.beforePage(ms, parameter, rowBounds)) {
//生成分页的缓存 key
CacheKey pageKey = cacheKey;
//处理参数对象
parameter = dialect.processParameterObject(ms, parameter, boundSql, pageKey);
//调用方言获取分页 sql
String pageSql = dialect.getPageSql(ms, boundSql, parameter, rowBounds, pageKey);
BoundSql pageBoundSql = new BoundSql(ms.getConfiguration(), pageSql, boundSql.getParameterMappings(), parameter);
//设置动态参数
for (String key : additionalParameters.keySet()) {
pageBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
}
//执行分页查询
resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, pageKey, pageBoundSql);
} else {
//不执行分页的情况下,也不执行内存分页
resultList = executor.query(ms, parameter, RowBounds.DEFAULT, resultHandler, cacheKey, boundSql);
}
} else {
//rowBounds用参数值,不使用分页插件处理时,仍然支持默认的内存分页
resultList = executor.query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
}
return dialect.afterPage(resultList, parameter, rowBounds);
} finally {
dialect.afterAll();
}
}
3.6 第六步
在 【3.4 第四步】中,我们还有预留一个 new Invocation(target, method, args)
类未做分析。这个 Invocation()类就是传入到 PageHelper 的 增强方法 intercept () 中的参数。这个参数是啥呢?我们来了解一下
/**
* @author Clinton Begin
*/
public class Invocation {
private Object target;
private Method method;
private Object[] args;
public Invocation(Object target, Method method, Object[] args) {
this.target = target;
this.method = method;
this.args = args;
}
public Object getTarget() {
return target;
}
public Method getMethod() {
return method;
}
public Object[] getArgs() {
return args;
}
public Object proceed() throws InvocationTargetException, IllegalAccessException {
//重点:
//此处,通过反射机制来调用被代理对象的原方法
return method.invoke(target, args);
}
}
在该类中,我们发现一个 proceed
方法。在该方法中,你看到什么重点东西了???method.invoke()
方法,这可是被代理类要执行的方法啊。
你还没看懂?那进入【JDK 动态代理】里面看看这个,你就了解了,如下图。
既然已经在自定义插件的 intrcept(Invocation invocation) 方法中传入了 这个参数,我们便能够通过invocation.proceed()
方法,直接调用被代理对象的原操作了。
至此,MyBatis插件源码分析结束
4.MyBatis 四大对象介绍
MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下,MyBatis 允许使用插件来拦截如下四大对象,以及这些对象对应的方法(来自官网的介绍)。具体如下:
Executor
(update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)ParameterHandler
(getParameterObject, setParameters)ResultSetHandler
(handleResultSets, handleOutputParameters)StatementHandler
(prepare, parameterize, batch, update, query)
以下为四个对象的解释,俗称 MyBatis 四大对象,均为接口。
- Executor:是 SqlSession 会话中的一个实例,用来执行对数据库的增删改查的操作,一个比较顶层的对象。
- ParameterHandler: SQL 语句组装的过程,在此过程拦截会用到 ParameterHandler 对象;
- ResultSetHandler:是处理结果集的过程。
- StatementHandler:是处理SQL语句预编译的过程
5.自定义MyBatis插件
我们来自定义一个 MyBatis 插件,用来统计每个 SQL 执行的时间。(可以用来统计慢 SQL 的执行,方便 SQL 的优化)
5.1 编写 SqlTimeInterceptor 插件类
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import java.sql.Statement;
import java.util.Properties;
/**
* 自定义的 MyBatis 组件类
* 1.用来获取执行的SQL语句
* 2.用来获取 SQL 执行时长
*/
@Intercepts(
@Signature(type = StatementHandler.class, method = "query",args = {Statement.class, ResultHandler.class})
)
public class SqlTimeInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
//开始时间
long startTime = System.currentTimeMillis();
//通过 invocation.getTarget() 可以获取被代理对象的一些方法等
StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
BoundSql boundSql = statementHandler.getBoundSql();
String sql = boundSql.getSql();
System.out.println("获取SQL语句:" + sql);
try {
return invocation.proceed();
} finally {
long endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println("SQL执行时间为:" + time + "ms");
}
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
//获取<plugins> 标签下参数配置
String prop = properties.getProperty("testProp");
System.out.println("获取到测试属性值:" + prop);
}
}
5.2 编写 SqlTimeInterceptor 插件类
将自定义的 MyBatis 组件,注册到 mybatis-config.xml 核心配置文件中,你也可以在该插件中设置插件中需要使用到的一些参数。
<plugins>
<plugin interceptor="com.springboot.plugins.SqlTimeInterceptor">
<property name="testProp" value="我是属性值"/>
</plugin>
</plugins>
5.3 代码中,不需要任何配置
PageHelper 中,需要配置PageHelper.startPage(2, 2);
,我们编写的这个,因为没有用到参数,可以不用在代码中作任何操作,便能够1.记录SQL 2.统计SQL执行时长
。我们使用本文 2.3 中代码 进行测试。将 PageHelper 插件 和我们编写的插件一起使用,测试结果如下所示。
18:38:12.172 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using 'class org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl' adapter.
获取到测试属性值:我是属性值
Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
Created connection 1210005556.
Returned connection 1210005556 to pool.
18:38:13.365 [main] DEBUG SQL_CACHE - Cache Hit Ratio [SQL_CACHE]: 0.0
Cache Hit Ratio [com.springboot.dao.UserMapper]: 0.0
Opening JDBC Connection
Checked out connection 1210005556 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@481f3834]
==> Preparing: SELECT count(0) FROM db_user
获取SQL语句:SELECT count(0) FROM db_user
==> Parameters:
<== Columns: count(0)
<== Row: 4
<== Total: 1
SQL执行时间为:18ms
Cache Hit Ratio [com.springboot.dao.UserMapper]: 0.0
==> Preparing: select * from db_user LIMIT 2,2
获取SQL语句:select * from db_user LIMIT 2,2
==> Parameters:
<== Columns: id, username, age, address
<== Row: 3, James, 31, 天津市南开区
<== Row: 4, Clark, 27, 重庆市渝中区
<== Total: 2
SQL执行时间为:3ms
User{id=3, username='James', age=31, address='天津市南开区'}
User{id=4, username='Clark', age=27, address='重庆市渝中区'}
MyBatis 插件原理分析 & 自定义插件,介绍到此为止
如果本文对你有所帮助,那就给我点个赞呗 ^ _ ^
End