代理模式
概述
由于某些原因需要给某对象提供一个代理以控制的对该对象的访问。这时，访问对象不适合或者不能直接应用目标对象，代理对象作为访问对象和目标对象之间的中介。
Java 中代理按照代理类生成的时机不同又分为静态代理和动态代理。静态代理代理类在编译器就生成，而动态代理代理类则是在Java 运行时动态生成，动态代理又有 JDK代理和 CGLib代理两种
结构
代理 (proxy) 模式分为三种角色：
- 抽象主题类 (Subject) ：通过接口或抽象类声明 真实主题 和 代理对象 实现的业务方法
- 真实主题类 (Real Subject)：实现 抽象主题类 中的具体业务，是 代理对象 所代表的真实对象，是最终要引用的对象
- 代理类 (Proxy)：提供与 真实主题 相同的接口，其内部含有对 真实主题 的引用，可以访问，控制或扩展 真实主题 的功能
静态代理
火车站售票：如果要去火车站买票，需要坐车到火车站，排队，取票等等一系列操作，显然比较麻烦，而火车站在多个地方都有代售点，我们去代售点买票就方便多了，
使用代理模式，火车站是目标对象，代售点是代理对象，类图如下：
代码实现：
Ticket 类：抽象主题类
package com.atguigu.proxy.static_proxy;
//买票 退票的接口
public interface Ticket {
//买票
void sell(String city);
//退票
void concel(String city);
}
TrainStation 类：真实主题类
package com.atguigu.proxy.static_proxy;
//火车类
public class TrainStation implements Ticket{
@Override
public void sell(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已订购");
}
@Override
public void concel(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已取消");
}
}
ProxyPoint 类：代理类
package com.atguigu.proxy.static_proxy;
//代售点类
public class ProxyPoint implements Ticket{
//声明火车站对象
private TrainStation trainStation = new TrainStation();
@Override
public void sell(String city) {
System.out.println("代理点收取服务费用");
trainStation.sell(city);
}
@Override
public void concel(String city) {
System.out.println("代理点收取服务费用");
trainStation.concel(city);
}
}
Client 类：测试类
package com.atguigu.proxy.static_proxy;
public class Client {
public static void main(String[] args) {
//创建代理对象
ProxyPoint proxyPoint = new ProxyPoint();
//调用方法进行操作
proxyPoint.sell("长沙");
proxyPoint.concel("长沙");
proxyPoint.sell("武汉");
}
}
代理点收取服务费用
火车站：您前往长沙的火车票已订购
代理点收取服务费用
火车站：您前往长沙的火车票已取消
代理点收取服务费用
火车站：您前往武汉的火车票已订购
从上面的代码中可以看出测试类直接访问的是 ProxyPoint 类对象，也就是说 ProxyPoint 作为访问对象和目标对象的中介，同时也对 目标对象中的方法进行增强
JDK动态代理
使用动态代理实现上面案例，JDK动态代理：Java中提供了一个动态代理类 Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法 (newProxyInstance方法) 开获取代理对象
代码实现：
Ticket 类：抽象主题
package com.atguigu.proxy.jdk_proxy;
//买票 退票的接口
public interface Ticket {
//买票
void sell(String city);
//退票
void concel(String city);
}
TrainStation 类：具体主题类
package com.atguigu.proxy.jdk_proxy;
//火车类
public class TrainStation implements Ticket {
@Override
public void sell(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已订购");
}
@Override
public void concel(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已取消");
}
}
ProxyFactory 类：代理工厂类，getProxyObject()：返回代理对象 注意此方法的实现
package com.atguigu.proxy.jdk_proxy;
//获取代理对象的工厂类
//注意：工厂类也实现了 Ticket 接口
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyFactory {
//声明目标对象
private TrainStation trainStation = new TrainStation();
//返回代理对象
public Ticket getProxyObject(){
/*
ClassLoader loader:类加载器,用于加载代理类 可以通过目标对象获取类加载器
定义由哪个classloader对象对生成的代理类进行加载
Class<?>[] interfaces:代理类实现接口的字节码对象
InvocationHandler h:代理对象的调用处理程序
*/
Ticket proxyObject = (Ticket) Proxy.newProxyInstance(
trainStation.getClass().getClassLoader(),
trainStation.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("代售点收取一定的服务费用(jdk动态代理)");
//执行目标对象的方法
Object obj = method.invoke(trainStation, args);
return obj;
}
}
);
return proxyObject;
}
}
Client 类：测试类
package com.atguigu.proxy.jdk_proxy;
public class Client {
public static void main(String[] args) {
//创建代理工厂对象
ProxyFactory factory = new ProxyFactory();
//获取代理对象
Ticket proxyObject = factory.getProxyObject();
//调用方法进行操作
proxyObject.sell("长沙");
proxyObject.concel("长沙");
proxyObject.sell("武汉");
}
}
代售点收取一定的服务费用(jdk动态代理)
火车站：您前往长沙的火车票已订购
代售点收取一定的服务费用(jdk动态代理)
火车站：您前往长沙的火车票已取消
代售点收取一定的服务费用(jdk动态代理)
火车站：您前往武汉的火车票已订购
分析源码：(保留重要内容)
public final class $Proxy0 entends Proxy implements Ticket{
private static Method m3;
private static Method m4;
public $Proxy0(InvocationHandler invocationHandler){
super(invocationHandler);
}
static{
m3 = Class.forName(" com.atguigu.proxy.jdk_proxy.Ticket").getMethod("sell",new Class[0]);
m4 = Class.forName(" com.atguigu.proxy.jdk_proxy.Ticket").getMethod("concel",new Class[0]);
}
public final void sell(){
this.h.invoke(this,m3,null);
}
public final void cocel(){
this.h.invoke(this,m4,null);
}
}
public class Proxy{
protected InvocationHandler h;
}
从上面的代码中，我们可以看到以下信息：
- 代理类 ($Proxy0) 实现了 Ticket，即真实类和代理类实现同样的接口
- 代理类 ($Proxy0) 将我们提供的的匿名内部类对象传递给了父类
动态代理的执行流程：以 sell() 方法为例
- 在测试类中通过代理对象调用 sell() 方法
- 根据多态的特性，执行的是代理类 ($Proxy0) 中 的 sell() 方法
- 代理类 ($Proxy0) 中的 sell() 方法调用 InvocationHandler 接口的子实现类对象的 invoke() 方法
- invoke() 通过反射执行真实对象所属类 (TrainStation) 的 sell()
CGLib动态代理
CGLib动态代理：如果没有定义 Ticket 接口，知识定义 TrainStation(火车站类)，很显然 JDK代理无法使用，因为 JDK动态代理要求必须定义接口，对接口进行处理
CGLib是一个功能强大，高性能的代码生产包，它为没有实现接口的类提供代理，为 JDK动态代理提供很好的补充
CGLib是第三方提供的包，需要导入jar包
- 在 https://mvnrepository.com/ 上搜索下载
- 在 酷码派(开发资源) 上搜索下载
顺便吐槽一句，csdn下载jar包真*******
模块上做CGLib动态代理需要 cglib.jar 和 asm.jar maven上只需要 cglib.jar
代码实现：
TrainStation 类：目标类
package com.atguigu.proxy.CGLib_proxy;
//火车类
public class TrainStation {
public void sell(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已订购");
}
public void concel(String city) {
System.out.println("火车站：您前往" + city
+ "的火车票已取消");
}
}
ProxyFactory 类：代理工厂类，getProxyObject() 返回代理对象
package com.atguigu.proxy.CGLib_proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
//代理工厂类
//提供方法返回代理对象
public class ProxyFactory implements MethodInterceptor {
//声明 TrainStation 对象
private TrainStation trainStation = new TrainStation();
public TrainStation getProxyObject(){
//创建 Enhancer对象,类似于JDK代理的Proxy类
Enhancer enhancer = new Enhancer();
//设置父类的字节码对象
//注意：代理类是目标类的子类
enhancer.setSuperclass(trainStation.getClass());
//设置回调函数
enhancer.setCallback(this);
//创建代理对象
TrainStation proxyObject = (TrainStation)enhancer.create();
return proxyObject;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("代售点收取一定的服务费用(CGLib动态代理)");
Object obj = method.invoke(trainStation, objects);
return obj;
}
}
Client 类：测试类
package com.atguigu.proxy.CGLib_proxy;
public class Client {
public static void main(String[] args) {
//创建代理工厂类对象
ProxyFactory factory = new ProxyFactory();
//获取代理类对象
//代理类是目标类的子类
TrainStation proxyObject = factory.getProxyObject();
//调用方法 进行操作
proxyObject.sell("长沙");
proxyObject.concel("长沙");
proxyObject.sell("武汉");
}
}
代售点收取一定的服务费用(CGLib动态代理)
火车站：您前往长沙的火车票已订购
代售点收取一定的服务费用(CGLib动态代理)
火车站：您前往长沙的火车票已取消
代售点收取一定的服务费用(CGLib动态代理)
火车站：您前往武汉的火车票已订购
三种代理的对比
jdk代理 vs CGLib代理
- CGLib 不能对声明为 final 的类或者方法进行代理，原因CGLib原理是动态生成被代理类
- 有接口使用 jdk代理，没有接口使用CGLib代理
动态代理 vs 静态代理
- 动态代理：接口中声明的所有方法都被转移道调用处理器中一个集中的方法中进行处理
- 静态代理需要为每一个方法进行处理，假如接口中增加方法，所有实现类和代理类均需要实现此方法，增加代理维护的复杂度
总结
优点：
- 代理模式在客户端和目标对象之间起到一个中介作用和保护目标对象的作用
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离，在一定程度上降低系统的耦合度
缺点：
- 增加系统的复杂度
使用场景
- 远程代理，防火墙模式，保护代理