[上一篇]：Mybatis源码解析之SqlSession来自何方
上一篇中我们知道了sqlSession是最后通调用sessionFactory.openSession(executorType)得到的，这里的sessionFactory为DefaultSqlSessionFactory。
在openSession(executorType)的时候还进行了本文主要讲的对拦截器处理的重要操作。
问题
在Mybatis源码解析之配置解析中看到了MyBatis将配置的plugins加入了Configuration里的interceptorChain里，那么这些plugins是如何执行生效的呢？
揭秘源码-答案
首先介绍对Executor进行拦截
@Override
public SqlSession openSession(ExecutorType execType) {
return openSessionFromDataSource(execType, null, false);
}
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);
//这里创建了一个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();
}
}
从上面代码看到在获取sqlSession时，创建了一个Executor并让sqlSession持有，因为我们关心如何MyBatis如何对Executor进行拦截的，所以先看Configuration中创建Executor的地方。
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);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
首先，根据ExecutorType创建了不同类型的Executor(默认的执行器SIMPLE、执行器重用REUSE、执行器重用语句批量更新BATCH)。
在倒数第二行看到了调用了Interceptor链中的pluginAll方法，传入的是executor
/**
* @author Clinton Begin
*/
public class InterceptorChain {
private final List interceptors = new ArrayList();
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
public void addInterceptor(Interceptor interceptor) {
interceptors.add(interceptor);
}
public List getInterceptors() {
return Collections.unmodifiableList(interceptors);
}
}
pluginAll方法依次调用了配置的interceptor的plugin方法，传入的是executor，以MyBatis实现的PageInterceptor为例，看下plugin方法，发现关键的最后一行Plugin.wrap(o, this);注意传入的是executor与Interceptor本身
PageInterceptor部分源码
public Object plugin(Object o) {
try {
this.additionalParametersField = BoundSql.class.getDeclaredField("additionalParameters");
this.additionalParametersField.setAccessible(true);
} catch (NoSuchFieldException var3) {
throw new RuntimeException("Mybatis BoundSql版本问题，不存在additionalParameters", var3);
}
return Plugin.wrap(o, this);
}
再看下Plugin下的源码
public class Plugin implements InvocationHandler {
private Object target;
private Interceptor interceptor;
private Map, Set> signatureMap;
private Plugin(Object target, Interceptor interceptor, Map, Set> signatureMap) {
this.target = target;
this.interceptor = interceptor;
this.signatureMap = signatureMap;
}
public static Object wrap(Object target, Interceptor interceptor) {
//首先会获取interceptor上的注解
Map, Set> signatureMap = getSignatureMap(interceptor);
Class type = target.getClass();
//获取需要拦截类的所有接口方法
Class[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
//进行代理
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
private static Map, Set> getSignatureMap(Interceptor interceptor) {
Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
// issue #251
if (interceptsAnnotation == null) {
throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
}
Signature[] sigs = interceptsAnnotation.value();
Map, Set> signatureMap = new HashMap, Set>();
for (Signature sig : sigs) {
Set methods = signatureMap.get(sig.type());
if (methods == null) {
methods = new HashSet();
signatureMap.put(sig.type(), methods);
}
try {
Method method = sig.type().getMethod(sig.method(), sig.args());
methods.add(method);
} catch (NoSuchMethodException e) {
throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
}
}
return signatureMap;
}
private static Class[] getAllInterfaces(Class type, Map, Set> signatureMap) {
Set> interfaces = new HashSet>();
while (type != null) {
for (Class c : type.getInterfaces()) {
if (signatureMap.containsKey(c)) {
interfaces.add(c);
}
}
type = type.getSuperclass();
}
return interfaces.toArray(new Class[interfaces.size()]);
}
}
wrap方法
1.首先会获取interceptor上的注解
2.再获取需要拦截的接口里的所有接口方法，（如下：PageInterceptor上的注解，signatureMap里只包含一个key为Executor.class，值是set
@Intercepts({ @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
RowBounds.class, ResultHandler.class }) })
3.最后使用JDK动态代理对Executor接口里的所有方法进行了代Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));）
这个动态代理的handler就是Plugin，所以当对数据库进行操作，调用Executor里的方法时，都会调用Plugin的invoke方法。
invoke()
1.首先通过调用的方法所在类获取了需要被interceptor拦截的方法有哪些
2.如果包含了该方法就调用拦截器的intercept进行处理
3.最后调用实际方法
就是这样就让一个对Executor的拦截器生效了。
如果有多个拦截器，由于在InterceptorChain 的源码pluginAll(Object object)通过for循环调用，每次返回的是对传入对象的jdk动态代理，然后又将代理对象传入，依次下去，这样就将Excutor对象包装了一层一层的Interceptor，在调用的时候，也会一层一层调用invoke方法，只有被拦截的方法才会进入interceptor的intercept()方法。
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
我们看到将对Executor的拦截器加入是在Configuration.newExecutor,对以下三种类型也是在Configuration中
对StatementHandler进行拦截
对ParameterHandler进行拦截
对ResultSetHandler进行拦截
贴出源码
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
return parameterHandler;
}
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
ResultHandler resultHandler, BoundSql boundSql) {
ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
当Executor执行相关操作时会调用具体Executor的相关方法，以SimpleExecutor为例
public class SimpleExecutor extends BaseExecutor {
public SimpleExecutor(Configuration configuration, Transaction transaction) {
super(configuration, transaction);
}
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.update(stmt);
} finally {
closeStatement(stmt);
}
}
@Override
public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
@Override
protected Cursor doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, null, boundSql);
Statement stmt = prepareStatement(handler, ms.getStatementLog());
return handler.queryCursor(stmt);
}
@Override
public List doFlushStatements(boolean isRollback) throws SQLException {
return Collections.emptyList();
}
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
}
每个进行相关数据库操作的方法都有获取StatementHandler的一步。在这一步会进行拦截器的设置。
而对ParameterHandler进行拦截与对ResultSetHandler进行拦截设置调用的Configuration相应的new方法是在newStatementHandler里
new RoutingStatementHandler ->new PreparedStatementHandler->super(也就是BaseStatementHandler)
protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
this.configuration = mappedStatement.getConfiguration();
this.executor = executor;
this.mappedStatement = mappedStatement;
this.rowBounds = rowBounds;
this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
this.objectFactory = configuration.getObjectFactory();
if (boundSql == null) { // issue #435, get the key before calculating the statement
generateKeys(parameterObject);
boundSql = mappedStatement.getBoundSql(parameterObject);
}
this.boundSql = boundSql;
this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
}
总结：
Mybatis中Interceptor的原理就是MyBatis通过jdk动态代理将需要的对象(一般使用默认的Plugin.wrap)进行代理，并记录哪些方法需要进行拦截处理，最后在invoke的时候查找是否是需要拦截处理的方法，是就调用intercept方法
如有错误，欢迎各位大佬斧正！
[下一篇]: