Java代理模式

前言

代理模式分为静态代理和动态代理，动态代理是一种常见的设计模式。

//抽象角色 
interface Api {
    void test(String a);
}

//真实角色 
class ApiImpl{
	@Override
	public void test(String a) { System.out.println("真实实现:" + a);} 
}

//创建真实角色实例
ApiImpl api = new ApiImpl();

//动态代理类
class MarkCompany implements InvocationHandler{
    /*持有的真实对象*/
    private Object factory;

    public Object getFactory() {
        return factory;
    }

    public void setFactory(Object factory) {
        this.factory = factory;
    }
    
     /*通过Proxy获得动态代理对象*/
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),this);
    }
    
      /*通过动态代理对象方法进行增强*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        doSthAfter();
        Object result = method.invoke(factory, args);
        doSthBefore();
        return result;
    }
    
     /*前置处理器*/
    private void doSthAfter() {
    }
    /*后置处理器*/

    private void doSthBefore() {
    }
}

public class Client {
		public static void main(String[] args) {
		      /*静态代理模式---------------*/
//        AInterface afactory = new AaFactory();
//        AProxy aProxy = new AProxy(afactory);//new一个代理类
//        aProxy.testA();
//
//        BInterface bFactory = new BbFactory();
//        BProxy bProxy = new BProxy(bFactory);//new一个代理类
//        bProxy.testB();

        /*动态代理模式---------------*/
        AInterface aFactory = new AaFactory();//A接口的Impl
        MarkCompany markCompany = new MarkCompany();
        markCompany.setFactory(afactory);
        AInterface aProxy = (AInterface)markCompany.getProxyInstance();
        aProxy.testA();
        
        BInterface bFactory = new BbFactory();//B接口的Impl
        markCompany.setFactory(bFactory);
        BInterface bProxy = (BInterface)markCompany.getProxyInstance();
        bProxy.testB();
		}
}

实际上，Proxy.newProxyInstance 会创建一个Class，与静态代理不同，这个Class不是由具体的.java源文件编译而来，即没有真正的文件，只是在内存中按照Class格式生成了一个名为proxyPkg + $Proxy + num的class文件，由源码可知是生成了一个byte数组。

InvocationHandler 接口，在使用动态代理时，传递的 InvocationHandler 就是一个监听，在代理对象上执行方法，都会由这个监听回调出来。

InvocationHandler接口是给动态代理类实现的，负责处理被代理对象的操作的，而Proxy是用来创建动态代理类实例对象的，因为只有得到了这个对象我们才能调用那些需要代理的方法。

实现原理

观察Proxy.newProxyInstance()方法，与创建对象有关的代码主要有：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) throws IllegalArgumentException
    {
        //复制一份接口
        final Class<?>[] intfs = interfaces.clone();
        // 获得代理类的class对象
        Class<?> cl = getProxyClass0(loader, intfs);
        // 获得代理类的构造器
         final Constructor<?> cons = cl.getConstructor(constructorParams);
         //创建代理类的实例
         ...
         return cons.newInstance(new Object[]{h});

其中的关键点就是如何获得代理类的class对象，我们进入getProxyClass0()方法

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    //对接口方法限制数量65535
		if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    //JDK内部使用了某种机制缓存了我们的代理类的class对象
    return proxyClassCache.get(loader, interfaces);
}

JDK内部使用WeakCache缓存了代理类的class对象，同时用到了被代理类的类加载器和类实现的接口这两个参数的是apply方法

// WeakCache.java
public V get(K key, P parameter) {
 
   // create subKey and retrieve the possible Supplier<V> stored by that
   // subKey from valuesMap
   Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
 }

subKeyFactory.apply具体实现是Proxy.ProxyClassFactory类

// Proxy.java   
private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        				/*
                 * Choose a name for the proxy class to generate.
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                
                return generateProxy(proxyName, interfaces, loader, methodsArray,
                                     exceptionsArray);
            }
     }
     
//调用native方法
private static native Class<?> generateProxy(String name, Class<?>[] interfaces,
                   ClassLoader loader, Method[] methods,Class<?>[][] exceptions);

动态代理类class的文件在内存中是byte数组形式存在，通过ProxyGenerator.generateProxyClass()生成的

// ProxyGenerator.class 
 public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
        ...
        return var4;
 }

优缺点

优点：只需要一个动态代理类就可以解决创建多个静态代理的问题，避免重复、多余代码，更强的灵活性。

缺点：效率较低，相比静态代理中直接调用目标对象方法，动态代理则需要先通过Java反射机制间接调用目标对象方法。

应用场景局限，因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口创建代理类，不能针对类创建代理类。

SongHang's Blog

Java代理模式

前言

目录

一、什么是代理模式

二、静态代理

三、动态代理

如何使用

实现原理

优缺点

总结