设计模式: 代理模式--JDK动态代理

一、JDK动态代理实现

// 创建一个接口(人类)
public interface Person {

    void findLove();
}

// 创建一个媒婆的客户，实现findLove方法
public class Customer implements Person {
    
    public void findLove() {
        System.out.println("高富帅");
    }
}

// 媒婆类 实现InvocationHandler接口
public class JDKAgentMeiPo implements InvocationHandler {

    // 被代理对象
    private Person target;

    public Object getInstance(Person target) {
        this.target = target;
        Class aClass = target.getClass();
        // 这里会创建代理类并返回
        return Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), this);
    }

    // 代理类只要调用invoke方法就可以实现被代理类的方法，可以对被代理方法执行前后进行功能的扩展
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在被代理方法执行前做处理
        before();
        // 执行被代理类的具体方法
        Object invoke = method.invoke(this.target, args);
        // 在被代理方法执行后做处理
        after();
        return invoke;
    }

    private void before() {
        System.out.println("我是媒婆:我要给你找对象,我现在已经确定你的需求了");
        System.out.println("开始物色");
    }

    private void after() {
        System.out.println("如果可以就结婚");
    }
}

// 创建测试类
public class JDKAgentTest {

    public static void main(String[] args) {
        try {
            // 被代理类
            Customer customer = new Customer();
            Person instance = (Person) new JDKAgentMeiPo().getInstance(customer);
            instance.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果:
我是媒婆:我要给你找对象,我现在已经确定你的需求了
开始物色
高富帅
如果可以就结婚

那么我们的JDK代理模式时怎么实现的呢:

1. 获取被代理对象的应用,并且获取它所有接口,反射获取
2. JDK动态代理重新生成一个新的类,同时新的类要实现被代理对象实现的所有接口
3. 动态生成JAVA代码
4. 编译新生成的JAVA代码.class 文件
5. 重新加载到JVM中运行

我们下面看下JDK生成的代理类:

// JDK生成的类名称一般由$符号开头
public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $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);
        }
    }
    // 实现了findLove方法
    public final void findLove() throws  {
        try {
            // 调用JDKAgentMeiPo.invoke方法
            // super.h 就是 JDKAgentMeiPo 这个对象,这个对象是在 Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), this); 这句代码中的this变量将JDKAgentMeiPo的对象传带Proxy中的
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.wangyahao.designpatterns.proxy.dynamicAgent.JDKAgent.Person").getMethod("findLove");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

大家可以使用这段代码将代理类输出到磁盘中

       try {
            // 被代理类
            Customer customer = new Customer();
            Person instance = (Person) new JDKAgentMeiPo().getInstance(customer);
            instance.findLove();

           //  将生成的代理对象转成字节数组
            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
            FileOutputStream fileOutputStream = new FileOutputStream("/Users/wangyahao/Desktop/$Proxy0.class");
            fileOutputStream.write(bytes);
            fileOutputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

以上就是JDK动态代理的基本使用了,下面说下它和静态代理的区别:

1. JDK动态代理和静态代理很像,只是静态代理是手动写代码,而JDK动态代理是根据反射自动生成代理,在代码维护上动态代理更加便于维护
2. 在代码编写上静态代理类和被代理对象都需要实现同一个接口,而动态代理不需要