前言

Mybatis拦截器注解的基本写法格式为：

  1. @Intercepts({
  2.     @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
  3. })

说明： @Intercepts：标识该类是一个拦截器 @Signature：拦截器相关属性设置

type

拦截器的类型，总共有4种，按照执行的先后顺序为：

  1. Executor：拦截执行器的方法。
  2. ParameterHandler：拦截参数的处理。
  3. ResultHandler：拦截结果集的处理。
  4. StatementHandler：拦截Sql语法构建的处理，绝大部分我们是在这里设置我们的拦截器。

image.png

method

可被拦截的方法，按照拦截器的不同类型，总共有下面这些方法：

拦截的类型 拦截的方法
Executor update, query, flushStatements, commit, rollback,getTransaction, close, isClosed
ParameterHandler getParameterObject, setParameters
StatementHandler prepare, parameterize, batch, update, query
ResultSetHandler handleResultSets, handleOutputParameters

args

设置对应接口中的哪一个方法，比如 Executor 中 query方法因为重载原因，方法有多个，args 就是指明参数类型，从而确定是哪一个方法。

这里的方法和上面的方法的要怎么理解呢？可以这样理解，上面的那个方法（method）是大类的方法，比如update方法，下面的这个方法（args）呢，是具体的方法，用来指明你到底的哪里的update方法。

注册拦截器

使用配置文件

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <!--其它配置项都在著配置文件配置了，所以这里只需要配置configuration项即可-->
  6. <configuration>
  7.     <settings>
  8.         <!--是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。 -->
  9.         <setting name="mapUnderscoreToCamelCase" value="true"/>
  10.     </settings>
  11.     <plugins>
  12.         <plugin interceptor="com.example.IbatisInterceptor"/>
  13.     </plugins>
  14. </configuration>

然后在主配置文件中，将mybatis配置文件引入：

  1. # Mybatis配置
  2. mybatis:
  3.   config-location: classpath:mybatis/config/mybatis-config.xml # mybatis配置文件,如果使用configuration的话就不需要mybatis配置文件了

todo：
mybatis的配置项中，有一个interceptors配置，其参数是一个列表（java.util.List）。通过查阅相关信息发现，不能在配置文件中引用自定义的拦截器。总之是暂时没找到 具体使用方法，先放着吧。

  1. # Mybatis配置
  2. mybatis:
  3. #  config-location: classpath:mybatis/config/mybatis-config.xml # mybatis配置文件,如果使用configuration的话就不需要mybatis配置文件了
  4.   mapper-locations: classpath:mybatis/*.xml # mybatis映射文件
  5.   configuration: # mybatis全局配置
  6.     map-underscore-to-camel-case: true #开启驼峰命名规则
  7.     interceptors:
  8.       - xxx
  9.       - xxxxx

使用配置类

  1. import com.example.IbatisInterceptor;
  2. import org.apache.ibatis.session.SqlSessionFactory;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  6. import java.util.Properties;
  9. @Configuration
  10. public class IbatisInterceptorConfig {
  12.     @Bean
  13.     public String MyBatisInterceptor(SqlSessionFactory sqlSessionFactory) {
  14.         IbatisInterceptor ibatisInterceptor = new IbatisInterceptor();
  15.         Properties properties = new Properties();
  16.         properties.setProperty("driver", "mysql");
  17.         properties.setProperty("username", "root");
  18.         properties.setProperty("password", "123456");
  20.         // 给拦截器添加自定义参数
  21.         ibatisInterceptor.setProperties(properties);
  22.         sqlSessionFactory.getConfiguration().addInterceptor(ibatisInterceptor);
  23.         return "interceptor";
  24.     }
  26. }

使用注解

直接在拦截器类上面使用@Component注解即可（本文中就是直接使用的注解）

使用拦截器

使用mybatis拦截器，需要实现Interceptor接口的三个方法：

  1. intercept()：当方法被拦截时调用，用于设置拦截后需要执行的业务逻辑，自定义拦截器时，此方法是必须实现的。
  2. plugin()：在mybatis加载配置时被调用。设置是否需要对对象进行拦截
  • 拦截对象：调用wrap()方法，返回一个代理对象，并执行intercept()方法
  • 不拦截对象：直接返回目标原本对象，不会执行intercept()方法
  1. setProperties()：在mybatis加载配置时被调用。获取并设置mybatis配置文件或配置类中的property属性的值，配置类见上面注册拦截器时的演示

mybatis配置文件演示：

  1.    <environments default="mysql">
  2.         <environment id="mysql">
  3.             <transactionManager type="JDBC"/>
  4.             <dataSource type="POOLED">
  5.                 <!--mybatis配置项，上面的setProperties()方法中获取的propertys就是这里的-->
  6.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  7.                 <property name="url" value="jdbc:mysql://localhost:3306/test"/>
  8.                 <property name="username" value="root"/>
  9.                 <property name="password" value="123456"/>
  10.             </dataSource>
  11.         </environment>
  12.     </environments>

原理图：
image.png

简单使用

以拦截执行器方法为例。
示例：拦截更新操作，在更新操作时统一添加 “更新时间 ”字段，同时打印当前sql语句。

从语义角度分析： insert、delete、update都是属于更新（update）操作； 而select属于查询（query）操作。

  2. import com.example.bean.User;
  3. import org.apache.ibatis.executor.Executor;
  4. import org.apache.ibatis.mapping.BoundSql;
  5. import org.apache.ibatis.mapping.MappedStatement;
  6. import org.apache.ibatis.mapping.SqlCommandType;
  7. import org.apache.ibatis.plugin.*;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import org.springframework.stereotype.Component;
  12. import java.lang.reflect.Field;
  13. import java.sql.Date;
  14. import java.time.LocalDateTime;
  15. import java.util.Properties;
  18. @Component
  19. @Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
  20. public class IbatisInterceptor implements Interceptor {
  22.     private Logger logger = LoggerFactory.getLogger(IbatisInterceptor.class);
  24.     @Override
  25.     public Object intercept(Invocation invocation) throws Throwable {
  27.         Object[] args = invocation.getArgs();
  28.         SqlCommandType sqlCommandType = null;
  30.         for (Object object : args) {
  32.             // 从MappedStatement中获取到操作类型
  33.             if (object instanceof MappedStatement) {
  34.                 MappedStatement mappedStatement = (MappedStatement) object;
  35.                 sqlCommandType = mappedStatement.getSqlCommandType();
  37.                 // 获取当前擦操作的sql语句
  38.                 BoundSql boundSql = mappedStatement.getBoundSql(object);
  39.                 String sql = boundSql.getSql();
  41.                 // 打印当前操作类型及当前操作的sql语句
  42.                 logger.info("操作类型： {},操作语句：{}", sqlCommandType, sql);
  43.             }
  44.             // 判断参数的类型是否和实体类一致（这里只有一个参数，所以直接用if判断）
  45.             if (object instanceof User) {
  46.                 if (SqlCommandType.UPDATE == sqlCommandType) {
  47.                     // 由于没有写额外的获取实体类属性的方法，所以这里只能利用反射机制，获取需要修改的字段对应的实体类属性
  48.                     Field updateTime = object.getClass().getDeclaredField("updateTime");
  49.                     updateTime.setAccessible(true);
  50.                     // 对数据进行修改
  51.                     updateTime.set(object, Date.valueOf(LocalDateTime.now().toLocalDate()));
  52.                 }
  54.             }
  55.         }
  56.         return invocation.proceed();
  57.     }
  59.     @Override
  60.     public Object plugin(Object target) {
  61.         //  拦截属于Executor的对象
  62.         if (target instanceof Executor) {
  63.             // 返回代理
  64.             return Plugin.wrap(target, this);
  65.         }
  66.         //  否则返回对象本身
  67.         return target;
  68.     }
  70.     @Override
  71.     public void setProperties(Properties properties) {
  73.     }
  74. }

拦截多个请求

示例：只做简单示例，不涉及业务逻辑

  2. import com.example.bean.User;
  3. import org.apache.ibatis.executor.Executor;
  4. import org.apache.ibatis.executor.parameter.ParameterHandler;
  5. import org.apache.ibatis.mapping.BoundSql;
  6. import org.apache.ibatis.mapping.MappedStatement;
  7. import org.apache.ibatis.mapping.SqlCommandType;
  8. import org.apache.ibatis.plugin.*;
  9. import org.apache.ibatis.session.RowBounds;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.stereotype.Component;
  14. import java.sql.PreparedStatement;
  15. import java.util.Properties;
  18. @Component
  19. @Intercepts({@Signature(type = Executor.class,method = "query", args = {MappedStatement.class, Object.class}),
  20.         @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
  21.         @Signature(type = Executor.class, method = "createCacheKey", args = {MappedStatement.class, Object.class, RowBounds.class, BoundSql.class}),
  22.         @Signature(type = ParameterHandler.class, method = "setParameters", args = PreparedStatement.class),
  24. })
  25. public class IbatisInterceptor implements Interceptor {
  27.     private Logger logger = LoggerFactory.getLogger(IbatisInterceptor.class);
  29.     @Override
  30.     public Object intercept(Invocation invocation) throws Throwable {
  32.         Object[] args = invocation.getArgs();
  33.         SqlCommandType sqlCommandType = null;
  35.         for (Object object : args) {
  37.             // 从MappedStatement中获取到操作类型
  38.             if (object instanceof MappedStatement) {
  39.                 MappedStatement mappedStatement = (MappedStatement) object;
  40.                 sqlCommandType = mappedStatement.getSqlCommandType();
  42.                 // 判断参数的类型是否和实体类一致（这里只有一个参数，所以直接用if判断）
  43.                 if (object instanceof User) {
  44.                     if (SqlCommandType.UPDATE == sqlCommandType) {
  45. //                   执行更新操作修改
  46.                     } else if (SqlCommandType.SELECT == sqlCommandType) {
  47. //                    执行查询操作修改
  48.                     } else if (SqlCommandType.DELETE == sqlCommandType) {
  49. //                    执行删除操作修改
  50.                     } else if (SqlCommandType.INSERT == sqlCommandType) {
  51. //                    执行插入操作修改
  52.                     }
  53.                 }
  54.             }else if(object instanceof PreparedStatement){
  55.                 // 从PreparedStatement中获取到操作类型
  56.                 PreparedStatement preparedStatement =  (PreparedStatement) object;
  57. //                doSomething
  58.             }
  59.             // 判断参数的类型是否和实体类一致（这里只有一个参数，所以直接用if判断）
  60.                 if (object instanceof User) {
  61.                     if (SqlCommandType.UPDATE == sqlCommandType) {
  62. //                   执行更新操作修改
  63.                     } else if (SqlCommandType.SELECT == sqlCommandType) {
  64. //                    执行查询操作修改
  65.                     } else if (SqlCommandType.DELETE == sqlCommandType) {
  66. //                    执行删除操作修改
  67.                     } else if (SqlCommandType.INSERT == sqlCommandType) {
  68. //                    执行插入操作修改
  69.                     }
  70.                 }
  71.         }
  72.         return invocation.proceed();
  73.     }
  75.     @Override
  76.     public Object plugin(Object target) {
  77.         if (target instanceof Executor) {
  78.             return Plugin.wrap(target, this);
  79.         }
  80.         return target;
  81.     }
  83.     @Override
  84.     public void setProperties(Properties properties) {
  85. //        String username = properties.getProperty("username");
  86. //        String password = properties.getProperty("password");
  87.     }
  88. }

拦截并修改sql语句

从上面的示例中我们能够发现，是可以在拦截器中获取到sql语句的，那么我们就可以通过反射修改sql语句。
将通过id删除数据的sql语句改为通过name删除的sql语句：
有两种方法：
第一种是通过Statement修改

  1. import org.apache.ibatis.executor.Executor;
  2. import org.apache.ibatis.mapping.*;
  3. import org.apache.ibatis.plugin.*;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.stereotype.Component;
  8. import java.util.Properties;
  11. @Component
  12. @Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
  13. public class IbatisInterceptor implements Interceptor {
  15.     private Logger logger = LoggerFactory.getLogger(IbatisInterceptor.class);
  17.     @Override
  18.     public Object intercept(Invocation invocation) throws Throwable {
  20.         Object[] args = invocation.getArgs();
  21.         SqlCommandType sqlCommandType = null;
  23.         for (Object object : args) {
  25.             // 从MappedStatement中获取到操作类型
  26.             if (object instanceof MappedStatement) {
  27.                 MappedStatement mappedStatement = (MappedStatement) object;
  28.                 sqlCommandType = mappedStatement.getSqlCommandType();
  30.                 // 获取当前擦操作的sql语句
  31.                 BoundSql boundSql = mappedStatement.getBoundSql(object);
  32.                 String sql = boundSql.getSql();
  34.                 // 打印当前操作类型及当前操作的sql语句
  35.                 logger.info("操作类型： {},操作语句：{}", sqlCommandType, sql);
  37.                 // 设置新的sql语句
  38.                 String newSql = "delete from users where u_name=?";
  40.                 /*
  41.                 * 通过statement修改sql语句
  42.                 */
  44.                 // 重新new一个查询语句对像
  45.                 BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), newSql, boundSql.getParameterMappings(), boundSql.getParameterObject());
  47.                 // 把新的查询放到statement里
  48.                 MappedStatement neMappedStatement = copyFromMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
  49.                 for (ParameterMapping mapping : boundSql.getParameterMappings()) {
  50.                     String prop = mapping.getProperty();
  51.                     if (boundSql.hasAdditionalParameter(prop)) {
  52.                         newBoundSql.setAdditionalParameter(prop, boundSql.getAdditionalParameter(prop));
  53.                     }
  54.                 }
  56.                 final Object[] queryArgs = invocation.getArgs();
  57.                 // 这个i就是设置你需要修改哪个拦截的请求,对应上面的@Intercepts注解中的数组中的元素(@Signature注解)对应的索引
  58.                 // 因为我上面只有一个(@Signature注解的)元素,对应的索引自然也就是0
  59.                 int i = 0;
  60.                 queryArgs[i] = neMappedStatement;
  61.             }
  62.         }
  63.         return invocation.proceed();
  64.     }
  66.     @Override
  67.     public Object plugin(Object target) {
  68.         //  拦截属于Executor的对象
  69.         if (target instanceof Executor) {
  70.             // 返回代理
  71.             return Plugin.wrap(target, this);
  72.         }
  73.         //  否则返回对象本身
  74.         return target;
  75.     }
  77.     @Override
  78.     public void setProperties(Properties properties) {
  80.     }
  82.     private MappedStatement copyFromMappedStatement(MappedStatement ms, SqlSource newSqlSource) {
  83.         MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), newSqlSource, ms.getSqlCommandType());
  84.         builder.resource(ms.getResource());
  85.         builder.fetchSize(ms.getFetchSize());
  86.         builder.statementType(ms.getStatementType());
  87.         builder.keyGenerator(ms.getKeyGenerator());
  88.         if (ms.getKeyProperties() != null && ms.getKeyProperties().length > 0) {
  89.             builder.keyProperty(ms.getKeyProperties()[0]);
  90.         }
  91.         builder.timeout(ms.getTimeout());
  92.         builder.parameterMap(ms.getParameterMap());
  93.         builder.resultMaps(ms.getResultMaps());
  94.         builder.resultSetType(ms.getResultSetType());
  95.         builder.cache(ms.getCache());
  96.         builder.flushCacheRequired(ms.isFlushCacheRequired());
  97.         builder.useCache(ms.isUseCache());
  98.         return builder.build();
  99.     }
  101.     public static class BoundSqlSqlSource implements SqlSource {
  102.         private BoundSql boundSql;
  104.         public BoundSqlSqlSource(BoundSql boundSql) {
  105.             this.boundSql = boundSql;
  106.         }
  108.         public BoundSql getBoundSql(Object parameterObject) {
  109.             return boundSql;
  110.         }
  111.     }
  112. }

第二种是直接通过反射修改：

  2. import org.apache.ibatis.executor.Executor;
  3. import org.apache.ibatis.mapping.BoundSql;
  4. import org.apache.ibatis.mapping.MappedStatement;
  5. import org.apache.ibatis.mapping.SqlCommandType;
  6. import org.apache.ibatis.plugin.*;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.stereotype.Component;
  11. import java.lang.reflect.Field;
  12. import java.util.Properties;
  15. @Component
  16. @Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
  17. public class IbatisInterceptor implements Interceptor {
  19.     private Logger logger = LoggerFactory.getLogger(IbatisInterceptor.class);
  21.     @Override
  22.     public Object intercept(Invocation invocation) throws Throwable {
  24.         Object[] args = invocation.getArgs();
  25.         SqlCommandType sqlCommandType = null;
  27.         for (Object object : args) {
  29.             // 从MappedStatement中获取到操作类型
  30.             if (object instanceof MappedStatement) {
  31.                 MappedStatement mappedStatement = (MappedStatement) object;
  32.                 sqlCommandType = mappedStatement.getSqlCommandType();
  34.                 // 获取当前擦操作的sql语句
  35.                 BoundSql boundSql = mappedStatement.getBoundSql(object);
  36.                 String sql = boundSql.getSql();
  38.                 // 打印当前操作类型及当前操作的sql语句
  39.                 logger.info("操作类型： {},操作语句：{}", sqlCommandType, sql);
  41.                 // 设置新的sql语句
  42.                 String newSql = "delete from users where u_name=?";
  44.                 // 通过反射修改sql语句
  45.                 Field field = boundSql.getClass().getDeclaredField("sql");
  46.                 field.setAccessible(true);
  47.                 field.set(boundSql, newSql);
  49.             }
  50.         }
  51.         return invocation.proceed();
  52.     }
  54.     @Override
  55.     public Object plugin(Object target) {
  56.         //  拦截属于Executor的对象
  57.         if (target instanceof Executor) {
  58.             // 返回代理
  59.             return Plugin.wrap(target, this);
  60.         }
  61.         //  否则返回对象本身
  62.         return target;
  63.     }
  65.     @Override
  66.     public void setProperties(Properties properties) {
  68.     }
  70. }

最后来个图吧：
image.png