在springboot中如何給mybatis加攔截器

@Intercepts({
        @Signature(method = "update", type = Executor.class, args = {MappedStatement.class, Object.class}),
        @Signature(method = "query", type = StatementHandler.class, args = {Statement.class, ResultHandler.class})
})
public class MyInterceptor implements Interceptor {
    /**
     * 這個方法很好理解
     * 作用只有一個：我們不是攔截方法嗎，攔截之後我們要做什麼事情呢？
     *      這個方法裡面就是我們要做的事情
     *
     * 解釋這個方法前，我們一定要理解方法引數 {@link Invocation} 是個什麼鬼？
     * 1 我們知道，mybatis攔截器預設只能攔截四種型別 Executor、StatementHandler、ParameterHandler 和 ResultSetHandler
     * 2 不管是哪種代理，代理的目標物件就是我們要攔截物件，舉例說明：
     *      比如我們要攔截 {@link Executor#update(MappedStatement ms, Object parameter)} 方法，
     *      那麼 Invocation 就是這個物件，Invocation 裡面有三個引數 target method args
     *          target 就是 Executor
     *          method 就是 update
     *          args   就是 MappedStatement ms, Object parameter
     *
     *   如果還是不能理解，我再舉一個需求案例：看下面方法程式碼裡面的需求
     *
     *  該方法在執行時呼叫
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        /*
         * 需求：我們需要對所有更新操作前列印查詢語句的 sql 紀錄檔
         * 那我就可以讓我們的自定義攔截器 MyInterceptor 攔截 Executor 的 update 方法，在 update 執行前列印sql紀錄檔
         * 比如我們攔截點是 Executor 的 update 方法 ：  int update(MappedStatement ms, Object parameter)
         *
         * 那當我們紀錄檔列印成功之後，我們是不是還需要呼叫這個query方法呢，如何如呼叫呢？
         * 所以就出現了 Invocation 物件，它這個時候其實就是一個 Executor，而且 method 對應的就是 query 方法，我們
         * 想要呼叫這個方法，只需要執行 invocation.proceed()
         */
        /* 因為我攔截的就是Executor，所以我可以強轉為 Executor，預設情況下，這個Executor 是個 SimpleExecutor */
        Executor executor = (Executor)invocation.getTarget();
        /*
         * Executor 的 update 方法裡面有一個引數 MappedStatement，它是包含了 sql 語句的，所以我獲取這個物件
         * 以下是虛擬碼，思路：
         * 1 通過反射從 Executor 物件中獲取 MappedStatement 物件
         * 2 從 MappedStatement 物件中獲取 SqlSource 物件
         * 3 然後從 SqlSource 物件中獲取獲取 BoundSql 物件
         * 4 最後通過 BoundSql#getSql 方法獲取 sql
         */
        MappedStatement mappedStatement = ReflectUtil.getMethodField(executor, MappedStatement.class);
        SqlSource sqlSource = ReflectUtil.getField(mappedStatement, SqlSource.class);
        BoundSql boundSql = sqlSource.getBoundSql(args);
        String sql = boundSql.getSql();
        logger.info(sql);
        /*
         * 現在紀錄檔已經列印，需要呼叫目標物件的方法完成 update 操作
         * 我們直接呼叫 invocation.proceed() 方法
         * 進入原始碼其實就是一個常見的反射呼叫 method.invoke(target, args)
         * target 對應 Executor物件
         * method 對應 Executor的update方法
         * args   對應 Executor的update方法的引數
         */
        return invocation.proceed();
    }
    /**
     * 這個方法也很好理解
     * 作用就只有一個：那就是Mybatis在建立攔截器代理時候會判斷一次，當前這個類 MyInterceptor 到底需不需要生成一個代理進行攔截，
     * 如果需要攔截，就生成一個代理物件，這個代理就是一個 {@link Plugin}，它實現了jdk的動態代理介面 {@link InvocationHandler}，
     * 如果不需要代理，則直接返回目標物件本身
     *
     * Mybatis為什麼會判斷一次是否需要代理呢？
     * 預設情況下，Mybatis只能攔截四種型別的介面：Executor、StatementHandler、ParameterHandler 和 ResultSetHandler
     * 通過 {@link Intercepts} 和 {@link Signature} 兩個註解共同完成
     * 試想一下，如果我們開發人員在自定義攔截器上沒有指明型別，或者隨便寫一個攔截點，比如Object，那Mybatis瘋了，難道所有物件都去攔截
     * 所以Mybatis會做一次判斷，攔截點看看是不是這四個介面裡面的方法，不是則不攔截，直接返回目標物件，如果是則需要生成一個代理
     *
     *  該方法在 mybatis 載入核心組態檔時被呼叫
     */
    @Override
    public Object plugin(Object target) {
        /*
         * 看了這個方法註釋，就應該理解，這裡的邏輯只有一個，就是讓mybatis判斷，要不要進行攔截，然後做出決定是否生成一個代理
         *
         * 下面程式碼什麼鬼，就這一句就搞定了？
         * Mybatis判斷依據是利用反射，獲取這個攔截器 MyInterceptor 的註解 Intercepts和Signature，然後解析裡面的值，
         * 1 先是判斷要攔截的物件是四個型別中 Executor、StatementHandler、ParameterHandler、 ResultSetHandler 的哪一個
         * 2 然後根據方法名稱和引數(因為有過載)判斷對哪一個方法進行攔截  Note：mybatis可以攔截這四個介面裡面的任一一個方法
         * 3 做出決定，是返回一個物件呢還是返回目標物件本身(目標物件本身就是四個介面的實現類，我們攔截的就是這四個型別)
         *
         * 好了，理解邏輯我們寫程式碼吧~~~  What !!! 要使用反射，然後解析註解，然後根據引數型別，最後還要生成一個代理物件
         * 我一個小白我怎麼會這麼高大上的程式碼嘛，怎麼辦？
         *
         * 那就是使用下面這句程式碼吧  哈哈
         * mybatis 早就考慮了這裡的複雜度，所以提供這個靜態方法來實現上面的邏輯
         */
        return Plugin.wrap(target, this);
    }
    /**
     * 這個方法最好理解，如果我們攔截器需要用到一些變數引數，而且這個引數是支援可設定的，
     *  類似Spring中的@Value("${}")從application.properties檔案獲取
     * 這個時候我們就可以使用這個方法
     *
     * 如何使用？
     * 只需要在 mybatis 組態檔中加入類似如下設定，然後 {@link Interceptor#setProperties(Properties)} 就可以獲取引數
     *      <plugin interceptor="liu.york.mybatis.study.plugin.MyInterceptor">
     *           <property name="username" value="LiuYork"/>
     *           <property name="password" value="123456"/>
     *      </plugin>
     *      方法中獲取引數：properties.getProperty("username");
     *
     * 問題：為什麼要存在這個方法呢，比如直接使用 @Value("${}") 獲取不就得了？
     * 原因是 mybatis 框架本身就是一個可以獨立使用的框架，沒有像 Spring 這種做了很多依賴注入的功能
     *
     *  該方法在 mybatis 載入核心組態檔時被呼叫 
     */
    @Override
    public void setProperties(Properties properties) {
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        // TODO: 2019/2/28  業務邏輯處理...
    }
}

package org.apache.ibatis.plugin;
/**
 * Plugin 類其實就是一個代理類，因為它實現了jdk動態代理介面 InvocationHandler
 * 我們核心只需要關注兩個方法
 * wrap：
 *      如果看懂了程式碼案例1的例子，那麼這個方法很理解，這個方法就是 mybatis 提供給開發人員使用的一個工具類方法，
 *      目的就是幫助開發人員省略掉 反射解析註解 Intercepts 和 Signature，有興趣的可以去看看原始碼 Plugin#getSignatureMap 方法
 *
 * invoke：
 *      這個方法就是根據 wrap 方法的解析結果，判斷當前攔截器是否需要進行攔截，
 *      如果需要攔截：將 目標物件+目標方法+目標引數 封裝成一個 Invocation 物件，給我們自定義的攔截器 MyInterceptor 的 intercept 方法
 *                   這個時候就剛好對應上了上面案例1中對 intercept 方法的解釋了，它就是我們要處理自己邏輯的方法，
 *                   處理好了之後是否需要呼叫目標物件的方法，比如上面說的 列印了sql語句，是否還要查詢資料庫呢？答案是肯定的
 *      如果不需要攔截：則直接呼叫目標物件的方法
 *                   比如直接呼叫 Executor 的 update 方法進行更新資料庫
 *
 */
class Plugin implements InvocationHandler {
    public static Object wrap(Object target, Interceptor interceptor) {
        // 省略
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 省略
    }
}

@Component
@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }) })
public class MybatisInterceptor implements Interceptor {
	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		//業務程式碼
	}
	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}
	@Override
	public void setProperties(Properties properties) {
		// TODO Auto-generated method stub
	}
}

@Configuration
public class MybatisConfig {
    @Bean
    public ConfigurationCustomizer mybatisConfigurationCustomizer() {
        return new ConfigurationCustomizer() {
            @Override
            public void customize(Configuration configuration) {
                configuration.addInterceptor(new MybatisInterceptor());
            }
        };
    }
}

mybatis:
  config-location: classpath:mybatis.xml
  type-aliases-package: me.zingon.pagehelper.model
  mapper-locations: classpath:mapper/*.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="me.zingon.pacargle.model"/>
    </typeAliases>
    <plugins>
        <plugin interceptor="me.zingon.pagehelper.interceptor.MyPageInterceptor"> 
            <property name="dialect" value="oracle"/>
        </plugin>
    </plugins>
</configuration>