设计模式-4.1代理模式

---

📝 概述

---

📌 代理模式的分类

---

代理模式主要用于控制对某个对象的访问，为其他对象提供一个代理或占位符。根据代理类的创建时机，代理模式可以分为以下几类：

🎯 静态代理

• 描述: 在编译期，代理类就已经被确定下来，通常代理类和被代理类在编译期间就确定了关系。
• 特点:
  • 代理类通常需要手动编写或通过第三方工具生成。
  • 对每一个被代理的方法，代理类都需要提供一个对应的方法。

🎯 动态代理

• 描述: 代理类不是在编译期生成的，而是在运行时动态生成。

1. JDK代理

• 特点:
  • 只能为实现了接口的类生成代理对象。
  • 使用Java的反射技术。
  • 代理类在运行时被创建，不需要手动编写代理类。

2. CGLib代理

• 特点:
  • 可以为没有实现接口的类生成代理对象。
  • 使用第三方CGLib库，基于ASM（高性能Java字节码处理框架）。
  • 在运行时动态生成字节码，并加载到JVM中。

---

⚠️ 注意: 静态代理因为其固定性，通常适用于代理关系不频繁变化的场合；动态代理则更具有灵活性，适用于需要频繁创建代理对象的场合。选择合适的代理方式应根据实际的需求和场景进行决策。

---

📝 结构

• 抽象主题 (Subject):

  • 描述: 定义代理类和实际对象的共同接口。
  • 作用: 使得在任何使用实际对象的地方都可以使用代理对象。

• 真实主题 (Real Subject):

  • 描述: 实际的对象，代理对象代表这个真实对象。
  • 作用: 定义代理对象所要代表的真实对象。

• 代理 (Proxy):

  • 描述: 包含对真实对象的引用，可以访问、控制或扩展真实对象的功能。
  • 作用: 控制对真实对象的访问，并可以在访问前后添加一些附加操作。

---

📝 优缺点

优点:

1. 访问控制: 代理对象可以控制对真实对象的访问，提供了一种访问对象的控制手段。
2. 附加功能: 不改变真实对象的前提下，可以通过代理为其增加一些附加功能。
3. 减少耦合: 代理可以将真实对象与其他代码分离，降低系统的耦合度。
4. 延迟初始化: 代理模式可以用于延迟创建和初始化一个大型对象，直到真正需要时才创建对象。

缺点:

1. 增加系统复杂性: 引入代理类，系统会变得更加复杂。
2. 性能开销: 由于增加了代理对象，特别是在访问频繁时，会导致额外的性能开销。
3. 可能的过度工程: 如果真实对象访问没有任何复杂性，使用代理可能导致设计过度。

---

📝 代码实现

---

📌 静态代理

---

卖火车票的接口

/**
 * @version v1.0
 * @ClassName: SellTickets
 * @Description: 卖火车票的接口
 * @Author: lzq
 */
public interface SellTickets {

    void sell();
}

---

火车站

/**
 * @version v1.0
 * @ClassName: TrainStation
 * @Description: 火车站类
 * @Author: lzq
 */
public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

---

代售点

/**
 * @version v1.0
 * @ClassName: ProxyPoint
 * @Description: 代售点类
 * @Author: lzq
 */
public class ProxyPoint implements SellTickets {

    //声明火车站类对象
    private TrainStation trainStation = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取一些服务费用");
        trainStation.sell();
    }

}

---

客户买票

/**
 * @version v1.0
 * @ClassName: Client
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //创建代售点类对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //调用方法进行买票
        proxyPoint.sell();
    }
}

---

📌 JDK动态代理

---

在Java中，java.lang.reflect.Proxy类提供了一个机制，可以动态地创建代理对象，而无需为每个接口写专门的代理类。这种代理方式称为动态代理。

🎯 核心组件:

• Proxy: Java内置的代理类，不是真正的代理对象。它提供了newProxyInstance方法，用于动态地创建代理对象。

• InvocationHandler接口: 该接口定义了一个invoke方法，它是代理对象调用任何方法时的调用方法。

🎯 执行流程:

1. 创建代理对象: 在测试类中或应用中，我们通过Proxy.newProxyInstance方法来创建代理对象。
2. 调用代理方法: 通过代理对象调用某个方法(例如 sell() 方法)。
3. 转向InvocationHandler: 由于代理对象实现了目标对象的接口，它会将调用重定向到与之关联的InvocationHandler实现类的invoke方法。
4. 执行真实方法: 在InvocationHandler的invoke方法内部，我们可以决定是否调用真正的目标对象方法，或者在调用前后添加其他行为（如日志、安全检查等）。通过反射机制，invoke方法将调用真实对象的方法。

这种动态代理方式具有很大的灵活性，因为它可以动态地为多个接口或类创建代理，而无需编写大量重复的代理类代码。这在很多框架中，例如Spring AOP，都有应用。

---

---

代售点

package com.study.notes.design.patterns.pattern.proxy.jdk_proxy.proxy;

import com.study.notes.design.patterns.pattern.proxy.jdk_proxy.service.SellTickets;
import com.study.notes.design.patterns.pattern.proxy.jdk_proxy.service.impl.TrainStation;

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

/**
 * @version v1.0
 * @ClassName: ProxyFactory
 * @Description: 获取代理对象的工厂类
 * 代理类也实现了对应的接口
 * @Author: lzq
 */
public class ProxyFactory {

    //声明目标对象
    private TrainStation station = new TrainStation();

    //获取代理对象的方法
    public SellTickets getProxyObject() {
        //返回代理对象
        /*
            ClassLoader loader : 类加载器，用于加载代理类。可以通过目标对象获取类加载器
            Class<?>[] interfaces ： 代理类实现的接口的字节码对象
            InvocationHandler h ： 代理对象的调用处理程序
         */
        SellTickets proxyObject = (SellTickets) Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {

                    /*
                        Object proxy : 代理对象。和proxyObject对象是同一个对象，在invoke方法中基本不用
                        Method method ： 对接口中的方法进行封装的method对象
                        Object[] args ： 调用方法的实际参数

                        返回值： 方法的返回值。
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //System.out.println("invoke方法执行了");
                        System.out.println("代售点收取一定的服务费用(jdk动态代理)");
                        //执行目标对象的方法
                        Object obj = method.invoke(station, args);
                        return obj;
                    }
                }
        );
        return proxyObject;
    }
}

---

买票

package com.study.notes.design.patterns.pattern.proxy.jdk_proxy;

import com.study.notes.design.patterns.pattern.proxy.jdk_proxy.proxy.ProxyFactory;
import com.study.notes.design.patterns.pattern.proxy.jdk_proxy.service.SellTickets;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        //1,创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //2,使用factory对象的方法获取代理对象
        SellTickets proxyObject = factory.getProxyObject();
        //3,调用卖调用的方法
        proxyObject.sell();

        System.out.println(proxyObject.getClass());

        //让程序一直执行
        while (true) {
        }

    }
}

---

📌 CGLIB动态代理(子类代理无需实现接口)

---

当目标对象没有实现接口或需要代理的接口太多时，使用JDK动态代理就不太适合了。这时，CGLIB动态代理就是一个很好的选择。

🎯 核心组件:

• Enhancer: CGLIB的核心类，用于生成代理对象。

• MethodInterceptor接口: 该接口定义了一个intercept方法，它是代理对象调用任何方法时的调用方法。

🎯 执行流程:

1. 创建代理对象: 使用Enhancer类并设置相关属性，如目标类、回调等，来创建代理对象。
2. 调用代理方法: 通过代理对象调用某个方法。
3. 转向MethodInterceptor: 由于代理对象是通过增强目标对象类生成的，它会将调用重定向到与之关联的MethodInterceptor实现类的intercept方法。
4. 执行真实方法: 在MethodInterceptor的intercept方法内部，我们可以决定是否调用真正的目标对象方法，或者在调用前后添加其他行为（如日志、安全检查等）。通过反射机制，intercept方法将调用真实对象的方法。

---

CGLIB代理通过使用字节码生成技术，为目标对象创建一个子类，并在子类中覆写目标对象的所有方法，实现对目标对象方法的增强。由于使用的是继承，所以不能代理final修饰的类和方法。CGLIB在许多Java开源框架中都有应用，例如Spring。

⚠️ 注意: 虽然CGLIB代理功能强大，但在性能上可能不如JDK动态代理（特别是在创建代理对象时）。因此，当目标对象实现了接口时，建议优先考虑使用JDK动态代理。

---

---

代售点

package com.study.notes.design.patterns.pattern.proxy.cglib_proxy.proxy;

import com.study.notes.design.patterns.pattern.proxy.cglib_proxy.serivce.TrainStation;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @version v1.0
 * @ClassName: ProxyFactory
 * @Description: 代理对象工厂，用来获取代理对象
 * @Author: lzq
 */
public class ProxyFactory implements MethodInterceptor {

    //声明火车站对象
    private TrainStation station = new TrainStation();

    public TrainStation getProxyObject() {
        //创建Enhancer对象，类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象。指定父类
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return proxyObject;
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //System.out.println("方法执行了");
        System.out.println("代售点收取一定的服务费用(CGLib代理)");
        //要调用目标对象的方法
        Object obj = method.invoke(station, objects);
        return obj;
    }
}

---

买票

package com.study.notes.design.patterns.pattern.proxy.cglib_proxy;

import com.study.notes.design.patterns.pattern.proxy.cglib_proxy.proxy.ProxyFactory;
import com.study.notes.design.patterns.pattern.proxy.cglib_proxy.serivce.TrainStation;

/**
 * @version v1.0
 * @ClassName: Client
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lzq
 */
public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyObject();
        //调用代理对象中的sell方法卖票
        proxyObject.sell();
    }
}

---

📌 三种代理的对比

---

🎯 JDK代理:

• 核心: 使用Java自带的java.lang.reflect.Proxy类进行代理。
• 适用场景: 目标对象基于接口。
• 原理: 生成一个实现目标接口的代理类，所有的方法调用都重定向到InvocationHandler接口的invoke方法。
• 优点:
  1. 无需引入外部依赖。
  2. 从JDK1.8开始，性能优化，比CGLIB高。

🎯 CGLIB代理:

• 核心: 使用字节码增强技术，通过Enhancer类和MethodInterceptor接口进行代理。
• 适用场景: 目标对象没有实现接口或需要代理的接口过多。
• 原理: 生成目标对象的子类作为代理类。
• 优点: 可以代理没有接口的类。
• 缺点: 无法代理final修饰的类和方法。

---

🎯 动态代理:

• 核心: 在运行时生成代理类。
• 优点:
  1. 代码简洁，不需要为每一个方法都写代理逻辑。
  2. 提高维护性，当接口方法增加时，代理类无需修改。
  3. 提供灵活性，可以在一个集中的方法中处理多个接口方法的调用。

🎯 静态代理:

• 核心: 在编译期间确定代理类。
• 优点: 明确，易于理解。
• 缺点:
  1. 代码冗余，每一个方法都需要编写代理逻辑。
  2. 当接口发生变化时，代理类需要同步修改。

---

📝 使用场景

---

代理模式提供了一个占位符来代表另一个对象，从而控制对这个对象的访问。以下是代理模式的一些常见使用场景：

🎯 远程 (Remote) 代理

• 描述: 为一个在不同地址空间的对象提供一个局部的代表。
• 应用场景: 当一个系统中的对象需要与另一个系统中的对象进行通信时，可以使用远程代理。例如，一个本地应用需要访问远程服务器上的数据。
• 优点: 隐藏了网络通信的细节，客户端和服务端可以像本地调用一样进行通信。

🎯 防火墙 (Firewall) 代理

• 描述: 控制网络资源的访问，保护主题免于“坏客户”的侵害。
• 应用场景: 当网络请求需要经过安全检查、过滤或进行内容转换时。
• 优点: 提供了对外部世界的访问控制，可以进行安全检查和内容过滤。

🎯 保护 (Protect or Access) 代理

• 描述: 控制对原始对象的访问，可能给不同的用户提供不同级别的访问权限。
• 应用场景: 当需要控制对某个对象的访问权限时，例如数据库的读写权限。
• 优点: 提供了对原始对象的访问控制，可以定义不同级别的权限。

---

⚠️ 注意: 代理模式的目的是提供一个代理对象，以控制对另一个对象的访问。不同的代理场景提供了不同的访问控制，选择合适的代理模式应根据实际的需求和场景进行决策。

---