由浅入深分析mybatis通过动态代理实现拦截器（插件）的原理！很值得一看

╰+攻爆jí腚メ 2022-05-10 00:48 116阅读 0赞

最近在用mybatis做项目，需要用到mybatis的拦截器功能，就顺便把mybatis的拦截器源码大致的看了一遍，为了温故而知新，在此就按照自己的理解由浅入深的理解一下它的设计。   
和大家分享一下，不足和谬误之处欢迎交流。直接入正题。   
首先，先不管mybatis的源码是怎么设计的，先假设一下自己要做一个拦截器应该怎么做。拦截器的实现都是基于代理的设计模式设计的，简单的说就是要创造一个目标类的代理类，在代理类中执行目标类的方法并拦截执行拦截器代码。   
那么我们就用JDK的动态代理设计一个简单的拦截器：   
  
将被拦截的目标接口：

Java代码

1.  public interface Target \{  
2.      public void execute();  
3.  \}

目标接口的一个实现类：

Java代码

1.      public class TargetImpl implements Target \{  
2.      public void execute() \{  
3.          System.out.println("Execute");  
4.      \}  
5.  \}

利用JDK的动态代理实现拦截器：

Java代码

1.  public class TargetProxy implements InvocationHandler \{  
2.      private Object target;  
3.      private TargetProxy(Object target) \{  
4.          this.target = target;  
5.      \}  
6.        
7.      //生成一个目标对象的代理对象  
8.      public static Object bind(Object target) \{  
9.          return Proxy.newProxyInstance(target.getClass() .getClassLoader(),   
10.                 target.getClass().getInterfaces(),  
11.                        new TargetProxy(target));  
12.     \}  
13.       
14.     //在执行目标对象方法前加上自己的拦截逻辑  
15.     public Object invoke(Object proxy, Method method,  
16.                              Object\[\] args) throws Throwable \{  
17.         System.out.println("Begin");  
18.         return method.invoke(target, args);  
19.     \}  
20. \}

客户端调用：

Java代码

![收藏代码][icon_star.png]

1.  public class Client \{  
2.  public static void main(String\[\] args) \{  
3.    
4.      //没有被拦截之前  
5.      Target target = new TargetImpl();  
6.      target.execute(); //Execute  
7.        
8.      //拦截后  
9.      target = (Target)TargetProxy.bind(target);  
10.     target.execute();   
11.     //Begin  
12.     //Execute  
13. \}

上面的设计有几个非常明显的不足，首先说第一个，拦截逻辑被写死在代理对象中：

Java代码

![收藏代码][icon_star.png]

1.  public Object invoke(Object proxy, Method method,  
2.                             Object\[\] args) throws Throwable \{  
3.          //拦截逻辑被写死在代理对象中，导致客户端无法灵活的设置自己的拦截逻辑  
4.          System.out.println("Begin");  
5.         return method.invoke(target, args);  
6.      \}

我们可以将拦截逻辑封装到一个类中，客户端在调用TargetProxy的bind()方法的时候将拦截逻辑一起当成参数传入：   
定义一个拦截逻辑封装的接口Interceptor，这才是真正的拦截器接口。

Java代码

![收藏代码][icon_star.png]

1.      public interface Interceptor \{  
2.      public void intercept();  
3.  \}

那么我们的代理类就可以改成：

Java代码

![收藏代码][icon_star.png]

1.  public class TargetProxy implements InvocationHandler \{  
2.    
3.  private Object target;  
4.  private Interceptor interceptor;  
5.    
6.  private TargetProxy(Object target, Interceptor interceptor) \{  
7.      this.target = target;  
8.      this.interceptor = interceptor;  
9.  \}  
10.   
11. //将拦截逻辑封装到拦截器中，有客户端生成目标类的代理类的时候一起传入，这样客户端就可以设置不同的拦截逻辑。  
12. public static Object bind(Object target, Interceptor interceptor) \{  
13.     return Proxy.newProxyInstance(target.getClass().getClassLoader(),   
14.                        target.getClass().getInterfaces(),  
15.                        new TargetProxy(target, interceptor));  
16. \}  
17.   
18. public Object invoke(Object proxy, Method method,   
19.                       Object\[\] args) throws Throwable \{  
20.     //执行客户端定义的拦截逻辑  
21.     interceptor.intercept();  
22.     return method.invoke(target, args);  
23. \}

客户端调用代码：

Java代码

![收藏代码][icon_star.png]

1.  //客户端可以定义各种拦截逻辑  
2.  Interceptor interceptor = new Interceptor() \{  
3.      public void intercept() \{  
4.          System.out.println("Go Go Go!!!");  
5.      \}  
6.  \};  
7.  target = (Target)TargetProxy.bind(target, interceptor);  
8.  target.execute();

当然，很多时候我们的拦截器中需要判断当前方法需不需要拦截，或者获取当前被拦截的方法参数等。我们可以将被拦截的目标方法对象，参数信息传给拦截器。   
拦截器接口改成：

Java代码

![收藏代码][icon_star.png]

1.  public interface Interceptor \{  
2.      public void intercept(Method method, Object\[\] args);  
3.  \}

在代理类执行的时候可以将当前方法和参数传给拦截，即TargetProxy的invoke方法改为：

Java代码

![收藏代码][icon_star.png]

1.  public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable \{  
2.      interceptor.intercept(method, args);  
3.      return method.invoke(target, args);  
4.  \}

在Java设计原则中有一个叫做迪米特法则，大概的意思就是一个类对其他类知道得越少越好。其实就是减少类与类之间的耦合强度。这是从类成员的角度去思考的。   
什么叫越少越好，什么是最少？最少就是不知道。   
所以我们是不是可以这么理解，一个类所要了解的类应该越少越好呢？   
当然，这只是从类的角度去诠释了迪米特法则。   
甚至可以反过来思考，一个类被其他类了解得越少越好。   
A类只让B类了解总要强于A类让B，C，D类都去了解。   
  
举个例子：   
我们的TargetProxy类中需要了解的类有哪些呢？   
1. Object target 不需要了解，因为在TargetProxy中，target都被作为参数传给了别的类使用，自己不需要了解它。   
2. Interceptor interceptor 需要了解，需要调用其intercept方法。   
3. 同样，Proxy需要了解。   
4. Method method 参数需要了解，需要调用其invoke方法。   
同样，如果interceptor接口中需要使用intercept方法传过去Method类，那么也需要了解它。那么既然Interceptor都需要使用Method，还不如将Method的执行也放到Interceptor中，不再让TargetProxy类对其了解。Method的执行需要target对象，所以也需要将target对象给Interceptor。将Method，target和args封装到一个对象Invocation中，将Invocation传给Interceptor。   
Invocation：

Java代码

![收藏代码][icon_star.png]

1.  public class Invocation \{  
2.      private Object target;  
3.      private Method method;  
4.      private Object\[\] args;  
5.        
6.      public Invocation(Object target, Method method, Object\[\] args) \{  
7.          this.target = target;  
8.          this.method = method;  
9.          this.args = args;  
10.     \}  
11.       
12.     //将自己成员变量的操作尽量放到自己内部，不需要Interceptor获得自己的成员变量再去操作它们，  
13.     //除非这样的操作需要Interceptor的其他支持。然而这儿不需要。  
14.     public Object proceed() throws InvocationTargetException, IllegalAccessException \{  
15.         return method.invoke(target, args);  
16.     \}  
17.         
18.     public Object getTarget() \{  
19.         return target;  
20.     \}  
21.     public void setTarget(Object target) \{  
22.         this.target = target;  
23.     \}  
24.     public Method getMethod() \{  
25.         return method;  
26.     \}  
27.     public void setMethod(Method method) \{  
28.         this.method = method;  
29.     \}  
30.     public Object\[\] getArgs() \{  
31.         return args;  
32.     \}  
33.     public void setArgs(Object\[\] args) \{  
34.         this.args = args;  
35.     \}  
36. \}

Interceptor就变成：

Java代码

![收藏代码][icon_star.png]

1.  public interface Interceptor \{  
2.      public Object intercept(Invocation invocation)throws Throwable ;  
3.  \}

TargetProxy的invoke方法就变成：

Java代码

![收藏代码][icon_star.png]

1.  public Object invoke(Object proxy, Method method,   
2.                            Object\[\] args) throws Throwable \{  
3.      return interceptor.intercept(new Invocation(target,   
4.                                                     method, args));  
5.  \}

那么就每一个Interceptor拦截器实现都需要最后执行Invocation的proceed方法并返回。   
客户端调用：

Java代码

![收藏代码][icon_star.png]

1.  Interceptor interceptor = new Interceptor() \{  
2.      public Object intercept(Invocation invocation)  throws Throwable \{  
3.          System.out.println("Go Go Go!!!");  
4.          return invocation.proceed();  
5.      \}  
6.  \};

好了，通过一系列调整，设计已经挺好了，不过上面的拦截器还是有一个很大的不足，   
那就是拦截器会拦截目标对象的所有方法，然而这往往是不需要的，我们经常需要拦截器   
拦截目标对象的指定方法。   
假设目标对象接口有多个方法：

Java代码

![收藏代码][icon_star.png]

1.  public interface Target \{  
2.      public void execute1();  
3.      public void execute2();  
4.  \}

利用在Interceptor上加注解解决。   
首先简单的定义一个注解：

Java代码

![收藏代码][icon_star.png]

1.  @Retention(RetentionPolicy.RUNTIME)  
2.  @Target(ElementType.TYPE)  
3.  public @interface MethodName \{  
4.      public String value();  
5.  \}

在拦截器的实现类加上该注解：

Java代码

![收藏代码][icon_star.png]

1.  @MethodName("execute1")  
2.  public class InterceptorImpl implements Interceptor \{...\}

在TargetProxy中判断interceptor的注解，看是否实行拦截：

Java代码

![收藏代码][icon_star.png]

1.  public Object invoke(Object proxy, Method method,  
2.                           Object\[\] args) throws Throwable \{  
3.          MethodName methodName =   
4.           this.interceptor.getClass().getAnnotation(MethodName.class);  
5.          if (ObjectUtils.isNull(methodName))  
6.              throw new NullPointerException("xxxx");  
7.            
8.          //如果注解上的方法名和该方法名一样，才拦截  
9.          String name = methodName.value();  
10.         if (name.equals(method.getName()))  
11.             return interceptor.intercept(new Invocation(target,    method, args));  
12.           
13.         return method.invoke(this.target, args);  
14. \}

最后客户端调用：

Java代码

![收藏代码][icon_star.png]

1.  Target target = new TargetImpl();  
2.  Interceptor interceptor = new InterceptorImpl();  
3.  target = (Target)TargetProxy.bind(target, interceptor);  
4.  target.execute();

从客户端调用代码可以看出，客户端首先需要创建一个目标对象和拦截器，然后将拦截器和目标对象绑定并获取代理对象，最后执行代理对象的execute()方法。   
根据迪米特法则来讲，其实客户端根本不需要了解TargetProxy类。将绑定逻辑放到拦截器内部，客户端只需要和拦截器打交道就可以了。   
即拦截器接口变为：

Java代码

![收藏代码][icon_star.png]

1.  public interface Interceptor \{  
2.  public Object intercept(Invocation invocation)  throws Throwable ;  
3.  public Object register(Object target);

拦截器实现：

Java代码

![收藏代码][icon_star.png]

1.  @MethodName("execute1")  
2.  public class InterceptorImpl implements Interceptor \{  
3.        
4.      public Object intercept(Invocation invocation)throws Throwable \{  
5.          System.out.println("Go Go Go!!!");  
6.          return invocation.proceed();  
7.      \}  
8.        
9.      public Object register(Object target) \{  
10.         return TargetProxy.bind(target, this);  
11.     \}  
12. \}

客户端调用：

Java代码

![收藏代码][icon_star.png]

1.  Target target = new TargetImpl();  
2.  Interceptor interceptor = new InterceptorImpl();  
3.    
4.  target = (Target)interceptor.register(target);  
5.  target.execute1();

OK，上面的一系列过程其实都是mybatis的拦截器代码结构，我只是学习了之后用最简单的方法理解一遍罢了。   
上面的TargetProxy其实就是mybatis的Plug类。Interceptor和Invocation几乎一样。只是mybatis的Interceptor支持的注解   
更加复杂。   
mybatis最终是通过将自定义的Interceptor配置到xml文件中：

Xml代码

![收藏代码][icon_star.png]

1.    
2.   <plugins>  
3.       <plugin interceptor="com.gs.cvoud.dao.interceptor.MapInterceptor" />  
4.   </plugins>

通过读取配置文件中的Interceptor，通过反射构造其实例，将所有的Interceptor保存到InterceptorChain中。

Java代码

![收藏代码][icon_star.png]

1.  public class InterceptorChain \{  
2.    
3.    private final List<Interceptor> interceptors = new ArrayList<Interceptor>();  
4.    
5.    public Object pluginAll(Object target) \{  
6.      for (Interceptor interceptor : interceptors) \{  
7.        target = interceptor.plugin(target);  
8.      \}  
9.      return target;  
10.   \}  
11.   
12.   public void addInterceptor(Interceptor interceptor) \{  
13.     interceptors.add(interceptor);  
14.   \}  
15.     
16.   public List<Interceptor> getInterceptors() \{  
17.     return Collections.unmodifiableList(interceptors);  
18.   \}  
19.   
20. \}

mybatis的拦截器只能代理指定的四个类：ParameterHandler、ResultSetHandler、StatementHandler以及Executor。   
这是在mybatis的Configuration中写死的，例如（其他三个类似）：

Java代码

![收藏代码][icon_star.png]

1.  public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) \{  
2.      ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);  
3.        
4.      //将配置文件中读取的所有的Interceptor都注册到ParameterHandler中，最后通过每个Interceptor的注解判断是否需要拦截该ParameterHandler的某个方法。  
5.      parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);  
6.      return parameterHandler;  
7.  \}

所以我们可以自定义mybatis的插件（拦截器）修改mybatis的很多默认行为，   
例如，   
通过拦截ResultSetHandler修改接口返回类型；   
通过拦截StatementHandler修改mybatis框架的分页机制；   
通过拦截Executor查看mybatis的sql执行过程等等

[icon_star.png]: /images/20220510/c78db225aa004446b92d9a666e6cbba9.png