前言
本篇我們來介紹MyBatis外掛的開發，這個也是來源於我之前的一個面試經歷，面試官為我如何統計Dao層的慢SQL，我當時的回答是藉助於Spring的AOP機制，攔截Dao層所有的方法，但面試官又問，這事實上不完全是SQL的執行時間，這其中還有其他程式碼的時間，問我還有其他思路嗎？ 我想了想說沒有，面試官接著問，有接觸過MyBatis外掛的開發嗎？ 我說沒接觸過。 但後面也給我過了，我認為這個問題是有價值的問題，所以也放在了我的學習計劃中。
看本篇之前建議先看:
- 《代理模式-AOP緒論》
- 《假裝是小白之重學MyBatis(一)》
如果有人問上面兩篇文章在哪裡可以找的到，可以去掘金或者思否翻翻，目前公眾號還沒有，預計年中會將三個平臺的文章統一一下。
概述
翻閱官方文件的話，MyBatis並沒有給處外掛的具體定義，但基本上還是攔截器，MyBatis的外掛就是一些能夠攔截某些MyBats核心元件方法，增強功能的攔截器。官方文件中列出了四種可供增強的切入點:
- Executor
執行SQL的核心元件。攔截Executor 意味著要干擾或增強底層執行的CRUD操作
- ParameterHandler
攔截該ParameterHandler，意味著要干擾SQL引數注入、讀取的動作。
- ResultSetHandler
攔截該ParameterHandler, 要干擾/增強封裝結果集的動作
- StatementHandler
攔截StatementHandler ，則意味著要干擾/增強Statement的建立和執行的動作
當然還是從HelloWorld開始
要做MyBatis的外掛，首先要實現MyBatis的Interceptor 介面 , 注意類不要導錯了，Interceptor很搶手，該類位於org.apache.ibatis.plugin.Interceptor下。實現該介面，MyBatis會將該實現類當作MyBatis的攔截器，那攔截哪些方法，該怎麼指定呢? 通過@Intercepts註解來實現，下面是使用示例:
@Intercepts(@Signature(type = Executor.class, method = "query",
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
public class MyBatisPluginDemo implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("into invocation ..........");
System.out.println(invocation.getTarget());
System.out.println(invocation.getMethod().getName());
System.out.println(Arrays.toString(invocation.getArgs()));
return invocation.proceed();
}
}@Intercepts可以填多個@Signature,@Signature是方法簽名,type用於定位類，method定位方法名，args用於指定方法的引數型別。三者加在一起就可以定位到具體的方法。注意寫完還需要將此外掛註冊到MyBatis的配置檔案中,讓MyBatis載入該外掛。注意這個標籤一定要放在environments上面，MyBatis嚴格限制住了標籤的順序。
<plugins>
<plugin interceptor="org.example.mybatis.MyBatisPluginDemo"></plugin>
</plugins>我們來看下執行結果:
效能分析外掛走起
那攔截誰呢？ 目前也只有Executor 和StatementHandler 供我們選擇，我們本身是要看SQL耗時，Executor 離SQL執行還有些遠，一層套一層才走到SQL執行，MyBatis中標籤的執行過程在《MyBatis原始碼學習筆記(一) 初遇篇》已經講述過了，這裡不再贅述，目前來看StatementHandler 是離SQL最近的, 它的實現類就直接走到JDBC了，所以我們攔截StatementHandler ，那有的插入插了很多值，我們要不要攔截，當然也要攔截, 我們的外掛方法如下:
@Intercepts({@Signature(type = StatementHandler.class, method = "query",
args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method = "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("-----開始進入效能分析外掛中----");
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
long endTime = System.currentTimeMillis();
// query方法入參是statement,所以我們可以將其轉為Statement
if (endTime - startTime > 1000){
}
return result;
}
}那對應的SQL該怎麼拿？ 我們還是到StatementHandler去看下:
我們還是得通過Statement這個入參來拿, 我們試試看, 你會發現在日誌級別為DEBUG之上，會輸出SQL，像下面這樣:
如果日誌級別為DEBUG輸出會是下面這樣:
這是為什麼呢？ 如果看過《MyBatis原始碼學習筆記(一) 初遇篇》這篇的可能會想到，MyBatis架構中的日誌模組，為了接入日誌框架，就會用到代理，那麼這個肯定就是代理類，我們打斷點來驗證一下我們的想法:
代理分析
我原本的想法是PreparedStatementLogger的代理類，仔細一想，感覺不對，感覺自己還是對代理模式瞭解不大透，於是我就又把之前的文章《代理模式-AOP緒論》看了一下，動態代理模式的目標:
- 我們有一批類，然後我們想在不改變它們的基礎之上，增強它們, 我們還希望只著眼於編寫增強目標物件程式碼的編寫。
- 我們還希望由程式來編寫這些類，而不是由程式設計師來編寫，因為太多了。
在《代理模式-AOP緒論》中我們做的是很簡單的代理:
public interface IRentHouse {
void rentHouse();
void study();
}
public class RentHouse implements IRentHouse{
@Override
public void rentHouse() {
System.out.println("sayHello.....");
}
@Override
public void study() {
System.out.println("say Study");
}
}我們現在的需求是增強IRentHouse中的方法，用靜態代理就是為IRentHouse再做一個實現類，相當於在RentHouse上再包裝一層。但如果我有很多想增強的類呢，這樣去包裝，事實上對程式碼的侵入性是很大的。對於這種狀況，我們最終的選擇是動態代理，在執行時產生介面實現類的代理類，我們最終產生代理物件的方法是:
/**
* @param target 為需要增強的類
* @return 返回的物件在呼叫介面中的任意方法都會走到Lambda回撥中。
*/
private static Object getProxy(Object target){
Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), (proxy1, method, args) -> {
System.out.println("方法開始執行..........");
Object obj = method.invoke(target, args);
System.out.println("方法執行結束..........");
return obj;
});
return proxy;
}接下來我們來看下MyBatis是怎麼包裝的，我們還是從PreparedStatementLogger開始看：
InvocationHandler是動態代理的介面，BaseJdbcLogger這個先不關注。值得關注的是:
public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
ClassLoader cl = PreparedStatement.class.getClassLoader();
return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}可能有同學會問newProxyInstance為什麼給了兩個引數, 因為CallableStatement繼承了PreparedStatement。 這裡是一層，事實上還能點出來另外一層，在ConnectionLogger的回撥中(ConnectionLogger也實現了InvocationHandler，所以這個也是個代理回撥類)，ConnectionLogger的例項化在BaseExecutor這個類裡面完成，如果你還能回憶JDBC產生SQL的話，當時的流程事實上是這樣的：
public static boolean execute(String sql, Object... param) throws Exception {
boolean result = true;
Connection connection = null;
PreparedStatement preparedStatement = null;
try {
//獲取資料庫連線
connection = getConnection();
connection.setAutoCommit(false);
preparedStatement = connection.prepareStatement(sql);
// 設定引數
for (int i = 0; i < param.length; i++) {
preparedStatement.setObject(i, param[i]);
preparedStatement.addBatch();
}
preparedStatement.executeBatch();
//提交事務
connection.commit();
} catch (SQLException e) {
e.printStackTrace();
if (connection != null) {
try {
connection.rollback();
} catch (SQLException ex) {
ex.printStackTrace();
// 日誌記錄事務回滾失敗
result = false;
return result;
}
}
result = false;
} finally {
close(preparedStatement, connection);
}
return result;
}我們來捋一下，ConnectionLogger是讀Connection的代理，但是Connection介面中有許多方法, 所以ConnectionLogger在回撥的時候做了判斷:
@Override
public Object invoke(Object proxy, Method method, Object[] params)
throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, params);
}
if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {
if (isDebugEnabled()) {
debug(" Preparing: " + removeExtraWhitespace((String) params[0]), true);
}
// Connection 的prepareStatement方法、prepareCall會產生PreparedStatement
PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
// 然後PreparedStatementLogger產生的還是stmt的代理類
// 我們在plugin中拿到的就是
stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
return stmt;
} else if ("createStatement".equals(method.getName())) {
Statement stmt = (Statement) method.invoke(connection, params);
stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);
return stmt;
} else {
return method.invoke(connection, params);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
PreparedStatementLogger是回撥類，這個PreparedStatementLogger有對應的Statement，我們通過Statement就可以拿到對應的SQL。那回撥類和代理類是什麼關係呢， 我們來看下Proxy類的大致構造:
所以我最初的想法是JDK為我們產生的類裡面有回撥類例項這個物件會有InvocationHandler成員變數，但是如果你用getClass().getDeclaredField("h")去獲取發現獲取不到，那麼代理類就沒有這個回撥類例項，那我們研究一下getProxyClass0這個方法:
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
// proxyClassCache 是 new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 的例項
// 最終會呼叫ProxyClassFactory的apply方法。
// 在ProxyClassFactory的apply方法中有 ProxyGenerator.generateProxyClass()
// 答案就在其中,最後呼叫的是ProxyGenerator的generateClassFile方法
// 中產生代理類時,讓代理類繼承Proxy類。
return proxyClassCache.get(loader, interfaces);
}
所以破案了，在Proxy裡的InvocationHandler是protected，所以我們取變數應當這麼取:
@Intercepts({@Signature(type = StatementHandler.class, method = "query",
args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method = "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("-----開始進入效能分析外掛中----");
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
long endTime = System.currentTimeMillis();
// query方法入參是statement,所以我們可以將其轉為Statement
Statement statement = (Statement)invocation.getArgs()[0];
if (Proxy.isProxyClass(statement.getClass())){
Class<?> statementClass = statement.getClass().getSuperclass();
Field targetField = statementClass.getDeclaredField("h");
targetField.setAccessible(true);
PreparedStatementLogger loggerStatement = (PreparedStatementLogger) targetField.get(statement);
PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
if (endTime - startTime > 1){
System.out.println(preparedStatement.toString());
}
}else {
if (endTime - startTime > 1){
System.out.println(statement.toString());
}
}
return result;
}
}最後輸出如下:
但是這個外掛還不是那麼完美，就是這個慢SQL查詢時間了，我們現在是寫死的
這兩個問題在MyBatis 裡面都可以得到解決，我們可以看Interceptor這個介面:
public interface Interceptor {
Object intercept(Invocation invocation) throws Throwable;
default Object plugin(Object target) {
return Plugin.wrap(target, this);
}
default void setProperties(Properties properties) {
// NOP
}
}setProperties用於從配置檔案中取值, plugin將當前外掛加入，intercept是真正增強方法。那上面的兩個問題已經被解決了:
- 硬編碼
首先在配置檔案裡面配置
<plugins>
<plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin">
<property name = "maxTolerate" value = "10"/>
</plugin>
</plugins>然後重寫:
@Override
public void setProperties(Properties properties) {
//maxTolerate 是MyBatisSlowSqlPlugin的成員變數
this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
}回憶一下JDBC我們執行SQl事實上有兩種方式:
- Connection中的prepareStatement方法
- Connection中的createStatement
在MyBatis中這兩種方法對應不同的StatementType, 上面的PreparedStatementLogger對應 Connection中的prepareStatement方法， 如果說你在MyBatis中將語句宣告為Statement，則我們的SQL監控語句就會出錯，所以這裡我們還需要在單獨適配一下Statement語句型別。
@Intercepts({@Signature(type = StatementHandler.class, method = "query",
args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method = "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
private long maxTolerate;
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("-----開始進入效能分析外掛中----");
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
SystemMetaObject
long endTime = System.currentTimeMillis();
// query方法入參是statement,所以我們可以將其轉為Statement
Statement statement = (Statement)invocation.getArgs()[0];
if (Proxy.isProxyClass(statement.getClass())){
Class<?> statementClass = statement.getClass().getSuperclass();
Field targetField = statementClass.getDeclaredField("h");
targetField.setAccessible(true);
Object object = targetField.get(statement);
if (object instanceof PreparedStatementLogger) {
PreparedStatementLogger loggerStatement = (PreparedStatementLogger) targetField.get(statement);
PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
if (endTime - startTime > maxTolerate){
System.out.println(preparedStatement.toString());
}
}else {
// target 是對應的語句處理器
// 為什麼不反射拿? Statement 對應的實現類未重寫toString方法
// 但是在RoutingStatementHandler 中提供了getBoundSql方法
RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
BoundSql boundSql = handler.getBoundSql();
if (endTime - startTime > maxTolerate){
System.out.println(boundSql);
}
}
}else {
if (endTime - startTime > maxTolerate){
System.out.println(statement.toString());
}
}
return result;
}
@Override
public void setProperties(Properties properties) {
this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
}
}事實上MyBatis裡面寫好了反射工具類，這個就是SystemMetaObject，用法示例如下:
@Intercepts({@Signature(type = StatementHandler.class, method = "query",
args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,method = "update" ,args = Statement.class )})
public class MyBatisSlowSqlPlugin implements Interceptor {
private long maxTolerate;
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("-----開始進入效能分析外掛中----");
long startTime = System.currentTimeMillis();
Object result = invocation.proceed();
long endTime = System.currentTimeMillis();
// query方法入參是statement,所以我們可以將其轉為Statement
Statement statement = (Statement)invocation.getArgs()[0];
MetaObject metaObject = SystemMetaObject.forObject(statement);
if (Proxy.isProxyClass(statement.getClass())){
Object object = metaObject.getValue("h");
if (object instanceof PreparedStatementLogger) {
PreparedStatementLogger loggerStatement = (PreparedStatementLogger) object;
PreparedStatement preparedStatement = loggerStatement.getPreparedStatement();
if (endTime - startTime > maxTolerate){
System.out.println(preparedStatement.toString());
}
}else {
// target 是對應的語句處理器
// 為什麼不反射拿? Statement 對應的實現類未重寫toString方法
// 但是在RoutingStatementHandler 中提供了getBoundSql方法
RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
BoundSql boundSql = handler.getBoundSql();
if (endTime - startTime > maxTolerate){
System.out.println(boundSql);
}
}
}else {
if (endTime - startTime > maxTolerate){
System.out.println(statement.toString());
}
}
return result;
}
@Override
public void setProperties(Properties properties) {
this.maxTolerate = Long.parseLong(properties.getProperty("maxTolerate"));
}
}那我有多個外掛，如何指定順序呢? 在配置檔案中指定，從上往下依次執行
<plugins>
<plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin01">
<property name = "maxTolerate" value = "10"/>
</plugin>
<plugin interceptor="org.example.mybatis.MyBatisSlowSqlPlugin02">
<property name = "maxTolerate" value = "10"/>
</plugin>
</plugins>如上面所配置執行順序就是MyBatisSlowSqlPlugin01、MyBatisSlowSqlPlugin02。 外掛的幾個方法執行順序呢
寫在最後
感慨頗深，原本預計兩個小時就能寫完的，然後寫了一下午，頗有種學海無涯的感覺。
參考資料
- mybatis攔截器外掛例項-獲取不帶佔位符的可直接執行的sql B站教學視訊 https://www.bilibili.com/vide...
- MyBatis高階 https://www.bilibili.com/vide...