Java 代理模式

Share on:

被问到了,就补一下。

简述代理模式

代理是英文(Proxy)翻译过来的,在我们的实际生活中,最常见的代理模式应该是朋友圈中的微商了。在起初的时候,厂商直接对标顾客,没有微商在中间赚差价,结构就是如图。 image 之后慢慢的微商汇总了优质资源,顾客没必要自己去挑厂商货比三家,只需要从微商那里买就行了。所有就有了如下的结构: image 而程序设计都是从生活中的实例出现的,所以Java中也产生了代理模式。

在Java中存在几种代理模式:

  • 静态代理
  • 动态代理

本文将一一介绍

静态代理

当我们看到了微商不厌其烦刷朋友圈的广告,耐不住优惠从微商那里买了一双,微商可能还会向我们推一些别的优惠活动之类的,那么这个过程我们用代码模拟一下。

首先我们需要有一个鞋子的接口,通用的接口是代理模式实现的基础。定义一个sell接口,代表鞋子可以被卖出去的能力。

1package com.proxy.weishang;
2
3// 定义鞋子接口
4public interface Shoes {
5    void sell();
6}

然后再来一个真正的鞋子类,需要实现Shoes的接口

1package com.proxy.weishang;
2
3// 真正的鞋子类
4public class RealShoes implements Shoes {
5    @Override
6    public void sell() {
7        System.out.println("卖出了一双鞋子哦,美汁汁~");
8    }
9}

和一个代理类(微商类)

 1package com.proxy.weishang;
 2
 3// 微商 代理
 4public class MicroSell implements Shoes {
 5    RealShoes realShoes;
 6
 7    public MicroSell(RealShoes realShoes) {
 8        this.realShoes = realShoes;
 9    }
10
11    public void setRealShoes(RealShoes realShoes) {
12        this.realShoes = realShoes;
13    }
14
15
16    @Override
17    public void sell() {
18        beforeSell();
19        realShoes.sell();
20        afterSell();
21    }
22
23    public void beforeSell() {
24        System.out.println("买之前宣传:帅哥,买双鞋子吗?高仿阿迪199两双");
25    }
26
27    public void afterSell() {
28        System.out.println("买之后推销:帅哥,再来双高仿耐克?");
29    }
30}

接下来我们测试下

 1package com.proxy;
 2
 3import com.proxy.weishang.MicroSell;
 4import com.proxy.weishang.RealShoes;
 5
 6public class Main {
 7
 8    public static void main(String[] args) {
 9        MicroSell microSell = new MicroSell(new RealShoes());
10        microSell.sell();
11    }
12}

image 在微商卖出鞋子的前后,执行了beforeSellafterSell疯狂推销,那么使用代理模式的好处就在于这,从之前最基本的厂商对顾客,鞋子只有单一的sell能力,而使用代理模式之后,我们并没有改变鞋子的sell能力就可以对其进行功能的拓展和附加

总结一下静态代理的优点:

  1. 无需修改被代理的对象
  2. 无损拓展功能
  3. 解耦合

缺点当然也存在:

  1. 要为每一个接口实现代理类,一旦接口增加方法,目标对象与代理对象都要维护。

动态代理

动态代理也是代理,他和静态代理的功能和目的是没有区别的,唯一的区别就在于动态代理是动态生成的,省去为接口实现代理类的操作。

何为动态生成

其实就是Java在内存中创建了一个实现接口的代理,而不需要我们自己定义。多说无益,看代码

我们仍然使用微商的例子来进行讲解。当微商想卖你莆田耐克的时候:

1package com.proxy.dynamicProxy;
2
3// 定义鞋子接口
4public interface Shoes {
5    void sell();
6}
1package com.proxy.dynamicProxy;
2
3// Nike鞋
4public class NikeShoes implements Shoes {
5    @Override
6    public void sell() {
7        System.out.println("卖出去一双莆田耐克,美滋滋~");
8    }
9}
 1package com.proxy.dynamicProxy;
 2
 3import java.lang.reflect.InvocationHandler;
 4import java.lang.reflect.Method;
 5
 6public class dynamicMicroSell implements InvocationHandler {
 7    Object shoes;
 8
 9    public dynamicMicroSell(Object shoes) {
10        this.shoes = shoes;
11    }
12
13    public void setShoes(Object shoes) {
14        this.shoes = shoes;
15    }
16
17    @Override
18    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
19        System.out.println("推销前:美女莆田阿迪来一双?");
20        method.invoke(shoes, args);
21        System.out.println("推销后:耐克要吗?");
22        return null;
23    }
24}

测试下

 1package com.proxy;
 2
 3import com.proxy.dynamicProxy.AdidasShoes;
 4import com.proxy.dynamicProxy.NikeShoes;
 5import com.proxy.dynamicProxy.Shoes;
 6import com.proxy.dynamicProxy.dynamicMicroSell;
 7
 8import java.lang.reflect.Proxy;
 9
10public class Main {
11
12    public static void main(String[] args) {
13        NikeShoes nikeShoes = new NikeShoes();
14        dynamicMicroSell nikeSeller = new dynamicMicroSell(nikeShoes);
15        Shoes nikeProxy = (Shoes) Proxy.newProxyInstance(NikeShoes.class.getClassLoader(), NikeShoes.class.getInterfaces(), nikeSeller);
16        nikeProxy.sell();
17    }
18}

image 可以看到我并没有像静态代理那样重新实现一个代理类,而是实现了 InvocationHandler 接口的invoke方法实现的代理。通过Proxy.newProxyInstance()创建了一个代理类来执行sell方法。

先不说InvocationHandler到底是什么东西,我们此时如果想要拓展一个阿迪鞋子的接口,应该怎么用动态代理实现?很简单,新建一个AdidasShoes还是实现Shoes接口

1package com.proxy.dynamicProxy;
2
3public class AdidasShoes implements Shoes {
4    @Override
5    public void sell() {
6        System.out.println("卖出去一双莆田阿迪,美滋滋~");
7    }
8}

其他不需要变化,在main中通过dynamicMicroSell和Proxy.newProxyInstance()动态生成代理类就可以了

 1package com.proxy;
 2
 3import com.proxy.dynamicProxy.AdidasShoes;
 4import com.proxy.dynamicProxy.NikeShoes;
 5import com.proxy.dynamicProxy.Shoes;
 6import com.proxy.dynamicProxy.dynamicMicroSell;
 7
 8import java.lang.reflect.Proxy;
 9
10public class Main {
11
12    public static void main(String[] args) {
13        NikeShoes nikeShoes = new NikeShoes();
14        dynamicMicroSell nikeSeller = new dynamicMicroSell(nikeShoes);
15        Shoes nikeProxy = (Shoes) Proxy.newProxyInstance(NikeShoes.class.getClassLoader(), NikeShoes.class.getInterfaces(), nikeSeller);
16        nikeProxy.sell();
17
18        AdidasShoes adidasShoes = new AdidasShoes();
19        dynamicMicroSell adidasSeller = new dynamicMicroSell(adidasShoes);
20        Shoes adidasProxy = (Shoes) Proxy.newProxyInstance(AdidasShoes.class.getClassLoader(), NikeShoes.class.getInterfaces(), adidasSeller);
21        adidasProxy.sell();
22
23    }
24}

运行如图 image

动态代理的优点是很明显的,它不需要为每一个接口都创建代理类,大大减少重复工作。

动态代理的秘密

在我们使用静态代理的时候,是通过new MicroSell()创建代理实例,动态代理肯定也有创建实例的动作,要找到在哪里创建了代理实例,我们需要跟进到Proxy.newProxyInstance()一探究竟

 1public static Object newProxyInstance(ClassLoader loader,
 2                                      Class<?>[] interfaces,
 3                                      InvocationHandler h)
 4    throws IllegalArgumentException
 5{
 6    Objects.requireNonNull(h);
 7
 8    final Class<?>[] intfs = interfaces.clone();
 9    final SecurityManager sm = System.getSecurityManager();
10    if (sm != null) {
11        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
12    }
13
14    /*
15         * Look up or generate the designated proxy class.
16         */
17    Class<?> cl = getProxyClass0(loader, intfs);
18
19    /*
20         * Invoke its constructor with the designated invocation handler.
21         */
22    try {
23        if (sm != null) {
24            checkNewProxyPermission(Reflection.getCallerClass(), cl);
25        }
26
27        final Constructor<?> cons = cl.getConstructor(constructorParams);
28        final InvocationHandler ih = h;
29        if (!Modifier.isPublic(cl.getModifiers())) {
30            AccessController.doPrivileged(new PrivilegedAction<Void>() {
31                public Void run() {
32                    cons.setAccessible(true);
33                    return null;
34                }
35            });
36        }
37        return cons.newInstance(new Object[]{h});
38    } catch (IllegalAccessException|InstantiationException e) {
39        throw new InternalError(e.toString(), e);
40    } catch (InvocationTargetException e) {
41        Throwable t = e.getCause();
42        if (t instanceof RuntimeException) {
43            throw (RuntimeException) t;
44        } else {
45            throw new InternalError(t.toString(), t);
46        }
47    } catch (NoSuchMethodException e) {
48        throw new InternalError(e.toString(), e);
49    }
50}

可以看到通过cl这个class反射调用其构造函数返回了一个实例

 1private 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 生成。

 1private static final class ProxyClassFactory
 2    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
 3{
 4    // prefix for all proxy class names
 5    private static final String proxyClassNamePrefix = "$Proxy";
 6
 7    // next number to use for generation of unique proxy class names
 8    private static final AtomicLong nextUniqueNumber = new AtomicLong();
 9
10    @Override
11    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
12
13        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
14        for (Class<?> intf : interfaces) {
15            /*
16                 * Verify that the class loader resolves the name of this
17                 * interface to the same Class object.
18                 */
19            Class<?> interfaceClass = null;
20            try {
21                interfaceClass = Class.forName(intf.getName(), false, loader);
22            } catch (ClassNotFoundException e) {
23            }
24            if (interfaceClass != intf) {
25                throw new IllegalArgumentException(
26                    intf + " is not visible from class loader");
27            }
28            /*
29                 * Verify that the Class object actually represents an
30                 * interface.
31                 */
32            if (!interfaceClass.isInterface()) {
33                throw new IllegalArgumentException(
34                    interfaceClass.getName() + " is not an interface");
35            }
36            /*
37                 * Verify that this interface is not a duplicate.
38                 */
39            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
40                throw new IllegalArgumentException(
41                    "repeated interface: " + interfaceClass.getName());
42            }
43        }
44
45        String proxyPkg = null;     // package to define proxy class in
46        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
47
48        /*
49             * Record the package of a non-public proxy interface so that the
50             * proxy class will be defined in the same package.  Verify that
51             * all non-public proxy interfaces are in the same package.
52             */
53        for (Class<?> intf : interfaces) {
54            int flags = intf.getModifiers();
55            if (!Modifier.isPublic(flags)) {
56                accessFlags = Modifier.FINAL;
57                String name = intf.getName();
58                int n = name.lastIndexOf('.');
59                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
60                if (proxyPkg == null) {
61                    proxyPkg = pkg;
62                } else if (!pkg.equals(proxyPkg)) {
63                    throw new IllegalArgumentException(
64                        "non-public interfaces from different packages");
65                }
66            }
67        }
68
69        if (proxyPkg == null) {
70            // if no non-public proxy interfaces, use com.sun.proxy package
71            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
72        }
73
74        /*
75             * Choose a name for the proxy class to generate.
76             */
77        long num = nextUniqueNumber.getAndIncrement();
78        String proxyName = proxyPkg + proxyClassNamePrefix + num;
79
80        /*
81             * Generate the specified proxy class.
82             */
83        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
84            proxyName, interfaces, accessFlags);
85        try {
86            return defineClass0(loader, proxyName,
87                                proxyClassFile, 0, proxyClassFile.length);
88        } catch (ClassFormatError e) {
89            /*
90                 * A ClassFormatError here means that (barring bugs in the
91                 * proxy class generation code) there was some other
92                 * invalid aspect of the arguments supplied to the proxy
93                 * class creation (such as virtual machine limitations
94                 * exceeded).
95                 */
96            throw new IllegalArgumentException(e.toString());
97        }
98    }
99}

可知代理类名为String proxyName = proxyPkg + proxyClassNamePrefix + num,即包名+$Proxy+id序号

生成代理类的核心代码

1byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
2return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

image

通过修改Java字节码的形式定义class,这就是动态代理自动生成的秘密。来看下动态代理的类名 image

总结

代理模式被运用于spring框架的aop面向切面编程中,个人业务需求可以应用在日志记录、性能统计等场景中。

最后几句话总结下:

  1. 代理模式的好处在于不修改现有代码的基础上进行拓展功能
  2. 不管是动态还是静态代理都要实现接口,本质是面向接口编程
  3. 静态代理需要自己实现Proxy类,动态由Proxy.newInstance()反射动态生成
  4. 两者区别在于是否需要自己手动实现Proxy类

文笔垃圾,措辞轻浮,内容浅显,操作生疏。不足之处欢迎大师傅们指点和纠正,感激不尽。