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

场景

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

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

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

当订单创建时，需要设置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的拦截器，以插件的形式对一些有审计字段的业务模型自动赋值，避免重复编写枯燥的重复代码。

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

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

我是小黑，一名在互联网“苟且”的程序员

流水不争先，贵在滔滔不绝