设计模式-代理模式

代理模式

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不合适或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般包含三种角色：

1. 抽象主题角色（Subject）：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类；
2. 真实主题角色（RealSubject）：该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象；
3. 代理主题角色（Proxy）：也被称为代理类，其内部持有RealSubject的引用，因此具备完全的对RealSubject的代理权。客户端调用代理对象的方法，同事也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。

在代码中，一般代理会被理解为代码增强，实际上就是再原代码逻辑前后增加一些代码逻辑，而使调用者无感知。代理模式属于结构型模式，分为静态代理和动态代理。

代理模式的应用场景

生活中的房屋中介，售票黄牛，婚介，快递，事务代理，非侵入式日志监听等，都是代理模式的体现。当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过给代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。

代理模式的通用写法

首先创建代理主题角色ISubject类：

public interface ISubject {
    void request();
}

创建真实主题角色RealSubject类：

public class RealSubject implements ISubject {
    public void request() {
        System.out.println("real service is called.");
    }
}

创建代理主题角色Proxy类:

public class Proxy implements ISubject {

    private ISubject subject;

    public Proxy(ISubject subject){
        this.subject = subject;
    }
    public void request() {
        before();
        subject.request();
        after();
    }
    public void before(){
        System.out.println("called before request().");
    }
    public void after(){
        System.out.println("called after request().");
    }
}

客户端调用代码：

public static void main(String[] args) {
    Proxy proxy = new Proxy(new RealSubject());
    proxy.request();
}

从静态代理到动态代理

举个例子，以父母为子女找对象，创建顶层接口IPerson：

public interface IPerson {
    void findLove();
}

儿子张三要找对象，实现ZhangSan类：

public class ZhangSan implements IPerson {
    public void findLove() {
        System.out.println("儿子要求：肤白貌美大长腿");
    }
}

父亲张老三帮儿子张三相亲，实现Father类

public class ZhangLaosan implements IPerson {
    private ZhangSan zhangsan;
    public ZhangLaosan(ZhangSan zhangsan) {
        this.zhangsan = zhangsan;
    }
    public void findLove() {
        System.out.println("张老三开始物色");
        zhangsan.findLove();
        System.out.println("开始交往");
    }

}

测试代码：

public class Test {
    public static void main(String[] args) {
        ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
        zhangLaosan.findLove();
    }
}

但是这样的场景有点不好，就是自己的父亲只会为自己的子女去物色对象，别人家的不会管，要是发展成一个产业，出现媒婆、婚介等，还是用静态代理成本那就很高，需要一个更加通用的解决方案。这就是静态代理升级到动态代理。在Java中，目前最普遍使用的是JDK自带的代理和Cglib提供的类库。

基于JDK的动态代理

首先创建媒婆类JdkMeipo:

public class JdkMeipo implements InvocationHandler {
    private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }
    private void after() { System.out.println("双方同意，开始交往");}
    private void before() { System.out.println("我是媒婆，已经收集到你的需求，开始物色"); }
}

再创建一个类ZhaoLiu：

public class ZhaoLiu implements IPerson {
    public void findLove() {
        System.out.println("赵六要求：有车有房学历高");
    }
}

测试代码

public static void main(String[] args) {
    JdkMeipo jdkMeipo = new JdkMeipo();
    IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
    zhangsan.findLove();

    IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
    zhaoliu.findLove();
}

静态模式在业务中的应用

再看一个实际业务场景，在分布式业务场景中，通常会对数据库进行分库分表，分库分表之后实际Java操作时就可能要配置多个数据源，我们通过设置数据源路由来动态切换数据源。先创建Order订单类：

@Data
public class Order {
    private Object orderInfo;
    //订单创建时间进行按年分库
    private Long createTime;
    private String id;
}

创建OrderDao持久层操作类：

public class OrderDao {
    public int insert(Order order){
        System.out.println("OrderDao创建Order成功!");
        return 1;
    }
}

创建IOrderService接口：

public interface IOrderService {
    int createOrder(Order order);
}

创建OrderService实现类

public class OrderService implements IOrderService {
    private OrderDao orderDao;
    public OrderService(){
        //如果使用Spring应该是自动注入的
        //我们为了使用方便，在构造方法中将orderDao直接初始化了
        orderDao = new OrderDao();
    }
    public int createOrder(Order order) {
        System.out.println("OrderService调用orderDao创建订单");
        return orderDao.insert(order);
    }
}

接下来使用静态代理，主要完成的功能是：根据订单创建时间自动按年进行分库。根据开闭原则，我们修改原来写好的代码逻辑，通过代理对象来完成。先创建数据源路由对象，使用ThreadLocal的单例实现DynamicDataSourceEntity类：

public class DynamicDataSourceEntity {
    // 默认数据源
    public final static String DEFAULE_SOURCE = null;
    private final static ThreadLocal<String> local = new ThreadLocal<String>();
    private DynamicDataSourceEntity(){}
    // 获取当前正在使用的数据源名字
    public static String get(){return  local.get();}
    // 还原当前切换的数据源
    public static void restore(){
         local.set(DEFAULE_SOURCE);
    }
    //DB_2020
    //DB_2021  设置已知名字的数据源
    public static void set(String source){local.set(source);}
    // 根据年份动态设置数据源
    public static void set(int year){local.set("DB_" + year);}
}

创建切换数据源的代理类OrderServiceSaticProxy“

public class OrderServiceStaticProxy implements IOrderService {
    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService) {
        this.orderService = orderService;
    }
    public int createOrder(Order order) {
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
        DynamicDataSourceEntity.set(dbRouter);
        this.orderService.createOrder(order);
        DynamicDataSourceEntity.restore();
        return 0;
    }
}

测试代码

    public static void main(String[] args) {
        try {
            Order order = new Order();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2020/03/01");
            order.setCreateTime(date.getTime());
            
            IOrderService orderService = (IOrderService)new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

动态代理在业务场景中的应用

public class OrderServiceDynamicProxy implements GPInvocationHandler {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private Object proxyObj;
    public Object getInstance(Object proxyObj) {
        this.proxyObj = proxyObj;
        Class<?> clazz = proxyObj.getClass();
        return GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args[0]);
        Object object = method.invoke(proxyObj,args);
        after();
        return object;
    }

    private void after() {
        System.out.println("Proxy after method");
        //还原成默认的数据源
        DynamicDataSourceEntity.restore();
    }

    //target 应该是订单对象Order
    private void before(Object target) {
        try {
            //进行数据源的切换
            System.out.println("Proxy before method");

            //约定优于配置
            Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
            Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
            System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");
            DynamicDataSourceEntity.set(dbRouter);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试代码

IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService());

依然能够达到相同运行效果。但是，使用动态代理后，我们不仅能实现Order的数据源动态路由，还可以实现其他任何类的数据源路由。当然，有个比较重要的约定，必须实现getCreateTime()方法，因为路由规则是根据时间来运算的。我们可以通过接口规范来达到约束的目的。

手写JDK动态代理实现原理

JDK动态代理采用字节重组，重新生成对象来替代原始对象，以达到动态代理的目的。

JDK动态代理生成对象的步骤如下：

1. 获取被代理对象的引用，获取它的所有接口，反射获取
2. JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口
3. 动态生成Java代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）
4. 编译新生成的Java代码 .class 文件
5. 重新加载到JVM中运行

以上过程叫字节码重组。JDK中有一个规范，在ClassPath下只要是$开头的 .class 文件，一般都自动生成的。

/**
 * 手写JDK代码主要逻辑  具体代码见git
 */
public class NewProxy {
    public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces, GPInvocationHandler h){
           //1、动态生成源代码.java文件

           //2、Java文件输出磁盘

           //3、把生成的.java文件编译成.class文件

           //4、编译生成的.class文件加载到JVM中来

           //5、返回字节码重组以后的新的代理对象
    }
 }
   

CGLIB代理调用API及原理分析

public class CGlibMeipo implements MethodInterceptor {
    public Object getInstance(Class<?> clazz) throws Exception{
        //相当于Proxy，代理的工具类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }
    private void before(){
        System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
        System.out.println("开始物色");
    }
    private void after(){
        System.out.println("OK的话，准备办事");
    }
}

public class Customer {
    public void findLove(){
        System.out.println("儿子要求：肤白貌美大长腿");
    }
}

CGLIB代理的目标对象不需要实现任何接口，他是通过动态继承目标对象实现动态代理的。

public static void main(String[] args) {
    try {
        //CGLib 有个坑，CGLib不能代理final的方法
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");
        Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
        System.out.println(obj);
        obj.findLove();
    } catch (Exception e) {
        e.printStackTrace();
    }

}

CGLIB和JDK动态代理对比

1. JDK动态代理实现被代理对象的接口，CGLIB代理继承了被代理对象
2. JDK动态代理和CGLIB代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLIB代理使用ASM框架写Class字节码，CGLIB代理实现更复杂，生成代理类比JDK动态代理效率低
3. JDK动态代理调用代理方法是通过反射机制调用的，CGLIB代理是通过FastClass机制直接调用方法的，CGLIB代理的执行效率更高。

代理模式与Spring生态

代理模式在Spring中应用

1. ProxyFactoryBean核心方法getObject()
2. Spring利用动态代理实现AOP时有两个非常重要的类：JdkDynamicAopProxy类和CglibAopProxy类

Spring中的代理选择原则

1. 当Bean有实现接口时，Spring就会用JDK动态代理
2. 当Bean没有实现接口时，Spring会选择CGLIB代理
3. Spring可以通过强制配置使用CGLIB，只需在配置文件中配置

静态代理和动态代理的本质区别

1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。
2. 动态代理采用再运行时动态生成代码方式，取消了对被代理类的扩展限制，遵循开闭原则
3. 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码

代理模式的优缺点

优点：

1. 代理模式能将代理对象与真实被调用目标对象分离
2. 在一定程度上降低了系统的耦合性，扩展性好
3. 可以起到保护目标对象的作用
4. 可以增强目标对象的功能

缺点：

1. 代理模式会造成系统设计中类的数量增加

2. 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢
   Spring中的代理选择原则

3. 当Bean有实现接口时，Spring就会用JDK动态代理

4. 当Bean没有实现接口时，Spring会选择CGLIB代理

5. Spring可以通过强制配置使用CGLIB，只需在配置文件中配置

静态代理和动态代理的本质区别

1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。
2. 动态代理采用再运行时动态生成代码方式，取消了对被代理类的扩展限制，遵循开闭原则
3. 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码

代理模式的优缺点

优点：

1. 代理模式能将代理对象与真实被调用目标对象分离
2. 在一定程度上降低了系统的耦合性，扩展性好
3. 可以起到保护目标对象的作用
4. 可以增强目标对象的功能

缺点：

1. 代理模式会造成系统设计中类的数量增加
2. 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢
3. 增加系统的复杂度