mybatis拦截器

最新推荐文章于 2024-04-28 15:13:57 发布
最新推荐文章于 2024-04-28 15:13:57 发布
阅读量3.5k 收藏 11
点赞数 2
文章标签： mybatis java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47594094/article/details/130129711
版权

在mubatis中提供了plugin插件的方法，实际上就是拦截器，比如分页插件也是基于此来实现的

1.在mybatis中拦截器可以针对4个点来进行拦截处理，也可以说是4个接口：

  1. Excutor:拦截器执行器的相关方法，可以对这些方法进行增强处理

  2. parameterHandler：拦截器参数处理，可以对参数进行统一的处理

  3. resultSetHandle：拦截器结果集处理，可以对返回的结果做统一处理

  4. Statement Handle：拦截sql构建的处理

执行与添加顺序

拦截器主要是拦截以上4个接口，对里面的方法进行增强处理，所以如果以方法来看拦截器的执行顺序是与这几个接口里面的方法在Mybatis执行流程里面的顺序有关，但如果以接口来看拦截器的执行顺序，大概流程是这样（不了解的可以去看看 Mybatis流程源码）：

Executor→ParameterHandler→StatementHandler→ResultSetHandler

拦截器生效入口

拦截器是什么时候介入到执行流程中来的呢？

以上述4个接口为例，所以有4个介入入口，均是在执行流程中初始化的时候介入的，如下图：

Configuration内部：

在这里插入图片描述

 

二、使用

使用拦截器其实很简单，我们只需要打上两个注解，实现一个接口，并在配置文件中配置一下就可以了

要打上的两个注解：

@Intercepts： 该注解等于是个标识，标识该类是个拦截器，需要配合@Signature来使用

@Signature： 该注解也是个标识，表示要拦截的接口以及接口内的哪个方法，有三个参数

type ：代表我们要拦截的是哪个接口（4个里面选一个）

method ：代表我们要拦截的是接口里面的哪一个方法（从接口里面去选一个）

args ：要拦截的方法里面的参数类型，方法里面有几个传参这里就要写几个（因为方法存在重载，名称还无法确定唯一性）

要实现的接口：

Interceptor，内部有三个方法，一个必须要实现，两个随意

  • intercept()：必须要实现的方法，这里就可以处理我们的逻辑

  • plugin()：可选择实现，返回目标对象或者代理对象

  • setProperties()：获取参数，可以从外部获取一些配置参数

例子：

/**
* 这里我们拦截Executor里面的query和update方法
* 一个@Signature 代表要拦截的一个方法
*/
@Intercepts({
        /**
         * type     ：代表我们要拦截的是哪个接口（4个里面选一个）
         * method   ：代表我们要拦截的是接口里面的哪一个方法（从接口里面去选一个）
         * args     ：要拦截的方法里面的参数类型，方法里面有几个传参这里就要写几个（因为方法存在重载，名称还无法确定唯一性）
         **/
        @Signature(
              type = Executor.class,
              method = "query",
              args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}
        ),
        @Signature(
              type = Executor.class,
              method = "update",
              args = {MappedStatement.class, Object.class}
        )
})
public class DemoInterceptor1 implements Interceptor {




    @Override
    public Object intercept(Invocation invocation) throws Throwable {
      //被代理对象
      Object target = invocation.getTarget();
      //代理方法
      Method method = invocation.getMethod();
      //方法参数
      Object[] args = invocation.getArgs();




      // do something ...方法拦截前执行代码块
      System.out.println("方法拦截前执行 do something ...");


      // 本方法执行（这就是执行被拦截的源方法）
      Object result = invocation.proceed();


      // do something ...方法拦截后执行代码块
      System.out.println("方法拦截后执行 do something ...");
      return result;
    }


    /**
     * 通过该方法决定要返回的对象是目标对象还是对应的代理
     * 一般就两种情况（乱来小心报错）：
     * 1. return target;  直接返回目标对象，相当于当前Interceptor没起作用，不会调用上面的intercept()方法
     * 2. return Plugin.wrap(target, this);  返回代理对象，会调用上面的intercept()方法
     */
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }


    /**
     * 用于获取在Configuration初始化当前的Interceptor时候设置的一些参数
     *
     * @param properties Properties参数
     */
    @Override
    public void setProperties(Properties properties) {
    }
}

方法plugin中如果使用的是Plugin.warp(target,this)表示使用代理方式，即上面重写的interceptor会被代理生效，如果直接返回对象，即不使用重写的interceptor，默认mybatis自带。

三.创建mybatis执行SQL语句的日志打印


@Component
@Intercepts(
        {@Signature(type = Executor.class,method = "query",args = {MappedStatement.class,Object.class, Result.class}),
                @Signature(type = Executor.class,method = "insert",args = {MappedStatement.class,Object.class,Result.class}),
                @Signature(type = Executor.class,method = "update",args = {MappedStatement.class,Object.class,Result.class}),
                @Signature(type = Executor.class,method = "delete",args = {MappedStatement.class,Object.class,Result.class})
        })
public class SqlExcutorLogsInterceptor implements Interceptor {
    Logger logger = LoggerFactory.getLogger(SqlExcutorLogsInterceptor.class);
    @Override
    public Object intercept(Invocation invocation) throws Throwable {

        MappedStatement mappedStatement = (MappedStatement)invocation.getArgs()[0];

        int one = 1;
        //sql参数
        Object paramter = invocation.getArgs()[one];
        //sql mapper id
        String id = mappedStatement.getId();
        //sql
        BoundSql boundSql = mappedStatement.getBoundSql(paramter);
        //configuration
        Configuration configuration = mappedStatement.getConfiguration();
        //执行的sql语句，携带真实参数
        String sql = sqlHandler(boundSql,configuration);
        //sql执行的当前时间
        long currentTime = System.currentTimeMillis();
        //执行sql
        invocation.proceed();
        long endTime = System.currentTimeMillis();
        //打印
        logger.info(String.format("SQL_Mapper:%s",id));
        logger.info(String.format("SQL:%s",sql));
        logger.info(String.format("SQL执行时间:%s ms",endTime-currentTime));
        return null;
    }
    /**
     * @Author 
     * @Description   sql语句里面的?替换成真实的参数
     **/
    private String sqlHandler(BoundSql boundSql, Configuration configuration){
        // 获取mapper里面方法上的参数
        Object sqlParameter = boundSql.getParameterObject();
        TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        // sql原始语句(?还没有替换成我们具体的参数)
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (sqlParameter == null) {
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(sqlParameter.getClass())) {
                        value = sqlParameter;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(sqlParameter);
                        value = metaObject.getValue(propertyName);
                    }
                    sql = sql.replaceFirst("\\?", value.toString());
                }
            }
        }
        return sql;
    }

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

    @Override
    public void setProperties(Properties properties) {
        Interceptor.super.setProperties(properties);
    }
}

四.实现自定义注解生效

使用反射机制获取类字段，并获取字段上的注解，提取内容

@Component
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class,Object.class})})
public class GeneratedKeyInterceptor implements Interceptor {
    private static final Logger logger = LoggerFactory.getLogger(GeneratedKeyInterceptor.class);

    /**
     *单个插入名称
     */
    private static final String INSERT = "insert";

    /**
     * 单个插入名称
     */
    private static final String SAVE = "save";

    /**
     * 批量插入名称
     */
    private static final String INSERT_BATCH = "insertBatch";

    /**
     * 批量插入名称
     */
    private static final String SAVE_BATCH = "saveBatch";
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        //获取sql
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        //不是插入语句直接放行，不拦截
        if (sqlCommandType != SqlCommandType.INSERT){
            invocation.proceed();
        }
        //获取sql参数
        Object paramter = invocation.getArgs()[1];
        //获取数据库对象
        BaseModel dbObj = findDbObj(paramter);

        if (dbObj == null){
            invocation.proceed();
        }

        //插入数据库
        if (mappedStatement.getId().contains(INSERT) || mappedStatement.getId().contains(SAVE)){
            generatedKey(dbObj);
        }
        return null;
    }

    /**
     * 获取私有成员变量并设置主键
     * @param dbObj
     */
    public void generatedKey(Object dbObj) throws IllegalAccessException {
        Field[] declaredFields = dbObj.getClass().getDeclaredFields();
        for (Field field : declaredFields){
            if (field.getType().isAssignableFrom(Long.class)){
                break;
            }
            //反射获取注解内容
            DistributedId annotation = field.getAnnotation(DistributedId.class);
            if (annotation == null){
                break;
            }
            //访问私有变量
            field.setAccessible(true);
            //已经设置了，退出
            if (field.get(dbObj) != null){
                break;
            }
            //自定义设置内容
            field.set(dbObj,null);
        }
    }
    @Override
    public Object plugin(Object target) {
        if (target instanceof Executor){
            //代理执行拦截器
            return Plugin.wrap(target,this);
        }else {
            //不进行自定义拦截器处理
            return target;
        }
    }
    public BaseModel findDbObj(Object paramenter){
        if (paramenter instanceof BaseModel){
            return (BaseModel) paramenter;
        }else if (paramenter instanceof Map){
            for (Object val : ((Map<?,?>)paramenter).values()){
                if (val instanceof BaseModel){
                    return (BaseModel) val;
                }
            }
        }
        return null;
    }

}

BaseModel类

public class BaseModel implements Serializable {
    /**
     * 创建时间
     */
    protected Date createTime;

    /**
     * 更新时间
     */
    protected Date updateTime;

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    @Override
    public String toString() {
        return "BaseModel{" + "createTime=" + createTime + ", updateTime=" + updateTime + '}';
    }
}

frozenwatermelon
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Mybatis的拦截器Interceptor
Kwoky的博客
06-09 2148
Mybatis的拦截器Interceptor
Mybatis 拦截器
qq_30436011的博客
12-02 6061
一.背景 在很多业务场景下我们需要去拦截sql，达到不入侵原有代码业务处理一些东西，比如：分页操作，数据权限过滤操作，SQL执行时间性能监控等等，这里我们就可以用到Mybatis的拦截器Interceptor 二.Mybatis核心对象介绍 从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个： Configuration 初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如，插件，映射器，ObjectFactory和typeHandl...
MyBatis 拦截器使用方法总结_mybatis拦截器的使用
最新发布
2401_84254418的博客
04-28 1340
拦截器默认可以拦截的类型只有四种，即四种接口类型、、和。对于我们的自定义拦截器必须使用提供的注解来指明我们要拦截的是四种类型中的哪一种接口。注解的参数： 2.1.1. type 拦截器默认会按顺序拦截以下的四个接口中的所有方法： 具体是拦截这四个接口对应的实现类： 这个可以根据源码了解下。根据参数类型区分重载的方法。进行拦截的时候要执行的方法。该方法参数类中有三个字段： 可通过这三个字段分别获取下面的信息： 拦截接口 接口实现类 2.2.2. plugin 插
Mybatis拦截器
m0_54853503的博客
03-28 4429
一 Mybatis拦截器介绍 Mybatis拦截器设计的初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。通过Mybatis拦截器我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。所以Mybatis拦截器的使用范围是非常广泛的。 Mybatis里面的核心对象还是比较多，如下： Mybatis核心对象 解释 SqlSession 作为MyBatis工作的主要顶层API，表示和数据库
mybatis：拦截器Interceptor:
QJY1437758743的博客
08-28 1635
定义特定注解，在切入时需要检查字段中是否包含注解来是否加解密。Intercepts注解需要一个Signature(拦截点)参数数组。说明： @Intercepts：标识该类是一个拦截器；@Signature：指明自定义拦截器需要拦截哪一个类型，哪一个方法；Mybatis 插件的使用就是通过实现 Mybatis 中的 Interceptor 接口。这个方法的作用是就是让mybatis判断，是否要进行拦截，然后做出决定是否生成一个代理。3.ParameterHandler：拦截参数的处理。
mybatis拦截器(一)
qq1010830256的博客
04-12 1506
文章目录一、MyBatis拦截器介绍二、创建拦截器 一、MyBatis拦截器介绍 mybatis拦截器可以拦截如下4中类型 Executor sql的内部执行器 ParameterHandler 拦截参数的处理 StatementHandler 拦截sql的构建 ResultSetHandler 拦截结果的处理 这4中不同类型的拦截器的拦截顺序为从上到下的顺序,即 Executor -> ParameterHandler -> StatementHandler -> ResultSet
mybatis拦截器中boundsql对象介绍与使用
dayeren02的博客
02-25 5225
在上一篇文中里，我们简单介绍了mybatis拦截器的使用。本文将介绍在拦截器中处理代码业务时，常用到的一个类——BoundSql。 本文用拦截StatementHandler类方法为主介绍BoundSql相关内容。 1、定义一个拦截器 写一个自定义的拦截器，拦截类型为StatementHandler，拦截方法为prepare。注解代码如下： @Intercepts(@Signature(type = StatementHandler.class, method = "prepare", args = {Co
MyBatis拦截器:给参数对象属性赋值的实例
08-30
MyBatis拦截器是MyBatis框架中的一种插件机制，允许用户自定义代码来扩展MyBatis的功能。在这个特定的实例中，我们讨论的是一个用于给参数对象属性赋值的拦截器。这个拦截器的主要目标是在执行增删改操作时，自动为...
mybatis拦截器实现通用权限字段添加的方法
08-25
MyBatis拦截器实现通用权限字段添加的方法 MyBatis拦截器是一种非常实用的技术，可以用来实现各种复杂的数据库操作。本文将详细介绍如何使用MyBatis拦截器来实现通用权限字段添加，达到灵活、可靠、可维护的数据库...
通过Mybatis拦截器自动定位慢SQL并记录日志
05-30
下面我们将详细介绍如何通过Mybatis拦截器实现这一功能。 首先，了解Mybatis拦截器的基本概念。Mybatis拦截器（Interceptor）是一种插件机制，它允许我们在Mybatis执行SQL语句之前或之后进行自定义操作，比如统计...
mybatis拦截器修改执行sql语句
09-11
通过mybatis拦截器将查询语句、更新语句、删除语句、插入语句中指定表明替换为另一个表名
mybatis拦截器的完整实现
08-31
mybatis拦截器的完整实现，test.sql是数据库测试脚本，主要目的是生成mybatis最终执行的sql语句，并打印出来，方便调试。 基于此，可以实现自动化分页。
简单了解mybatis拦截器实现原理及实例
08-25
MyBatis拦截器实现原理及实例 MyBatis拦截器是一种强大的机制，能够在MyBatis执行SQL语句之前或之后执行自定义逻辑。拦截器可以用来实现诸如日志记录、性能监控、安全认证等功能。本文将详细介绍MyBatis拦截器的...
Mybatis自定义注解（BatchUpdAnnotation），批量更新处理拦截器
雨落未成曲的博客
06-21 852
2、创建一个Mybatis的拦截器：MybatisBatchUpdateInterceptor，拦截update操作，如果存在对应的注解，则超过batchSize则分批处理，分批处理通过BatchUtil.execute( )方法。1、首先创建一个注解：BatchUpdAnnotation，默认一次处理100条，可以自己调整。3、创建批量处理类：BatchUtil，多次循环调用mapper方法进行更新。4、mapper层的使用。
Mybatis之自定义拦截器
2302_77659577的博客
08-10 827
首先让我们来创建实现了Interceptor接口的自定义拦截器类.这里我们创建3个@Override// 拦截逻辑@Override// 动态代理@Override// 可以在这里设置配置属性@Override@Override@Override@Override@Override@OverrideMyBatis的拦截器机制为我们提供了灵活的扩展方式，可以在SQL执行的不同阶段插入自定义逻辑。
mybatis 拦截器
热门推荐
beiduofen2011的专栏
04-05 1万+
在mybatis中可被拦截的类型有四种(按照拦截顺序)： Executor：拦截执行器的方法。 ParameterHandler：拦截参数的处理。 ResultHandler：拦截结果集的处理。 StatementHandler：拦截Sql语法构建的处理。 其实Executor都可以实现ParameterHandler，ResultHandler，StatementHandler拦截器的功能 拦截器一般在业务处理中用于： 1、分页查询 2、多租户添加条件过滤 3、对返回结果，过滤掉审计字段，
Mybatis SQL拦截器
m0_64332518的博客
09-04 406
Slf4j@Component)})@Override//未经过包装的sql/*** sql拦截器*/@Component))@Slf4j@Resource@Override//获取执行sql的类信息//自定义b//如果原SQL没变就不用反射if (!//通过反射设置新值接口/*** @description: 包装器修改权限的基础接口，自定义数据源皆要基于此接口/*** @param sql 原sql。
mybatis 自定义拦截器
qq_42162899的博客
07-22 1347
* mybatis拦截器 * 拦截所有的update/insert/insertbatch操作 * 拦截方法执行前：自定义id插入并返回id(重点关注 insertbach类型时的解析) * 拦截方法执行后：获取执行sql的表名和参数，处理业务逻辑 @Slf4j @Component @Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object....
MYBATIs拦截器
10-14
MyBatis拦截器是MyBatis提供的一种插件机制，可以在MyBatis执行SQL语句的过程中，对SQL语句进行拦截和修改。通过拦截器，我们可以在执行SQL语句前后进行一些自定义的操作，比如打印SQL语句、分页、加解密等。 MyBatis拦截器主要由四个接口组成： 1. Interceptor：拦截器接口，所有自定义拦截器都需要实现该接口。 2. Invocation：拦截器链中的调用对象，可以通过它来调用下一个拦截器。 3. Plugin：插件接口，用于包装目标对象，返回一个代理对象。 4. InterceptorChain：拦截器链，用于存储所有的拦截器。 在使用MyBatis拦截器时，我们需要实现Interceptor接口，并在配置文件中配置拦截器。配置文件中需要指定要拦截的目标对象和要使用的拦截器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值