MyBatis 插件开发

已于 2025-06-26 23:33:13 修改
阅读量270 收藏 6
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 数据库 文章标签： mybatis 插件 sql 拦截器
于 2025-06-22 13:56:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_t_t/article/details/148826921

说明

Mybatis 允许在映射语句执行过程中的某些点拦截对的调用。默认情况下，MyBatis 允许插件拦截以下方法调用：

拦截器方法说明
Executorupdate, query, flushStatements, commit, rollback, getTransaction, close, isClosed执行 SQL 的核心对象（增删改查、事务控制等），可以在这里打印 SQL 语句，监控 SQL 执行时间等
StatementHandlerprepare, parameterize, batch, update, query封装了 JDBC Statement 操作，是 SQL 语法的构建器，可以在这里对 SQL 语句进行修改
ParameterHandlergetParameterObject, setParameters处理 SQL 入参绑定
ResultSetHandlerhandleResultSets, handleOutputParameters处理查询结果

注：拦截需求并不一定要跟拦截器类型严格对应。如，一般在StatementHandler中修改SQL，但是也可以在ParameterHandler修改SQL，只要可以在执行前获取、修改SQL即可。

代码

NotInjectSQL注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 不需要修改SQL的方法的注解
 *
 * @author java_t_t
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotInjectSQL {
}

Desensitization注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 需要脱密的字段的注解
 *
 * @author java_t_t
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Desensitization {
}

Executor拦截器示例：

import lombok.extern.slf4j.Slf4j;
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.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;

@Slf4j
@Intercepts({
        @Signature(
                type = Executor.class, // 拦截的类
                method = "update", // 拦截的方法。insert、update、delete都属于update方法
                args = {MappedStatement.class, Object.class} // 方法参数
        ),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
                RowBounds.class, ResultHandler.class})
})
public class MybatisExecutorInterceptor implements Interceptor {
    private static final DateTimeFormatter LOCAL_DATE_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final DateTimeFormatter LOCAL_DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter LOCAL_TIME_FORMAT = DateTimeFormatter.ofPattern("HH:mm:ss");
    private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        log.info("=====> Executor");
        printSql(invocation);
        long startTime = System.currentTimeMillis();
        Object proceed = invocation.proceed();
        log.info("===> Executor ===> SQL expend " + (System.currentTimeMillis() - startTime) + " ms");
        return proceed;
    }

    private void printSql(Invocation invocation) {
        Object[] queryArgs = invocation.getArgs();
        MappedStatement mappedStatement = (MappedStatement) queryArgs[0];
        // 获取BoundSql对象，包含带占位符'?'的SQL，以及对应的参数列表
        BoundSql boundSql = mappedStatement.getBoundSql(queryArgs[1]);
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        Configuration configuration = mappedStatement.getConfiguration();
        // 替换空白符
        String originalSql = boundSql.getSql().replaceAll("[\\s]+", " ");
        String[] split = originalSql.split("\\?");
        int index = 0;
        StringBuffer sql = new StringBuffer(split[index++]);
        StringBuffer sb = new StringBuffer();
        if (parameterMappings.size() > 0 && parameterObject != null) {
            if (configuration.getTypeHandlerRegistry().hasTypeHandler(parameterObject.getClass())) {
                sql.append(String.format("\"%s\"", parameterObject)).append(index < split.length ? split[index++] : "");
            } else {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    Object obj = null;
                    if (metaObject.hasGetter(propertyName)) {
                        obj = metaObject.getValue(propertyName);
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        obj = boundSql.getAdditionalParameter(propertyName);
                    }
                    if (obj == null) {
                        sql.append("null").append(index < split.length ? split[index++] : "");
                        sb.append(propertyName).append(" = null, ");
                        continue;
                    }
                    String parameterValue;
                    String className = obj.getClass().getName();
                    switch (className) {
                        case "java.lang.String" -> parameterValue = "\"" + obj + "\"";
                        case "java.time.LocalDateTime" ->
                                parameterValue = String.format("STR_TO_DATE(\"%s\",\"%%Y-%%m-%%d %%H:%%i:%%s\")",
                                        LOCAL_DATE_TIME_FORMAT.format((LocalDateTime) obj));
                        case "java.time.LocalDate" ->
                                parameterValue = String.format("STR_TO_DATE(\"%s\",\"%%Y-%%m-%%d\")",
                                        LOCAL_DATE_FORMAT.format((LocalDate) obj));
                        case "java.time.LocalTime" ->
                                parameterValue = String.format("STR_TO_DATE(\"%s\",\"%%H:%%i:%%s\")",
                                        LOCAL_TIME_FORMAT.format((LocalTime) obj));
                        case "java.util.Date" ->
                                parameterValue = String.format("STR_TO_DATE(\"%s\",\"%%Y-%%m-%%d %%H:%%i:%%s\")",
                                        SIMPLE_DATE_FORMAT.format((Date) obj));
                        default -> parameterValue = obj.toString();
                    }
                    sql.append(parameterValue).append(index < split.length ? split[index++] : "");
                    sb.append(propertyName).append("=").append(obj).append("(").append(obj.getClass().getSimpleName()).append("), ");
                }
            }
            if (sb.length() > 2) {
                sb.deleteCharAt(sb.length() - 1);
                sb.deleteCharAt(sb.length() - 1);
            }
        }

        log.info("===> Executor ===> Original SQL: " + originalSql);
        log.info("===> Executor ===> Real SQL: " + sql);
        log.info("===> Executor ===> Real PARAM: " + sb);
    }
}

StatementHandler拦截器示例：

import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.JdbcParameter;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SetOperationList;
import net.sf.jsqlparser.statement.select.Values;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.statement.update.UpdateSet;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
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.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;

import java.io.StringReader;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

@Slf4j
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class MybatisStatementHandlerInterceptor implements Interceptor {
    private static final String IS_DELETE = "IS_DELETE";
    private static final String UPDATE_TIME = "UPDATE_TIME";
    private static final String CREATE_TIME = "CREATE_TIME";
    private static final String SQL_PATH = "delegate.boundSql.sql";
    private static final Column INJECT_CURRENT_TIMESTAMP = new Column("CURRENT_TIMESTAMP()");
    private static final EqualsTo INJECT_IS_DELETE = new EqualsTo()
            .withLeftExpression(new Column(IS_DELETE))
            .withRightExpression(new LongValue(0));
    private static final CCJSqlParserManager SQL_PARSER = new CCJSqlParserManager();

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        log.info("=====> StatementHandler");
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        log.info("===> StatementHandler ===> Original Sql:{}", metaObject.getValue(SQL_PATH).toString().replaceAll("[\\s]+", " "));
        injectSql(metaObject);
        log.info("===> StatementHandler ===> Modified Sql:{}", metaObject.getValue(SQL_PATH).toString().replaceAll("[\\s]+", " "));

        return invocation.proceed();

        /* 修改或添加查询参数
        metaObject.setValue("delegate.parameterHandler.parameterObject.pageSize", 5);
        metaObject.setValue("delegate.parameterHandler.parameterObject.addValue", "add_value");

        // 关闭内存分页。内存分页（逻辑分页）：把数据查询到内存中，再分页；物理分页：在sql语句中添加limit offset, size
        metaObject.setValue("delegate.rowBounds.offset", RowBounds.NO_ROW_OFFSET);
        metaObject.setValue("delegate.rowBounds.limit", RowBounds.NO_ROW_LIMIT);*/
    }

    private void injectSql(MetaObject metaObject) {
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        if (hasAnnotation(mappedStatement)) {
            return;
        }
        // mappedStatement.getSqlCommandType()的值是xml中的标签，跟实际的查询类型不一定完全符合，所以需要根据解析的实际结果决定注入方式
        String originalSql = (String) metaObject.getValue(SQL_PATH);
        try (StringReader sr = new StringReader(originalSql)) {
            Statement parse = SQL_PARSER.parse(sr);
            if (parse instanceof Insert) {
                injectInsert((Insert) parse, metaObject);
            } else if (parse instanceof Update) {
                injectUpdate((Update) parse, metaObject);
            } else if (parse instanceof Delete) {
                injectDelete((Delete) parse, metaObject);
            } else if (parse instanceof Select) {
                injectSelect((Select) parse, metaObject);
            }
        } catch (JSQLParserException e) {
            log.warn(e.getMessage());
        }
    }

    private void injectInsert(Insert insert, MetaObject metaObject) {
        ExpressionList<Column> columns = insert.getColumns();
        Values values = insert.getValues();
        if (columns == null || columns.isEmpty()
                || values == null || values.getExpressions() == null || values.getExpressions().isEmpty()) {
            return;
        }
        boolean noUpdateTime = true;
        boolean noCreateTime = true;
        boolean noIsDelete = true;
        for (Column column : columns) {
            String columnName = column.getColumnName().replace("`", "").trim().toUpperCase(Locale.ROOT);
            if (UPDATE_TIME.equals(columnName)) {
                noUpdateTime = false;
            }
            if (CREATE_TIME.equals(columnName)) {
                noCreateTime = false;
            }
            if (IS_DELETE.equals(columnName)) {
                noIsDelete = false;
            }
        }
        if (noUpdateTime) {
            columns.add(new Column(UPDATE_TIME));
            addValues(values.getExpressions(), INJECT_CURRENT_TIMESTAMP);
        }
        if (noCreateTime) {
            columns.add(new Column(CREATE_TIME));
            addValues(values.getExpressions(), INJECT_CURRENT_TIMESTAMP);
        }
        if (noIsDelete) {
            columns.add((Column) INJECT_IS_DELETE.getLeftExpression());
            addValues(values.getExpressions(), INJECT_IS_DELETE.getRightExpression());
        }
        metaObject.setValue(SQL_PATH, insert.toString());
    }

    private void addValues(List expressions, Expression expression) {
        if (expressions == null) {
            return;
        }
        Iterator iterator = expressions.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            if (next instanceof JdbcParameter) {
                expressions.add(expression);
                return;
            }
            if (next instanceof List) {
                addValues((List) next, expression);
            }
        }
    }

    private void injectUpdate(Update update, MetaObject metaObject) {
        Expression where = update.getWhere();
        if (where == null) {
            update.setWhere(INJECT_IS_DELETE);
        } else if (!where.toString().toUpperCase(Locale.ROOT).contains(IS_DELETE)) {
            update.setWhere(BinaryExpression.and(where, INJECT_IS_DELETE));
        }
        List<UpdateSet> updateSets = update.getUpdateSets();
        if (updateSets == null) {
            metaObject.setValue(SQL_PATH, update.toString());
            return;
        }
        boolean noUpdateTime = true;
        outer:
        for (UpdateSet updateSet : updateSets) {
            for (Column column : updateSet.getColumns()) {
                if (UPDATE_TIME.equals(column.getColumnName().replace("`", "").trim().toUpperCase(Locale.ROOT))) {
                    noUpdateTime = false;
                    break outer;
                }
            }
        }
        if (noUpdateTime) {
            UpdateSet updateSet = new UpdateSet();
            updateSet.setColumns(new ExpressionList<>().withExpressions(new Column(UPDATE_TIME)));
            updateSet.setValues(new ExpressionList().withExpressions(INJECT_CURRENT_TIMESTAMP));
            updateSets.add(updateSet);
        }

        metaObject.setValue(SQL_PATH, update.toString());
    }

    private void injectDelete(Delete delete, MetaObject metaObject) {
        Expression where = delete.getWhere();
        if (where == null) {
            delete.setWhere(INJECT_IS_DELETE);
        } else if (!where.toString().toUpperCase(Locale.ROOT).contains(IS_DELETE)) {
            delete.setWhere(BinaryExpression.and(where, INJECT_IS_DELETE));
        }
        metaObject.setValue(SQL_PATH, delete.toString());
    }

    private void injectSelect(Select select, MetaObject metaObject) {
        int childNum = select.getASTNode().jjtGetNumChildren();
        if (childNum == 1) {
            PlainSelect plainSelect = select.getPlainSelect();
            addWhere(plainSelect);
        } else if (childNum > 1) {
            SetOperationList operationList = select.getSetOperationList();
            for (Select operationSelect : operationList.getSelects()) {
                addWhere(operationSelect.getPlainSelect());
            }
        }
        metaObject.setValue(SQL_PATH, select.toString());
    }

    private void addWhere(PlainSelect plainSelect) {
        // 有join的多表查询不自动添加is_delete字段
        if (plainSelect.getJoins() != null && plainSelect.getJoins().size() > 0) {
            return;
        }
        Expression where = plainSelect.getWhere();
        if (where == null) {
            plainSelect.setWhere(INJECT_IS_DELETE);
        } else if (!where.toString().toUpperCase(Locale.ROOT).contains(IS_DELETE)) {
            plainSelect.setWhere(BinaryExpression.and(where, INJECT_IS_DELETE));
        }
    }

    /**
     * 判断方法上是否有@NotInjectSQL注解
     * 原理是mappedStatement.id的命名规则是 ${package名}.${mapper类名}.${方法名}。可以获取类路径，再通过反射加载类
     *
     * @param mappedStatement mappedStatement
     * @return true-有@NotInjectSQL注解/false-没有@NotInjectSQL注解
     */
    private boolean hasAnnotation(MappedStatement mappedStatement) {
        String sqlId = mappedStatement.getId();
        int lastIndexOf = sqlId.lastIndexOf('.');
        String className = sqlId.substring(0, lastIndexOf);
        String methodName = sqlId.substring(lastIndexOf + 1);

        try {
            Class<?> mapperClass = Class.forName(className);
            for (Method declaredMethod : mapperClass.getDeclaredMethods()) {
                if (declaredMethod.getName().equals(methodName)) {
                    return declaredMethod.getAnnotation(NotInjectSQL.class) != null;
                }
            }
            return false;
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

ParameterHandler拦截器示例：

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.parameter.ParameterHandler;
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 java.sql.PreparedStatement;
import java.util.Map;

@Slf4j
@Intercepts({@Signature(type = ParameterHandler.class, method = "setParameters", args = {PreparedStatement.class})})
public class MybatisParameterHandlerInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        log.info("=====> ParameterHandler");
        ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();

        Object parameterObject = parameterHandler.getParameterObject();
        if (parameterObject instanceof Map<?, ?>) {
            Map<String, Object> parameterMap = (Map<String, Object>) parameterObject;
            for (Map.Entry<String, Object> entry : parameterMap.entrySet()) {
                if ("pageSize".equals(entry.getKey())) {
                    Object pageSize = parameterMap.get("pageSize");
                    if (pageSize != null && Long.parseLong(pageSize.toString()) > 10) {
                        // 修改查询参数
                        parameterMap.put("pageSize", 10);
                    }
                }
            }

        }
        return invocation.proceed();
    }
}

ResultSetHandler拦截器示例：

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.resultset.ResultSetHandler;
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 java.lang.reflect.Field;
import java.sql.Statement;
import java.util.List;
import java.util.Locale;

@Slf4j
@Intercepts({@Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})})
public class MybatisResultSetHandlerInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        log.info("=====> ResultSetHandler");
        Object proceedResult = invocation.proceed();
        if (proceedResult == null) {
            return proceedResult;
        }
        if (proceedResult instanceof List<?>) {
            List<?> list = (List<?>) proceedResult;
            for (Object item : list) {
                desensitization(item);
            }
        } else {
            desensitization(proceedResult);
        }
        return proceedResult;
    }

    private void desensitization(Object obj) throws IllegalAccessException {
        for (Field field : obj.getClass().getDeclaredFields()) {
            // 对可能的密码字段脱敏
            if (field.getName().toLowerCase(Locale.ROOT).contains("password")) {
                field.setAccessible(true);
                Object fieldValue = field.get(obj);
                field.set(obj, getDesensitiveValue(fieldValue));
                continue;
            }
            Desensitization annotation = field.getAnnotation(Desensitization.class);
            if (annotation == null) {
                continue;
            }
            field.setAccessible(true);
            Object fieldValue = field.get(obj);
            if (fieldValue == null) {
                continue;
            }
            field.set(obj, getDesensitiveValue(fieldValue));
        }
    }

    private static Object getDesensitiveValue(Object obj) {
        if (obj instanceof String) {
            String str = (String) obj;
            if (str.length() <= 2) {
                return "***";
            } else {
                return str.charAt(0) + "***" + str.charAt(str.length() - 1);
            }
        }
        // 处理基本类型byte/short/int/long/float/double/boolean/char
        if (obj instanceof Byte || obj instanceof Short || obj instanceof Integer || obj instanceof Long || obj instanceof Float || obj instanceof Double) {
            return (byte) 0;
        }
        if (obj instanceof Boolean) {
            return false;
        }
        if (obj instanceof Character) {
            return '*';
        }
        return null;
    }
}

如果需要解析SQL，需要在pom.xml中引入jsqlparser：

<!-- https://mvnrepository.com/artifact/com.github.jsqlparser/jsqlparser -->
<dependency>
    <groupId>com.github.jsqlparser</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>5.2</version>
</dependency>

注册插件

  1. 使用Spring Boot默认连接池，使用配置文件注册：

1.1. 在resources/mybatis目录下添加mybatis-config.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="com.example.study.config.MybatisExecutorInterceptor"/>
        <plugin interceptor="com.example.study.config.MybatisStatementHandlerInterceptor"/>
        <plugin interceptor="com.example.study.config.MybatisParameterHandlerInterceptor"/>
        <plugin interceptor="com.example.study.config.MybatisResultSetHandlerInterceptor"/>
    </plugins>
</configuration>

1.2. 在application.properties添加以下配置：

mybatis.config-location=classpath:mybatis/mybatis-config.xml
  1. 使用Druid连接池，通过配置类注册：

在配置类中，SqlSessionFactoryBean对象调用setPlugins()方法注册（参考SpringBoot连接Mysql数据库）

    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
        factoryBean.setPlugins(new MybatisExecutorInterceptor(),
                new MybatisStatementHandlerInterceptor(),
                new MybatisParameterHandlerInterceptor(),
                new MybatisResultSetHandlerInterceptor());
        return factoryBean.getObject();
    }

注：以上拦截器可以放到一个类中，在@Intercepts中添加对应的@Signature，然后在intercept(invocation)方法中，用invocation.getTarget() instanceof（如invocation.getTarget() instanceof Executor、invocation.getTarget() instanceof StatementHandler）判断当前是哪个拦截器，然后执行对应的拦截逻辑。

参考文章

  1. MyBatis 3 | Configuration – mybatis

  2. MyBatis 插件开发的完整详细例子

  3. 简述 Mybatis 的插件运⾏原理，如何编写⼀个插件

  4. Mybatis 自定义拦截器与插件开发

  5. 深入理解Mybatis插件开发

Java 领域的 MyBatis 插件开发指南
Java技术栈实战开发的博客
04-22 755
MyBatis 是一款优秀的持久层框架，它简化了数据库操作，但在某些特定场景下，可能无法满足开发者的个性化需求。MyBatis 插件开发的目的就是为了扩展 MyBatis 的功能，允许开发者在 SQL 执行的不同阶段插入自定义逻辑。本指南的范围涵盖了 MyBatis 插件开发的基础知识、核心原理、开发步骤、实际应用场景以及相关资源推荐，旨在帮助开发者全面掌握 MyBatis 插件开发的技能。本文将按照以下结构进行组织：首先介绍 MyBatis 插件开发的背景知识，包括目的、读者对象和文档结构。
利用mybatis插件开发动态更改sql
promisessh的博客
09-26 1623
1、业务背景需求 目前楼主所在公司线上与预发环境用的是同一套数据库，这样做的目的是在预发环境验收线上的真实情况。但是有几个配置表需要单独在预发环境更改，如果更改了会影响到线上用户使用，所以如何将配置表做环境隔离，在不更改现有代码的情况下；做法就是利用mybatis提供的插件开发机制对底层的4大内置对象进行拦截；那么4大内置对象都有哪些？ 2、4大内置对象 Executor：代表执行器，由它调度StatementHandler、ParameterHandler、ResultSetHandler等来执行对
MyBatis插件开发 : 插件原理、插件开发流程
Guizy
04-22 1697
增强代码 MyBatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。MyBatis 允许在已映射语句执行过程中的某一点进行拦截调用。 默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) ParameterHa...
MyBatis的插件开发
wenqi1992的博客
06-22 2552
MyBatis的插件运行原理介绍及插件开发流程
MyBatis 插件开发的完整详细例子
最新发布
爱的叹息的专栏
04-27 901
MyBatis 插件开发的完整详细例子
MyBatis源码解析系列之十二：自定义插件开发
阿里渣渣java研发组-群主
06-02 600
欢迎回到我的MyBatis源码解析系列。在前几篇文章中，我们详细介绍了MyBatis的架构及其核心组件的实现原理，并深入探讨了MyBatis与Spring的集成。本篇文章将探讨如何开发自定义插件，以扩展MyBatis的功能，满足特定的业务需求。MyBatis插件机制基于Java的动态代理，允许开发者通过实现接口来拦截执行的核心方法，从而实现诸如性能监控、日志记录、SQL重写等功能。Executor：执行器，负责SQL语句的执行。：语句处理器，负责SQL语句的生成和参数设置。
MyBatis加强（4）~mybatis 插件开发
「 虚幻私塾」
02-16 373
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 作者:一乐乐 欢迎大家来一乐乐的博客园 #MySignature { display: block; background-color: rgba(198, 206, 212, 1); border-radius: 7px; box-shadow: 1px 1px 1px rg
MyBatis自定义插件开发
Clover的博客
04-01 429
插件的原理： 1.每个创建出来的对象都不是直接返回 interceptorChain.pluginAll(parameterHandler); 2.获取到所有的Interceptor（拦截器）（插件需要实现的接口） 调用interceptor.plugin(target);返回target包装后的对象 3.插件机制，我们可以使用插件为目标对象创建一个代理对象，AOP（面向切面） 我们的插...
【图灵】MyBatis插件开发
白羊座的橙子
04-07 550
指定拦截上述四大对象的哪个方法@Component@Overridereturn res;// 或者source的类型Class
IDEA的MyBatis插件两个
03-07
本篇文章将详细介绍两个针对MyBatis框架的IntelliJ IDEA插件——MyBatisCodeHelper-Pro和MybatisX，它们都是为了提升MyBatis开发体验而设计的。 首先，我们来看MyBatisCodeHelper-Pro。这款插件是专为MyBatis开发者...
MybatisX 快速开发插件
05-21
MybatisX 快速开发插件是一款专为Java开发者设计的高效工具，旨在提升使用Mybatis框架进行开发的工作效率。这款插件是针对IntelliJ IDEA（简称IDEA）集成开发环境的扩展，通过集成在IDEA中，它能够提供一系列便捷的...
Mybatis_第⼋部分：Mybatis插件
qq_52922453的博客
06-05 1430
这样的好处是显⽽易⻅的，⼀是增加了框架的灵活性。初始化的时候创建的。来说插件就是拦截器，⽤来增强核⼼对象的功能，增强功能本质上是借助于底层的 动态代理实现的，换句话说，MyBatis。顺序写到这，不要多也不要少，如果⽅法重载，可是要通过⽅法名和⼊参来确定唯⼀的。⽅法会 对所拦截的⽅法进⾏检测，以决定是否执⾏插件逻辑。插件初始化的时候调⽤，也只调⽤⼀次，插件配置的属性从这⾥设置进来。是将分⻚的复杂操作进⾏封装，使⽤简单的⽅式即可获得分⻚的相关数据。注解中，若是，则执⾏插件逻辑，否则执⾏被拦截⽅法。
mybatis 开发自定义插件，你学废了吗
做一个有思想的技术人
01-18 1953
mybatis自定义插件 介绍 MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。比如执行前、执行后或者对SQL结果集处理、sql入参处理等，这样就可以在不修改mybatis源码的情况下对sql执行的过程或结果进行修改，实现了解耦。mybatis 是在动态代理的基础上实现的。对动态代理感兴趣的可以看下JAVA 代理模式不了解一下吗？ 使用场景 如果业务中需要设置一些通用数据库操作，比如创建时间、创建人等通用字段又或者是分页操作等，这类都可...
手把手教你开发 MyBatis 插件
江南一点雨的专栏
03-01 3038
小伙伴们元宵节快乐，记得吃元宵哦～ 在日常开发中，小伙伴们多多少少都有用过 MyBatis 插件，松哥猜测大家用的最多的就是 MyBatis 的分页插件！不知道小伙伴们有没有想过有一天自己也来开发一个 MyBatis 插件？ 其实自己动手撸一个 MyBatis 插件并不难，今天松哥就把手带大家撸一个 MyBatis 插件！ 1.MyBatis 插件接口 即使你没开发过 MyBatis 插件，估计也能猜出来，MyBatis 插件是通过拦截器来起作用的，MyBatis 框架在设计的时候，就已经为插件的开发预留了
【Mybatis相关】mybatis框架基础以及自定义插件开发
wendao76的专栏
09-08 1010
mybatis框架结构，自定义插件开发
MyBatis插件原理探究和自定义插件实现
write less , do more
07-24 4112
⼀般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者⾃⾏拓展。这样的好处是显⽽易⻅的，⼀是增加了框架的灵活性。⼆是开发者可以结合实际需求，对框架进⾏拓展，使其能够更好的⼯作。以MyBatis为例，我们可基于MyBati s插件机制实现分⻚、分表，监控等功能。由于插件和业务⽆关，业务也⽆法感知插件的存在。因此可以⽆感植⼊插件，在⽆形中增强功能。
MyBatis 中，如何实现插件开发？
luoluoal的博客
06-30 312
除了这个例子，如果还需要了解更多的插件开发技巧，可以看官方文档中有关插件开发的章节：https://mybatis.org/mybatis-3/zh/configuration.html#plugins。需要注意的是，在使用以上方式过程中，也需要确保 SQL 语句的安全性，并避免 SQL 注入等安全问题的出现。需要注意的是，当有多个插件时，它们的执行顺序和在配置文件中的顺序有关，应根据需要设置执行顺序。例如，在一个查询中，可能会根据用户提供的参数动态拼接查询条件，可以使用。
MyBatis 插件介绍及应用
baidu_41907361的博客
04-29 3515
MyBatis 插件是 MyBatis 框架的扩展点，它们可以拦截 MyBatis 的核心处理过程，包括执行器、参数处理器、结果处理器等。通过编写插件，开发者可以在不修改 MyBatis 核心代码的情况下，增加新的功能或改变 MyBatis 的行为。
mybatis插件开发
03-06
MyBatis是一个开源的持久层框架，它简化了数据库访问的过程，提供了灵活的SQL映射和结果集处理方式。MyBatis插件开发可以扩展MyBatis的功能，满足特定需求。下面是介绍MyBatis插件开发的步骤： 1. 创建插件类：创建一个实现了Interceptor接口的插件类，该接口定义了插件的核心逻辑。 2. 实现拦截方法：在插件类中实现intercept方法，该方法会在MyBatis执行SQL语句前后进行拦截。 3. 配置插件：在MyBatis的配置文件中配置插件，指定要拦截的目标对象和拦截器。 4. 编写逻辑：根据需求编写具体的插件逻辑，可以在SQL执行前后进行一些自定义操作，如日志记录、性能监控等。 5. 测试插件：编写测试用例，验证插件的功能是否符合预期。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值