jdk代理模拟

本文模拟实现了jdk代理，从固定逻辑到策略模式，从代理单个方法到代理多个方法，循序渐进。

1. 实现1
   代理类和被代理类实现相同接口，代理类持有被代理类的引用，在调用被代理方法的前后添加增强逻辑。

 interface Foo {
        void foo();
        int bar();
    }

    static class Target implements Foo {
        public void foo() {
            System.out.println("target foo");
        }
    }

public class $ProxyS implements Foo {
    @Override
    public void foo() {
        //1. 功能 增强
        System.out.println("foo");
        //2. 调用 目标
        new A12.Target().foo();
    }

    @Override
    public int bar() {
        return 0;
    }
}

public static void main(String[] param) {
        Foo proxy_=new $ProxyS();
        proxy_.foo();
        }

在上述，增强的逻辑是固定的，使用范围很有限。
2. 实现2
使用策略模式将代理类的逻辑做成抽象方法

interface InvocationHandler {
        void invoke();
    }

public class $ProxyS implements Foo {
    private InvocationHandler h;
    public $ProxyS(InvocationHandler h){
        this.h = h;
    }
    @Override
    public void foo() {
        h.invoke();
    }
}

实现不同的InvocationHandler接口即可调用不同的方法。

方法2可以对foo方法做各种类型的增强，但是当Foo类不止一个方法需要增强，并且动态的选择调用哪一个方法时，方法2就无法解决了。
3. 实现3
将被增强的方法作为参数从而实现代理不同的方法。

public class A12 {

    interface Foo {
        void foo();
        int bar();
    }

    static class Target implements Foo {
        public void foo() {
            System.out.println("target foo");
        }

        @Override
        public int bar() {
            System.out.println("target bar");
            return 1;
        }
    }

    interface InvocationHandler {
        void invoke(Method method,Object[] args) throws Throwable;
    }

    public static void main(String[] param) {
        Foo proxy = new $ProxyS(new InvocationHandler() {
            @Override
            public void invoke(Method method, Object[] args) throws Throwable{
                // 1. 功能增强
                System.out.println("before...");
                // 2. 调用目标
                method.invoke(new Target(), args);
            }
        });
        proxy.foo();
        proxy.bar();
    }
}

调用proxy.foo方法时，将Foo接口的foo方法
当做参数传到InvocationHandler的invoke方法内，也就是被增强方法被当做参数传到了增强方法内。
InvocationHandler的invoke方法做了两件事：
（1）
（2）

public class $ProxyS implements A12.Foo {
    private A12.InvocationHandler h;
    public $ProxyS(A12.InvocationHandler h){
        this.h = h;
    }
    @Override
    public void foo()  {
        try{
            Method foo = A12.Foo.class.getMethod("foo");
            h.invoke(foo,new Object[0]);
        }catch (Throwable e){
            e.printStackTrace();
        }

    }

    @Override
    public int bar() {
        try{
            Method bar = A12.Foo.class.getMethod("bar");
            h.invoke(bar,new Object[0]);
            return 1;
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            return 0;
        }
    }


}

proxy.foo和proxy.bar的执行结果为：

在方法3中，每次进行增强都要调用getMethod方法，可以将getMethod获取的方法对象作为静态变量。

 static Method foo;
    static Method bar;
    static {
        try {
            foo = A12.Foo.class.getMethod("foo");
            bar = A12.Foo.class.getMethod("bar");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

5. 对方法3整理优化
   整理好的完整代码如下

public class A12 {

    interface Foo {
        void foo();
        int bar();
    }

    static class Target implements Foo {
        public void foo() {
            System.out.println("target foo");
        }

        @Override
        public int bar() {
            System.out.println("target bar");
            return 1;
        }
    }

//    interface InvocationHandler {
//        Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
//    }

    public static void main(String[] param) {
        Foo proxy = new $Proxy0(new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //1. 功能增强
                System.out.println("before...");
                //2. 调用目标
                return method.invoke(new Target(),args);
            }
        });
        proxy.foo();
        proxy.bar();
        /*
            学到了什么: 代理一点都不难, 无非就是利用了多态、反射的知识
                1. 方法重写可以增强逻辑, 只不过这【增强逻辑】千变万化, 不能写死在代理内部
                2. 通过接口回调将【增强逻辑】置于代理类之外
                3. 配合接口方法反射(也是多态), 就可以再联动调用目标方法
         */
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public class $Proxy0 extends Proxy implements A12.Foo {

    public $Proxy0(InvocationHandler h) {
        super(h);
    }
    @Override
    public void foo() {
        try {
            h.invoke(this, foo, new Object[0]);
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    @Override
    public int bar() {
        try {
            Object result = h.invoke(this, bar, new Object[0]);
            return (int) result;
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    static Method foo;
    static Method bar;
    static {
        try {
            foo = A12.Foo.class.getMethod("foo");
            bar = A12.Foo.class.getMethod("bar");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }
}

在jdk中，进行动态代理时并不会生成.java文件，而是直接生成.class文件实现代理，.class反编译后的形式与方法3类似。具体生成方法可以自行了解。