使用MyBatis拦截器后，摸鱼时间又长了。

- 日理万妓 2023-09-23 15:17 126阅读 0赞

### 场景 ###

在后端服务开发时，现在很流行的框架组合一般都是SSM（Spring MVC + Spring + MyBatis）或者SpringBoot集成Mybatis，JPA等持久层框架，在我们进行一些业务系统开发时，会有很多的业务数据表，而表中的信息从新插入开始，整个生命周期过程中可能会进行很多次的操作。

比如，我们在某网站购买一件商品，会生成一条订单记录，在支付完金额后订单状态会变为已支付，等最后我们收到订单商品，这个订单状态会变成已完成等。

假设我们的订单表`t_order`结果如下：

![format_png][]

当订单创建时，需要设置`insert_by`，`insert_time`，`update_by`，`update_time`的值；

在进行订单状态更新时，则只需要更新`update_by`，`update_time`的值。

那应该如何处理呢？

### 麻瓜做法 ###

最简单的做法，也是最容易想到的做法，就是在每个业务处理的代码中，对相关的字段进行处理。

比如订单创建的方法中，如下处理：

public void create(Order order){
        // ...其他代码
        // 设置审计字段
        Date now = new Date();
        order.setInsertBy(appContext.getUser());
        order.setUpdateBy(appContext.getUser());
        order.setInsertTime(now);
        order.setUpdateTime(now);
        orderDao.insert(order);
    }
    复制代码

订单更新方法则只设置`updateBy`和`updateTime`：

public void update(Order order){
        // ...其他代码
    
        // 设置审计字段
        Date now = new Date();
        order.setUpdateBy(appContext.getUser());
        order.setUpdateTime(now);
        orderDao.insert(order);
    }
    复制代码

这种方式虽然可以完成功能，但是存在一些问题：

*  需要在每个方法中按照不同的业务逻辑决定设置哪些字段；
 *  在业务模型变多后，每个模型的业务方法中都要进行设置，重复代码太多。

那我们知道这种方式存在问题以后，就得找找有什么好方法对不对，往下看！

### 优雅做法 ###

因为我们持久层框架更多地使用MyBatis，那我们就借助于MyBatis的拦截器来完成我们的功能。

首先我们来了解一下，什么是拦截器？

### 什么是拦截器？ ###

MyBatis的拦截器顾名思义，就是对某些操作进行拦截。通过拦截器可以对某些方法执行前后进行拦截，添加一些处理逻辑。

MyBatis的拦截器可以对Executor、StatementHandler、PameterHandler和ResultSetHandler 接口进行拦截，也就是说会对这4种对象进行代理。

拦截器设计的初衷就是为了让用户在MyBatis的处理流程中不必去修改MyBatis的源码，能够以插件的方式集成到整个执行流程中。

比如MyBatis中的`Executor`有`BatchExecutor`、`ReuseExecutor`、`SimpleExecutor`和`CachingExecutor`，如果这几种实现的`query`方法都不能满足你的需求，我们可以不用去直接修改MyBatis的源码，而通过建立拦截器的方式，拦截`Executor`接口的`query`方法，在拦截之后，实现自己的query方法逻辑。

在MyBatis中的拦截器通过Interceptor接口表示，该接口中有三个方法。

public interface Interceptor {
    
      Object intercept(Invocation invocation) throws Throwable;
    
      Object plugin(Object target);
    
      void setProperties(Properties properties);
    
    }
    复制代码

plugin方法是拦截器用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理。

当返回的是代理的时候我们可以对其中的方法进行拦截来调用intercept方法，当然也可以调用其他方法。

setProperties方法是用于在Mybatis配置文件中指定一些属性的。

#### 使用拦截器更新审计字段 ####

那么我们应该如何通过拦截器来实现我们对审计字段赋值的功能呢？

在我们进行订单创建和修改时，本质上是通过MyBatis执行insert、update语句，MyBatis是通过Executor来处理的。

我们可以通过拦截器拦截Executor，然后在拦截器中对要插入的数据对象根据执行的语句设置insert\_by,insert\_time,update\_by,update\_time等属性值就可以了。

#### 自定义拦截器 ####

自定义`Interceptor`最重要的是要实现`plugin`方法和`intercept`方法。

在`plugin`方法中我们可以决定是否要进行拦截进而决定要返回一个什么样的目标对象。

在`intercept`方法就是要进行拦截的时候要执行的方法。

对于`plugin`方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做`Plugin`的类，里面有一个静态方法`wrap(Object target,Interceptor interceptor)`，通过该方法可以决定要返回的对象是目标对象还是对应的代理。

但是这里还存在一个问题，就是我们如何在拦截器中知道要插入的表有审计字段需要处理呢？

因为我们的表中并不是所有的表都是业务表，可能有一些字典表或者定义表是没有审计字段的，这样的表我们不需要在拦截器中进行处理。

也就是说**我们要能够区分出哪些对象需要更新审计字段**。

这里我们可以定义一个接口，让需要更新审计字段的模型都统一实现该接口，这个接口起到一个标记的作用。

public interface BaseDO {
    }
    
    public class Order implements BaseDO{
    
        private Long orderId;
    
        private String orderNo;
    
        private Integer orderStatus;
    
        private String insertBy;
    
        private String updateBy;
    
        private Date insertTime;
    
        private Date updateTime;
        //... getter ,setter
    }
    复制代码

接下来，我们就可以实现我们的自定义拦截器了。

@Component("ibatisAuditDataInterceptor")
    @Intercepts({@Signature(method = "update", type = Executor.class, args = {MappedStatement.class, Object.class})})
    public class IbatisAuditDataInterceptor implements Interceptor {
    
        private Logger logger = LoggerFactory.getLogger(IbatisAuditDataInterceptor.class);
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
            // 从上下文中获取用户名
            String userName = AppContext.getUser();
            
            Object[] args = invocation.getArgs();
            SqlCommandType sqlCommandType = null;
            
            for (Object object : args) {
                // 从MappedStatement参数中获取到操作类型
                if (object instanceof MappedStatement) {
                    MappedStatement ms = (MappedStatement) object;
                    sqlCommandType = ms.getSqlCommandType();
                    logger.debug("操作类型： {}", sqlCommandType);
                    continue;
                }
                // 判断参数是否是BaseDO类型
                // 一个参数
                if (object instanceof BaseDO) {
                    if (SqlCommandType.INSERT == sqlCommandType) {
                        Date insertTime = new Date();
                        BeanUtils.setProperty(object, "insertedBy", userName);
                        BeanUtils.setProperty(object, "insertTimestamp", insertTime);
                        BeanUtils.setProperty(object, "updatedBy", userName);
                        BeanUtils.setProperty(object, "updateTimestamp", insertTime);
                        continue;
                    }
                    if (SqlCommandType.UPDATE == sqlCommandType) {
                        Date updateTime = new Date();
                        BeanUtils.setProperty(object, "updatedBy", userName);
                        BeanUtils.setProperty(object, "updateTimestamp", updateTime);
                        continue;
                    }
                }
                // 兼容MyBatis的updateByExampleSelective(record, example);
                if (object instanceof ParamMap) {
                    logger.debug("mybatis arg: {}", object);
                    @SuppressWarnings("unchecked")
                    ParamMap<Object> parasMap = (ParamMap<Object>) object;
                    String key = "record";
                    if (!parasMap.containsKey(key)) {
                        continue;
                    }
                    Object paraObject = parasMap.get(key);
                    if (paraObject instanceof BaseDO) {
                        if (SqlCommandType.UPDATE == sqlCommandType) {
                            Date updateTime = new Date();
                            BeanUtils.setProperty(paraObject, "updatedBy", userName);
                            BeanUtils.setProperty(paraObject, "updateTimestamp", updateTime);
                            continue;
                        }
                    }
                }
                // 兼容批量插入
                if (object instanceof DefaultSqlSession.StrictMap) {
                    logger.debug("mybatis arg: {}", object);
                    @SuppressWarnings("unchecked")
                    DefaultSqlSession.StrictMap<ArrayList<Object>> map = (DefaultSqlSession.StrictMap<ArrayList<Object>>) object;
                    String key = "collection";
                    if (!map.containsKey(key)) {
                        continue;
                    }
                    ArrayList<Object> objs = map.get(key);
                    for (Object obj : objs) {
                        if (obj instanceof BaseDO) {
                            if (SqlCommandType.INSERT == sqlCommandType) {
                                Date insertTime = new Date();
                                BeanUtils.setProperty(obj, "insertedBy", userName);
                                BeanUtils.setProperty(obj, "insertTimestamp", insertTime);
                                BeanUtils.setProperty(obj, "updatedBy", userName);
                                BeanUtils.setProperty(obj, "updateTimestamp", insertTime);
                            }
                            if (SqlCommandType.UPDATE == sqlCommandType) {
                                Date updateTime = new Date();
                                BeanUtils.setProperty(obj, "updatedBy", userName);
                                BeanUtils.setProperty(obj, "updateTimestamp", updateTime);
                            }
                        }
                    }
                }
            }
            return invocation.proceed();
        }
    
        @Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }
    
        @Override
        public void setProperties(Properties properties) {
        }
    }
    复制代码

通过上面的代码可以看到，我们自定义的拦截器`IbatisAuditDataInterceptor`实现了`Interceptor`接口。

在我们拦截器上的`@Intercepts`注解，`type`参数指定了拦截的类是`Executor`接口的实现，`method` 参数指定拦截`Executor`中的`update`方法，因为数据库操作的增删改操作都是通过`update`方法执行。

#### 配置拦截器插件 ####

在定义好拦截器之后，需要将拦截器指定到`SqlSessionFactoryBean`的`plugins`中才能生效。所以要按照如下方式配置。

<bean id="transSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="transDataSource" />
        <property name="mapperLocations">
            <array>
                <value>classpath:META-INF/mapper/*.xml</value>
            </array>
        </property>
        <property name="plugins">
            <array>
                
                <ref bean="ibatisAuditDataInterceptor" />
            </array>
        </property>
    复制代码

到这里，我们自定义的拦截器就生效了，通过测试你会发现，不用在业务代码中手动设置审计字段的值，会在事务提交之后，通过拦截器插件自动对审计字段进行赋值。

### 小结 ###

在本期内容中小黑给大家介绍了对于我们日常开发中很频繁的审计字段的更新操作，应该如何优雅地处理。

通过自定义MyBatis的拦截器，以插件的形式对一些有审计字段的业务模型自动赋值，避免重复编写枯燥的重复代码。

毕竟人生苦短，少写代码，多摸鱼。

如果本文对你有所帮助，给小黑点个赞鼓励下。

[format_png]: https://img-blog.csdnimg.cn/img_convert/ae8b8e445faf08e3b9dddbe40c65f3bc.webp?x-oss-process=image/format,png