代理模式-设计模式

动机

1. 在面向对象系统中，有些对象由于某种原因（比如对象创建的开销很大，或者某些操作需要安全控制，或者需要进程外的访问等），直接访问会给使用者、或者系统结构带来很多麻烦。
2. 如何在不失去透明操作对象的同时来管理/控制这些对象特有的复杂性？增加一层接口是软件开发中常见的解决方式。

模式定义

为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问。

类图

总结

代理的核心：添加一层，封装目标对象，对外提供目标对象的相同的接口，同时又聚合目标对象。

1. “增加一层间接层”是软件系统中对许多复杂问题的一种常见解决方法。在面向对象系统中，直接使用某些对象会带来很多问题，作为间接层的Proxy对象便是解决这一问题的常用手段。
2. 具体Proxy设计模式的实现方法、实现粒度都相差很大，有些可能对某个对象做细粒度的控制，如copy-on-write技术，有些可能对组件模块提供抽象代理层，在架构层次对对象做代理。
3. Proxy并不一定要求保持接口完整的一致性，只要能够实现间接控制，有时候损失一些透明性是可以接受的。
4. 增加一个代理层，来达成在完成目标功能是实现某些不为外界所感知的功能，比如安全、性能、日志等。典型的就是Spring的切面编程，使用到了的jdk的动态代理和Cglib的字节码代理技术。

实例

场景：
房屋装修，装修公司其实就是代理，真正干活的人是工人师傅，装修公司委托装修工人装修客户的房屋。

三种代理技术

三种代理技术其实都是，创建一个代理类实现一个接口，同时关联被代理类；
不同的是：
静态代理实现的是自己定义的接口；
JDK动态代理实现的是JDK提供的InvocationHandler接口；
Cglib动态代理实现的是Cglib提供的MethodInterceptor接口。

静态代理

总结：

• 代理类和被代理类必须实现相同的接口，因为代理类需要实现和被代理类相同的功能，所以需要实现相同的接口。
• 每次代理一个类，必须手动实现一个代理类，直接造成类数量翻倍，很是麻烦。

1. 定义装修房屋的接口

public interface IDecorateHouse {
    void decorate();
}

2. 装修工人，装修公司分别实现接口，同时装修公司关联装修工人类。

public class DecorationWorker implements IDecorateHouse {
    @Override
    public void decorate() {
        System.out.println("Decoration workers decoration house");
    }
}
public class DecorationCompany implements IDecorateHouse {
    private DecorationWorker worker;

    public DecorationCompany() {
        this.worker = new DecorationWorker();
    }

    @Override
    public void decorate() {
        System.out.println("Decorate company proxy");
        worker.decorate();
    }
}

3. 客户直接找装修公司装修房子，不再过问具体是谁装修的房子

public class Client {
    public static void main(String[] args) {
        IDecorateHouse house = new DecorationCompany();
        house.decorate();
    }
}

JDK动态代理

总结

• JDK的动态代理不需要在为每一个被代理类写一个代理类了。
• 只能代理实现了接口的被代理对象。
• 因为动态代理需要继承被代理类，才能生存代理对象，这是动态代理的实现本质；但是JDK动态代理继承了Proxy类，由于Java语言中不能多继承，导致无法动态代理那么没有实现接口的类对象。

示例1

package com.msb.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Random;

public class ProxyMode {

    interface Movable {
        void move();
    }

    static class Tank implements Movable {

        @Override
        public void move() {
            try {
                System.out.println("tank move");
                Thread.sleep(new Random().nextInt(3000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("tank claclacla...");
        }
    }

    class TimeProxy implements InvocationHandler {

        private Tank tank;

        public TimeProxy (Tank tank) {
            this.tank = tank;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("proxy invoke begin");
            //代理类返回的是目标方法执行的结果
            Object invoke = method.invoke(tank, args);
            System.out.println("proxy invoke end");
            return invoke ;
        }
    }


    public static void main(String[] args1) {
        // jdk8及之前
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        // jdk8之后
//        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
        final Tank tank = new Tank();
//        Movable obj = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(), new Class[]{Movable.class}, new TimeProxy(new Tank()));
        Movable obj = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(), new Class[]{Movable.class}, (proxy, method, args) -> {
            System.out.println("proxy invoke begin");
            System.out.println(proxy.getClass().getName());
            System.out.println(Arrays.toString(proxy.getClass().getDeclaredConstructors()));
            //代理类返回的是目标方法执行的结果
            Object result = method.invoke(tank, args);
            System.out.println("proxy invoke end");
            return result ;
        });
        obj.move();
    }
}

时序图如下：

示例2

1. 设计动态代理工厂类，生成被代理类的代理类

public class DynamicProxyFactory {
    private Object target;

    public DynamicProxyFactory(Object target) {
        this.target = target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        InvocationHandler handler = (proxy, method, args) -> {
            System.out.println("Dynamic proxy decorate house");
            //代理类返回的是目标方法执行的结果
            Object result = method.invoke(target, args);
            return result;
        };
        Object result = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);
        return result;
    }
}

2. 客户端调用代理类，需要客户端知道具体的装修工人

public class Client {
    public static void main(String[] args) {
        DynamicProxyFactory factory = new DynamicProxyFactory(new DecorationWorker());
        IDecorateHouse house = (IDecorateHouse)factory.getProxyInstance();
        house.decorate();
    }
}

Cglib字节码层面代理

总结：

• 实现与JDK代理类基本一致，只不过一个是实现JDK的接口，一个是实现Cglib的接口。
• 因为使用的字节码层面的代理，使用的是继承被代理类的原理。
  1. Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
  2. Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类，不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
• 因为是使用继承，不能代理final类、类中final和static的方法。
• 性能比较jdk代理高，但是生成速度比jdk动态代理慢，如果是单列模式或者较少创建对象的场景，使用Cglib代理比较好。
• Spring AOP切面原理，使用动态代理：如果被代理的对象实现了接口，使用JDK动态代理，如果没有实现接口使用Cglib代理。

1. 创建Cglib代理类，实现cglib的方法拦截接口

public class CglibProxyFactory implements MethodInterceptor {
    private Object target;

    public CglibProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        // 创建Enhancer对象，类似JDK中的Proxy类
        Enhancer enhancer = new Enhancer();
        // 设置代理类的父类，父类就是被代理对象，代理对象继承被代理对象
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib proxy decorate house");
        // 如果使用proxy(这个是最终生成的代理对象),使用下面的实现
        // return methodProxy.invokeSuper(proxy, args);
        // 如果使用target(这个是被代理类),使用下面实现
        return methodProxy.invoke(target, args);
    }
}

2. 客户端调用代理类

public class Client {
    public static void main(String[] args) {
        CglibProxyFactory proxyFactory = new CglibProxyFactory(new DecorationWorker());
        IDecorateHouse house = (IDecorateHouse) proxyFactory.getProxyInstance();
        house.decorate();
    }
}

参考

jdk动态代理使用详解
Java JDK 动态代理（AOP）使用及实现原理分析
JDK动态代理(介绍理解，如何实现)