mybatis-3.5.0使用插件拦截sql以及通用字段赋值

已于 2024-05-02 17:55:21 修改
阅读量348 收藏
点赞数 2
文章标签： mybatis sql java
于 2024-04-19 09:02:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z275598733/article/details/137949421
版权

1、添加插件配置类

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.defaults.DefaultSqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import tk.mybatis.mapper.annotation.LogicDelete;
import tk.mybatis.mapper.annotation.Version;

import java.io.File;
import java.lang.reflect.Field;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

    public MybatisInterception() {
    }

    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement)invocation.getArgs()[0];
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();

        Object parameter = invocation.getArgs()[1];
        if (parameter == null) {
            return invocation.proceed();
        } else {
            Field[] declaredFields = this.getAllFields(parameter);
            Date now = new Date();
            String userId = ContextUtil.getUserId();
            Integer dteptId = ContextUtil.getDteptId();
            Field[] var9 = declaredFields;

            if (SqlCommandType.DELETE.equals(sqlCommandType)) {

                BoundSql boundSql = mappedStatement.getBoundSql(parameter);

                //转换DELETE语句为逻辑删除语句
                String logicDeleteSql = convertToLogicDelete(boundSql.getSql());

                FieldUtils.writeField(boundSql, "sql", logicDeleteSql, true);

                MappedStatement newMappedStatement = new MappedStatement.Builder(mappedStatement.getConfiguration(),
                        mappedStatement.getId(), new BoundSqlSqlSource(boundSql), mappedStatement.getSqlCommandType())
                        .build();

                invocation.getArgs()[0] = newMappedStatement;

                return invocation.proceed();
            }

            if(parameter instanceof DefaultSqlSession.StrictMap) {
                DefaultSqlSession.StrictMap strictMap = (DefaultSqlSession.StrictMap) parameter;
                Object collection = strictMap.get("collection");
                if(collection instanceof Collection) {
                    for (Object obj : ((Collection<Object>) collection)) {
                        Field[] fields = this.getAllFields(obj);
                        for (Field field : fields) {
                            extracted(sqlCommandType, obj, now, userId, dteptId, field);
                        }
                    }
                }
            } else {
                for (Field field : var9) {
                    extracted(sqlCommandType, parameter, now, userId, dteptId, field);
                }
            }
            return invocation.proceed();
        }
    }

    private void extracted(SqlCommandType sqlCommandType, Object parameter, Date now, String userId, Integer dteptId, Field field) throws IllegalAccessException {
        if (field.getAnnotation(NotAutoFill.class) == null) {
            Class clazz;
            if (SqlCommandType.INSERT.equals(sqlCommandType)) {
                if (field.getAnnotation(CreateTime.class) != null || Objects.equals(field.getName(), "createTime")) {
                    field.setAccessible(true);
                    field.set(parameter, now);
                }

                if (field.getAnnotation(Version.class) != null || Objects.equals(field.getName(), "version")) {
                    field.setAccessible(true);
                    field.set(parameter, 1);
                }

                if (field.getAnnotation(LogicDelete.class) != null || Objects.equals(field.getName(), "isDeleted")) {
                    field.setAccessible(true);
                    field.set(parameter, 0);
                }

                if (Objects.equals(field.getName(), "status")) {
                    field.setAccessible(true);
                    if (field.getType() == Integer.class) {
                        field.set(parameter, 0);
                    }
                }

                if (Objects.equals(field.getName(), "createBy")) {
                    field.setAccessible(true);
                    if (StringUtils.isNotEmpty(userId)) {
                        clazz = field.getType();
                        if (clazz == Integer.class) {
                            field.set(parameter, Integer.parseInt(userId));
                        } else {
                            field.set(parameter, userId);
                        }
                    }
                }

                if (Objects.equals(field.getName(), "createDeptId")) {
                    field.setAccessible(true);
                    field.set(parameter, dteptId);
                }
            }

            if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) {
                if (field.getAnnotation(UpdateTime.class) != null || Objects.equals(field.getName(), "updateTime")) {
                    field.setAccessible(true);
                    field.set(parameter, now);
                }

                if (Objects.equals(field.getName(), "updateBy")) {
                    field.setAccessible(true);
                    clazz = field.getType();
                    if (StringUtils.isNotEmpty(userId)) {
                        if (clazz == Integer.class) {
                            field.set(parameter, Integer.parseInt(userId));
                        } else {
                            field.set(parameter, userId);
                        }
                    }
                }
            }
        }
    }

    public static Class<?> findEntityClassByTableName(String tableName, String basePackage) {
        ClassPathScanningCandidateComponentProvider scanner =
                new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(Table.class));
        Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(basePackage);
        for (BeanDefinition beanDefinition : beanDefinitions) {
            try {
                Class<?> clazz = Class.forName(beanDefinition.getBeanClassName());
                Table table = clazz.getAnnotation(Table.class);
                if (table != null && table.name().equals(tableName)) {
                    return clazz;
                }
            } catch (ClassNotFoundException e) {
               continue;
            }
        }
        return null;
    }

    private String convertToLogicDelete(String sql) throws NoSuchFieldException {
        Pattern pattern = Pattern.compile("DELETE\\s+FROM\\s+(\w+)\\s+WHERE\\s+(.*)", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Matcher matcher = pattern.matcher(sql);

        if (matcher.matches()) {
            String tableName = matcher.group(1); //获取表名

            Class<?> classByTableName = findEntityClassByTableName(tableName, "com.demo.entity");
            if(classByTableName == null) {
                return sql;
            }

            Field isDeletedField = getDeletedField(classByTableName);

            if(isDeletedField == null || isDeletedField.getAnnotation(LogicDelete.class) == null) {
                return sql;
            }

            String whereClause = matcher.group(2).trim(); //获取WHERE子句并去除两端空白字符

            // 构建逻辑删除的UPDATE语句
            StringBuilder logicDeleteSql = new StringBuilder();
            logicDeleteSql.append("UPDATE ").append(tableName).append(" SET ").append("is_deleted").append(" = ").append(1);

            //如果WHERE子句不为空或不全为空白字符，则加上WHERE子句
            if (!whereClause.isEmpty()) {
                logicDeleteSql.append(" WHERE ").append(whereClause);
            }
            return logicDeleteSql.toString();
        } else {
            // 如果SQL语句格式不匹配，则返回原始SQL或抛出异常，这里为了简单起见，直接返回原始 SQL
            return sql;
        }
    }

    public Object plugin(Object o) {
        return Plugin.wrap(o, this);
    }

    public void setProperties(Properties properties) {
    }

    private Field getDeletedField(Class clazz) {
        String isDeleted =  "isDeleted";
        Field isDeletedField = null;
        for (Class<?> c = clazz; c != null; c = c.getSuperclass()) {
            Field[] declaredFields = c.getDeclaredFields();
            for (Field field : declaredFields) {
                if(field.getName().equals(isDeleted)) {
                    isDeletedField = field;
                    break;
                }
            }
        }
        return isDeletedField;
    }

    private Field[] getAllFields(Object object) {
        Class<?> clazz = object.getClass();
        ArrayList fieldList;
        for(fieldList = new ArrayList(); clazz != null; clazz = clazz.getSuperclass()) {
            fieldList.addAll(new ArrayList(Arrays.asList(clazz.getDeclaredFields())));
        }
        Field[] fields = new Field[fieldList.size()];
        fieldList.toArray(fields);
        return fields;
    }

    public class BoundSqlSqlSource implements SqlSource {

        private BoundSql boundSql;

        public BoundSqlSqlSource(BoundSql boundSql) {
            this.boundSql = boundSql;
        }

        @Override
        public BoundSql getBoundSql(Object parameterObject) {
            return boundSql;
        }
    }
}

2、修改mybatis-config.xml

切身经历但不一定是真相：项目已经有拦截器和mybatis-config.xml比如在公共依赖中，再新建mybatis-config.xml会存在覆盖xml配置的情况，虽然拦截器都生效了。如果命名为mybatis-config-xxx.xml等拦截器就没有生效。通过采用配置类的形式，暂时未发现不良影响。

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 插件配置... -->
    <plugins>
        <plugin interceptor="xxx.xxx.MybatisInterceptor">
            <!-- 插件可以配置属性，如果需要的话 -->
            <!-- <property name="someProperty" value="someValue"/> -->
        </plugin>
    </plugins>

    <!-- 其他配置... -->
</configura

3、配置类，一般叫MybatisConfig，显然不可重名。于是另起炉灶。

@Configuration
@AutoConfigureAfter({PageHelperAutoConfiguration.class})
public class MybatisFeatureConfig {
    @Autowired
    private List<SqlSessionFactory> sqlSessionFactoryList;

    public MybatisFeatureConfig() {
    }

    @PostConstruct
    public void addMyInterceptor() {
        MybatisInterception e = new MybatisInterception();
        Iterator var2 = this.sqlSessionFactoryList.iterator();

        while(var2.hasNext()) {
            SqlSessionFactory sqlSessionFactory = (SqlSessionFactory)var2.next();
            sqlSessionFactory.getConfiguration().addInterceptor(e);
        }

    }
}

4、基本思路，如果使用mybatis-plus我尚未注意过批量操作的问题，所以不知会有什么坑

5、遗留问题，采用替换sql的方式处理逻辑删除，会导致一些在xml里面自定义非逻辑删除语句变成逻辑删除。

与遨游于天地
关注
MyBatis之动态sql，插件
weixin_59196705的博客
04-18 959
动态SQL 基于OGNL表达式 完成多条件查询等逻辑实现 用于实现动态SQL的元素主要有 if trim where set choose（when、otherwise） foreach if 改造查询用户信息列表的演示示例，增加查询条件 用户角色（根据角色id查询） 用户名称（模糊查询） <!-- 当数据库中的字段信息与对象的属性不一致时需要通过resultMap
mybatis-plus-boot-starter-3.5.0.jar
最新发布
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-3.5.0.zip
08-09
mybatis-3.5.0的jar包
mybatis 3.5.0版本（一）
weixin_34261415的博客
03-31 726
2019独角兽企业重金招聘Python工程师标准>>> ...
mybatis自动sql生成插件源码
07-13
提供了一种自动生成sql语句的方法，它针对的对象是有主键或唯一索引的单表，提供的操作有增、删、改、查4种。适配的mybatis版本是3.2.2。
mybatis sql 监控插件
李荣强
12-24 1159
1、拦截器代码 @Intercepts({ @Signature(type = StatementHandler.class, method = "update", args = { Statement.class }), @Signature(type = StatementHandler.class, method = "query", args = {
mybatis-3.5.0-API文档-中英对照版.zip
07-13
赠送jar包：mybatis-3.5.0.jar； 赠送原API文档：mybatis-3.5.0-javadoc.jar； 赠送源代码：mybatis-3.5.0-sources.jar； 赠送Maven依赖信息文件：mybatis-3.5.0.pom； 包含翻译后的API文档：mybatis-3.5.0-javadoc-...
mybatis-3.5.0-API文档-中文版.zip
07-13
赠送jar包：mybatis-3.5.0.jar； 赠送原API文档：mybatis-3.5.0-javadoc.jar； 赠送源代码：mybatis-3.5.0-sources.jar； 赠送Maven依赖信息文件：mybatis-3.5.0.pom； 包含翻译后的API文档：mybatis-3.5.0-javadoc-...
mybatis-3.5.0.jar
01-08
mybatis-3.5.0.jar
mybatis SQL打印插件
编码爱好者
06-19 540
import java.text.DateFormat; import java.util.Date; import java.util.List; import java.util.Locale; import java.util.Properties; import java.util.regex.Matcher; import org.apache.commons.collections.CollectionUtils; import org.apache.ibatis.executor.Execu
mybatis替换问号完整Sql插件
11-22
<plugin interceptor="com.zheling.interceptor.FullSQLInterceptor"/>
官网mybatis3.4.5
09-25
mybatis3.4.5官网下载。mybatis3.4.5官网下载。mybatis3.4.5官网下载。mybatis3.4.5官网下载。mybatis3.4.5官网下载。
MyBatis拦截器 添加查询条件动态修改sql
08-17
通过mybatis的拦截器，实现为所有sql(或指定sql) 统一添加查询条件，譬如通过线程变量传递某参数（日期），来实现对指定参数的数据筛选，而不需要在每个查询前，手动将该条件注入到查询中。因该资料网络较少，故特此分享，如有优化之处，希望大家多多指点。
Mybatis-动态SQL、分页插件
金鳞踏雨
02-27 1209
Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL是动态变化的，此时在前面的学习中我们的 SQL 就不能满足要求了。 * 分页可以将很多条结果进行分页显示。 * 如果当前在第一页，则没有上一页。如果当前在最后一页，则没有下一页。 * 需要明确当前是第几页，这一页中显示多少条结果。
手写mybatis完整sql插件
whhwch1986的博客
05-22 2256
问题产生 我们在使用mybatis的过程中，如果开启了mysql的日志功能的话，会在控制台打印一些sql的信息，但是日志中的sql语句，是没有拼接参数的，也就是说，是不可以直接放到数据库中执行的。 some times，我们在调试问题的时候，会希望有一个直接可以运行的SQL语句，那将方便很多，特别是在sql语句绑定参数很多的时候。 现象描述 默认的mysql日志配置和打印情况如下： <settings> <setting name="logImpl" value="STDOUT_L
mybatis 拦截器 给所有表的sql增删改查操作加上某个字段，配合springboot
weixin_38729746的博客
01-07 3416
mybatis 拦截器 有个需求需要对所有表新增一个字段resource_mark，来区分环境，但代码已经开发好，一个个添加麻烦，并且每个表都会有这个字段。 解决方法：mybatis拦截器 @Configuration public class MyBatisConfig { private final static Logger logger = LoggerFactory.getLogger(MyBatisConfig.class); //设计到的表，在配置文件配置，为空则代表全部
MyBatis插件开发——解析和记录输出完整的SQL语句
发现问题，面对问题，分析问题，解决问题，总结问题
06-18 3176
自定义MyBatis插件，该插件实现当MyBatis执行SQL发生异常时输出错误原因，SQL参数以及完整的SQL语句。在日常的开发中我们可以通过mybatis配置设置是否输出SQL，但是对于正常运行的SQL全部输出出来日志量过大，所以这里实现了仅针对于发生异常的时候输出执行的SQL语句。对于日志输出的SQL框架仅提供了带有占位符的SQL以及对应的参数，如果想要测试运行这个SQL还需要自己手动拼接下，所以为了提高效率，在插件中对于SQL进行解析和占位符的替换，最终输出的SQL语句是可以直接在数据库中运行的。
mybatis 打印完整sql插件
m0_67393295的博客
03-22 1321
昨天跟朋友吃饭,朋友不知怎么说到mybatis的sql打印,我说,我记得可以直接打印sql出来的,还需要插件吗他说打印的是有 代替符号的,这样参数如果多了就不好操作, 然后说了一个插件mybatis log plugin,直接下载然后重启,按照如图打开,发现多了一个窗口: 这时候打印的就是完整的sql了,当然,前提是要开启sql: 开发就很方便,如果线上有问题…暂时还是拼接好了,没有试过远程debug行不行,现在公司没有权限了…不像以前小公司自己玩… ...
mybatis 拦截器（Interceptor）实现公共属性赋值（代码优化）
比嗨皮兔
04-05 775
https://blog.csdn.net/qq_38428623/article/details/103981432 package com.jh.erp.web.interceptor; import com.jh.erp.service.model.UserInfo; import com.jh.erp.service.util.UserInfoUtils; import org.a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值