📝 概述
📌 代理模式的分类
代理模式主要用于控制对某个对象的访问,为其他对象提供一个代理或占位符。根据代理类的创建时机,代理模式可以分为以下几类:
🎯 静态代理
- 描述: 在编译期,代理类就已经被确定下来,通常代理类和被代理类在编译期间就确定了关系。
- 特点:
- 代理类通常需要手动编写或通过第三方工具生成。
- 对每一个被代理的方法,代理类都需要提供一个对应的方法。
🎯 动态代理
- 描述: 代理类不是在编译期生成的,而是在运行时动态生成。
1. JDK代理
- 特点:
- 只能为实现了接口的类生成代理对象。
- 使用Java的反射技术。
- 代理类在运行时被创建,不需要手动编写代理类。
2. CGLib代理
- 特点:
- 可以为没有实现接口的类生成代理对象。
- 使用第三方CGLib库,基于ASM(高性能Java字节码处理框架)。
- 在运行时动态生成字节码,并加载到JVM中。
⚠️ 注意: 静态代理因为其固定性,通常适用于代理关系不频繁变化的场合;动态代理则更具有灵活性,适用于需要频繁创建代理对象的场合。选择合适的代理方式应根据实际的需求和场景进行决策。
📝 结构
-
抽象主题 (Subject):
- 描述: 定义代理类和实际对象的共同接口。
- 作用: 使得在任何使用实际对象的地方都可以使用代理对象。
-
真实主题 (Real Subject):
- 描述: 实际的对象,代理对象代表这个真实对象。
- 作用: 定义代理对象所要代表的真实对象。
-
代理 (Proxy):
- 描述: 包含对真实对象的引用,可以访问、控制或扩展真实对象的功能。
- 作用: 控制对真实对象的访问,并可以在访问前后添加一些附加操作。
📝 优缺点
优点:
- 访问控制: 代理对象可以控制对真实对象的访问,提供了一种访问对象的控制手段。
- 附加功能: 不改变真实对象的前提下,可以通过代理为其增加一些附加功能。
- 减少耦合: 代理可以将真实对象与其他代码分离,降低系统的耦合度。
- 延迟初始化: 代理模式可以用于延迟创建和初始化一个大型对象,直到真正需要时才创建对象。
缺点:
- 增加系统复杂性: 引入代理类,系统会变得更加复杂。
- 性能开销: 由于增加了代理对象,特别是在访问频繁时,会导致额外的性能开销。
- 可能的过度工程: 如果真实对象访问没有任何复杂性,使用代理可能导致设计过度。
📝 代码实现
📌 静态代理
卖火车票的接口
/**
* @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
方法,它是代理对象调用任何方法时的调用方法。
🎯 执行流程:
- 创建代理对象: 在测试类中或应用中,我们通过
Proxy.newProxyInstance
方法来创建代理对象。 - 调用代理方法: 通过代理对象调用某个方法(例如
sell()
方法)。 - 转向InvocationHandler: 由于代理对象实现了目标对象的接口,它会将调用重定向到与之关联的
InvocationHandler
实现类的invoke
方法。 - 执行真实方法: 在
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
方法,它是代理对象调用任何方法时的调用方法。
🎯 执行流程:
- 创建代理对象: 使用
Enhancer
类并设置相关属性,如目标类、回调等,来创建代理对象。 - 调用代理方法: 通过代理对象调用某个方法。
- 转向MethodInterceptor: 由于代理对象是通过增强目标对象类生成的,它会将调用重定向到与之关联的
MethodInterceptor
实现类的intercept
方法。 - 执行真实方法: 在
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
方法。 - 优点:
- 无需引入外部依赖。
- 从JDK1.8开始,性能优化,比CGLIB高。
🎯 CGLIB代理:
- 核心: 使用字节码增强技术,通过
Enhancer
类和MethodInterceptor
接口进行代理。 - 适用场景: 目标对象没有实现接口或需要代理的接口过多。
- 原理: 生成目标对象的子类作为代理类。
- 优点: 可以代理没有接口的类。
- 缺点: 无法代理
final
修饰的类和方法。
🎯 动态代理:
- 核心: 在运行时生成代理类。
- 优点:
- 代码简洁,不需要为每一个方法都写代理逻辑。
- 提高维护性,当接口方法增加时,代理类无需修改。
- 提供灵活性,可以在一个集中的方法中处理多个接口方法的调用。
🎯 静态代理:
- 核心: 在编译期间确定代理类。
- 优点: 明确,易于理解。
- 缺点:
- 代码冗余,每一个方法都需要编写代理逻辑。
- 当接口发生变化时,代理类需要同步修改。
📝 使用场景
代理模式提供了一个占位符来代表另一个对象,从而控制对这个对象的访问。以下是代理模式的一些常见使用场景:
🎯 远程 (Remote) 代理
- 描述: 为一个在不同地址空间的对象提供一个局部的代表。
- 应用场景: 当一个系统中的对象需要与另一个系统中的对象进行通信时,可以使用远程代理。例如,一个本地应用需要访问远程服务器上的数据。
- 优点: 隐藏了网络通信的细节,客户端和服务端可以像本地调用一样进行通信。
🎯 防火墙 (Firewall) 代理
- 描述: 控制网络资源的访问,保护主题免于“坏客户”的侵害。
- 应用场景: 当网络请求需要经过安全检查、过滤或进行内容转换时。
- 优点: 提供了对外部世界的访问控制,可以进行安全检查和内容过滤。
🎯 保护 (Protect or Access) 代理
- 描述: 控制对原始对象的访问,可能给不同的用户提供不同级别的访问权限。
- 应用场景: 当需要控制对某个对象的访问权限时,例如数据库的读写权限。
- 优点: 提供了对原始对象的访问控制,可以定义不同级别的权限。
⚠️ 注意: 代理模式的目的是提供一个代理对象,以控制对另一个对象的访问。不同的代理场景提供了不同的访问控制,选择合适的代理模式应根据实际的需求和场景进行决策。