Spring6 -（14）GoF之代理模式

1. 对代理模式的理解

场景：拍电影的时候，演员找替身演员，这就是一个代理模式

替身演员 去代理 演员 完成表演

思考：演员为什么要找替身呢？（为什么要使用代理模式呢？）

• 第一个原因：怕自己受伤，找个替身（保护自己）
• 第二个原因：自己完成不来这种高难度的动作，替身演员可以完成（功能增强）
• A对象无法和B对象直接交互时，也可以使用代理模式来解决

Java程序中的代理模式的作用：

• 当一个对象需要受到保护的时候，可以考虑使用代理对象去完成某个行为
• 需要给某个对象的功能个进行增强的时候，可以考虑找一个代理进行增强

代理模式中有一个非常重要的特点：对于客户端程序来说，使用代理对象时就像在使用目标对象一样。【在程序中，目标需要被保护时】

代理模式中有三大角色：

• 目标对象（演员）
• 代理对象（替身演员）
• 目标对象和代理对象的公共接口（演员和替身演员应该具有相同的行为动作）

为什么演员和替身演员要有相同的行为动作呢？

是因为不想让观众知道是替身演员。这里的观众其实就是“客户端程序”，如果你使用代理模式的话，对应客户端程序来所，客户端是无法察觉到的，客户端在使用代理对象的时候就象在使用目标对象。

代理模式的类图：

代理模式在代码实现上，包括两种形式：

• 静态代理
• 动态代理

2. 静态代理

代理类是程序员提前写好的，成为静态代理

下面是静态动力的演示：

定义一个接口：OrderService

package com.julissa.proxy.service;public interface OrderService {/* 生成订单*/void generate();/* 查看订单详情*/void detail();/* 修改订单*/void modify();
}

定义接口的实现类：OrderServiceImpl

package com.julissa.proxy.service;public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {//模拟生成订单的耗时try {Thread.sleep(1234);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成");}@Overridepublic void detail() {//模拟查看订单的耗时try {Thread.sleep(2541);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单信息如下：");}@Overridepublic void modify() {//模拟修改订单的耗时try {Thread.sleep(1010);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改");}
}

客户端程序：

package com.julissa.proxy.client;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;public class Test {public static void main(String[] args) {OrderService orderService = new OrderServiceImpl();orderService.generate();orderService.modify();orderService.detail();}
}

其中Thread.sleep()方法的调用是为了模拟操作耗时。

项目已上线，并且运行正常，只是客户反馈系统有一些地方运行较慢，要求项目组对系统进行优化。于是项目负责人就下达了这个需求。首先需要搞清楚是哪些业务方法耗时较长，于是让我们统计每个业务方法所耗费的时长。如果是你，你该怎么做呢？

第一种方案：直接修改Java源代码，在每个业务方法中添加统计逻辑，如下：

package com.julissa.proxy.service;public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {//模拟生成订单的耗时long begin = System.currentTimeMillis();try {Thread.sleep(1234);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成");long end = System.currentTimeMillis();System.out.println("耗费时长"+(end - begin)+"毫秒");}@Overridepublic void detail() {//模拟查看订单的耗时long begin = System.currentTimeMillis();try {Thread.sleep(2541);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单信息如下：");long end = System.currentTimeMillis();System.out.println("耗费时长"+(end - begin)+"毫秒");}@Overridepublic void modify() {//模拟修改订单的耗时long begin = System.currentTimeMillis();try {Thread.sleep(1010);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改");long end = System.currentTimeMillis();System.out.println("耗费时长"+(end - begin)+"毫秒");}
}

需求可以满足，但显然是违背了OCP开闭原则,而且代码没有得到复用，这种方案不可取。

第二种方案：编写一个子类继承OrderServiceImpl，在子类中重写每个方法，代码如下：

package com.julissa.proxy.service;public class OrderServiceImplSub extends OrderServiceImpl{@Overridepublic void generate() {long begin = System.currentTimeMillis();super.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}@Overridepublic void detail() {long begin = System.currentTimeMillis();super.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}@Overridepublic void modify() {long begin = System.currentTimeMillis();super.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}
}

这种方式可以解决，但是存在两个问题：

• 第一个问题：假设系统中有100个这样的业务类，需要提供100个子类，并且之前写好的创建Service对象的代码，都要修改为创建子类对象。
• 第二个问题：由于采用了继承的方式，导致代码之间的耦合度较高。

这种方案也不可取。

第三种方案：使用代理模式（这里采用静态代理）

可以为OrderService接口提供一个代理类。

package com.julissa.proxy.service;public class OrderServiceProxy implements OrderService{// 代理对象（代理对象和目标对象要有相同的行为或方法，所有要实现公共接口）// 将目标对象作为代理对象的属性，这种关系叫做关联关系，比继承关系的耦合度低private OrderService orderService;// 通过构造方法将目标对象传递给代理对象public OrderServiceProxy(OrderService orderService) {this.orderService = orderService;}@Overridepublic void generate() {// 代理方法//增强long begin = System.currentTimeMillis();// 执行目标对象的目标方法orderService.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}@Overridepublic void detail() {// 代理方法//增强long begin = System.currentTimeMillis();// 执行目标对象的目标方法orderService.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}@Overridepublic void modify() {// 代理方法//增强long begin = System.currentTimeMillis();// 执行目标对象的目标方法orderService.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");}
}

这种方式的优点：符合OCP开闭原则，同时采用的是关联关系，所以程序的耦合度较低。所以这种方案是被推荐的。

编写客户端程序：

package com.julissa.proxy.client;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.OrderServiceProxy;public class Client {public static void main(String[] args) {// 创建目标对象OrderService target = new OrderServiceImpl();// 创建代理对象OrderService proxy = new OrderServiceProxy(target);// 调用代理对象的代理方法proxy.generate();proxy.modify();proxy.detail();}
}

运行结果：

以上就是代理模式中的静态代理，其中OrderService接口是代理类和目标类的共同接口。OrderServiceImpl是目标类。OrderServiceProxy是代理类。

大家思考一下：如果系统中业务接口很多，一个接口对应一个代理类，显然也是不合理的，会导致类爆炸。怎么解决这个问题？动态代理可以解决。因为在动态代理中可以在内存中动态的为我们生成代理类的字节码。代理类不需要我们写了。类爆炸解决了，而且代码只需要写一次，代码也会得到复用。

3. 动态代理

在程序运行阶段，在内存中动态生成代理类，被称为动态代理，目的是为了减少代理类的数量。解决代码复用的问题。

在内存当中动态生成类的技术常见的包括：

• JDK动态代理技术：只能代理接口。
• CGLIB动态代理技术：CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。它既可以代理接口，又可以代理类，底层是通过继承的方式实现的。性能比JDK动态代理要好。（底层有一个小而快的字节码处理框架ASM。）
• Javassist动态代理技术：Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码JBoss 应用服务器项目，通过使用Javassist对字节码操作为JBoss实现动态"AOP"框架。

3.1 JDK动态代理

还是使用静态代理中的例子：一个接口和一个实现类。

OrderService

package com.julissa.proxy.service;public interface OrderService {/* 生成订单*/void generate();/* 查看订单详情*/void detail();/* 修改订单*/void modify();
}

OrderServiceImpl

package com.julissa.proxy.service;public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {//模拟生成订单的耗时try {Thread.sleep(1234);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成");}@Overridepublic void detail() {//模拟查看订单的耗时try {Thread.sleep(2541);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单信息如下：");}@Overridepublic void modify() {//模拟修改订单的耗时try {Thread.sleep(1010);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改");}
}

我们在静态代理的时候，除了以上一个接口和一个实现类之外，还需要写一个代理类UserServiceProxy！

在动态代理中UserServiceProxy代理类是可以动态生成的。这个类不需要写。我们直接写客户端程序即可：

package com.julissa.proxy.client;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;import java.lang.reflect.Proxy;public class Client {public static void main(String[] args) {//创建目标对象OrderService target = new OrderServiceImpl();//创建代理对象Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),调用处理器对象)//调用代理对象的代理方法}
}

OrderService orderServiceProxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), 调用处理器对象);

这行代码做了两件事：

• 第一件事：在内存中生成了代理类的字节码class
• 第二件事：创建代理对象

Proxy类全名：java.lang.reflect.Proxy。这是JDK提供的一个类（所以称为JDK动态代理）。主要是通过这个类在内存中生成代理类的字节码。

其中newProxyInstance()方法有三个参数：

• 第一个参数：类加载器。在内存中生成了字节码，要想执行这个字节码，也是需要先把这个字节码加载到内存当中的，加载类就需要类加载器，并且JDK要求，目标类的的类加载器类和代理类的类加载器要使用同一个。
• 第二个参数：接口类型。代理类和目标类实现相同的接口，所以要通过这个参数告诉JDK动态代理生成的类要实现哪些接口。
• 第三个参数：调用处理器。这是一个JDK动态代理规定的接口，接口全名：java.lang.reflect.InvocationHandler。显然这是一个回调接口，也就是说调用这个接口中方法的程序已经写好了，就差这个接口的实现类了，在调用处理器接口编写的代码，就是增强代码。

所以接下来我们要写一下java.lang.reflect.InvocationHandler接口的实现类，并且实现接口中的方法，代码如下：

package com.julissa.proxy.service;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class TimerInvocationHandler implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}
}

InvocationHandler接口中有一个方法invoke，这个invoke方法上有三个参数：

• 第一个参数：Object proxy。代理对象。设计这个参数只是为了后期的方便，如果想在invoke方法中使用代理对象的话，尽管通过这个参数来使用。
• 第二个参数：Method method。目标对象上的目标方法（要执行的目标方法就是它）。
• 第三个参数：Object[] args。目标方法调用时要传的参数。

我们将来肯定是要调用“目标方法”的，但要调用目标方法的话，需要“目标对象”的存在，“目标对象”从哪儿来呢？我们可以给TimerInvocationHandler提供一个构造方法，可以通过这个构造方法传过来“目标对象”，代码如下：

package com.julissa.proxy.service;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class TimerInvocationHandler implements InvocationHandler {// 目标对象private Object target;// 通过构造方法来传目标对象public TimerInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return null;}
}

有了目标对象我们就可以在invoke()方法中调用目标方法了。代码如下：

package com.julissa.proxy.service;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class TimerInvocationHandler implements InvocationHandler {// 目标对象private Object target;// 通过构造方法来传目标对象public TimerInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 目标执行之前增强。long begin = System.currentTimeMillis();// 调用目标对象的目标方法//四要素：那个对象，哪个方法，什么参数。返回什么值Object retValue = method.invoke(target, args);// 目标执行之后增强。long end = System.currentTimeMillis();System.out.println("耗时"+(end - begin)+"毫秒");// 一定要记得返回return retValue;}
}

到此为止，调用处理器就完成了。接下来，应该继续完善Client程序：

package com.julissa.proxy.client;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.TimerInvocationHandler;import java.lang.reflect.Proxy;public class Client {public static void main(String[] args) {//创建目标对象OrderService target = new OrderServiceImpl();//创建代理对象//实现了OrderService接口，所以可以向下转型OrderService proxyObj =(OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimerInvocationHandler(target));//调用代理对象的代理方法proxyObj.generate();proxyObj.detail();proxyObj.modify();}
}

运行客户端程序

InvocationHandler接口中的invoke()方法什么时候被调用？

注意：当你调用代理对象的代理方法的时候，注册在InvocationHandler接口中的invoke()方法会被调用，注册在InvocationHandler接口中的invoke()方法都会被调用。

可以看到，不管你有多少个Service接口，多少个业务类，这个TimerInvocationHandler接口是不是只需要写一次就行了，代码是不是得到复用了

而且最重要的是，以后程序员只需要关注核心业务的编写了，像这种统计时间的代码根本不需要关注。因为这种统计时间的代码只需要在调用处理器中编写一次即可。

到这里，JDK动态代理的原理就结束了。

不过我们看以下这个代码确实有点繁琐，对于客户端来说，用起来不方便：

我们可以提供一个工具类：ProxyUtil，封装一个方法：

package com.julissa.proxy.utils;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.TimerInvocationHandler;import java.lang.reflect.Proxy;public class ProxyUtil {/* 获取代理对象* @param target 目标对象* @return 代理对象*/public static OrderService getProxyObj(Object target){//底层调用JDK动态代理OrderService proxyObj =(OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new TimerInvocationHandler(target));return proxyObj;}
}

这样客户端代码就不需要写那么繁琐了：

package com.julissa.proxy.client;import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.TimerInvocationHandler;
import com.julissa.proxy.utils.ProxyUtil;import java.lang.reflect.Proxy;public class Client {public static void main(String[] args) {//创建目标对象OrderService target = new OrderServiceImpl();//创建代理对象//实现了OrderService接口，所以可以向下转型OrderService proxyObj = ProxyUtil.getProxyObj(target);//调用代理对象的代理方法proxyObj.generate();proxyObj.detail();proxyObj.modify();}
}

3.2 CGLIB动态代理

CGLIB既可以代理接口，又可以代理类。底层采用继承的方式实现。所以被代理的目标类不能使用final修饰。

使用CGLIB，需要引入它的依赖：

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version>
</dependency>			

我们准备一个没有实现接口的类，如下：

package com.julissa.proxy.service;/* 目标类*/
public class UserService {/* 用户登陆* @param username 用户名* @param password 密码* @return 登陆结果*/public Boolean login(String username, String password){System.out.println("系统正砸验证信息");if ("admin".equals(username) && "123456".equals(password)) {return true;}return false;}/* 用户注销*/public void logout(){System.out.println("用户退出");}
}

使用CGLIB在内存中为UserService类生成代理类，并创建对象

package com.julissa.proxy.client;import com.julissa.proxy.service.UserService;
import net.sf.cglib.proxy.Enhancer;/* 客户端程序*/
public class Client2 {public static void main(String[] args) {// 创建字节码增强器// 这个对象是CGLib库中的核心对象，就是依靠它生成代理类Enhancer enhancer = new Enhancer();// 告诉cglib要继承哪个类enhancer.setSuperclass(UserService.class);// 设置回调函数(等同于JDK动态代理的调用处理器)enhancer.setCallback(new UserServiceInterceptor());// 创建代理对象// 这一步会做两件事：// 1.在内存中生成UserService的子类，其实就是代理类的字节码// 2. 创建代理对象UserService userService = (UserService) enhancer.create();// 调用代理对象的方法Boolean aBoolean = userService.login("admin", "123456");System.out.println(aBoolean?"登陆成功":"登陆失败");userService.logout();}
}

编写MethodInterceptor接口实现类：

package com.julissa.proxy.service;import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class UserServiceInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {// 前增强long begin = System.currentTimeMillis();// 调用目标Object retValue = methodProxy.invokeSuper(target, objects);// 后增强long end = System.currentTimeMillis();System.out.println("耗时" + (end - begin) + "毫秒");// 一定要返回return retValue;}
}

MethodInterceptor接口中有一个方法intercept()，该方法有4个参数：

第一个参数：目标对象

第二个参数：目标方法

第三个参数：目标方法调用时的实参

第四个参数：代理方法

对于高版本的JDK，如果使用CGLIB，需要在启动项中添加两个启动参数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7WCayQAn-1679894878459)(null)]

• –add-opens java.base/java.lang=ALL-UNNAMED
• –add-opens java.base/sun.net.util=ALL-UNNAMED

运行客户端程序