動態代理的實現原理

動態代理

動態代理來源於設計模式中的代理模式，在這裏“動態”的意思作者將其理解為更加靈活多變，在動態代理類中定義一個接口作(InvocationHandler)為成員變量，並且調用接口定義的方法(invoke)，接口定義的方法(invoke)並不實現它，而是讓這個接口的實現類(此處使用lambda錶達式實現)來實現它。因此可以達到動態的效果。

Foo接口

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

Foo接口的實現類Target

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

    @Override
    public void bar() {
    
        System.out.println("bar()");
    }
}

代理接口

// 代理接口
interface InvocationHandler{
    
    void invoke(Method method,Object[] objects) throws Throwable;
}

代理類

public class $Proxy0 implements Foo {
    
 	/** * 使用InvocationHandler接口，將需要代理的方法的實現部分轉移到其子類實現， * 而在代理類中只需要定一個接口，並在需要代理的方法中調用invoke方法即可。 */
    private InvocationHandler h;

    public $Proxy0(InvocationHandler h) {
    
        this.h = h;
    }

    @Override
    public void foo() {
    
        try {
    
            Method foo = Foo.class.getDeclaredMethod("foo");
            h.invoke(foo,new Object[0]);
        } catch (Throwable throwable) {
    
            throwable.printStackTrace();
        }
    }

    @Override
    public void bar() {
    
        try {
    
            Method bar = Foo.class.getDeclaredMethod("bar");
            h.invoke(bar,new Object[0]);
        } catch (Throwable throwable) {
    
            throwable.printStackTrace();
        }
    }
}

main方法類

public class Main{
    
    public static void main(String[] args) {
    
        $Proxy0 proxy = new $Proxy0(new InvocationHandler() {
    
            @Override
            public void invoke(Method method, Object[] objects) throws Throwable {
    
                // 1、功能增强
                System.out.println("before....");
                // 2、原始方法
                Object result = method.invoke(new Target(), objects);

            }
        });

        proxy.foo();
        proxy.bar();
    }
}