在实际开发过程当中,咱们常用的Mybaits插件就是分页插件了，经过分页插件咱们能够在不用写count语句和limit的状况下就能够获取分页后的数据,给咱们开发带来很大java
的便利。除了分页，插件使用场景主要还有更新数据库的通用字段，分库分表，加解密等的处理。spring
这篇博客主要讲Mybatis插件原理,下一篇博客会设计一个Mybatis插件实现的功能就是每当新增数据的时候不用数据库自增ID而是经过该插件生成雪花ID,做为每条数据的主键。数据库
1、JDK动态代理+责任链设计模式
Mybatis的插件其实就是个拦截器功能。它利用JDK动态代理和责任链设计模式的综合运用。采用责任链模式，经过动态代理组织多个拦截器,经过这些拦截器你能够作一些apache
一、JDK动态代理案例
public class MyProxy { /** * 一个接口 */ public interface HelloService{ void sayHello(); } /** * 目标类实现接口 */ static class HelloServiceImpl implements HelloService{ @Override public void sayHello() { System.out.println("sayHello......"); } } /** * 自定义代理类须要实现InvocationHandler接口 */ static class HWInvocationHandler implements InvocationHandler { /** * 目标对象 */ private Object target; public HWInvocationHandler(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------插入前置通知代码-------------"); //执行相应的目标方法 Object rs = method.invoke(target,args); System.out.println("------插入后置处理代码-------------"); return rs; } public static Object wrap(Object target) { return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new HWInvocationHandler(target)); } } public static void main(String[] args) { HelloService proxyService = (HelloService) HWInvocationHandler.wrap(new HelloServiceImpl()); proxyService.sayHello(); } }
运行结果设计模式
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
二、优化
上面代理的功能是实现了,可是有个很明显的缺陷，就是HWInvocationHandler是动态代理类，也能够理解成是个工具类，咱们不可能会把业务代码写到写到到invoke方法里，数组
不符合面向对象的思想，能够抽象一下处理。能够设计一个Interceptor接口，须要作什么拦截处理实现接口就好了。缓存
public interface Interceptor { /** * 具体拦截处理 */ void intercept(); }
intercept() 方法就能够处理各类前期准备了mybatis
public class LogInterceptor implements Interceptor { @Override public void intercept() { System.out.println("------插入前置通知代码-------------"); } } public class TransactionInterceptor implements Interceptor { @Override public void intercept() { System.out.println("------插入后置处理代码-------------"); } }
代理对象也作一下修改app
public class HWInvocationHandler implements InvocationHandler { private Object target; private List<Interceptor> interceptorList = new ArrayList<>(); public TargetProxy(Object target,List<Interceptor> interceptorList) { this.target = target; this.interceptorList = interceptorList; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //处理多个拦截器 for (Interceptor interceptor : interceptorList) { interceptor.intercept(); } return method.invoke(target, args); } public static Object wrap(Object target,List<Interceptor> interceptorList) { HWInvocationHandler targetProxy = new HWInvocationHandler(target, interceptorList); return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),targetProxy); } }
如今能够根据须要动态的添加拦截器了，在每次执行业务代码sayHello()以前都会拦截，看起来高级一点，来测试一下框架
public class Test { public static void main(String[] args) { List<Interceptor> interceptorList = new ArrayList<>(); interceptorList.add(new LogInterceptor()); interceptorList.add(new TransactionInterceptor()); HelloService target = new HelloServiceImpl(); Target targetProxy = (Target) TargetProxy.wrap(target,interceptorList); targetProxy.sayHello(); } }
运行结果
------插入前置通知代码------------- ------插入后置处理代码------------- sayHello......
三、再优化
上面的动态代理确实能够把代理类中的业务逻辑抽离出来，可是咱们注意到，只有前置代理，没法作到先后代理，因此还须要在优化下。因此须要作更一步的抽象，
把拦截对象信息进行封装，做为拦截器拦截方法的参数，把拦截目标对象真正的执行方法放到Interceptor中完成，这样就能够实现先后拦截，而且还能对拦截
对象的参数等作修改。设计一个Invocation 对象。
public class Invocation { /** * 目标对象 */ private Object target; /** * 执行的方法 */ private Method method; /** * 方法的参数 */ private Object[] args; //省略getset public Invocation(Object target, Method method, Object[] args) { this.target = target; this.method = method; this.args = args; } /** * 执行目标对象的方法 */ public Object process() throws Exception{ return method.invoke(target,args); } }
Interceptor拦截接口作修改
public interface Interceptor { /** * 具体拦截处理 */ Object intercept(Invocation invocation) throws Exception; }
Interceptor实现类
public class TransactionInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Exception{ System.out.println("------插入前置通知代码-------------"); Object result = invocation.process(); System.out.println("------插入后置处理代码-------------"); return result; } }
Invocation 类就是被代理对象的封装，也就是要拦截的真正对象。HWInvocationHandler修改以下：
public class HWInvocationHandler implements InvocationHandler { private Object target; private Interceptor interceptor; public TargetProxy(Object target,Interceptor interceptor) { this.target = target; this.interceptor = interceptor; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Invocation invocation = new Invocation(target,method,args); return interceptor.intercept(invocation); } public static Object wrap(Object target,Interceptor interceptor) { HWInvocationHandler targetProxy = new HWInvocationHandler(target, interceptor); return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),targetProxy); } }
测试类
public class Test { public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor transactionInterceptor = new TransactionInterceptor(); HelloService targetProxy = (Target) TargetProxy.wrap(target,transactionInterceptor); targetProxy.sayHello(); } }
运行结果
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
四、再再优化
上面这样就能实现先后拦截，而且拦截器能获取拦截对象信息。可是测试代码的这样调用看着很别扭，对应目标类来讲，只须要了解对他插入了什么拦截就好。
再修改一下，在拦截器增长一个插入目标类的方法。
public interface Interceptor { /** * 具体拦截处理 */ Object intercept(Invocation invocation) throws Exception; /** * 插入目标类 */ Object plugin(Object target); } public class TransactionInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Exception{ System.out.println("------插入前置通知代码-------------"); Object result = invocation.process(); System.out.println("------插入后置处理代码-------------"); return result; } @Override public Object plugin(Object target) { return TargetProxy.wrap(target,this); } }
这样目标类仅仅须要在执行前，插入须要的拦截器就行了，测试代码：
public class Test { public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor transactionInterceptor = new TransactionInterceptor(); //把事务拦截器插入到目标类中 target = (HelloService) transactionInterceptor.plugin(target); target.sayHello(); } }
运行结果
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
五、多个拦截器如何处理
到这里就差很少完成了，那咱们再来思考若是要添加多个拦截器呢，怎么搞？
public class Test { public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor transactionInterceptor = new TransactionInterceptor(); target = (HelloService) transactionInterceptor.plugin(target); LogInterceptor logInterceptor = new LogInterceptor(); target = (HelloService)logInterceptor.plugin(target); target.sayHello(); } }
运行结果
------插入前置通知代码------------- ------插入前置通知代码------------- sayHello...... ------插入后置处理代码------------- ------插入后置处理代码-------------
六、责任链设计模式
其实上面已经实现的没问题了，只是还差那么一点点，添加多个拦截器的时候不太美观，让咱们再次利用面向对象思想封装一下。咱们设计一个InterceptorChain 拦截器链类
public class InterceptorChain { private List<Interceptor> interceptorList = new ArrayList<>(); /** * 插入全部拦截器 */ public Object pluginAll(Object target) { for (Interceptor interceptor : interceptorList) { target = interceptor.plugin(target); } return target; } public void addInterceptor(Interceptor interceptor) { interceptorList.add(interceptor); } /** * 返回一个不可修改集合，只能经过addInterceptor方法添加 * 这样控制权就在本身手里 */ public List<Interceptor> getInterceptorList() { return Collections.unmodifiableList(interceptorList); } }
其实就是经过pluginAll() 方法包一层把全部的拦截器插入到目标类去而已。测试代码：
public class Test { public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor transactionInterceptor = new TransactionInterceptor(); LogInterceptor logInterceptor = new LogInterceptor(); InterceptorChain interceptorChain = new InterceptorChain(); interceptorChain.addInterceptor(transactionInterceptor); interceptorChain.addInterceptor(logInterceptor); target = (Target) interceptorChain.pluginAll(target); target.sayHello(); } }
这里展现的是JDK动态代理+责任链设计模式，那么Mybatis拦截器就是基于该组合进行开发。
2、Mybatis Plugin 插件概念
一、原理
Mybatis的拦截器实现机制跟上面最后优化后的代码很是的类似。它也有个代理类Plugin(就是上面的HWInvocationHandler）这个类一样也会实现了InvocationHandler接口,
当咱们调用ParameterHandler,ResultSetHandler,StatementHandler,Executor的对象的时候,,就会执行Plugin的invoke方法,Plugin在invoke方法中根据
@Intercepts的配置信息(方法名,参数等)动态判断是否须要拦截该方法.再而后使用须要拦截的方法Method封装成Invocation,并调用Interceptor的proceed方法。
这样咱们就达到了拦截目标方法的结果。例如Executor的执行大概是这样的流程:
拦截器代理类对象->拦截器->目标方法 Executor.Method->Plugin.invoke->Interceptor.intercept->Invocation.proceed->method.invoke。
二、如何自定义拦截器？
1) Interceptor接口
首先Mybatis官方早就想到咱们开发会有这样的需求，因此开放了一个org.apacheibatis.plugin.Interceptor这样一个接口。这个接口就是和上面Interceptor性质是同样的
public interface Interceptor { //当plugin函数返回代理，就能够对其中的方法进行拦截来调用intercept方法 Object intercept(Invocation invocation) throws Throwable; //plugin方法是拦截器用于封装目标对象的，经过该方法咱们能够返回目标对象自己，也能够返回一个它的代理。 Object plugin(Object target); //在Mybatis配置文件中指定一些属性 void setProperties(Properties properties); }
2）自定义拦截器
这里的ExamplePlugin和上面的LogInterceptor和TransactionInterceptor性质是同样的
@Intercepts({@Signature( type= Executor.class, method = "update", args ={MappedStatement.class,Object.class})}) public class ExamplePlugin implements Interceptor { public Object intercept(Invocation invocation) throws Throwable { return invocation.proceed(); } public Object plugin(Object target) { return Plugin.wrap(target, this); } public void setProperties(Properties properties) { } }
3)、全局xml配置
最后若是你使用的是Mybatis.xml也就是Mybatis自己单独的配置，你能够须要在这里配置相应的拦截器名字等。
若是你使用的是spring管理的Mybatis，那么你须要在Spring配置文件里面配置注册相应的拦截器。
这样一个自定义mybatis插件流程大体就是这样了。
三、Mybatis四大接口
居然Mybatis是对四大接口进行拦截的，那咱们要先要知道Mybatis的四大接口对象 Executor, StatementHandle, ResultSetHandler, ParameterHandler。
1.Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) MyBatis的执行器，用于执行增删改查操做； 2.ParameterHandler (getParameterObject, setParameters) 处理SQL的参数对象； 3.ResultSetHandler (handleResultSets, handleOutputParameters) 处理SQL的返回结果集； 4.StatementHandler (prepare, parameterize, batch, update, query) 拦截Sql语法构建的处理
上图Mybatis框架的整个执行过程。
3、Mybatis Plugin 插件源码
通过上面的分析，再去看Mybastis Plugin 源码的时候就很轻松了。
这几个也就对应上面的几个，只不过添加了注解，来判断是否拦截指定方法。
一、拦截器链InterceptorChain
public class InterceptorChain { private final List<Interceptor> interceptors = new ArrayList<Interceptor>(); public Object pluginAll(Object target) { //循环调用每一个Interceptor.plugin方法 for (Interceptor interceptor : interceptors) { target = interceptor.plugin(target); } return target; } public void addInterceptor(Interceptor interceptor) { interceptors.add(interceptor); } public List<Interceptor> getInterceptors() { return Collections.unmodifiableList(interceptors); } }
这个就和咱们上面实现的是同样的。定义了拦截器链
二、Configuration
经过初始化配置文件把全部的拦截器添加到拦截器链中。
public class Configuration { protected final InterceptorChain interceptorChain = new InterceptorChain(); //建立参数处理器 public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) { //建立ParameterHandler ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql); //插件在这里插入 parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler); return parameterHandler; } //建立结果集处理器 public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) { //建立DefaultResultSetHandler ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds); //插件在这里插入 resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler); return resultSetHandler; } //建立语句处理器 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) interceptorChain.pluginAll(statementHandler); return statementHandler; } public Executor newExecutor(Transaction transaction) { return newExecutor(transaction, defaultExecutorType); } //产生执行器 public Executor newExecutor(Transaction transaction, ExecutorType executorType) { executorType = executorType == null ? defaultExecutorType : executorType; //这句再作一下保护,囧,防止粗枝大叶的人将defaultExecutorType设成null? executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Executor executor; //而后就是简单的3个分支，产生3种执行器BatchExecutor/ReuseExecutor/SimpleExecutor if (ExecutorType.BATCH == executorType) { executor = new BatchExecutor(this, transaction); } else if (ExecutorType.REUSE == executorType) { executor = new ReuseExecutor(this, transaction); } else { executor = new SimpleExecutor(this, transaction); } //若是要求缓存，生成另外一种CachingExecutor(默认就是有缓存),装饰者模式,因此默认都是返回CachingExecutor if (cacheEnabled) { executor = new CachingExecutor(executor); } //此处调用插件,经过插件能够改变Executor行为 executor = (Executor) interceptorChain.pluginAll(executor); return executor; } }
从代码能够看出Mybatis 在实例化Executor、ParameterHandler、ResultSetHandler、StatementHandler四大接口对象的时候调用interceptorChain.pluginAll()方法插入
进去的。其实就是循环执行拦截器链全部的拦截器的plugin() 方法，mybatis官方推荐的plugin方法是Plugin.wrap() 方法,这个类就是咱们上面的TargetProxy类。
三、Plugin
这里的Plugin就是咱们上面的自定义代理类TargetProxy类
public class Plugin implements InvocationHandler { public static Object wrap(Object target, Interceptor interceptor) { //从拦截器的注解中获取拦截的类名和方法信息 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); //取得要改变行为的类(ParameterHandler|ResultSetHandler|StatementHandler|Executor) Class<?> type = target.getClass(); //取得接口 Class<?>[] interfaces = getAllInterfaces(type, signatureMap); //产生代理，是Interceptor注解的接口的实现类才会产生代理 if (interfaces.length > 0) { 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()); //是Interceptor实现类注解的方法才会拦截处理 if (methods != null && methods.contains(method)) { //调用Interceptor.intercept，也即插入了咱们本身的逻辑 return interceptor.intercept(new Invocation(target, method, args)); } //最后仍是执行原来逻辑 return method.invoke(target, args); } catch (Exception e) { throw ExceptionUtil.unwrapThrowable(e); } } //取得签名Map,就是获取Interceptor实现类上面的注解，要拦截的是那个类（Executor，ParameterHandler， ResultSetHandler，StatementHandler）的那个方法 private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) { //取Intercepts注解，例子可参见ExamplePlugin.java Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class); // issue #251 //必须得有Intercepts注解，没有报错 if (interceptsAnnotation == null) { throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName()); } //value是数组型，Signature的数组 Signature[] sigs = interceptsAnnotation.value(); //每一个class里有多个Method须要被拦截,因此这么定义 Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>(); for (Signature sig : sigs) { Set<Method> methods = signatureMap.get(sig.type()); if (methods == null) { methods = new HashSet<Method>(); signatureMap.put(sig.type(), methods); } try { Method method = sig.type().getMethod(sig.method(), sig.args()); methods.add(method); } 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<Class<?>>(); while (type != null) { for (Class<?> c : type.getInterfaces()) { //拦截其余的无效 if (signatureMap.containsKey(c)) { interfaces.add(c); } } type = type.getSuperclass(); } return interfaces.toArray(new Class<?>[interfaces.size()]); } }
四、Interceptor接口
public interface Interceptor { //拦截 Object intercept(Invocation invocation) throws Throwable; //插入 Object plugin(Object target); //设置属性(扩展) void setProperties(Properties properties); }
思路 这么下来思路就很清晰了，咱们经过实现Interceptor类实现自定义拦截器，而后把它放入InterceptorChain(拦截器链)中，而后经过JDK动态代理来实现依次拦截处理。