Spring中的拦截器与动态代理的几大模式

什么是代理模式?

如果用专业术语来解：为其他对象提供一种代理以控制对这个对象的访问。如果投影在生活中，它可以理解成中介 黄牛 经纪人等…

解决的问题:

在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。说白了就是在你代码前面插一段后面插一段。

Java动态代理实现方式:

• JDK 自带的动态代理

• Cglib动态代理

1. JDK 自带的动态代理

我以黄牛为例，黄牛刚开始了解该人需求，该人将信息(JAY演唱会门票)给予黄牛，黄牛给票。黄牛就是该买票人的代理。

1.1 People.java

注意这必须是一个接口，原因往下看。

1. public interface People {

2.    /**

3.     * 交谈

4.     */

5.    void speak();

6. }

这个接口很简单，就是一个讲话的功能，但是它为什么必须是一个接口呢。因为在HuangNiu这个类中，Proxy.newProxyInstance 这个方法的实现需要接口,这一点我在HuangNiu类下解释的很清楚，往下看。

1.2 HuangNiu.java

黄牛代理类，获取到People信息后调用Proxy来生成一个新的代理类,它必须实现InvocationHandler接口,这个接口使得它可以通过invoke方法实现对真实角色(People)的代理访问。

1. public class HuangNiu  implements InvocationHandler {

2.  

3.    private People people;

4.    /**

5.     * 获取被代理对象信息

6.     */

7.    public Object getInstance(People people){

8.        this.people = people;

9.        Class clazz = people.getClass();

10.        System.out.println("没生成代理之前的class对象:"+clazz );

11.        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);

12.    }

13.  

14.    @Override

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

16.        System.out.println("代理中...");

17.        method.invoke(people);

18.        System.out.println("代理处理完毕,OK,请查收");

19.        return null;

20.    }

21. }

在实例化HuangNiu这个对象的时候，我们调用了Proxy的newProxyInstance方法:

1. return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);

其中clazz是People的class对象。再来看看newProxyInstance的源码实现:

1. public static Object newProxyInstance(ClassLoader loader,

2.                                          Class<?>[] interfaces,

3.                                          InvocationHandler h){

4.  

5.        final Class<?>[] intfs = interfaces.clone();

6.  

7.        //Look up or generate the designated proxy class.

8.  

9.        Class<?> cl = getProxyClass0(loader, intfs);

10.  

11.        //获取代理类的构造函数对象

12.        //参数constructorParames为常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };

13.        final Constructor<?> cons = cl.getConstructor(constructorParames);

14.        final InvocationHandler ih = h;

15.        //根据代理类的构造函数对象来创建代理类对象

16.        return newInstance(cons, ih);

17. }

getProxyClass0方法源码:

1.    private static Class<?> getProxyClass0(ClassLoader loader,

2.                                           Class<?>... interfaces) {

3.        if (interfaces.length > 65535) {

4.            throw new IllegalArgumentException("interface limit exceeded");

5.        }

6.  

7.        // If the proxy class defined by the given loader implementing

8.        // the given interfaces exists, this will simply return the cached copy;

9.        // otherwise, it will create the proxy class via the ProxyClassFactory

10.        return proxyClassCache.get(loader, interfaces);

11.    }

如果缓存中有该代理类，则取缓存，如果没有，则通过ProxyClassFactory来创建代理类。如果对如何生成代理类感兴趣则追踪下去即可。

我只取了核心代码和注释，可以看到JDK的动态代理实现是依据接口来重新生成一个新的代理类，

什么是新的代理类?

通俗点说就是综合和前后代理逻辑并重新生成一份.class文件来实现动态代理的类，下面也会具体说。

1.3 Me.java

被代理对象，实现了People接口,给代理提供需要的信息来实现被代理。

1. public class Me implements People {

2.  

3.    private String name;

4.    private String type;

5.  

6.    Me(String name, String type){

7.        this.name = name;

8.        this.type = type;

9.    }

10.    @Override

11.    public void speak() {

12.        System.out.println("我叫"+name+", 我要一张"+type);

13.    }

14. }

1.4 Main.java

1. public class Main {

2.    public static void main(String[] args) {

3.        People instance = (People)new HuangNiu().getInstance(new Me("Fantj", "JAY演唱会门票"));

4.        instance.speak();

5.        System.out.println("生成代理对象后对象变成:"+instance.getClass());

6.    }

7. }

执行结果:

1. 没生成代理之前的class对象:class com.fantj.proxy.jdk.Me

2. 代理中...

3. 我叫Fantj, 我要一张JAY演唱会门票

4. 代理处理完毕,OK,请查收

5. 生成代理对象后对象变成:class com.sun.proxy.$Proxy0

为了证明事实上真的有代理类的产生，我在代理完成前和代理完成后分别打印出它的类信息，可以看出是不同的，可以猜想到代理中是有代理类产生的，这个代理类就是$Proxy0。

那既然知道了这个类的信息，我们就可以逆向生成这个.class文件来看看(在main方法后追加):

1. /**

2. * 生成代码

3. */

4. try {

5.    byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{instance.getClass()});

6.    String path = Main.class.getResource("").toString();

7. //            System.out.println("get the path"+path);

8.    FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");

9.    fileOutputStream.write($Proxy0s);

10.    fileOutputStream.close();

11. } catch (IOException e) {

12.    e.printStackTrace();

13. }

它默认生成在项目根目录下: 我使用的IDEA工具会自动反编译.class文件为java代码，直接打开即刻看到源码，如果用别的工具的可以下载反编译工具来进行反编译。

$Proxy0.class

1. //

2. // Source code recreated from a .class file by IntelliJ IDEA

3. // (powered by Fernflower decompiler)

4. //

5.  

6. import com.sun.proxy..Proxy0;

7. import java.lang.reflect.InvocationHandler;

8. import java.lang.reflect.Method;

9. import java.lang.reflect.Proxy;

10. import java.lang.reflect.UndeclaredThrowableException;

11.  

12. public final class $Proxy0 extends Proxy implements Proxy0 {

13.    private static Method m1;

14.    private static Method m5;

15.    private static Method m2;

16.    private static Method m4;

17.    private static Method m11;

18.    private static Method m13;

19.    private static Method m0;

20.    private static Method m10;

21.    private static Method m12;

22.    private static Method m6;

23.    private static Method m9;

24.    private static Method m3;

25.    private static Method m7;

26.    private static Method m8;

27.  

28.    public $Proxy0(InvocationHandler var1) throws  {

29.        super(var1);

30.    }

31.  

32.    public final boolean equals(Object var1) throws  {

33.        try {

34.            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});

35.        } catch (RuntimeException | Error var3) {

36.            throw var3;

37.        } catch (Throwable var4) {

38.            throw ne