103 动态代理

一、静态代理

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

好处

• 通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性
• 通过代理对象对访问进行控制

缺点

• 一对一则会出现时静态代理对象量多、代码量大，从而导致代码复杂，可维护性差的问题，一对多则代理对象会出现扩展能力差的问题。

代理三大角色

• 抽象角色

代理角色和真实角色对外提供的公共方法，一般为一个接口

• 代理角色

需要实现抽象角色接口，持有真是角色引用，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理

• 真实角色

需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业 务逻辑在此。

二、动态代理

在运行时再创建代理类和其实例，因此显然效率更低。要完成这个场景，需要在运行期动态创建一个Class。JDK提供了 Proxy 来完成这件事情

• 案例如下

//抽象角色 
interface Api {
    void test(String a);
}
//真实角色 
class ApiImpl{
@Override
public void test(String a) {
   System.out.println("真实实现:" + a);
} }
//创建真实角色实例
ApiImpl api = new ApiImpl();
//JDK动态代理: 
Proxy.newProxyInstance(getClass().getClassLoader(),new Class[]{Api.class}, //JDK实现只能代理接口 
  new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable { 
//执行真实对象方法
        return method.invoke(api, args); }
});

注：Proxy.newProxyInstance 会创建一个Class，与静态代理不同，这个Class不是由具体的.java源文件编译而来，即没有真正的文件，只是在内存中按照Class格式生成了一个Class。

public interface Api {

    String getString();

}

String name = Api.class.getName()+"$Proxy0";
//生成代理指定接口的Class数据
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{Api.class}); 
FileOutputStream fos = new FileOutputStream("lib/" + name+".class"); 
fos.write(bytes);
fos.close();
//生成的class文件源码
public final class Api$Proxy0 extends Proxy implements Api {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;

    public Api$Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String getString() throws  {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.example.lib.Api").getMethod("getString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

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