实现自己的拦截器框架（通过JDK自动代理）

最新推荐文章于 2024-05-14 08:12:38 发布

老崔

最新推荐文章于 2024-05-14 08:12:38 发布

阅读量674

点赞数

分类专栏： OpenSource IOC、AOP Java 文章标签：框架 jdk interceptor classloader object javadoc

Java 同时被 3 个专栏收录

143 篇文章 0 订阅

订阅专栏

OpenSource

52 篇文章 0 订阅

订阅专栏

IOC、AOP

8 篇文章 0 订阅

订阅专栏

AOP技术是spring框架的一个重要特征。通过该特性能够在函数运行之前，之后，或者异常处理的时候执行我们需要的一些操作。

下面我们就是需要抛开AOP，Spring这样成型的框架不用，而仅仅使用java反射机制中的Proxy,InvocationHandler来实现类似Spring框架的拦截器的效果。

动态代理DynamicProxy

首先，在设计这个拦截器框架之前，我们需要明白java中动态代理是什么？我想如果早就清楚请直接跳过，如果需要了解，那我想你手边最好有一个javadoc的电子书。

Java.lang.reflect.Proxy是反射包的成员之一。具体说明请查javadoc。
用法就是比如有一个对象，我们需要在调用它提供的方法之前，干点别的什么，就不能直接调用它，而是生成一个它的代理，这个代理有这个对象所提供的所有接口方法，我们通过直接调用代理的这些方法，来实现：函数既能像原来对象的那样工作，又能在函数运行过程前后加入我们自己的处理。

这个类有个非常重要的函数用来实现某个类的代理：

Object java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
参数有点迷惑人，解释下：
ClassLoader 是类加载器，这个参数用来定义代理类，一般使用原对象的即可，也可以为null用上下文解决。
Class<?>[] 接口数组,就是我们需要这个代理能够提供原来的类的什么函数。如果全部则直接class.getInterfaces()来解决.
InvocationHandler 调用处理器，这个就是如果你调用代理的方法，那么这个处理器就会被关联过来，处理调用这个函数的整个过程。这个接口只定义了一个方法：

1 public Object invoke(Object proxy, Method method,
2 Object[] args) throws Throwable;

参数中proxy就是你调用的代理，method指的是你调用的代理的那个方法，args是传给该方法的参数。

我们生成某个类的代理步骤，一般需要先考虑我们在调用这个类的函数的时候（之前，或者之后）如何处理某些事情，因此我们首先考虑的就是如何实现InvocationHandler这个接口。

让我们做一个实践，做这么一个调用处理器：任何使用此处理器的代理在调用它的任何方法的时候，都打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。

步骤1: 定义接口IUser

1   package com.cyh.proxy.sample;
2
3   public interface IUser {
4    public String getName();
5
6    public void setName(String name);
7}

步骤2: 写IUser接口的实现类User

1 package com.cyh.proxy.sample.impl;
2
3 import com.cyh.proxy.sample.IUser;
4
5 public class User implements IUser {
6     String name;
7
8     public User(String name) {
9     this.name = name;
10     }
11
12     public String getName() {
13     return name;
14     }
15
16     public void setName(String name) {
17     this.name = name;
18     }
19 }

步骤3: 写TraceHandler实现调用处理器InvocationHandler,即在invoke()方法里我们要打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。

1 package com.cyh.proxy.sample.impl;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5
6 public class TraceHandler implements InvocationHandler {
7     private Object target;
8
9     public TraceHandler(Object target) {
10     this.target = target;
11     }
12
13     public Object invoke(Object proxy, Method method, Object[] args)
14         throws Throwable {
15
16     // print implicit argument
17     System.out.print(target.getClass().getName());
18     // print method name
19     System.out.print("." + method.getName() + "(" );
20     // print explicit arguments
21     if (args != null ) {
22         for (int i = 0; i < args.length; i++ ) {
23         System.out.print(args[i]);
24         if (i < args.length - 1 ) {
25             System.out.print("," );
26         }
27         }
28     }
29     System.out.println(")" );
30
31     return method.invoke(this .target, args);
32     }
33 }

步骤4: 最后,让我们写测试类ProxyTest

1 package com.cyh.proxy.sample.test;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Proxy;
5
6 import com.cyh.proxy.sample.IUser;
7 import com.cyh.proxy.sample.impl.TraceHandler;
8 import com.cyh.proxy.sample.impl.User;
9
10 public class ProxyTest {
11     User user;
12
13     public ProxyTest() {
14     user = new User("LaraCroft" );
15
16     ClassLoader classLoader = user.getClass().getClassLoader();
17     Class[] interfaces = user.getClass().getInterfaces();
18     InvocationHandler handler = new TraceHandler(user);
19     IUser proxy = (IUser) Proxy.newProxyInstance(classLoader, interfaces,
20         handler);
21
22     proxy.setName("David Beckham" );
23     }
24
25     public static void main(String[] args) {
26     new ProxyTest();
27     }
28
29 }

好了,所有代码写好了,运行一下,测试结果是:
com.cyh.proxy.impl.User.setName(David Beckham)

讲一下运行原理：
首先我们初始化了user对象，user.name = = “LaraCroft”;
然后创建了user对象的代理proxy。
注意这里：Proxy.newProxyInstance()函数的返回值使用接口IUser转型的，你或许会想到
用User来做强制类型转换，但是会抛出下面的异常
Exception in thread "main" java.lang.ClassCastException: $Proxy0 cannot be cast to com.cyh.proxy.impl.User
因为：代理类是实现了User类的所有接口，但是它的类型是$Proxy0，不是User。

最后，我们调用代理的setName()方法：
proxy.setName("David Beckham");

代理在执行此方法的时候，就好触发调用处理器 TraceHandler，并执行 TraceHandler的invoke()方法，然后就会打印：
com.cyh.proxy.impl.User.setName(David Beckham)

拦截器框架的实现

好了，关于代理的知识我们讲完了，我们可以考虑如何实现这个拦截器的框架，所谓拦截器就是在函数的运行前后定制自己的处理行为，也就是通过实现InvocationHandler达到的。

设计思路

我们来理清一下思路，在使用一个拦截器的时候？什么是不变的，什么是变化的？

不变的：
每次都要创建代理
拦截的时间：函数执行之前，之后，异常处理的时候

变化的：
每次代理的对象不同
拦截器每次拦截到执行时的操作不同

好了，废话少说，看类图：

图中：
DynamicProxyFactory 和它的实现类，是一个工厂，用来创建代理

Interceptor 这个接口用来定义拦截器的拦截处理行为配合DynamicProxyInvocationHandler达到拦截效果
DynamicProxyInvocationHandler 调用处理器的实现，它有两个成员，一个是Object target指的是被代理的类，另一个是Interceptor interceptor就是在invoke()方法执行target的函数之前后，异常处理时，调用interceptor的实现来达到拦截，并处理的效果。

代码实现

步骤1: 定义接口DynamicProxyFactory

1 package com.cyh.proxy.interceptor;
2
3 public interface DynamicProxyFactory {
4     /**
5      * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
6      *
7      * @param clazz
8      *            需要实现的接口
9      * @param target
10      *            实现此接口的类
11      * @param interceptor
12      *            拦截器
13      * @return
14      */
15     public <T> T createProxy(T target, Interceptor interceptor);
16 }

步骤2: 定义接口Interceptor

1 package com.cyh.proxy.interceptor;
2
3 import java.lang.reflect.Method;
4
5 public interface Interceptor {
6     public void before(Method method, Object[] args);
7
8     public void after(Method method, Object[] args);
9
10     public void afterThrowing(Method method, Object[] args, Throwable throwable);
11
12     public void afterFinally(Method method, Object[] args);
13 }
14

步骤3: 实现接口DynamicProxyFactory

1 package com.cyh.proxy.interceptor.impl;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Proxy;
5
6 import com.cyh.proxy.interceptor.DynamicProxyFactory;
7 import com.cyh.proxy.interceptor.Interceptor;
8
9 public class DynamicProxyFactoryImpl implements DynamicProxyFactory {
10     /**
11      * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
12      *
13      * @param target
14      *  需要代理的实例
15      * @param interceptor
16      *  拦截器实现,就是我们希望代理类执行函数的前后,
17      *  抛出异常,finally的时候去做写什么
18      */
19     @Override
20     @SuppressWarnings("unchecked" )
21     public <T> T createProxy(T target, Interceptor interceptor) {
22     // 当前对象的类加载器
23     ClassLoader classLoader = target.getClass().getClassLoader();
24     // 获取此对象实现的所有接口
25     Class<?>[] interfaces = target.getClass().getInterfaces();
26     // 利用DynamicProxyInvocationHandler类来实现InvocationHandler
27     InvocationHandler handler = new DynamicProxyInvocationHandler(target,
28         interceptor);
29
30     return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
31     }
32 }

步骤4: 实现调用处理器

1 package com.cyh.proxy.interceptor.impl;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5
6 import com.cyh.proxy.interceptor.Interceptor;
7
8 /**
9 * 动态代理的调用处理器
10 *
11  * @author chen.yinghua
12  */
13 public class DynamicProxyInvocationHandler implements InvocationHandler {
14     private Object target;
15     private Interceptor interceptor;
16
17     /**
18      * @param target
19      *            需要代理的实例
20      * @param interceptor
21      *            拦截器
22      */
23     public DynamicProxyInvocationHandler(Object target,
24                                   Interceptor interceptor) {
25     this.target = target;
26     this.interceptor = interceptor;
27     }
28
29     /**
30      * @param proxy
31      *            所生成的代理对象
32      * @param method
33      *            调用的方法示例
34      * @args args 参数数组
35      * @Override
36      */
37     public Object invoke(Object proxy, Method method, Object[] args)
38         throws Throwable {
39     Object result = null ;
40
41     try {
42         // 在执行method之前调用interceptor去做什么事
43         this .interceptor.before(method, args);
44         // 在这里我们调用原始实例的method
45         result = method.invoke(this .target, args);
46         // 在执行method之后调用interceptor去做什么事
47         this .interceptor.after(method, args);
48     } catch (Throwable throwable) {
49         // 在发生异常之后调用interceptor去做什么事
50         this .interceptor.afterThrowing(method, args, throwable);
51         throw throwable;
52     } finally {
53         // 在finally之后调用interceptor去做什么事
54         interceptor.afterFinally(method, args);
55     }
56
57     return result;
58     }
59
60 }

好了，目前为止，这个框架算完成了，怎么用呢？
接下来我们完成测试包。

完成测试

步骤1：首先，给需要代理的类定义一个接口Service

1 package com.cyh.proxy.interceptor.test;
2
3 public interface Service {
4     public String greet(String name);
5 }

步骤2：实现这个接口，编写类ServiceImpl

1 package com.cyh.proxy.interceptor.test;
2
3 public class ServiceImpl implements Service {
4     @Override
5     public String greet(String name) {
6     String result = "Hello, " + name;
7     System.out.println(result);
8     return result;
9     }
10 }

步骤3：实现拦截器接口Interceptor，编写类InterceptorImpl

package com.cyh.proxy.interceptor.test;
2

import java.lang.reflect.Method;
4

import com.cyh.proxy.interceptor.Interceptor;
6

public class InterceptorImpl implements Interceptor {
8

@Override
9

public void after(Method method, Object[] args) {
10

System.out.println("after invoking method: " + method.getName());
11

}
12

@Override
14

public void afterFinally(Method method, Object[] args) {
15

System.out.println("afterFinally invoking method: " + method.getName());
16

}
17

@Override
19

public void afterThrowing(Method method, Object[] args,
20

Throwable throwable) {
21

System.out.println("afterThrowing invoking method: "
22

+ method.getName());
23

}
24

@Override
26

public void before(Method method, Object[] args) {
27

System.out.println("before invoking method: " + method.getName());
28

}
29

}

步骤4：编写测试类TestDynamicProxy

1 package com.cyh.proxy.interceptor.test;
2
3 import com.cyh.proxy.interceptor.DynamicProxyFactory;
4 import com.cyh.proxy.interceptor.Interceptor;
5 import com.cyh.proxy.interceptor.impl.DynamicProxyFactoryImpl;
6
7 public class TestDynamicProxy {
8     public TestDynamicProxy() {
9     DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactoryImpl();
10     Interceptor interceptor = new InterceptorImpl();
11     Service service = new ServiceImpl();
12
13     Service proxy = dynamicProxyFactory.createProxy(service, interceptor);
14     // Service proxy = DefaultProxyFactory.createProxy(service,
15     // interceptor);
16     proxy.greet("iwindyforest" );
17     }
18
19     public static void main(String[] args) {
20     new TestDynamicProxy();
21     }
22 }

好了，整个测试包完成了，让我们运行下看看运行结果：

before invoking method: greet
Hello, iwindyforest
after invoking method: greet
afterFinally invoking method: greet

完善设计

现在，让我们回顾一下：接口DynamicProxyFactory，真的需要么？
它只是一个工厂，负责生产代理的，但是我们并没有过多的要求，因此可以说它的实现基本上是不变的。鉴于此，我们在使用createProxy()函数的时候，只需要一个静态方法就可以了，没有必要再初始化整个类，这样才比较方便么。
因此，我在com.cyh.proxy.interceptor.impl包里加了一个默认的工厂DefaultProxyFactory：

1 package com.cyh.proxy.interceptor.impl;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Proxy;
5
6 import com.cyh.proxy.interceptor.Interceptor;
7
8 public class DefaultProxyFactory {
9     @SuppressWarnings("unchecked" )
10     public static <T> T createProxy(T target, Interceptor interceptor) {
11     // 当前对象的类加载器
12     ClassLoader classLoader = target.getClass().getClassLoader();
13     // 获取此对象实现的所有接口
14     Class<?>[] interfaces = target.getClass().getInterfaces();
15     // 利用DynamicProxyInvocationHandler类来实现InvocationHandler
16     InvocationHandler handler = new DynamicProxyInvocationHandler(target,
17         interceptor);
18
19     return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
20     }
21 }