MyBatis中拦截器(Interceptor)实现原理分析

最新推荐文章于 2024-08-18 01:05:38 发布
最新推荐文章于 2024-08-18 01:05:38 发布
阅读量4.3k 收藏 17
点赞数 4
分类专栏： MyBatis 文章标签： mybatis proxy mysql java sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43448868/article/details/112184232
版权

简介

拦截器(Interceptor)是用来改变或者扩展MyBaits原有的功能，例如可以通过拦截器机制来分析项目中存在那些慢SQL(统计SQL执行时间)，分页工具PageHelper正是基于该机制来完成的分页。MyBatis对外提供的扩展点共有四个，可以进行拦截的接口和方法如下：

Executor(接口中所有方法都可以拦截)
StatementHandler(接口中所有方法都可以拦截)
org.apache.ibatis.executor.parameter.ParameterHandler(接口中所有方法都可以拦截)
StatementHandler(接口中所有方法都可以拦截)

怎么用？

这里首先需要熟悉四个东西，分别是Interceptor接口以及Invocation和@Intercepts、@Signature注解。

public interface Interceptor {
  // 该方法就是MyBatis在使用前面提到的四个接口中的方法时进行回调的方法。
  Object intercept(Invocation invocation) throws Throwable;
  // 用来为目标对象创建代理对象的方法，通常不需要覆写。
  default Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }
  // 设置一些属性
  default void setProperties(Properties properties) {
    // NOP
  }

}

Invocation 的定义信息很简单，其共有三个属性，分别为target(目标对象)、method(方法)、args(方法参数)以及相关Getter/Setter方法，还有一个proceed方法，就是执行目标方法。

public class Invocation {

  private final Object target; // 目标对象
  private final Method method; // 执行方法
  private final Object[] args; // 方法参数

  public Invocation(Object target, Method method, Object[] args) {
    this.target = target;
    this.method = method;
    this.args = args;
  }

  public Object getTarget() {
    return target;
  }

  public Method getMethod() {
    return method;
  }

  public Object[] getArgs() {
    return args;
  }

  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }

}

@Intercepts和@Signature注解要合在一起来看，@Intercepts注解只有一个属性，即value，其返回值类型是一个@Signature类型的数组。这代表我们可以配置多个@Signature注解。

@Signature注解其实就是一个方法签名，其共有三个属性，分别为：type、method、args。type指接口的class，method指接口中的方法名，args指的是方法参数类型(该属性返回值是一个数组)。

public @interface Intercepts {
  /**
   * 方法签名
   */
  Signature[] value();
}

public @interface Signature {
  /**
   * 用来指定接口类型
   */
  Class<?> type();

  /**
   * 用来指定方法名
   */
  String method();

  /**
   * 用来指定方法参数
   */
  Class<?>[] args();
}

小伙伴们看上面的解释可能还是不太明白，没关系，接下来我们就编码实战！

Talk is cheap. Show me the code

第一步：定义一个类实现MyBatis的Interceptor 接口。通过@Intercepts以及@Signature注解来指定我们要拦截的接口为Executor的query方法，通过指定args，即方法参数类型来确定是哪个query方法。下面的通过@Signature指定的update、commit方法都一样。

package com.tech.mybatis.interceptors;

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
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.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

import java.util.Arrays;


@Intercepts(
		{@Signature(type = Executor.class, method = "query",
				args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class,
						CacheKey.class, BoundSql.class}),
				@Signature(type = Executor.class, method = "update",
						args = {MappedStatement.class, Object.class}),
				@Signature(type = Executor.class, method = "commit",
						args = {boolean.class})}
)
public class CustomizedInterceptor implements Interceptor {


	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		Object[] args = invocation.getArgs(); // 获取方法参数
		System.out.println("拦截到 " + invocation.getMethod().getName() + " 执行！方法参数为：" + Arrays.toString(args));
		return invocation.proceed();
	}
}

第二步：编写启动类(数据库DDL，JavaDO，Mapper详见附录)。需注意的是一定要将自定义的拦截器注册到MyBatis中，这里我们用代码的方式来添加。

package com.tech.mybatis.interceptors;

import com.alibaba.druid.pool.DruidDataSource;
import com.xxx.spring.entity.TUserDO;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
/***
 * 演示Mybatis拦截器使用{@link Intercepts}
 * @author 君战
 * */
@Configuration
@EnableTransactionManagement
@MapperScan("com.tech.mybatis.interceptors")
public class MyBatisInterceptorDemo {

	public static void main(String[] args) {
		// 创建注解驱动应用上下文
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); 
		context.register(MyBatisInterceptorDemo.class); // 将当前类作为配置类注册
		context.refresh(); // 刷新应用上下文
		TUserMapper userMapper = context.getBean(TUserMapper.class); // 通过应用上下文来获取TUserMapper接口实现类实例
		TUserDO userDO = new TUserDO();
		userDO.setAge(22);
		userDO.setUserName("君战");
		userMapper.insert(userDO); // 执行TUserMapper的insert方法。
	}
	/**
	* 将SqlSession注册到Bean中，MyBatis在为Mapper接口生成代理对象时需要用到
	*/
	@Bean
	public static SqlSessionFactory sqlSessionFactory() throws Exception {
		SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
		factoryBean.setDataSource(dataSource());
		factoryBean.afterPropertiesSet();
		SqlSessionFactory sessionFactory = factoryBean.getObject();
		org.apache.ibatis.session.Configuration configuration = sessionFactory.getConfiguration();
		configuration.addInterceptor(new CustomizedInterceptor()); // 一定要将自定义拦截器添加到Mybatis配置中心Configuration
		return sessionFactory;
	}
	/*
	* 配置数据源
	*/
	@Bean
	public static DataSource dataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setUrl("jdbc:mysql://localhost:3306/study?useSSL=false");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");
		return dataSource;
	}
	/*
	* 配置事务管理，关于事务管理器的作用可以查看我的另一篇博文-
	* 《从源码轻松理解什么是事务传播特性？Spring事务传播是如何实现的？Spring事务传播行为有哪些？》
	* 地址：https://blog.csdn.net/m0_43448868/article/details/112115749
	*/
	@Bean
	public TransactionManager transactionManager() {
		return new DataSourceTransactionManager(dataSource());
	}


}

XML方式注册自定义拦截器。

<plugins>
	<plugin interceptor="com.tech.mybatis.interceptors.CustomizedInterceptor"></plugin>
</plugins>

执行main方法，可以看到控制台已经输出拦截器的打印语句。

拦截到 update 执行！方法参数为：[org.apache.ibatis.mapping.MappedStatement@70cf32e3, com.xxx.spring.entity.TUserDO@5a59ca5e]
21:32:11.117 [main] DEBUG com.tech.mybatis.interceptors.TUserMapper.insert - ==>  Preparing: INSERT INTO t_user VALUES(null,?,?)
21:32:11.160 [main] DEBUG com.tech.mybatis.interceptors.TUserMapper.insert - ==> Parameters: 君战(String), 22(Integer)
21:32:11.171 [main] DEBUG com.tech.mybatis.interceptors.TUserMapper.insert - <==    Updates: 1
拦截到 commit 执行！方法参数为：[true]

了解到MyBatis的拦截器怎么用之后，接下来我们就分析下MyBatis中的拦截器是如何实现的。

MyBatis拦截器机制底层实现分析

我们只需要分析一个扩展点的拦截器机制实现即可，因为其余三个的实现基本一致。这里我们就来分析下Executor扩展点的拦截器机制实现。

在DefaultSqlSessionFactory的openSessionFromDataSource方法中，

// DefaultSqlSessionFactory#openSessionFromDataSource
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
   Transaction tx = null;
   try {
     final Environment environment = configuration.getEnvironment();// 获取MyBatis的环境对象
     final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); // 根据环境对象获取事务工厂
     tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
     final Executor executor = configuration.newExecutor(tx, execType); // 重点是这里，在创建SqlSession之前首先通过configuration来创建了Executor
     return new DefaultSqlSession(configuration, executor, autoCommit);
   } catch (Exception e) {
     closeTransaction(tx); // may have fetched a connection so lets call close()
     throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
   } finally {
     ErrorContext.instance().reset();
   }
 }

在newExecutor方法中，创建完Executor 后，会调用interceptorChain的pluginAll方法来对Executor进行增强(如果应用程序定义了拦截器，并且在拦截器的@Intercepts({@Signature(…)})注解中配置的是Executor的某个方法)。

// Configuration#newExecutor
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
   executorType = executorType == null ? defaultExecutorType : executorType;
   executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
   Executor executor;
   if (ExecutorType.BATCH == executorType) { // 如果是批量Executor 
     executor = new BatchExecutor(this, transaction);
   } else if (ExecutorType.REUSE == executorType) { // 如果是可复用的Executor 
     executor = new ReuseExecutor(this, transaction);
   } else {// 默认使用SimpleExecutor
     executor = new SimpleExecutor(this, transaction);
   }
   if (cacheEnabled) {
     executor = new CachingExecutor(executor);
   }// 创建完Executor之后，调用interceptorChain的pluginAll方法来对Executor进行增强
   executor = (Executor) interceptorChain.pluginAll(executor);
   return executor;
 }

InterceptorChain 类就定义了一个集合用来存放用户注册的所有Interceptor实现，在pluginAll方法中遍历每一个Interceptor实现类，调用其plugin方法，传入目标对象。

package org.apache.ibatis.plugin;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class InterceptorChain {
	
  private final List<Interceptor> interceptors = new ArrayList<>();
  // 遍历用户注册的所有拦截器实现类的plugin方法，注意这是一个链式增强
  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }
  // 将Interceptor 实现类实例保存进interceptors 集合中
  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }
  // 获取一个不可修改的interceptors 集合的副本
  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

因为我们没有重写plugin方法，所以执行的是Interceptor接口默认的plugin方法，在默认实现中调用Plugin的wrap方法。

// Interceptor#plugin
default Object plugin(Object target) {
   return Plugin.wrap(target, this);
 }

既然如此，那么我们就着重分析下Plugin类，因为在其wrap方法中基本调用到了该类的所有方法以及使用到了所有属性。需要注意的是该类实现了JDK动态代理中的InvocationHandler接口。


public class Plugin implements InvocationHandler {

  private final Object target; // 目标对象
  private final Interceptor interceptor; // 拦截器对象
  private final Map<Class<?>, Set<Method>> signatureMap; // 方法签名，Key为接口Class，value为方法

  private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
    this.target = target;
    this.interceptor = interceptor;
    this.signatureMap = signatureMap;
  }

  public static Object wrap(Object target, Interceptor interceptor) {
    // 首先根据拦截器来获取其关注的类以及类中的方法
    Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
    Class<?> type = target.getClass();
    // 根据用户在@Intercepts中@Signature注解中配置的类型来和目标对象接口进行匹配
    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
    if (interfaces.length > 0) { // 使用JDK动态代理
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    }
    return target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try { // 首先根据传入的方法的定义类类型来判断当前拦截器是否感兴趣
      Set<Method> methods = signatureMap.get(method.getDeclaringClass());
      if (methods != null && methods.contains(method)) {// 如果当前拦截器感兴趣，则调用其intercept方法
        return interceptor.intercept(new Invocation(target, method, args));
      }
      return method.invoke(target, args);// 否则直接执行目标方法
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
  }

  private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class); // 获取到拦截器中的@Intercepts注解数据
    if (interceptsAnnotation == null) {
      throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
    }
    Signature[] sigs = interceptsAnnotation.value(); // 获取@Intercepts注解中的所有@Signature
    Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();
    for (Signature sig : sigs) {// 遍历每一个@Signature注解
      Set<Method> methods = signatureMap.computeIfAbsent(sig.type(), k -> new HashSet<>());
      try {
        Method method = sig.type().getMethod(sig.method(), sig.args()); // 以@Signature注解中配置的type来获取其method，根据@Signature注解中配置的method以及args
        methods.add(method); // 将获取到的方法保存进methods集合中。
      } catch (NoSuchMethodException e) {
        throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
      }
    }
    return signatureMap;
  }

  private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
    Set<Class<?>> interfaces = new HashSet<>();
    while (type != null) {
    // 获取目标类型的所有接口并遍历，需注意的是这里传递的实际类型(type)是接口实现类，
    // 并不是接口本身。如果是接口本身，那么type.getInterfaces()获取到的接口只有父接口了。
      for (Class<?> c : type.getInterfaces()) { 
        if (signatureMap.containsKey(c)) { 
        // 如果signatureMap中包含该接口，则将该接口添加到interfaces集合中
          interfaces.add(c);
        }
      }// 如果当前类存在父类，对其父类进行相同的查找
      type = type.getSuperclass();
    }// 最后返回合适的接口
    return interfaces.toArray(new Class<?>[interfaces.size()]);
  }

}

总结

MyBatis中的拦截器机制其实就是基于JDK的动态代理实现，在创建完目标对象后，循环用户注册的所有拦截器实现，然后对每个拦截器的@Intercepts中@Signature注解中配置的类型来和目标对象所实现的接口进行匹配，如果匹配上了，则说明目标对象是当前拦截器所关注的。

在代理对象执行的时候，对目标方法进行拦截判断是不是当前拦截器所关注的方法，如果是则执行拦截器的intercept方法，否则直接执行目标方法。

附录

数据库DDL

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(30) DEFAULT NULL,
  `age` int(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

TUserMapper

package com.tech.mybatis.interceptors;

import com.xxx.spring.entity.TUserDO;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

/**
 * @author: 君战
 **/
public interface TUserMapper {


	@Select("SELECT * FROM t_user")
    List<TUserDO> selectAll();

	@Insert("INSERT INTO t_user VALUES(null,#{userName},#{age})")
    Integer insert(TUserDO userDO);

	@Update("UPDATE t_user SET age = #{age} WHERE user_name = #{userName}")
	Integer update(TUserDO userDO);

}

TUserDO

package com.xxx.spring.entity;

/**
 * @author: 君战
 **/
public class TUserDO {

	private Integer id;

	private String userName;

	private Integer age;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}
}
君战
关注
专栏目录
Mybatis Interceptor 拦截器的实现
08-26
主要介绍了Mybatis Interceptor 拦截器的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
mybatis interceptor
06-06
mybatis实现分页的例子，为了记录下来以便于今后自己用。
科普文：MyBatis系列之【Mybatis常用的4种拦截器】
最新发布
为无为，事无事，味无味。
08-18 1138
MyBatis 的拦截器是一个十分强大的特性，它可以让我们在 MyBatis 调用数据库操作的过程中插入自己的逻辑，非常适合做一些数据操作的审计、性能优化、事务管理、执行日志输出等。MyBatis 的拦截器机制基于 AOP（面向切面编程），允许在执行 SQL 语句前后插入自定义逻辑。MyBatis 提供了几个内置的拦截点，这些拦截点对应于 MyBatis 内部组件的不同阶段。拦截器可以用来修改 SQL 语句、参数、结果集等。
如何使用gitee码云项目管理
xuehen86的博客
09-23 489
第一个是很好的创建方法 https://blog.csdn.net/m0_37788308/article/details/79032816?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLe
Mybatis——拦截器Interceptor
娜娜米的博客
05-08 3万+
本篇介绍Mybatis拦截器/插件相关知识，包括相关的类及作用、拦截器有哪几种、拦截器可以在Mybatis的执行过程中的哪些节点起作用、拦截器如何使用、相关的API，最后附上代码示例。
Mybatis拦截器Interceptor
wind_chasing_boy的博客
06-13 6432
最近项目使用Mybatis拦截器对数据进行加解密，以下记录如何将拦截器集成到项目中以及在使用过程中踩过的一些小坑，与君共勉Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。SqlSessionFactory：SqlSession工厂。
MyBatis 插件之拦截器（Interceptor）
热门推荐
M义薄云天的博客
06-12 8万+
一.背景 在很多业务场景下我们需要去拦截sql，达到不入侵原有代码业务处理一些东西，比如：分页操作，数据权限过滤操作，SQL执行时间性能监控等等，这里我们就可以用到Mybatis的拦截器Interceptor 二.Mybatis核心对象介绍 从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个： Configuration 初始化基础配置，比如MyBatis的别...
Mybatis中拦截器的简单实现方法
08-25
在介绍Mybatis拦截器的实现之前，先来回顾一下JDK动态代理的基本原理。动态代理机制主要涉及到Java的java.lang.reflect包，它允许程序在运行期间创建接口的代理实例。通过Proxy类与InvocationHandler接口，可以在...
mybatis拦截器实现通用权限字段添加的方法
08-25
MyBatis拦截器实现通用权限字段添加的方法 MyBatis拦截器是一种非常实用的技术，可以用来实现各种复杂的数据库操作。本文将详细介绍如何使用MyBatis拦截器来实现通用权限字段添加，达到灵活、可靠、可维护的数据库...
简单了解mybatis拦截器实现原理及实例
08-25
MyBatis拦截器实现原理及实例 MyBatis拦截器是一种强大的机制，能够在MyBatis执行SQL语句之前或之后执行自定义逻辑。拦截器可以用来实现诸如日志记录、性能监控、安全认证等功能。本文将详细介绍MyBatis拦截器的...
Mybatis之Interceptor原理分析
liujie379908的博客
10-20 332
Mybatis之Interceptor原理分析Mybatis之Interceptor原理分析Interceptor介绍Interceptor具体使用1.新增实现类2.配置文件配置拦截器源码分析1.读取配置文件plugins加载到内存中2.执行sql的命令时从内存中获取拦截器，执行拦截操作 Mybatis之Interceptor原理分析 Interceptor介绍 Mybatis提供了一种插件plu...
mybatis拦截器
11-09
MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。
Mybatis的拦截器Interceptor
Kwoky的博客
06-09 2194
Mybatis的拦截器Interceptor
mybatis的Interceptor
smileLs的博客
02-21 1679
mybatis的拦截器
Mybatis拦截器(Interceptor)的理解与实践
weixin_61478518的博客
07-08 1360
MyBatis 的拦截器是一个十分强大的特性，它可以让我们在 MyBatis 调用数据库操作的过程中插入自己的逻辑，非常适合做一些数据操作的审计、性能优化、事务管理、执行日志输出等。
MyBatis拦截器(Interceptor)的理解与实践
学IT，找陈寒
06-19 1184
MyBatis拦截器是一种基于Java反射机制和动态代理的插件，用于拦截MyBatis的方法调用。它允许开发者在SQL语句执行前后、结果集处理前后等关键节点进行拦截，并在拦截器中编写自定义逻辑。SQL语句重写、增强或修改；对参数进行加工；对结果集进行加工；统计SQL执行时间；实现分页、缓存等通用功能。接下来，我们将通过一个实际的示例来展示如何编写和配置自定义拦截器，并说明其实现的功能和作用。
Mybatis的Interceptor接口
five-five
02-07 1130
Mybatis基本流程理解(详情点击) 引入 首先那一段最简单的mybatis调用的代码块来说明 { SqlSession session = null; String resource = "configuration.xml"; // 使用io流读取配置 InputStream inputStream; inputStream = Resources.getResourceAsStream(resource); //这里是解析配置文件 sqlSessionFactory = new Sql
Mybatis拦截器的原理
Chen4852010的博客
12-25 568
拦截器底层就是aop,那么是aop,就要有代理对象，和invocationHandler，另外拦截器必须得有 标识（拦截哪些对象的哪些方法） 拦截器的主要2个功能 1.创建代理对象的方法 2.具体的执行aop操作的方法（一般拦截器不是InvocationHandler） 3.具体的InvocationHandler需要配套组件提供 注册拦截器：我们需要做的 1.注册拦截器 2.编写拦截器的方法： 1.生成代理对象的方法 plugin方法 2.具体执行目标方法的 intercept方法
MyBatis源码剖析 - MyBatis 插件之拦截器（Interceptor）实现原理
lowols的博客
06-30 293
转载（https://blog.csdn.net/top_code/article/details/55657776 在上一篇文章：MyBatis 教程 - MyBatis插件（Plugins）开发 中已经介绍了如何去开发一个MyBatis 插件，本文将结合MyBatis 源码来揭秘MyBatis Plugins内部实现原理。 Mybatis3 插件采用责任链模式，通过动态代理组织多个拦截器（插件），通过这些拦截器可以改变Mybatis的默认行为（诸如SQL重写之类的）。 本文分析使用的MyBatis 源代
mybatis 拦截器interceptor
07-12
MyBatis拦截器（Interceptor）是MyBatis框架提供的一种高级功能，它允许开发者在数据访问的生命周期中添加自定义逻辑。Interceptor是一种基于AOP（面向切面编程）的概念，可以在执行SQL语句前、执行后、甚至更新结果集等关键点插入代码，进行事务管理、日志记录、权限检查等操作，而无需修改Mapper XML或基础Mapper接口。 MyBatis拦截器通常通过实现`org.apache.ibatis.session.interceptor.Interceptor`接口，并在配置文件中注册，然后在需要的地方注入到`SqlSession`中来启用。常见的拦截器包括： 1. `BeforeCallback`：在查询开始之前调用，可以设置参数、获取数据库连接等。 2. `AfterCallback`：查询执行后调用，可以处理返回的结果。 3. `AroundCallback`：环绕通知，环绕整个查询过程，可以在执行前后执行自定义逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值