【MyBatis原始碼分析】plugins解析屬性配置元素詳述
Plugins解析、
plugin有何作用? 需要配置嗎?
plugins 是一個可選配置。mybatis中的plugin其實就是個interceptor, 它可以攔截Executor 、ParameterHandler 、ResultSetHandler 、StatementHandler 的部分方法,處理我們自己的邏輯。Executor就是真正執行sql語句的東西, ParameterHandler 是處理我們傳入引數的,還記得前面講TypeHandler的時候提到過,mybatis預設幫我們實現了不少的typeHandler, 當我們不顯示配置typeHandler的時候,mybatis會根據引數型別自動選擇合適的typeHandler執行,其實就是ParameterHandler 在選擇。ResultSetHandler 就是處理返回結果的。
怎麼自定義plugin ? 怎麼配置?
要自定義一個plugin, 需要去實現Interceptor介面。定義好之後,配置如下:
<plugins>
<plugin interceptor="Interceptor.SqlCostInterceptor"/>
</plugins>
接下來我們看實現一個SqlCostInterceptor類;
package Interceptor; import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Properties; import java.lang.reflect.Field; import java.sql.Statement; import org.apache.ibatis.executor.statement.StatementHandler; import org.apache.ibatis.mapping.BoundSql; import org.apache.ibatis.mapping.ParameterMapping; import org.apache.ibatis.plugin.Signature; import org.apache.ibatis.session.ResultHandler; import org.apache.ibatis.session.defaults.DefaultSqlSession.StrictMap; import org.apache.ibatis.plugin.Interceptor; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Plugin; /** * Sql執行時間記錄攔截器 */ @Intercepts( {@Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}), @Signature(type = StatementHandler.class, method = "batch", args = { Statement.class })}) public class SqlCostInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { Object target = invocation.getTarget(); long startTime = System.currentTimeMillis(); StatementHandler statementHandler = (StatementHandler)target; try { return invocation.proceed(); } finally { long endTime = System.currentTimeMillis(); long sqlCost = endTime - startTime; BoundSql boundSql = statementHandler.getBoundSql(); String sql = boundSql.getSql(); Object parameterObject = boundSql.getParameterObject(); List<ParameterMapping> parameterMappingList = boundSql.getParameterMappings(); // 格式化Sql語句,去除換行符,替換引數 sql = formatSql(sql, parameterObject, parameterMappingList); System.out.println("SQL:[" + sql + "]執行耗時[" + sqlCost + "ms]"); } } @Override public Object plugin(Object target) { return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { } @SuppressWarnings("unchecked") private String formatSql(String sql, Object parameterObject, List<ParameterMapping> parameterMappingList) { // 輸入sql字串空判斷 if (sql == null || sql.length() == 0) { return ""; } // 美化sql sql = beautifySql(sql); // 不傳引數的場景,直接把Sql美化一下返回出去 if (parameterObject == null || parameterMappingList == null || parameterMappingList.size() == 0) { return sql; } // 定義一個沒有替換過佔位符的sql,用於出異常時返回 String sqlWithoutReplacePlaceholder = sql; try { if (parameterMappingList != null) { Class<?> parameterObjectClass = parameterObject.getClass(); // 如果引數是StrictMap且Value型別為Collection,獲取key="list"的屬性,這裡主要是為了處理<foreach>迴圈時傳入List這種引數的佔位符替換 // 例如select * from xxx where id in <foreach collection="list">...</foreach> if (isStrictMap(parameterObjectClass)) { StrictMap<Collection<?>> strictMap = (StrictMap<Collection<?>>)parameterObject; if (isList(strictMap.get("list").getClass())) { sql = handleListParameter(sql, strictMap.get("list")); } } else if (isMap(parameterObjectClass)) { // 如果引數是Map則直接強轉,通過map.get(key)方法獲取真正的屬性值 // 這裡主要是為了處理<insert>、<delete>、<update>、<select>時傳入parameterType為map的場景 Map<?, ?> paramMap = (Map<?, ?>) parameterObject; sql = handleMapParameter(sql, paramMap, parameterMappingList); } else { // 通用場景,比如傳的是一個自定義的物件或者八種基本資料型別之一或者String sql = handleCommonParameter(sql, parameterMappingList, parameterObjectClass, parameterObject); } } } catch (Exception e) { // 佔位符替換過程中出現異常,則返回沒有替換過佔位符但是格式美化過的sql,這樣至少保證sql語句比BoundSql中的sql更好看 return sqlWithoutReplacePlaceholder; } return sql; } /** * 美化Sql */ private String beautifySql(String sql) { // sql = sql.replace("\n", "").replace("\t", "").replace(" ", " ").replace("( ", "(").replace(" )", ")").replace(" ,", ","); sql = sql.replaceAll("[\\s\n ]+"," "); return sql; } /** * 處理引數為List的場景 */ private String handleListParameter(String sql, Collection<?> col) { if (col != null && col.size() != 0) { for (Object obj : col) { String value = null; Class<?> objClass = obj.getClass(); // 只處理基本資料型別、基本資料型別的包裝類、String這三種 // 如果是複合型別也是可以的,不過複雜點且這種場景較少,寫程式碼的時候要判斷一下要拿到的是複合型別中的哪個屬性 if (isPrimitiveOrPrimitiveWrapper(objClass)) { value = obj.toString(); } else if (objClass.isAssignableFrom(String.class)) { value = "\"" + obj.toString() + "\""; } sql = sql.replaceFirst("\\?", value); } } return sql; } /** * 處理引數為Map的場景 */ private String handleMapParameter(String sql, Map<?, ?> paramMap, List<ParameterMapping> parameterMappingList) { for (ParameterMapping parameterMapping : parameterMappingList) { Object propertyName = parameterMapping.getProperty(); Object propertyValue = paramMap.get(propertyName); if (propertyValue != null) { if (propertyValue.getClass().isAssignableFrom(String.class)) { propertyValue = "\"" + propertyValue + "\""; } sql = sql.replaceFirst("\\?", propertyValue.toString()); } } return sql; } /** * 處理通用的場景 */ private String handleCommonParameter(String sql, List<ParameterMapping> parameterMappingList, Class<?> parameterObjectClass, Object parameterObject) throws Exception { for (ParameterMapping parameterMapping : parameterMappingList) { String propertyValue = null; // 基本資料型別或者基本資料型別的包裝類,直接toString即可獲取其真正的引數值,其餘直接取paramterMapping中的property屬性即可 if (isPrimitiveOrPrimitiveWrapper(parameterObjectClass)) { propertyValue = parameterObject.toString(); } else { String propertyName = parameterMapping.getProperty(); Field field = parameterObjectClass.getDeclaredField(propertyName); // 要獲取Field中的屬性值,這裡必須將私有屬性的accessible設定為true field.setAccessible(true); propertyValue = String.valueOf(field.get(parameterObject)); if (parameterMapping.getJavaType().isAssignableFrom(String.class)) { propertyValue = "\"" + propertyValue + "\""; } } sql = sql.replaceFirst("\\?", propertyValue); } return sql; } /** * 是否基本資料型別或者基本資料型別的包裝類 */ private boolean isPrimitiveOrPrimitiveWrapper(Class<?> parameterObjectClass) { return parameterObjectClass.isPrimitive() || (parameterObjectClass.isAssignableFrom(Byte.class) || parameterObjectClass.isAssignableFrom(Short.class) || parameterObjectClass.isAssignableFrom(Integer.class) || parameterObjectClass.isAssignableFrom(Long.class) || parameterObjectClass.isAssignableFrom(Double.class) || parameterObjectClass.isAssignableFrom(Float.class) || parameterObjectClass.isAssignableFrom(Character.class) || parameterObjectClass.isAssignableFrom(Boolean.class)); } /** * 是否DefaultSqlSession的內部類StrictMap */ private boolean isStrictMap(Class<?> parameterObjectClass) { return parameterObjectClass.isAssignableFrom(StrictMap.class); } /** * 是否List的實現類 */ private boolean isList(Class<?> clazz) { Class<?>[] interfaceClasses = clazz.getInterfaces(); for (Class<?> interfaceClass : interfaceClasses) { if (interfaceClass.isAssignableFrom(List.class)) { return true; } } return false; } /** * 是否Map的實現類 */ private boolean isMap(Class<?> parameterObjectClass) { Class<?>[] interfaceClasses = parameterObjectClass.getInterfaces(); for (Class<?> interfaceClass : interfaceClasses) { if (interfaceClass.isAssignableFrom(Map.class)) { return true; } } return false; } }
接著看一下pluginElement(root.evalNode("plugins"));方法,這句讀取的是<configuration>下的<plugins>節點,程式碼實現為:
private void pluginElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { String interceptor = child.getStringAttribute("interceptor"); Properties properties = child.getChildrenAsProperties(); Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance(); interceptorInstance.setProperties(properties); configuration.addInterceptor(interceptorInstance); } } }
這裡拿<plugin>標籤中的interceptor屬性,這是自定義的攔截器的全路徑,第6行的程式碼通過反射生成攔截器例項。
再拿<plugin>標籤下的所有<property>標籤,解析name和value屬性成為一個Properties,將Properties設定到攔截器中。
最後,通過第8行的程式碼將攔截器設定到Configuration中,原始碼實現為:
public void addInterceptor(Interceptor interceptor) {
interceptorChain.addInterceptor(interceptor);
}
InterceptorChain是一個攔截器鏈,儲存了所有定義的攔截器以及相關的幾個操作的方法:public class InterceptorChain {
private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
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<Interceptor> getInterceptors() {
return Collections.unmodifiableList(interceptors);
}
}
分別有新增攔截器、為目標物件新增所有攔截器、獲取當前所有攔截器三個方法。
MyBatis外掛原理----pluginAll方法新增外掛
上面我們在InterceptorChain中看到了一個pluginAll方法,pluginAll方法為目標物件生成代理,之後目標物件呼叫方法的時候走的不是原方法而是代理方法,這個在後面會說明。
MyBatis官網文件有說明,在以下四個程式碼執行點上允許使用外掛:
為之生成外掛的時機(換句話說就是pluginAll方法呼叫的時機)是Executor、ParameterHandler、ResultSetHandler、StatementHandler四個介面實現類生成的時候,每個介面實現類在MyBatis中生成的時機是不一樣的,這個就不看它們是在什麼時候生成的了,每個開發工具我相信都有快捷鍵可以看到pluginAll方法呼叫的地方,我使用的Eclipse就是Ctrl+Alt+H。
再看pluginAll方法:
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
這裡值得注意的是:- 形參Object target,這個是Executor、ParameterHandler、ResultSetHandler、StatementHandler介面的實現類,換句話說,plugin方法是要為Executor、ParameterHandler、ResultSetHandler、StatementHandler的實現類生成代理,從而在呼叫這幾個類的方法的時候,其實呼叫的是InvocationHandler的invoke方法
- 這裡的target是通過for迴圈不斷賦值的,也就是說如果有多個攔截器,那麼如果我用P表示代理,生成第一次代理為P(target),生成第二次代理為P(P(target)),生成第三次代理為P(P(P(target))),不斷巢狀下去,這就得到一個重要的結論:<plugins>...</plugins>中後定義的<plugin>實際其攔截器方法先被執行,因為根據這段程式碼來看,後定義的<plugin>代理實際後生成,包裝了先生成的代理,自然其代理方法也先執行(先進後出<棧>)
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) {
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
首先看一下第2行的程式碼,獲取Interceptor上定義的所有方法簽名:private static Map<Class<?>, Set<Method>> 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<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
for (Signature sig : sigs) {
Set<Method> methods = signatureMap.get(sig.type());
if (methods == null) {
methods = new HashSet<Method>();
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;
}
看到先拿@Intercepts註解,如果沒有定義@Intercepts註解,丟擲異常,這意味著使用MyBatis的外掛,必須使用註解方式。
接著拿到@Intercepts註解下的所有@Signature註解,獲取其type屬性(表示具體某個介面),再根據method與args兩個屬性去type下找方法簽名一致的方法Method(如果沒有方法簽名一致的就丟擲異常,此簽名的方法在該介面下找不到),能找到的話key=type,value=Set<Method>,新增到signatureMap中,構建出一個方法簽名對映。舉個例子來說,就是我定義的@Intercepts註解,Executor下我要攔截的所有Method、StatementHandler下我要攔截的所有Method。
回過頭繼續看wrap方法,在拿到方法簽名對映後,呼叫getAllInterfaces方法,傳入的是Target的Class物件以及之前獲取到的方法簽名對映:
private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
Set<Class<?>> interfaces = new HashSet<Class<?>>();
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()]);
}
這裡獲取Target的所有介面,如果方法簽名對映中有這個介面,那麼新增到interfaces中,這是一個Set,最終將Set轉換為陣列返回。wrap方法的最後一步:
if (interfaces.length > 0) {
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
如果當前傳入的Target的介面中有@Intercepts註解中定義的介面,那麼為之生成代理,否則原Target返回。
這段理論可能大家會看得有點雲裡霧裡,我這裡舉個例子:
就以SqlCostPlugin為例,我的@Intercepts定義的是:
@Intercepts({@Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}), @Signature(type = StatementHandler.class,
method = "update", args = {Statement.class})})
此時,生成的方法簽名對映signatureMap應當是(我這裡把Map給toString()了):
{interface org.apache.ibatis.executor.statement.StatementHandler=[public abstract int org.apache.ibatis.executor.statement.StatementHandler.update(java.sql.
Statement) throws java.sql.SQLException, public abstract java.util.List org.apache.ibatis.executor.statement.StatementHandler.query(java.sql.Statement,org.apache.
ibatis.session.ResultHandler) throws java.sql.SQLException]}
一個Class對應一個Set,Class為StatementHandler.class,Set為StataementHandler中的兩個方法
如果我new的是StatementHandler介面的實現類,那麼可以為之生成代理,因為signatureMap中的key有StatementHandler這個介面
如果我new的是Executor介面的實現類,那麼直接會把Executor介面的實現類原樣返回,因為signatureMap中的key並沒有Executor這個介面
相信這麼解釋大家應該會明白一點。注意這裡生不生成代理,只和介面在不在@Intercepts中定義過有關,和方法簽名無關,具體某個方法走攔截器,在invoke方法中,馬上來看一下。MyBatis外掛原理----Plugin的invoke方法
首先看一下Plugin方法的方法定義:
public class Plugin implements InvocationHandler {
private Object target;
private Interceptor interceptor;
private Map<Class<?>, Set<Method>> signatureMap;
private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
this.target = target;
this.interceptor = interceptor;
this.signatureMap = signatureMap;
}
...
}
看到Plugin是InvocationHandler介面的實現類,換句話說,為目標介面生成代理之後,最終執行的都是Plugin的invoke方法,看一下invoke方法的實現: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)) {
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
在這裡,將method對應的Class拿出來,獲取該Class中有哪些方法簽名,換句話說就是Executor、ParameterHandler、ResultSetHandler、StatementHandler,在@Intercepts註解中定義了要攔截哪些方法簽名。
如果當前呼叫的方法的方法簽名在方法簽名集合中,即滿足第4行的判斷,那麼呼叫攔截器的intercept方法,否則方法原樣呼叫,不會執行攔截器。