代理模式

作者: ilaoke | 来源:发表于2017-08-11 17:43 被阅读10次

设计模式
设计模式
kube-proxy的3种模式
第4章结构型模式-代理模式
理解代理模式
结构型代理模式（文末有项目连接）
设计模式－动态代理模式
代理模式
设计模式之代理模式（Proxy模式）
Java设计模式之代理模式

Provide a surrogate or placeholder for another object to control access to it.

代理模式

抽象类

public abstract class AbstractSubject {
    public abstract void work();
}

被代理对象

public class Subject extends AbstractSubject {
    @Override
    public void work() {
        System.out.println(getClass() + " execute work()");
    }
}

代理

public class Proxy extends AbstractSubject {

    Subject subject;

    @Override
    public void work() {
        System.out.println("Proxy call happening now");
        // Lazy initialization
        if (subject == null) {
            subject = new Subject();
        }
        subject.work();
    }
}

运行

public class Proxy extends AbstractSubject {

    Subject subject;

    @Override
    public void work() {
        System.out.println("Proxy call happening now");
        // Lazy initialization
        if (subject == null) {
            subject = new Subject();
        }
        subject.work();
    }
}

类图

proxy.png

代理的作用：

延迟初始化被代理对象，仅当真正需要时才被初始化，特别是当被代理对象初始化比较消耗资源时。
可以在被代理对象的方法执行前后，添加任意需要的动作。

JAVA动态代理

JDK实现了代理模式，通过java.lang.reflect.Proxy.newProxyInstance类来创建代理对象，并且需要一个java.lang.reflect.InvocationHandler接口的实现类，代理对象会实现被代理对象实现的接口，当调用代理对象的方法，JDK就会执行InvocationHandler.invoke()方法，此时给了我们添加额外动作的机会。

接口

public interface IFoo {
    // 接口方法默认是public abstract的，不需要添加修饰符
    Object bar(Object obj);
}

实现类

public class Foo implements IFoo {
    public Object bar(Object obj) {
        System.out.println("Foo execute bar(obj)");
        return obj;
    }
}

InvocationHandler实现类

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

public class DebugInvocationHandler implements InvocationHandler {
    private Object obj;

    private DebugInvocationHandler(Object obj) {
        this.obj = obj;
    }

    public static Object newInstance(Object obj) {
        // 返回代理对象
        return Proxy.newProxyInstance(
                obj.getClass().getClassLoader(),    // 类加载器
                obj.getClass().getInterfaces(),     // 被代理类实现的接口
                new DebugInvocationHandler(obj));   // InvocationHandler实例
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result;
        try {
            System.out.println("before method " + method.getName());
            result = method.invoke(obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        } catch (Exception e) {
            throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
        } finally {
            System.out.println("after method " + method.getName());
        }
        return result;
    }
}

执行

public class Test {
    public static void main(String[] args) {
        /**
         * java.lang.reflect.Proxy类需要一个java.lang.reflect.InvocationHandler对象
         *
         * Proxy.newProxyInstance()方法返回一个代理对象，该代理对象实现了被代理对象实现的接口（IFoo）
         *
         * 调用代理对象的方法，JDK就会执行InvocationHandler.invoke()方法，此时给了我们添加额外动作的机会
         */
        IFoo proxy = (IFoo) DebugInvocationHandler.newInstance(new Foo());
        proxy.bar(null);
    }
}

Spring中的AOP就是通过代理来实现，有三种实现方式：动态代理，CGLIB，AspectJ 。
动态代理只能对存在接口的实现类进行代理，CGLIB可以直接对类进行代理，AspectJ可以在类加载时织入。

参考：