sqlSessionFoctory添加自定义拦截器，给数据库表设置默认值

1、给sqlSessionFoctory添加自定义拦截器

package com.scm.common.config;

import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
// 这里注释了，下面的不生效，所以所有的服务我都加了数据库配置，entrance去掉了排除数据源
//@ConditionalOnBean({SqlSessionFactory.class})
public class AutoSetConfiguration {
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    public AutoSetConfiguration() {
    }

    @PostConstruct
    public void init() {
        // 给sqlSessionFactory添加拦截器
        this.sqlSessionFactory.getConfiguration().addInterceptor(new AutoSetValueInterceptor());
    }
}

2、自定义拦截器

import lombok.Getter;
import lombok.Setter;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import tk.mybatis.mapper.annotation.LogicDelete;
import tk.mybatis.mapper.annotation.Version;
import tk.mybatis.mapper.entity.EntityColumn;
import tk.mybatis.mapper.entity.EntityField;
import tk.mybatis.mapper.mapperhelper.EntityHelper;
import tk.mybatis.mapper.util.MetaObjectUtil;

import javax.persistence.Table;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;

@Getter
@Setter
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
public class AutoSetValueInterceptor implements Interceptor {

    public Map<String, String> getUserInfo() {
        HttpServletRequest request = HttpContextUtils.getCurrentHttpRequest();

        String token = request.getHeader("Authorization");

        CacheService cacheService = SpringUtils.getBean(CacheService.class);
        Map<String, String> object = cacheService.getObject("usr:" + token, Map.class);
        return object;
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement mappedStatement = (MappedStatement) args[0];
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        if (sqlCommandType != SqlCommandType.INSERT && sqlCommandType != SqlCommandType.UPDATE) {
            return invocation.proceed();
        }
        Object parameter = args[1];
        Class<?> clazz = parameter.getClass();
        if (Map.class.isAssignableFrom(clazz)) {
            Map<String, Object> paramMap = (Map<String, Object>) parameter;
            if (paramMap.containsKey("param1")) {
                processData(sqlCommandType, paramMap.get("param1"));
            } else if (paramMap.containsKey("arg0")) {
                processData(sqlCommandType, paramMap.get("arg0"));
            } else if (paramMap.containsKey("list")) {
                processData(sqlCommandType, paramMap.get("list"));
            }
        } else {
            processData(sqlCommandType, parameter);
        }
        return invocation.proceed();
    }

    private boolean isSkipInject(Class clazz) {
        return clazz.getAnnotation(Table.class) == null;
    }

    private void processData(SqlCommandType sqlCommandType, Object parameter) {
        Map<String, String> userInfo = getUserInfo();
        Class<?> clazz = parameter.getClass();
        if (Collection.class.isAssignableFrom(clazz)) {
            Collection<?> collection = (Collection<?>) parameter;
            for (Object object : collection) {
                processData(sqlCommandType, object);
            }
            return;
        }

        if (isSkipInject(clazz)) {
            return;
        }

        List<EntityField> entityFieldList = getFields(clazz);
        MetaObject metaObject = MetaObjectUtil.forObject(parameter);
        for (EntityField field : entityFieldList) {
            // 如果是新增。走这
            if (sqlCommandType == SqlCommandType.INSERT) {
                if (field.isAnnotationPresent(CreatedDate.class)) {
                    metaObject.setValue(field.getName(), new Date());
                }
                if (field.isAnnotationPresent(CreatedBy.class)) {
                    metaObject.setValue(field.getName(), userInfo.get("userCode"));
                }
                if (field.isAnnotationPresent(CreatedName.class)) {
                    metaObject.setValue(field.getName(), userInfo.get("username"));
                }
                if (field.isAnnotationPresent(Org.class)) {
                    metaObject.setValue(field.getName(), userInfo.get("orgId"));
                }
                if (field.isAnnotationPresent(Platform.class)) {
                    metaObject.setValue(field.getName(), "SF");
                }
                if (field.isAnnotationPresent(Version.class)) {
                    metaObject.setValue(field.getName(), 0);
                }
                if (field.isAnnotationPresent(LogicDelete.class)) {
                    metaObject.setValue(field.getName(), false);
                }
            }
            // 修改走这
            if (sqlCommandType == SqlCommandType.UPDATE) {
                if (field.isAnnotationPresent(LastModifiedDate.class)) {
                    metaObject.setValue(field.getName(), new Date());
                }
                if (field.isAnnotationPresent(LastModifiedBy.class)) {
                    metaObject.setValue(field.getName(), userInfo.get("userCode"));
                }
                if (field.isAnnotationPresent(LastModifiedName.class)) {
                    metaObject.setValue(field.getName(), userInfo.get("username"));
                }
            }
        }
    }

    private List<EntityField> getFields(Class clazz) {
        return EntityHelper.getColumns(clazz).stream().map(EntityColumn::getEntityField).collect(Collectors.toList());
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

3、注解  可以自定义

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface CreatedBy {
}

4、实体在对应的字段上加上注解

  /**
     * 修改人名称
     */
    @LastModifiedName
    @Column(name = "update_user_name")
    private String updateUserName;

    /**
     * 修改时间
     */
    @LastModifiedDate
    @Column(name = "update_date")
    private Date updateDate;

    /**
     * 公司id
     */
    @Org
    @Column(name = "org_id")
    private String orgId;

5、执行测试用例