Mybati填充基础信息

AI_PLUS_911

已于 2024-08-31 15:59:20 修改

阅读量280

点赞数 5

文章标签：开发语言

于 2024-08-31 15:55:32 首次发布

本文链接：https://blog.csdn.net/firstbluesky/article/details/141754030

版权

案例1

package com.byd.hr.annotation.aspect;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.*;


/**
 * @author lv.chunlei
 * @Version 1.0
 */
@Component
@Slf4j
// sql拦截器常规配置
@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 {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        // 获取sql的类型
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        // 获取sql的参数对象
        Object parameter = invocation.getArgs()[1];
        // 如果参数对象为空，就直接放行
        if (parameter == null) {
            return invocation.proceed();
        }
        // 获取当前用户登录的id
        //String loginId = LoginUtil.getLoginId();
        String loginId = "lvcl-test";
        if (StringUtils.isBlank(loginId)) {
            return invocation.proceed();
        }
        // 如果sql的类型是插入或者更新，对参数做替换，填充created_by、created_time、update_by、update_time、is_deleted
        if (SqlCommandType.INSERT == sqlCommandType || SqlCommandType.UPDATE == sqlCommandType) {
            replaceEntityProperty(parameter, loginId, sqlCommandType);
        }
        // 放行
        return invocation.proceed();
    }

    // 填充created_by、created_time、update_by、update_time、is_deleted
    private void replaceEntityProperty(Object parameter, String loginId, SqlCommandType sqlCommandType) {
        if (parameter instanceof Map) {
            // Map类型，就相当于批量插入的那种情况
            replaceMap((Map) parameter, loginId, sqlCommandType);
        } else {
            // 普通的eneity类型
            replace(parameter, loginId, sqlCommandType);
        }
    }

    private void replaceMap(Map parameter, String loginId, SqlCommandType sqlCommandType) {
        // 获取到所有的参数对象
        Collection values = parameter.values();
        for (Object value : values) {
            // 将每个参数对象都进行替换
            replace(value, loginId, sqlCommandType);
        }
    }

    /**
     * 填充数据的逻辑
     *
     * @param parameter
     * @param loginId
     * @param sqlCommandType
     */
    private void replace(Object parameter, String loginId, SqlCommandType sqlCommandType) {
        // 如果是插入类型的sql
        if (SqlCommandType.INSERT == sqlCommandType) {
            dealInsert(parameter, loginId);
        } else {
            // 由于只有插入类型和更新类型的sql类型会走到这里，所以这里一定就是更新类型了
            dealUpdate(parameter, loginId);
        }
    }

    /**
     * 更新类型的sql，填充数据的方式，对update_by、update_time进行填充
     *
     * @param parameter
     * @param loginId
     */
    private void dealUpdate(Object parameter, String loginId) {
        // 获取这个对象对应类的所有字段
        Field[] allFields = getAllFields(parameter);
        // 遍历字段
        for (Field field : allFields) {
            // 使用try-catch捕捉异常，使其不影响主程序的执行
            try {
                // 设置这个字段为可访问的
                field.setAccessible(true);
                // 得到字段的值，后面指定对象
                Object o = field.get(parameter);
                if (Objects.nonNull(o)) {
                    // 如果字段的值不是空的，将这个字段设置成不可访问的
                    field.setAccessible(false);
                    // 然后跳过这次循环，遍历下一个字段
                    continue;
                }
                // 如果字段的值是空的，则根据字段的名字来填充数据
                if ("modifier".equals(field.getName())) {
                    // 设置为用户的loginId
                    field.set(parameter, loginId);
                    // 设置字段为不可访问
                    field.setAccessible(false);
                } else if ("modifiedTime".equals(field.getName())) {
                    // 设置为当前时间
                    field.set(parameter, new Date());
                    // 设置字段为不可访问
                    field.setAccessible(false);
                } else {
                    // 如果不是这三个字段，就直接将这个字段设置为不可访问，然后遍历下一个字段
                    field.setAccessible(false);
                }

            } catch (Exception e) {
                log.error("dealInsert.error:{}", e.getMessage(), e);
            }
        }
    }

    /**
     * 插入类型的sql，填充数据的方式，对created_by、created_time、is_deleted进行填充
     *
     * @param parameter
     * @param loginId
     */
    private void dealInsert(Object parameter, String loginId) {
        // 获取这个对象对应类的所有字段
        Field[] allFields = getAllFields(parameter);
        // 遍历字段
        for (Field field : allFields) {
            // 使用try-catch捕捉异常，使其不影响主程序的执行
            try {
                // 设置这个字段为可访问的
                field.setAccessible(true);
                // 得到字段的值，后面指定对象
                Object o = field.get(parameter);
                if (Objects.nonNull(o)) {
                    // 如果字段的值不是空的，将这个字段设置成不可访问的
                    field.setAccessible(false);
                    // 然后跳过这次循环，遍历下一个字段
                    continue;
                }
                // 如果字段的值是空的，则根据字段的名字来填充数据
                if ("isDeleted".equals(field.getName())) {
                    // 默认设置为0，即未删除
                    field.set(parameter, 0);
                    // 设置字段为不可访问
                    field.setAccessible(false);
                } else if ("creator".equals(field.getName())) {
                    // 设置为用户的loginId
                    field.set(parameter, loginId);
                    // 设置字段为不可访问
                    field.setAccessible(false);
                } else if ("createTime".equals(field.getName())) {
                    // 设置为当前时间
                    field.set(parameter, new Date());
                    // 设置字段为不可访问
                    field.setAccessible(false);
                } else {
                    // 如果不是这三个字段，就直接将这个字段设置为不可访问，然后遍历下一个字段
                    field.setAccessible(false);
                }

            } catch (Exception e) {
                log.error("dealInsert.error:{}", e.getMessage(), e);
            }
        }
    }

    /**
     * 反射获取类的所有字段，并以字段数组的形式返回
     *
     * @param object
     * @return
     */
    private Field[] getAllFields(Object object) {
        // 获取当前对象对应类的Class对象
        Class<?> clazz = object.getClass();
        // 使用一个列表存储该类的所有字段信息
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null) {
            // 将字段信息放到字段列表中
            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
            // clazz指向父类
            clazz = clazz.getSuperclass();
        }
        // 循环完成后，就会将当前的对象对应的类以及父类的字段对象放到字段列表中
        // 创建一个Field类型的数组，大小跟字段列表相同
        Field[] fields = new Field[fieldList.size()];
        // 将字段列表的元素放到数组中
        fieldList.toArray(fields);
        return fields;
    }

    @Override
    public Object plugin(Object target) {
        // 返回一个代理对象，用于在方法调用时进行拦截处理
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 不需要任何处理
    }

}

案例2

/*******************************************************************************
 * Package: com.song.kkxxpoi.common
 * Type:    AutoInsertTime
 * Date:    2022-08-12 21:50
 *
 *
 *
 * You may not use this file except in compliance with the License.
 *******************************************************************************/
package com.alibaba.hr.annotation.aspect;

import com.byd.hr.annotation.CreateTime;
import com.byd.hr.annotation.CreatorId;
import com.byd.hr.annotation.ModifiedTime;
import com.byd.hr.annotation.ModifierId;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Date;
import java.util.Objects;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 功能描述：拦截器  反射
 *
 */
@Component
@Intercepts({@Signature(type = Executor.class, method = "update",
        args = {MappedStatement.class, Object.class})})
public class AutoInsertTimeAndUser implements Interceptor {


    @Override
    public Object intercept(Invocation invocation) throws Throwable {

        System.out.println("自动设置基本内容");
        System.out.println("自动设置基本内容");
        System.out.println("自动设置基本内容");
        // 线程安全
        /*AtomicReference<User> userAtomicReference = new AtomicReference<>();
        userAtomicReference.set(new User("sxy"));*/

        // 获取一个MappedStatement
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        // 获取 SQL 命令 UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        // 获取参数
        Object parameter = invocation.getArgs()[1];

        // 获取私有成员变量
        Field[] declaredFields = parameter.getClass().getDeclaredFields();

        for (Field field : declaredFields) {
            if (Objects.nonNull(field.getAnnotation(CreateTime.class))) {
                // 插入
                if (SqlCommandType.INSERT.equals(sqlCommandType)) {
                    field.setAccessible(true);
                    field.set(parameter, new Date());
                }
            }
            if (Objects.nonNull(field.getAnnotation(CreatorId.class))) {
                // 插入
                if (SqlCommandType.INSERT.equals(sqlCommandType)) {
                    field.setAccessible(true);
                    //field.set(parameter, userAtomicReference.get().getName());
                    field.set(parameter, "lvcl测试");
                }
            }
            if (Objects.nonNull(field.getAnnotation(ModifiedTime.class))) {
                // 修改
                if (SqlCommandType.UPDATE.equals(sqlCommandType) || SqlCommandType.INSERT.equals(sqlCommandType)) {
                    field.setAccessible(true);
                    field.set(parameter, new Date());
                }
            }
            if (Objects.nonNull(field.getAnnotation(ModifierId.class))) {
                // 修改
                if (SqlCommandType.UPDATE.equals(sqlCommandType) || SqlCommandType.INSERT.equals(sqlCommandType)) {
                    field.setAccessible(true);
                    /*field.set(parameter, userAtomicReference.get().getName());*/
                    field.set(parameter, "lvcl测试");
                }
            }
        }

        //获取方法参数
        Object[] args = invocation.getArgs();
        //获取方法名
        invocation.getMethod();
        //获取代理对象
        invocation.getTarget();
        return invocation.proceed();
    }

    /**
     * 生成MyBatis拦截器代理对象
     */
    @Override
    public Object plugin(Object target) {
        return Interceptor.super.plugin(target);
    }

    /**
     * 设置插件属性（直接通过Spring的方式获取属性，所以这个方法一般也用不到）
     * 项目启动的时候数据就会被加载
     */
    @Override
    public void setProperties(Properties properties) {
        Interceptor.super.setProperties(properties);
    }
}

案例3

package com.alibaba.hr.annotation.aspect;

import com.byd.hr.annotation.CreatorId;
import com.byd.hr.annotation.CreateTime;
import com.byd.hr.annotation.ModifierId;
import com.byd.hr.annotation.ModifiedTime;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Date;

@Aspect
@Component
public class SqlAspect {

    //@Before("execution(* com.byd.hr.entity..*(..)) && args(entity,..)")en
    //@Before("execution(* com.byd.hr.entity..*(..))")
    @Before("execution(* com.byd.hr.entity.*(..))")
    public void beforeSaveOrUpdate(Object entity) throws IllegalAccessException {
        System.out.println("注解生效");
        System.out.println("注解生效");
        System.out.println("注解生效");
        System.out.println("注解生效");
        if (entity != null) {
            // 获取所有字段，包括继承的字段
            Class<?> clazz = entity.getClass();
            while (clazz != null) {
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    field.setAccessible(true); // 设置可访问私有字段
                    if (field.isAnnotationPresent(CreatorId.class)) {
                        // 当前登录用户ID
                        field.set(entity, "login_user_id");
                    } else if (field.isAnnotationPresent(CreateTime.class)) {
                        // 当前时间
                        field.set(entity, new Date());
                    } else if (field.isAnnotationPresent(ModifierId.class)) {
                        // 当前登录用户ID
                        field.set(entity, "login_user_id");
                    } else if (field.isAnnotationPresent(ModifiedTime.class)) {
                        // 当前时间
                        field.set(entity, new Date());
                    }
                }
                clazz = clazz.getSuperclass();
            }
        }
    }

}```