送命題:講一講Mybatis外掛的原理及如何實現?
阿新 • • 發佈:2020-09-17
持續原創輸出,點選上方藍字關注我吧
目錄
前言 環境配置 什麼是外掛? 如何自定義外掛? 舉個栗子 用到哪些註解? 如何注入Mybatis? 測試
外掛原理分析 如何生成代理物件? 如何執行? 總結
分頁外掛的原理分析 總結
前言
Mybatis的分頁外掛相信大家都使用過,那麼可知道其中的實現原理?分頁外掛就是利用的Mybatis中的外掛機制實現的,在 Executor
的query
執行前後進行分頁處理。此篇文章就來介紹以下Mybatis的外掛機制以及在底層是如何實現的。
環境配置
本篇文章講的一切內容都是基於 Mybatis3.5
和SpringBoot-2.3.3.RELEASE
。
什麼是外掛?
外掛是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提供的 Interceptor
這個介面即可,原始碼如下:
public interface Interceptor {
//攔截的方法
Object intercept(Invocation invocation) throws Throwable;
//返回攔截器的代理物件
Object plugin(Object target);
//設定一些屬性
void setProperties(Properties properties);
}
舉個栗子
有這樣一個需求:需要在Mybatis執行的時候篡改 selectByUserId
「分析」:修改SQL的入參,應該在哪個元件的哪個方法上攔截篡改呢?研究過原始碼的估計都很清楚的知道, ParameterHandler
中的setParameters()
方法就是對引數進行處理的。因此肯定是攔截這個方法是最合適。自定義的外掛如下:
/**
* @Intercepts 註解標記這是一個攔截器,其中可以指定多個@Signature
* @Signature 指定該攔截器攔截的是四大物件中的哪個方法
* type:攔截器的四大物件的型別
* method:攔截器的方法,方法名
* args:入參的型別,可以是多個,根據方法的引數指定,以此來區分方法的過載
*/
@Intercepts(
{
@Signature(type = ParameterHandler.class,method ="setParameters",args = {PreparedStatement.class})
}
)
public class ParameterInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("攔截器執行:"+invocation.getTarget());
//目標物件
Object target = invocation.getTarget();
//獲取目標物件中所有屬性的值,因為ParameterHandler使用的是DefaultParameterHandler,因此裡面的所有的屬性都封裝在其中
MetaObject metaObject = SystemMetaObject.forObject(target);
//使用xxx.xxx.xx的方式可以層層獲取屬性值,這裡獲取的是mappedStatement中的id值
String value = (String) metaObject.getValue("mappedStatement.id");
//如果是指定的查詢方法
if ("cn.cb.demo.dao.UserMapper.selectByUserId".equals(value)){
//設定引數的值是admin_1,即是設定id=admin_1,因為這裡只有一個引數,可以這麼設定,如果有多個需要需要迴圈
metaObject.setValue("parameterObject", "admin_1");
}
//執行目標方法
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
//如果沒有特殊定製,直接使用Plugin這個工具類返回一個代理物件即可
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
}
}
intercept
方法:最終會攔截的方法,最重要的一個方法。plugin
方法:返回一個代理物件,如果沒有特殊要求,直接使用Mybatis的工具類Plugin
返回即可。setProperties
:設定一些屬性,不重要。
用到哪些註解?
自定義外掛需要用到兩個註解,分別是 @Intercepts
和@Signature
。@Intercepts
:標註在實現類上,表示這個類是一個外掛的實現類。@Signature
:作為@Intercepts
的屬性,表示需要增強Mybatis的某些
元件中的某些
方法(可以指定多個)。常用的屬性如下:Class<?> type()
:指定哪個元件(Executor
、ParameterHandler
、ResultSetHandler
、StatementHandler
)String method()
:指定增強元件中的哪個方法,直接寫方法名稱。Class<?>[] args()
:方法中的引數,必須一一對應,可以寫多個;這個屬性非常重用,區分過載方法。
如何注入Mybatis?
上面已經將外掛定義好了,那麼如何注入到Mybatis中使其生效呢?
「前提」:由於本篇文章的環境是
SpringBoot+Mybatis
,因此講一講如何在SpringBoot中將外掛注入到Mybatis中。在Mybatis的自動配置類
MybatisAutoConfiguration
中,注入SqlSessionFactory
的時候,有如下一段程式碼:上圖中的
this.interceptors
是什麼,從何而來,其實就是從容器中的獲取的Interceptor[]
,如下一段程式碼:從上圖我們知道,這外掛最終還是從IOC容器中獲取的
Interceptor[]
這個Bean
,因此我們只需要在配置類中注入這個Bean
即可,如下程式碼:
/**
* @Configuration:這個註解標註該類是一個配置類
*/
@Configuration
public class MybatisConfig{
/**
* @Bean : 該註解用於向容器中注入一個Bean
* 注入Interceptor[]這個Bean
* @return
*/
@Bean
public Interceptor[] interceptors(){
//建立ParameterInterceptor這個外掛
ParameterInterceptor parameterInterceptor = new ParameterInterceptor();
//放入陣列返回
return new Interceptor[]{parameterInterceptor};
}
}
測試
此時自定義的外掛已經注入了Mybatis中了,現在測試看看能不能成功執行呢?測試程式碼如下:
@Test
void contextLoads() {
//傳入的是1222
UserInfo userInfo = userMapper.selectByUserId("1222");
System.out.println(userInfo);
}
測試程式碼傳入的是 1222
,由於外掛改變了入參,因此查詢出來的應該是admin_1
這個人。
外掛原理分析
外掛的原理其實很簡單,就是在建立元件的時候生成代理物件( Plugin
),執行元件方法的時候攔截即可。下面就來詳細介紹一下外掛在Mybatis底層是如何工作的?Mybatis的四大元件都是在Mybatis的配置類 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);
}
//呼叫pluginAll方法,生成代理物件
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
//建立ParameterHandler
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
//呼叫pluginAll方法,生成代理物件
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
return parameterHandler;
}
//建立ResultSetHandler
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);
//呼叫pluginAll方法,生成代理物件
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}
//建立StatementHandler
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);
//呼叫pluginAll方法,生成代理物件
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
從上面的原始碼可以知道,建立四大元件的方法中都會執行 pluginAll()
這個方法來生成一個代理物件。具體如何生成的,下面詳解。
如何生成代理物件?
建立四大元件過程中都執行了 pluginAll()
這個方法,此方法原始碼如下:
public Object pluginAll(Object target) {
//迴圈遍歷外掛
for (Interceptor interceptor : interceptors) {
//呼叫外掛的plugin()方法
target = interceptor.plugin(target);
}
//返回
return target;
}
pluginAll()
方法很簡單,直接迴圈呼叫外掛的plugin()
方法,但是我們呼叫的是Plugin.wrap(target, this)
這行程式碼,因此要看一下wrap()
這個方法的原始碼,如下:
public static Object wrap(Object target, Interceptor interceptor) {
//獲取註解的@signature的定義
Map<Class<?>, Set<Method>> 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;
}
Plugin.wrap()
這個方法的邏輯很簡單,判斷這個外掛是否是攔截對應的元件,如果攔截了,生成代理物件(Plugin
)返回,沒有攔截直接返回,上面例子中生成的代理物件如下圖:
如何執行?
上面講了Mybatis啟動的時候如何根據外掛生成代理物件的( Plugin
)。現在就來看看這個代理物件是如何執行的?既然是動態代理,肯定會執行的 invoke()
這個方法,Plugin
類中的invoke()
原始碼如下:
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//獲取@signature標註的方法
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
//如果這個方法被攔截了
if (methods != null && methods.contains(method)) {
//直接執行外掛的intercept()這個方法
return interceptor.intercept(new Invocation(target, method, args));
}
//沒有被攔截,執行原方法
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
邏輯很簡單,這個方法被攔截了就執行外掛的 intercept()
方法,沒有被攔截,則執行原方法。還是以上面自定義的外掛來看看執行的流程: setParameters()
這個方法在PreparedStatementHandler
中被呼叫,如下圖:執行 invoke()
方法,發現setParameters()
這個方法被攔截了,因此直接執行的是intercept()
方法。
總結
Mybatis中外掛的原理其實很簡單,分為以下幾步: 在專案啟動的時候判斷元件是否有被攔截,如果沒有直接返回原物件。 如果有被攔截,返回動態代理的物件( Plugin
)。執行到的元件的中的方法時,如果不是代理物件,直接執行原方法 如果是代理物件,執行 Plugin
的invoke()
方法。
分頁外掛的原理分析
此處安利一款經常用的分頁外掛 pagehelper
,Maven依賴如下:
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.1.6</version>
</dependency>
分頁外掛很顯然也是根據Mybatis的外掛來定製的,來看看外掛 PageInterceptor
的原始碼如下:
@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 {}
既然是分頁功能,肯定是在 query()
的時候攔截,因此肯定是在Executor
這個元件中。分頁外掛的原理其實很簡單,不再一一分析原始碼了,根據的自己定義的分頁資料重新賦值 RowBounds
來達到分頁的目的,當然其中涉及到資料庫方言等等內容,不是本章重點,有興趣可以看一下GitHub上的文件。
總結
對於業務開發的程式設計師來說,外掛的這個功能很少用到,但是不用就不應該瞭解嗎?做人要有追求,哈哈。 歡迎關注作者的微信公眾號 碼猿技術專欄
,作者為你們精心準備了springCloud最新精彩視訊教程
、精選500本電子書
、架構師免費視訊教程
等等免費資源,讓我們一起進階,一起成長。