插件Interceptor
- 拦截器实现:实现Interceptor接口,完成拦截器功能。
- 被拦截对象标记:@Intercepts+@Signature注解定义被拦截对象以及对应需要拦截的方法。(用在拦截器上)
- 拦截器链绑定:InterceptorChain封装了所有拦截器,并为被拦截对象创建代理或者其他处理逻辑。
- 拦截:代理对象Plugin.invoke拦截,调用拦截器的intercept方法。
0、MyBatis支持的拦截点
- Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
- ParameterHandler (getParameterObject, setParameters)
- ResultSetHandler (handleResultSets, handleOutputParameters)
- StatementHandler (prepare, parameterize, batch, update, query)
1、拦截器实现
- Interceptor接口
//NOTE: 插件 拦截器
public interface Interceptor {
/**
* 拦截 逻辑处理
* @param invocation
*/
Object intercept(Invocation invocation) throws Throwable;
/**
* 拦截器绑定
* @param target 被拦截目标对象
*/
Object plugin(Object target);
/**
* 属性添加
*/
void setProperties(Properties properties);
}
- 比如对Executor的query接口进行拦截
@Intercepts(
@Signature(
type = Executor.class,
method="query",
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}
)
)
public class ExamplePlugin implements Interceptor {
......
}
- 配置:定义好拦截器后,好需要将拦截器添加到配置文件中,在初始化MyBatis时会自动加载。
- 触发过程:先通过 DefaultSqlSessionFactory 创建 SqlSession 。Executor 实例会在创建 SqlSession 的过程中被创建,Executor 实例创建完毕后,MyBatis 会通过 JDK 动态代理为实例生成代理类。这样,插件逻辑即可在 Executor 相关方法被调用前执行。
1.1、拦截器绑定
以Executor为例,分析拦截器是如何绑定在Executor上的?Executor实例是在开启SqlSession时被创建的:
//☆☆-DefaultSqlSessionFactory
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
......
//NOTE: 获取Executor对象
final Executor executor = configuration.newExecutor(tx, execType);
return new DefaultSqlSession(configuration, executor, autoCommit);
}
}
Executor 的创建过程封装在 Configuration 中,
//☆☆-Configuration
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
......
//拦截器绑定
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
创建好Executor后,通过拦截器链 interceptorChain
为 Executor 实例绑定拦截代理逻辑。
//☆☆InterceptorChain
public class InterceptorChain {
private final List<Interceptor> interceptors = new ArrayList<>();
public Object pluginAll(Object target) {
//遍历拦截器集合,调用拦截器的 plugin 方法植入相应的插件逻辑
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
//添加拦截器:通过解析配置文件的<plugins/>节点
public void addInterceptor(Interceptor interceptor) {
interceptors.add(interceptor);
}
public List<Interceptor> getInterceptors() {
return Collections.unmodifiableList(interceptors);
}
}
通过interceptor.plugin
方法对target对象包裹一层层代理类,当在执行Executor时,执行顺序由外到内,如plugin2->plugin1->Executor。
interceptor.plugin
方法只是过度,实际生成代理是调用Plugin.wrap()
方法实现的。Plugin
类实现了InvocationHandler
接口,因此它可以作为参数传给 Proxy 的 newProxyInstance 方法。
//☆☆--ExamplePlugin
@Intercepts(
@Signature(type = Executor.class, method="query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
)
public class ExamplePlugin implements Interceptor {
@Override
public Object plugin(Object target) {
//调用Plugin.wrap方法
return Plugin.wrap(target, this);
}
}
//☆☆--Plugin
public static Object wrap(Object target, Interceptor interceptor) {
//NOTE: 获取拦截器上定义的被拦截类和具体的方法签名信息
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
//NOTE: 被拦截类
Class<?> type = target.getClass();
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
//NOTE: JDK创建动态代理
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
1.2、拦截器执行
为每个被拦截对象绑定拦截器后,运行过程中的“对象”其实是一个代理,当发起方法调用时,会先触发拦截器内部逻辑,再调用被拦截对象的逻辑。
- 拦截器的逻辑在
Plugin
类中,其实现InvocationHandler
接口。- 先获取目标类是否被@Intercepts、@Signature注解,有则走拦截器逻辑;否则执行被拦截方法。
//☆☆--Plugin
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//NOTE: 获取当前方法所在类或者接口中,可被放弃Interceptor拦截的方法
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
//NOTE: 对应方法被拦截,则调用interceptor.intercept
return interceptor.intercept(new Invocation(target, method, args));
}
//NOTE: 没有则直接走原始的方法
return method.invoke(target, args);
} catch (Exception e) {
......
}
}
Invocation
类用于封装目标类并提供一个在执行完拦截器逻辑后,回归到目标类的被拦截方法。
//☆☆--Invocation
public class Invocation {
private final Object target;
private final Method method;
private final Object[] args;
public Invocation(Object target, Method method, Object[] args) {
this.target = target;
this.method = method;
this.args = args;
}
......
public Object proceed() throws InvocationTargetException, IllegalAccessException {
//调用被拦截的方法,一般都是在执行完interceptor.intercept后,被调用
return method.invoke(target, args);
}
}
2、实现一个分页插件
实现一个插件,也就是实现Interceptor
接口,具体逻辑在intercept(...)
方法中。
/**
* NOTE: 执行拦截逻辑
* 1、通过RowBounds获取分页参数
* 2、修改MappedStatement的BoundSql,增加limit 分页
* 3、调用执行方法
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
Object[] args = invocation.getArgs();
//获取query方法中的RowBounds参数
RowBounds rowBounds = (RowBounds) args[2];
if (rowBounds.equals(RowBounds.DEFAULT)) {
// 无需分页
return invocation.proceed();
}
//将原 RowBounds 参数设为 RowBounds.DEFAULT,关闭 MyBatis 内置的分页机制
args[2] = RowBounds.DEFAULT;
//获取query方法中的MappedStatement参数和传入参数
MappedStatement mappedStatements = (MappedStatement) args[0];
Object params = args[1];
BoundSql boundSql = mappedStatements.getBoundSql(params);
//获取Sql并增加分页limit
String sql = boundSql.getSql();
String limit = String.format("limit %s, %s", rowBounds.getOffset(), rowBounds.getLimit());
sql = sql + " " + limit;
//将新的sql重新塞会MappedStatement -- SqlSource
SqlSource sqlSource = new StaticSqlSource(mappedStatements.getConfiguration(), sql, boundSql.getParameterMappings());
//☆☆-重置MappedStatement的sqlSource
// 方式1:通过反射获取并设置 MappedStatement 的 sqlSource 字段
Field field = MappedStatement.class.getDeclaredField("sqlSource");
field.setAccessible(true);
field.set(mappedStatements, sqlSource);
//方式2:通过MyBatis内部的反射模块实现
MetaObject metaObject = SystemMetaObject.forObject(mappedStatements);
metaObject.setValue("sqlSource", sqlSource);
//调用被拦截方法
return invocation.proceed();
}
通过获取Executor.query方法的三个参数,对SQL执行的所有信息进行修改,主要思路:
- 获取RowBounds参数,获取分页的信息,若配置不需要分页
RowBounds.DEFAULT
,则直接调用被拦截方法,否则将传入的RowBounds设置为RowBounds.DEFAULT
来关闭MyBatis内置的分页机制; - 获取MappedStatement参数以及BoundSql,得到原生的sql语句,再集合RowBounds参数拼接处新的sql语句;
- 重新创建SqlSource并通过反射重置MappedStatement的sqlSource属性,完成插件逻辑。