基于mybatis的Interceptor拦截器实现简单的CDC功能

最新推荐文章于 2024-08-21 23:39:15 发布
最新推荐文章于 2024-08-21 23:39:15 发布
阅读量631 收藏 19
点赞数 22
文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingning151/article/details/141029577
版权

一、背景

  1. 项目中有 30 多个功能点每个功能对应一张表。要求：每张表的增、删（逻辑删相当修改）、改的数据都需要同步到下游系统中。
  2. 客户方不让使用 Flink、Datax、canal 等工具。
  3. 这里的删除是逻辑删，相当于修改。
  4. 因为项目中有 30 多个功能点，我这里不想在接口中进行判断。因此考虑 mybatis 的拦截器。

二、思路

  1. 继承 Interceptor 接口实现自定义拦截器。
  2. 需要在自定义拦截器中获取到表名和字段值，主要是修改时间。
  3. 因为所有的表中都有修改时间字段，并且接口中所有对数据的新增修改都会更新这个时间。因此在拦截器中获取到表名和修改时间后反查表，捞出修改时间对应的所有数据。
  4. 整理获取到数据，发送到下游系统。

三、代码

  1. maven相关依赖
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.5</version>
        </dependency>
  1. CDCInterceptor.java //自定义拦截器，功能核心
package com.liran.middle.common.mybatis.interceptor;


import cn.hutool.core.convert.Convert;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.annotation.IEnum;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.liran.middle.common.base.utils.ThreadPoolUtil;
import com.liran.middle.common.mybatis.mapper.CommonMapper;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.JdbcParameter;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;


@Component
@Intercepts({
        @Signature(
                type = Executor.class,
                method = "update",
                args = {MappedStatement.class, Object.class}),
        // mybatis plus的批量方法最后后执行这个方法，因此进行拦截
        @Signature(
                type = Executor.class,
                method = "flushStatements",
                args = {})
})
@Slf4j
public class CDCInterceptor implements Interceptor {

    @Autowired
    public CommonMapper commonMapper;

    @Override
    public void setProperties(Properties properties) {
    }

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

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 先执行sql语句，保证数据入库之后再推送数据
        Object proceed = invocation.proceed();
        try {
            // 当使用mybatis plus的批量方法时，如updateBatchById、saveBatch，每条数据都会执行这个方法，会造成数据短时间内重复推送
            // "-2147482646" 表示批量操作其中一条数据的返回结果，遇到后直接抛弃不执行推送数据。所有的数据都执行完成后，会执行flushStatements方法，这个地方在进行拦截
            String str = Convert.toStr(proceed, "-1");
            if ("-2147482646".equals(str)) {
                return proceed;
            }

            Map<Date, String> updateAtMap;

            // "flushStatements" 表示批量操作的最后一次操作，此处进行发送消息
            if ("flushStatements".equals(invocation.getMethod().getName())) {
                updateAtMap = getBatchOperationsUpdateAt((List<Map<String, Object>>) proceed);
            } else {
                updateAtMap = getUpdateAt(invocation);
            }

            // 此处可以配置忽略的表（表的黑名单），如文件处理日志表，
            if (CollectionUtils.isEmpty(updateAtMap) || updateAtMap.values().stream().anyMatch(Arrays.asList("file_process_logs", "table2", "table3")::contains)) {
                log.info("表 {} 加入黑名单，不进行CDC同步数据", updateAtMap.values().stream().limit(1).toString());
                return proceed;
            }

            // 批量操作时，可能同一个表对应多个修改时间，因此使用map进行保存
            for (Map.Entry<Date, String> entry : updateAtMap.entrySet()) {
                sendData(entry.getValue(), entry.getKey());
            }

        } catch (Exception e) {
            log.error("CDC同步数据失败 error", e);
            return proceed;
        }
        return proceed;
    }

    private Map<Date, String> getBatchOperationsUpdateAt(List<Map<String, Object>> proceedList) throws Exception {
        BatchResult batchResult = (BatchResult) proceedList.get(0);
        SqlCommandType sqlCommandType = batchResult.getMappedStatement().getSqlCommandType();
        List<Object> parameterObjects = batchResult.getParameterObjects();
        Statement statement = CCJSqlParserUtil.parse(batchResult.getSql());
        String tableName = "";
        Map<Date, String> updateAtMap = new HashMap<>();
        if (sqlCommandType == SqlCommandType.INSERT) {
            Insert apply = (Insert) statement;
            tableName = apply.getTable().getName();
            for (Object parameterObject : parameterObjects) {
                Map etMap = JSON.parseObject(JSON.toJSONString(parameterObject), Map.class);
                updateAtMap.put(new Date(Convert.toLong(etMap.get("updatedAt"))), tableName);
            }
        } else if (sqlCommandType == SqlCommandType.UPDATE) {
            Update apply = (Update) statement;
            tableName = apply.getTable().getName();
            for (Object parameterObject : parameterObjects) {
                Map<String, Object> paraMap = (Map<String, Object>) parameterObject;
                Map etMap = JSON.parseObject(JSON.toJSONString(paraMap.get("et")), Map.class);
                updateAtMap.put(new Date(Convert.toLong(etMap.get("updatedAt"))), tableName);
            }
        } else {
            return Collections.emptyMap();
        }
        log.info("{} 这个是批量操作的方法!", tableName);
        return updateAtMap;
    }

    private Map<Date, String> getUpdateAt(Invocation invocation) throws Exception {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        Object parameter = invocation.getArgs()[1];
        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        Statement statement = CCJSqlParserUtil.parse(boundSql.getSql());
        String tableName = "";
        Map<String, Object> columnDatas = new HashMap<>();

        // 处理插入操作
        if (sqlCommandType == SqlCommandType.INSERT) {
            Insert apply = (Insert) statement;
            tableName = apply.getTable().getName();
            Map<String, Object> map = JSON.parseObject(JSON.toJSONString(parameter), Map.class);
            if (!Objects.isNull(map.get("collection"))) {
                List<Map<String, Object>> collectionList = (List<Map<String, Object>>) map.get("collection");
                for (Map<String, Object> collection : collectionList) {
                    columnDatas.put("UPDATED_AT", new Date(Convert.toLong(collection.get("updatedAt"))));
                }
            } else {
                columnDatas = getUpdatedColumnDatas(tableName, boundSql, statement);
            }
            log.info(tableName + "处理插入操作 ");
        } else if (sqlCommandType == SqlCommandType.UPDATE) { // 处理更新操作
            Update apply = (Update) statement;
            tableName = apply.getTable().getName();
            columnDatas = getUpdatedColumnDatas(tableName, boundSql, statement);
            log.info(tableName + "处理更新操作 ");
        } else if (sqlCommandType == SqlCommandType.DELETE) { // 处理删除操作
            log.info(tableName + "处理删除操作 ");
            // 处理删除操作，如何需要安装自己的逻辑编写
            return Collections.emptyMap();
        }

        Object updatedObject = columnDatas.get("UPDATED_AT");
        if (updatedObject instanceof String) {
            Date data = dateFormat((String) columnDatas.get("UPDATED_AT"));
            return Collections.singletonMap(data, tableName);
        } else {
            return Collections.singletonMap((Date) updatedObject, tableName);
        }
    }

    /**
     * 这个方法中可以写自己的业务逻辑
     * @param tableName 表名
     * @param updatedAt 修改时间
     */
    private void sendData(String tableName, Date updatedAt) {
        // 这里使用了线程池进行异步操作
        ThreadPoolUtil.submit(() -> {
            List<Map<String, Object>> data = commonMapper.getData(tableName, updatedAt);
            log.info("同步到其他系统的数据为 send data: {}", JSON.toJSONString(data));
            // 后续可以添加发送数据的逻辑
        });
    }

    protected Map<String, Object> getUpdatedColumnDatas(String tableName, BoundSql updateSql, Statement statement) {
        Map<String, Object> columnNameValMap = new HashMap<>(updateSql.getParameterMappings().size());
        Map<Integer, String> columnSetIndexMap = new HashMap<>(updateSql.getParameterMappings().size());
        List<Column> selectItemsFromUpdateSql = new ArrayList<>();
        if (statement instanceof Update) {
            Update updateStmt = (Update) statement;
            int index = 0;
            selectItemsFromUpdateSql.addAll(updateStmt.getColumns());
            List<Expression> updateList = updateStmt.getExpressions();
            for (int i = 0; i < updateList.size(); ++i) {
                Expression updateExps = updateList.get(i);
                if (!(updateExps instanceof JdbcParameter)) {
                    columnNameValMap.put(updateStmt.getColumns().get(i).getColumnName().toUpperCase(), updateExps.toString());
                }
                columnSetIndexMap.put(index++, updateStmt.getColumns().get(i).getColumnName().toUpperCase());
            }
        } else if (statement instanceof Insert) {
            Insert insert = (Insert) statement;
            selectItemsFromUpdateSql.addAll(insert.getColumns());
        }
        Map<String, String> relatedColumnsUpperCaseWithoutUnderline = new HashMap<>(selectItemsFromUpdateSql.size(), 1);
        for (Column item : selectItemsFromUpdateSql) {
            relatedColumnsUpperCaseWithoutUnderline.put(item.getColumnName().replaceAll("[._\\-$]", "").toUpperCase(), item.getColumnName().toUpperCase());
        }
        MetaObject metaObject = SystemMetaObject.forObject(updateSql.getParameterObject());
        int index = 0;
        for (ParameterMapping parameterMapping : updateSql.getParameterMappings()) {
            String propertyName = parameterMapping.getProperty();
            if (propertyName.startsWith("ew.paramNameValuePairs")) {
                ++index;
                continue;
            }
            String[] arr = propertyName.split("\\.");
            String propertyNameTrim = arr[arr.length - 1].replace("_", "").toUpperCase();
            try {
                final String columnName = columnSetIndexMap.getOrDefault(index++, getColumnNameByProperty(propertyNameTrim, tableName));
                if (relatedColumnsUpperCaseWithoutUnderline.containsKey(propertyNameTrim)) {
                    String colkey = relatedColumnsUpperCaseWithoutUnderline.get(propertyNameTrim);
                    Object valObj = metaObject.getValue(propertyName);
                    if (valObj instanceof IEnum) {
                        valObj = ((IEnum<?>) valObj).getValue();
                    } else if (valObj instanceof Enum) {
                        valObj = getEnumValue((Enum) valObj);
                    }
                    if (columnNameValMap.containsKey(colkey)) {
                        columnNameValMap.put(relatedColumnsUpperCaseWithoutUnderline.get(propertyNameTrim), String.valueOf(columnNameValMap.get(colkey)).replace("?", valObj == null ? "" : valObj.toString()));
                    }
                    if (columnName != null && !columnNameValMap.containsKey(columnName)) {
                        columnNameValMap.put(columnName, valObj);
                    }
                } else {
                    if (columnName != null) {
                        columnNameValMap.put(columnName, String.valueOf(metaObject.getValue(propertyName)));
                    }
                }
            } catch (Exception e) {
                log.warn("get value error,propertyName:{},parameterMapping:{}", propertyName, parameterMapping);
            }
        }
        dealWithUpdateWrapper(columnSetIndexMap, columnNameValMap, updateSql);
        return columnNameValMap;
    }


    private void dealWithUpdateWrapper(Map<Integer, String> columnSetIndexMap, Map<String, Object> columnNameValMap, BoundSql updateSql) {
        if (columnSetIndexMap.size() <= columnNameValMap.size()) {
            return;
        }
        MetaObject mpgenVal = SystemMetaObject.forObject(updateSql.getParameterObject());
        if (!mpgenVal.hasGetter(Constants.WRAPPER)) {
            return;
        }
        Object ew = mpgenVal.getValue(Constants.WRAPPER);
        if (ew instanceof UpdateWrapper || ew instanceof LambdaUpdateWrapper) {
            final String sqlSet = ew instanceof UpdateWrapper ? ((UpdateWrapper) ew).getSqlSet() : ((LambdaUpdateWrapper) ew).getSqlSet();// columnName=#{val}
            if (sqlSet == null) {
                return;
            }
            MetaObject ewMeta = SystemMetaObject.forObject(ew);
            Map paramNameValuePairs = (Map) ewMeta.getValue("paramNameValuePairs");
            String[] setItems = sqlSet.split(",");
            for (String setItem : setItems) {
                //age=#{ew.paramNameValuePairs.MPGENVAL1}
                String[] nameAndValuePair = setItem.split("=", 2);
                if (nameAndValuePair.length == 2) {
                    String setColName = nameAndValuePair[0].trim().toUpperCase();
                    String setColVal = nameAndValuePair[1].trim();//#{.mp}
                    if (columnSetIndexMap.containsValue(setColName)) {
                        String[] mpGenKeyArray = setColVal.split("\\.");
                        String mpGenKey = mpGenKeyArray[mpGenKeyArray.length - 1].replace("}", "");
                        final Object setVal = paramNameValuePairs.get(mpGenKey);
                        if (setVal instanceof IEnum) {
                            columnNameValMap.put(setColName, String.valueOf(((IEnum<?>) setVal).getValue()));
                        } else {
                            columnNameValMap.put(setColName, String.valueOf(setVal));
                        }
                    }
                }
            }
        }
    }

    private Object getEnumValue(Enum enumVal) {
        Optional<String> enumValueFieldName = MybatisEnumTypeHandler.findEnumValueFieldName(enumVal.getClass());
        if (enumValueFieldName.isPresent()) {
            return SystemMetaObject.forObject(enumVal).getValue(enumValueFieldName.get());
        }
        return enumVal;

    }

    private String getColumnNameByProperty(String propertyName, String tableName) {
        for (TableInfo tableInfo : TableInfoHelper.getTableInfos()) {
            if (tableName.equalsIgnoreCase(tableInfo.getTableName())) {
                final List<TableFieldInfo> fieldList = tableInfo.getFieldList();
                if (CollectionUtils.isEmpty(fieldList)) {
                    return propertyName;
                }
                for (TableFieldInfo tableFieldInfo : fieldList) {
                    if (propertyName.equalsIgnoreCase(tableFieldInfo.getProperty())) {
                        return tableFieldInfo.getColumn().toUpperCase();
                    }
                }
                return propertyName;
            }
        }
        return propertyName;
    }

    private Date dateFormat(String dataString) {
        // 定义第一个日期时间格式
        SimpleDateFormat inputFormat1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", java.util.Locale.ENGLISH);
        // 定义第二个日期时间格式
        SimpleDateFormat inputFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parsedDate;
        // 尝试使用第一个格式解析
        try {
            parsedDate = inputFormat1.parse(dataString);
        } catch (ParseException e) {
            log.info("BISendDorisServiceImpl#dateFormat-日期 {} 与格式 EEE MMM dd HH:mm:ss zzz yyyy 不匹配", dataString);
            // 如果第一个格式解析失败，尝试使用第二个格式解析
            try {
                parsedDate = inputFormat2.parse(dataString);
            } catch (ParseException ex) {
                // 如果第二个格式也解析失败，输出错误信息
                log.info("BISendDorisServiceImpl#dateFormat-日期 {} 与格式 yyyy-MM-dd HH:mm:ss 不匹配", dataString);
                log.info("BISendDorisServiceImpl#dateFormat-日期解析失败，返回为空");
                return null;
            }
        }
        return parsedDate;
    }
}
  1. CommonMapper.java // 反查表时 SQL 语句
package com.liran.middle.common.mybatis.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.Date;
import java.util.List;
import java.util.Map;

public interface CommonMapper extends BaseMapper<Object> {

    @Select("select * from  ${tableName} where  updated_at = #{updatedAt}")
    List<Map<String, Object>> getData(@Param("tableName") String tableName,
                                      @Param("updatedAt") Date updatedAt);

}
  1. ThreadPoolUtil.java // 线程池工具
package com.liran.middle.common.base.utils;


import java.util.concurrent.*;

public class ThreadPoolUtil {

    private static final ExecutorService EXECUTOR_SERVICE;

    static {
        // 配置线程池
        EXECUTOR_SERVICE = new ThreadPoolExecutor(
                5, // 核心线程数
                10, // 最大线程数
                60L, // 空闲线程存活时间
                TimeUnit.SECONDS, // 时间单位
                new LinkedBlockingQueue<>(1000), // 工作队列
                ThreadPoolUtil.threadFactory("async-CDC-"), // 线程工厂
                new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
    }

    private static ThreadFactory threadFactory(String name) {
        return runnable -> {
            Thread thread = new Thread(runnable, name);
            thread.setDaemon(true); // 设置为守护线程
            return thread;
        };
    }

    /**
     * 提交异步任务
     *
     * @param task 要执行的任务
     */
    public static void submit(Runnable task) {
        EXECUTOR_SERVICE.submit(task);
    }

    /**
     * 关闭线程池
     */
    public static void shutdown() {
        if (EXECUTOR_SERVICE != null) {
            EXECUTOR_SERVICE.shutdown();
        }
    }
}

四、注意事项

  1. 代码中生成的修改时间要和数据库保存的保持一致。比如：如果实体类中修改时间使用的 Date 类型数据库中字段使用 datetime 类型，并且使用 new Date() 生成当前时间，那么当毫秒值大于 500 时保存到数据库中时会自动加上一秒。导致代码中和数据库中时间不一致。
  2. mybatis plus 中提供了很多批量操作 updateBatchById、saveBatch 等。其中每条数据会触发一遍拦截器，并且所有的数据都加载完成后统一入库。因此我这边做了拦截，只有最后一条数据入库后才进行反查数据。
  3. 这种实现方式有很多限制：
    1. 每个表都要有修改时间。
    2. 拦截器中业务过于复杂时会有性能问题。所有的新增、修改的SQL都会慢。
    3. 通过修改时间反查表时可能获取不到。
    4. 多人在同一时间点修改了数据，导致相同的数据推送给下游系统多条。
  4. 推荐使用现有的CDC工具进行实时同步数据。
栗然
关注
Mybatis Interceptor 拦截器的实现
lemonrel的博客
10-11 3449
Mybatis采用责任链模式，通过动态代理组织多个拦截器（插件），通过这些拦截器可以改变Mybatis的默认行为（诸如SQL重写之类的），由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。 拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor，ParameterHandler，R...
Mybatis的拦截器Interceptor
Kwoky的博客
06-09 2182
Mybatis的拦截器Interceptor
MyBatis Interceptor拦截器高级用法
u010960161的专栏
04-12 401
场景描述：插入当前数据时，同时复制当前数据插入多行。比如平台权限的用户，可以同时给其他国家级别用户直接插入数据。更新数据时候，可能不止更新当前表，可能需要同时更新其他行数据。查询数据时候，可能需要同时默认加上某个条件。有些实体可能需要自行创建。
Mybatis拦截器Interceptor
wind_chasing_boy的博客
06-13 6361
最近项目使用Mybatis拦截器对数据进行加解密，以下记录如何将拦截器集成到项目中以及在使用过程中踩过的一些小坑，与君共勉Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。SqlSessionFactory：SqlSession工厂。
Mybatis之Interceptor拦截器
qh870754310的博客
02-07 3585
MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。那么拦截器拦截MyBatis中的哪些内容呢？ 我们进入官网看一看： MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) ParameterHandler (g
Spring Boot实践 --Mybatis Interceptor 拦截器应用
造梦先森Kai的专栏
10-21 1046
通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。//拦截器具体实现//拦截器的代理类//添加属性@Intercepts // 描述：标志该类是一个拦截器@Signature // 描述：指明该拦截器需要拦截哪一个接口的哪一个方法// @Signature注解中属性:type;// 四种类型接口中的某一个接口，如Executor.class；method;
Mybatis——拦截器Interceptor
热门推荐
娜娜米的博客
05-08 3万+
本篇介绍Mybatis拦截器/插件相关知识，包括相关的类及作用、拦截器有哪几种、拦截器可以在Mybatis的执行过程中的哪些节点起作用、拦截器如何使用、相关的API，最后附上代码示例。
自定义 Mybatis 拦截器实现权限功能
m0_63208096的博客
03-20 725
将信息存储到 TreadLocalhost 中，方便后续修改sql的时候可以读取到需要修改的字段。- method：对应接口中的哪类方法（因为可能存在重载方法）；Signature来指定咱们需要拦截那个类对象的哪个方法。- type：上述四种类型中的一种；- args：对应哪一个方法的入参；切面（AuthAspect）在所在接口上添加注解。
mybatis Interceptor拦截器代码详解
baihan2015的博客
12-29 537
　　mybatis官方定义：MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 　...
MyBatis拦截器(Interceptor)的理解与实践
学IT，找陈寒
06-19 1175
MyBatis拦截器是一种基于Java反射机制和动态代理的插件，用于拦截MyBatis的方法调用。它允许开发者在SQL语句执行前后、结果集处理前后等关键节点进行拦截，并在拦截器中编写自定义逻辑。SQL语句重写、增强或修改；对参数进行加工；对结果集进行加工；统计SQL执行时间；实现分页、缓存等通用功能。接下来，我们将通过一个实际的示例来展示如何编写和配置自定义拦截器，并说明其实现的功能和作用。
MyBatis拦截器实现分页功能的实现方法
09-09
总结来说，MyBatis拦截器实现分页功能需要定义一个分页对象来存储分页参数，然后通过实现Interceptor接口并重写intercept方法来修改原始SQL语句，最后在MyBatis配置中正确注册拦截器。这样就可以在不侵入原有业务...
mybatis拦截器实现通用权限字段添加的方法
08-25
拦截器可以实现各种功能，如权限控制、日志记录、性能监控等。 实现通用权限字段添加 在实际开发中，我们经常需要在SQL语句中添加一些通用权限字段，以便控制用户的操作权限。使用MyBatis拦截器，我们可以轻松地...
Mybatis中拦截器的简单实现方法
08-25
Mybatis的拦截器功能就是基于这样的动态代理机制实现的。 在Mybatis中，拦截器接口Interceptor定义了三个方法：intercept, plugin和setProperties。其中，intercept方法是核心，它会在拦截器链执行过程中被调用，...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 4875
【代码】MybatisPlus的LambdaQueryWrapper用法。
基于微信小程序的新生报到系统设计与实现.docx
09-13
基于微信小程序的新生报到系统设计与实现.docx
基于java的电商平台的设计与实现.docx
09-13
基于java的电商平台的设计与实现.docx
基于java的大学生智能消费记账系统的设计与实现.docx
09-13
基于java的大学生智能消费记账系统的设计与实现.docx
基于java的植物健康系统设计与实现.docx
最新发布
09-13
基于java的植物健康系统设计与实现.docx
MyBatis拦截器实现分页功能详解
"MyBatis拦截器用于实现分页功能的方法" 在MyBatis框架中，为了实现分页功能，我们可以利用拦截器机制来拦截原始的SQL查询，动态地添加分页相关的条件，然后生成带有分页信息的新SQL语句进行执行。这种方式避免了在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栗然

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值