mybatis自定义插件要实现什么接口

竟然Mybatis是对四大接口进行拦截的，那我们药先要知道Mybatis的四大接口对象 Executor, StatementHandler, ResultSetHandler, ParameterHandler。

上图Mybatis框架的整个执行过程。Mybatis插件能够对则四大对象进行拦截，可以包含到了Mybatis一次会议的所有 *** 作。可见Mybatis的的插件很强大。

Executor是 Mybatis的内部执行器，它负责调用StatementHandler *** 作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的 *** 作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。

StatementHandler是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的 *** 作(禁用等等)。

ParameterHandler是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。

ResultSetHandler是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。

插件Interceptor

Mybatis的插件实现要实现Interceptor接口，我们看下这个接口定义的方法。

public interface Interceptor {

Object intercept(Invocation invocation) throws Throwable;

Object plugin(Object target);

void setProperties(Properties properties);

}

这个接口只声明了三个方法。

setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置

plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Pluginwrap(target, this);

intercept方法就是要进行拦截的时候要执行的方法

理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。

Mybatis四大接口对象创建方法

Mybatis的插件是采用对四大接口的对象生成动态代理对象的方法来实现的。那么现在我们看下Mybatis是怎么创建这四大接口对象的。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {

//确保ExecutorType不为空(defaultExecutorType有可能为空)

executorType = executorType == null defaultExecutorType : executorType;

executorType = executorType == null ExecutorTypeSIMPLE : executorType;

Executor executor; if (ExecutorTypeBATCH == executorType) {

executor = new BatchExecutor(this, transaction);

} else if (ExecutorTypeREUSE == executorType) {

executor = new ReuseExecutor(this, transaction);

} else {

executor = new SimpleExecutor(this, transaction);

} if (cacheEnabled) {

executor = new CachingExecutor(executor);

}

executor = (Executor) interceptorChainpluginAll(executor);

return executor;

}

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);

statementHandler = (StatementHandler) interceptorChainpluginAll(statementHandler);

return statementHandler;

}

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {

ParameterHandler parameterHandler = mappedStatementgetLang()createParameterHandler(mappedStatement, parameterObject, boundSql);

parameterHandler = (ParameterHandler) interceptorChainpluginAll(parameterHandler);

return parameterHandler;

}

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {

ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);

resultSetHandler = (ResultSetHandler) interceptorChainpluginAll(resultSetHandler);

return resultSetHandler;

}

查看源码可以发现， Mybatis框架在创建好这四大接口对象的实例后，都会调用InterceptorChainpluginAll()方法。InterceptorChain对象是插件执行链对象，看源码就知道里面维护了Mybatis配置的所有插件(Interceptor)对象。

// target --> Executor/ParameterHandler/ResultSetHander/StatementHandler

public Object pluginAll(Object target) {

for (Interceptor interceptor : interceptors) {

target = interceptorplugin(target);

}

return target;

}

其实就是安顺序执行我们插件的plugin方法,一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口对象的方法时候，实际上是调用代理对象的响应方法，代理对象又会调用十大接口对象的实例。

Plugin对象

我们知道，官方推荐插件实现plugin方法为：Pluginwrap(target, this);

public static Object wrap(Object target, Interceptor interceptor) {

// 获取插件的Intercepts注解

Map<Class<>, Set<Method>> signatureMap = getSignatureMap(interceptor);

Class<> type = targetgetClass();

Class<>[] interfaces = getAllInterfaces(type, signatureMap);

if (interfaceslength > 0) {

return ProxynewProxyInstance(typegetClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));

}

return target;

}

这个方法其实是Mybatis简化我们插件实现的工具方法。其实就是根据当前拦截的对象创建了一个动态代理对象。代理对象的InvocationHandler处理器为新建的Plugin对象。

插件配置注解@Intercepts

Mybatis的插件都要有Intercepts注解来指定要拦截哪个对象的哪个方法。我们知道，Pluginwarp方法会返回四大接口对象的代理对象(通过new Plugin()创建的IvocationHandler处理器)，会拦截所有的执行方法。在代理对象执行对应方法的时候，会调用InvocationHandler处理器的invoke方法。Mybatis中利用了注解的方式配置指定拦截哪些方法。具体如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

try {

Set<Method> methods = signatureMapget(methodgetDeclaringClass());

if (methods != null && methodscontains(method)) {

return interceptorintercept(new Invocation(target, method, args));

}

return methodinvoke(target, args);

} catch (Exception e) {

throw ExceptionUtilunwrapThrowable(e);

}

}

可以看到，只有通过Intercepts注解指定的方法才会执行我们自定义插件的intercept方法。未通过Intercepts注解指定的将不会执行我们的intercept方法。

官方插件开发方式

@Intercepts({@Signature(type = Executorclass, method = "query",

args = {MappedStatementclass, Objectclass, RowBoundsclass, ResultHandlerclass})})

public class TestInterceptor implements Interceptor {

public Object intercept(Invocation invocation) throws Throwable {

Object target = invocationgetTarget(); //被代理对象

Method method = invocationgetMethod(); //代理方法

Object[] args = invocationgetArgs(); //方法参数

// do something 方法拦截前执行代码块

Object result = invocationproceed();

// do something 方法拦截后执行代码块

return result;

}

public Object plugin(Object target) {

return Pluginwrap(target, this);

}

}

以上就是Mybatis官方推荐的插件实现的方法，通过Plugin对象创建被代理对象的动态代理对象。可以发现，Mybatis的插件开发还是很简单的。

自定义开发方式

Mybatis的插件开发通过内部提供的Plugin对象可以很简单的开发。只有理解了插件实现原理，对应不采用Plugin对象我们一样可以自己实现插件的开发。下面是我个人理解之后的自己实现的一种方式。

public class TestInterceptor implements Interceptor {

public Object intercept(Invocation invocation) throws Throwable {

Object target = invocationgetTarget(); //被代理对象

Method method = invocationgetMethod(); //代理方法

Object[] args = invocationgetArgs(); //方法参数

// do something 方法拦截前执行代码块

Object result = invocationproceed();

// do something 方法拦截后执行代码块

return result;

}

public Object plugin(final Object target) {

return ProxynewProxyInstance(InterceptorclassgetClassLoader(), targetgetClass()getInterfaces(), new InvocationHandler() {

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

return intercept(new Invocation(target, method, args));

}

});

}

public void setProperties(Properties properties) {

}

}

当然，Mybatis插件的那这个时候Intercepts的注解起不到作用了。

作者：曹金桂

链接：>

引入了以下包

其中自动装配的包就是mybatis-spring-boot-autoconfigure。

META-INF下有一个springfactories文件

导入了这个类MybatisAutoConfiguration

注册MapperScannerConfigurer的Bean定义到Spring容器中,并设置扫描包的路径

MapperScannerConfigurer 实现BeanDefinitionRegistryPostProcessor接口,实例化的时候会调到postProcessBeanDefinitionRegistry方法,这个方法里会创建一个ClassPathMapperScanner对象,然后去扫描

扫描到之后修改BeanDefinition

@MapperScan注解，会import进来MapperScannerRegistrar这个类

MapperScannerRegistrar类实现ImportBeanDefinitionRegistrar接口,实例化的时候会调用registerBeanDefinitions方法

和@Mapper一样，同样会创建MapperScannerConfigurer的BeanDefition,用于后续实例化

只不过要扫描的包路径变了，不再是默认的,而是@MapperScan配置的包路径

后面的话则和@Mapper扫描到之后的工作原理是一样的,扫描到之后，更改BeanDefinition，一毛一样的。

==可以看出@MapperScan最主要的工作原理除了提供BasePackage的值之外,就是用@Import注解导入MapperScannerRegistrar所以这个注解打在任何可以被spring扫描到的类上都可以,并不一定要打在启动类上(大多数为了只是为了看起来方便，把全局性的配置注解打在启动类上而已)==

前面提到,注册扫描@Mapper接口的MapperScannerConfigurer实例的类是AutoConfiguredMapperScannerRegistrar,那么这个类是如何被导入进来的呢

MybatisAutoConfiguration还有一个静态内部类,@Import了AutoConfiguredMapperScannerRegistrar类,但是有@ConditionalOnMissingBean,即spring容器中不存在MapperFactoryBean,MapperScannerConfigurer的实例。

如果@MapperScan注解生效,并且扫描到任意一个Mapper接口(前面被改造成MapperFactoryBean类型的了)，那么就不满足注册这个类MapperScannerRegistrarNotFoundConfiguration的实例的条件，继而不会导入AutoConfiguredMapperScannerRegistrar类。

前面提到,所有的Mapper接口被扫描到,封装成BeanDefinition,还经历了一次改造,

最主要的就是将mapper接口BeanDefination的beanClass改成了orgmybatisspringmapperMapperFactoryBeanclass

并且将mapper接口BeanDefination的名称作为构造函数的入参传入进去

并讲BeanDefinition的autowireMode属性改成 AUTOWIRE_BY_TYPE ,后面实例化该bean的时候会调用属性的描述器,用write的方式注入属性值，最重要的那个属性那就是SqlSessionTemplate 会通过这种方式将前面MybatisAutoConfiguration中@Bean出来的SqlSessionTemplate注入到其中。

类图：

这里他实现了FactoryBean,

FactoryBean有以下方法

这里是spring的一个拓展点,实现了FactoryBean接口的类,将可以实现getObject() 和getObjectType来实例化额外的一个bean并装到spring容器中

好吧,其实Mapper代理对象的创建就是在MapperFactoryBean的getObject方法中返回的

这里就是熟悉的原生Mybatis创建Mapper接口的味道了。

附上调用的类时序图,回过头来看一下调用的整体流程。

1、创建数据库，先把mysql文件夹中的 sql 文件以文件名称创建数据库（或者找下sql文件中，有没有DROP DATABASE xxxxxx ，有的话一般项目数据库名称就是这个 xxxxxx），执行sql后，检查数据库是否创建好，是否有数据等；

2、如果不知道数据库在哪儿配置，用搜索工具，例如 dreamweaver 搜索一下源代码，搜索数据库名称，看看能否找到，找到的话密码设置正确，可以发布项目，浏览器访问看看，

一般如果是用hibernate的话，要么在hibernate的配置文件 hibernatecfg 中设置，要么在spring配置文件 的dataSource 里配置，，用MyBatis 的话，也是在配置文件中找，配置文件一般要么放在 WEB-INF/ 目录下，要么放在 WEB-INF\classes 下 的 xml 文件

用过MyBatis3的人可能会觉得为什么MyBatis的Mapper接口没有实现类，但是可以直接用？

那是因为MyBatis使用Java动态代理实现的接口。

这里仅仅举个简单例子来说明原理，不是完全针对MyBatis的，这种思想我们也可以应用在其他地方。

定义一个接口

public interface MethodInterface {

String helloWorld();

}123

实现动态代理接口

public class MethodProxy<T> implements InvocationHandler {

private Class<T> methodInterface;

public MethodProxy(Class<T> methodInterface) {

thismethodInterface = methodInterface;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

Systemoutprintln("=========================");

Systemoutprintln("方法名:" + methodgetName());

//针对不同的方法进行不同的 *** 作

return null;

}

}123456789101112131415

这里针对invoke方法简单说说MyBatis的实现原理，在该方法中，我们通过Method能够获取接口和方法名，接口的全名相当于MyBatis XML中的namespace，方法名相当于具体一个方法中的id。也就是说通过动态代理后，可以通过SqlSession来通过namespaceid方式来调用相应的方法。使用接口更方便，但是是一种间接的方式。

动态代理工厂类

public class MethodProxyFactory {

public static <T> T newInstance(Class<T> methodInterface) {

final MethodProxy<T> methodProxy = new MethodProxy<T>(methodInterface);

return (T) ProxynewProxyInstance(

ThreadcurrentThread()getContextClassLoader(),

new Class[]{methodInterface},

methodProxy);

}

}123456789

通过该工厂类可以生成任意接口的动态代理类。

测试

MethodInterface method = MethodProxyFactorynewInstance(MethodInterfaceclass);

methodhelloWorld();12

可以看到MethodInterface没有实现类也可以执行。

总结

一般谈到动态代理我们通常的用法都是处理事务、日志或者记录方法执行效率等方面的应用。都是对实现类方法的前置或者后置的特殊处理。

以上就是关于mybatis自定义插件要实现什么接口全部的内容，包括:mybatis自定义插件要实现什么接口、使用mybatis的mapper接口调用时有哪些要求、springboot中,mybatis的mapper接口是如何生成代理对象的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！