设计模式----代理模式

GoF中的代理模式定义：

代理模式给某一个对象提供一个代理或者占位符，并由代理对象来控制对原对象的访问，属于结构型模式。在实现形式上分为两种静态代理和动态代理。

设计动机

由于跨越网络、或者安全方面的原因，不能直接或者不需要直接被访问，直接访问的代价会给系统带来不必要的复杂性，如可能会导致访问延迟、运行效率低下等问题，通过引入一个代理对象代替目标对象完成客户端程序对目标对象的各种操作要求，从而实现目标对象与客户端以透明的方式进行交互。

按照功能可以分为远程代理、虚拟代理、保护代理、缓冲代理、智能引用代理。

远程代理：在本地创建一个代理对象来控制

应用场景举例：springAOP

UML类图：

 静态代理

自己实现代理类和被代理类，且代理类和被代理类要实现同一个接口。结合例子来说明，如下所示：

小明没时间去火车站买票，要托火车票代买点帮其购买，则火车站就是被代理对象，火车票代买点就是代理对象，买车票就是一个行为被抽象出来作为共同的接口。

public interface BuyTicket {
    void showTicket();
}

被代理类

public class Train implements BuyTicket {

    @Override
    public void showTicket() {
        System.out.println("买张火车票");

    }
}

代理类

public class TicketCenter implements BuyTicket {

    private BuyTicket ticket;

    public TicketCenter(BuyTicket ticket) {
        this.ticket = ticket;
    }

    public void buy(){
        showTicket();
    }

    @Override
    public void showTicket() {
        System.out.println("通过代理可得");
        ticket.showTicket();
    }


}

测试程序

public class Test {
    public static void main(String[] args) {
        //创建被代理对象和代理对象
        Train train = new Train();
        TicketCenter buyTicket = new TicketCenter(train);
        //调用代理对象中用于代理的方法
        buyTicket.buy();
    }
}

 动态代理的话分为两种实现：

1、依赖于asm框架的proxy类

2、依赖于cglib的Enhancer类

 用proxy类实现动态代理的话，代理类和被代理类必须要实现同一个接口，并通过反射的方式来创建代理对象，主要依赖于newProxyInstance()方法来实现，如下所示，在调用该方法时需要指定3个参数，分别是类加载器，实现的共同接口，处理器（代理逻辑）。

@CallerSensitive
    
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

实现：

//proxy的处理器，实现调用处理器的接口
class handler implements InvocationHandler{

    Train train;

    public handler(Train train) {
        this.train = train;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println(method.getName() + "动态代理");
        System.out.println("通过代理可得");
        Object invoke = method.invoke(train, args);
        return invoke;
    }
}

基于Enhancer的实现是依赖于instructment，其代理对象可以不用实现接口。其处理逻辑如下：

        //建立一个动态代理类
        Enhancer enhancer = new Enhancer();
        //指定被代理对象
        enhancer.setSuperclass(Train.class);
        //指定代理逻辑
        enhancer.setCallback(new handle2());
        //创建代理类
        Train train1 = (Train) enhancer.create();
        //调用代理方法
        train1.showTicket();

处理逻辑如下：

//enhance的处理器，实现方法拦截器接口
class handle2 implements MethodInterceptor{

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println(o.getClass().getSuperclass().getName());
        System.out.println("enhance 动态代理");
        Object result = null;
        result = methodProxy.invokeSuper(o, objects);
        return result;
    }
}

测试程序：

public class Test {
    public static void main(String[] args) {
        //静态代理
        Train train = new Train();
        TicketCenter buyTicket = new TicketCenter(train);
        buyTicket.buy();
        //基于proxy的动态代理
        System.out.println("-----------------");
        BuyTicket proxyInstance = (BuyTicket) Proxy.newProxyInstance(Train.class.getClassLoader(), new Class[]{BuyTicket.class},
                new handler(train));
        proxyInstance.showTicket();

        System.out.println("----------------");

        //基于enhancer建立一个动态代理类
        Enhancer enhancer = new Enhancer();
        //指定被代理对象
        enhancer.setSuperclass(Train.class);
        //指定代理逻辑
        enhancer.setCallback(new handle2());
        //创建代理类
        Train train1 = (Train) enhancer.create();
        //调用代理方法
        train1.showTicket();
    }
}

测试结果如下：

通过代理可得
买张火车票
-----------------
showTicket动态代理
通过代理可得
买张火车票
----------------
ProxyPattern.StaticProxy.Train
enhance 动态代理
买张火车票