设计模式-结构型模式-代理模式

概述

代理模式: Proxy Pattern : 是一种结构型设计模式.
它允许你提供一个替代对象来代表真实对象，以此控制对真实对象的访问。
通过代理对象，可以在不改变目标对象的前提下，扩展其功能或控制对其的访问。

简单理解 ： 代理模式就是一个中间人，通过中间人调用真实的目标对象。

根据代理的类型，可以分为 静态代理和动态代理。
其中动态代理 又可以根据实现方式的不同分为 jdk动态代理 和 cglib 动态代理。

角色

1、抽象主题（Subject）
定义了代理和实际主题的公共接口，以便任何使用实际主题的地方都可以使用代理而无需修改代码。这通常是接口或抽象类。

2、真实主题（Real Subject）
实现了抽象主题定义的接口，包含了实际业务逻辑。这是被代理的对象。

3、代理（Proxy）
也实现了抽象主题定义的接口，并持有一个对真实主题的引用。
代理负责在必要时创建和删除真实主题实例，并在调用真实主题的方法前或后添加额外的行为（例如：权限检查、日志记录等）。

静态代理

静态代理是代理模式的一种实现方式.
它的特点是：代理类在编译时就已经存在，并且代理类与目标类都实现了相同的接口。
（代码固定、实现接口）
就是 ： 通过直接写一个代理类的方式来代理目标对象。

案例描述

有一个 UserService  的服务接口，有一个方法 queryUserInfo，可以实现 对 用户信息的查询操作。
有一个具体的实现类 UserServiceImpl ，实现该接口，完成数据库的信息查询。
此时，有一个代理类，UserServiceProxy , 实现该接口，并代理实现类 UserServiceImpl，实现在用户信息查询之前的日志打印操作。
最终，客户端调用的时候，使用 代理类完成操作。

类图

具体实现

接口

public interface UserService {void queryUserInfo(String userId);
}

实现类-被代理类

public class UserServiceImpl implements UserService{@Overridepublic void queryUserInfo(String userId) {System.out.println(" 模拟查询用户信息的数据库 ： 查询的是 ： "+userId);}
}

实现类-代理类

public class UserServiceProxy implements UserService{/*** 被代理的对象*/private UserService userService;public UserServiceProxy(UserService userService) {this.userService = userService;}@Overridepublic void queryUserInfo(String userId) {// 添加日志System.out.println("代理类 - 添加 日志  begin");// 业务逻辑 ： 执行原来被代理类的业务逻辑userService.queryUserInfo(userId);// 添加日志System.out.println("代理类 - 添加 日志  end");}
}

客户端

public class Client {public static void main(String[] args) {// 创建目标对象（被代理对象）UserService userService = new UserServiceImpl();// 创建代理对象UserServiceProxy userServiceProxy = new UserServiceProxy(userService);// 通过代理对象执行对应的方法userServiceProxy.queryUserInfo("10001");}
}

运行结果：
代理类 - 添加 日志  begin模拟查询用户信息的数据库 ： 查询的是 ： 10001
代理类 - 添加 日志  end

动态代理-JDK动态代理

JDK 动态代理 是一种基于反射机制的代理模式实现方式。
与静态代理不同，动态代理不需要手动编写代理类，而是在运行时动态生成代理对象。
被代理的类，需要实现接口！
它通过 java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler 实现。

核心概念

Proxy 类
提供了创建动态代理对象的方法（如 Proxy.newProxyInstance()）。

InvocationHandler 接口
定义了一个方法 invoke()，用于拦截对代理对象方法的调用。在 invoke() 方法中可以添加额外逻辑（如权限检查、日志记录等）。

特点
动态生成：代理类在运行时动态生成，无需手动编写代码。
依赖接口：目标类必须实现接口，动态代理只能代理接口中的方法。

案例描述

有一个 UserService  的服务接口，有一个方法 queryUserInfo，可以实现 对 用户信息的查询操作。
有一个具体的实现类 UserServiceImpl ，实现该接口，完成数据库的信息查询。
此时，有一个代理类，UserServiceProxyHandler, 实现InvocationHandler接口，在 invoke 方法中调用目标类的方法。
最终，客户端调用的时候，使用 代理类完成操作。

类图

具体实现

接口

public interface UserService {String queryUserInfoWithReturn(String userId);
}

具体实现

public class UserServiceImpl implements UserService{@Overridepublic String queryUserInfoWithReturn(String userId) {System.out.println(" 模拟查询用户信息的数据库-带返回值 ： 查询的是 ： "+userId);return "被代理类的返回值-helloworld";}}

代理类

这里用到的是 reflect 反射的包中的内容。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class UserServiceProxyHandler implements InvocationHandler {/*** 被代理对象*/private Object target;public UserServiceProxyHandler(Object target) {this.target = target;}// todo 核心的代理方法@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代理类 - 添加日志 - 开始");// 通过反射的方式调用目标方法Object result = method.invoke(target, args);System.out.println("代理类 - 添加日志 - 结束");return result;}
}

客户端

public class Client {public static void main(String[] args) {// 创建目标对象（被代理对象）UserService userService = new UserServiceImpl();// 创建代理对象-jdk动态代理 , 强转一下类型即可UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),userService.getClass().getInterfaces(),new UserServiceProxyHandler(userService));// 通过代理对象执行对应的方法String s = userServiceProxy.queryUserInfoWithReturn("10001");System.out.println("s = " + s);}
}

运行结果：
代理类 - 添加日志 - 开始模拟查询用户信息的数据库-带返回值 ： 查询的是 ： 10001
代理类 - 添加日志 - 结束
s = 被代理类的返回值-helloworld

动态代理-CGLib代理

核心概念

CGLIB（Code Generation Library）动态代理 是一种基于字节码生成技术的代理模式实现方式。与 JDK 动态代理不同，CGLIB 不需要目标类实现接口，而是通过继承的方式动态生成目标类的子类，并在子类中拦截方法调用。

CGLIB 的工作原理
CGLIB 通过 ASM 字节码生成库，在运行时动态生成目标类的子类。
子类会重写目标类的方法，并在方法调用前后插入额外逻辑（如日志记录、权限检查等）。

特点
无需接口：目标类不需要实现任何接口。
依赖继承：通过继承目标类生成代理类，因此目标类不能是 final 类或包含 final 方法。
性能较高：相比反射机制，CGLIB 的性能通常更高。

使用场景

• 当目标类没有实现接口时，JDK 动态代理无法使用，而 CGLIB 是一个很好的替代方案。
• 需要对目标类的所有方法进行统一增强时（如事务管理、日志记录等）。

CGLIB 的主要组件

• Enhancer
  CGLIB 的核心类，用于创建代理对象。
• MethodInterceptor 接口
  定义了一个方法 intercept()，用于拦截对代理对象方法的调用。可以在此方法中添加额外逻辑。

案例描述

有一个普通的类 UserHelper ，有一个方法 queryUserInfo，完成数据库的用户信息的查询。
有一个增强类，UserHelperInterceptor, 实现MethodInterceptor接口，在 intercept 方法中调用目标类的方法。
有一个代理类，UserHelperProxy，提供一个获取代理对象的方法，getProxy();
最终，客户端调用的时候，使用 代理类获取到代理对象，调用目标方法完成操作。

类图

被代理类

public class UserHelper {/*** 一个普通的方法* @param userId* @return*/public String queryUserInfoWithReturn(String userId) {System.out.println(" 模拟查询用户信息的数据库-带返回值 ： 查询的是 ： "+userId);return "被代理类的返回值-helloworld";}
}

拦截器类

这里直接使用了 spring 包中的 相关的接口和类。

也可以 单独导入 CGLib 相关的依赖包。
单独使用时，如果jdk版本较高，需要在 启动参数中添加 --add-opens java.base/java.lang=ALL-UNNAMED",这是因为高版本中增加了对未命名类的限制！

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class UserHelperInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println(" 方法拦截器 - begin :  "+method.getName());Object res =  methodProxy.invokeSuper(o, objects);System.out.println(" 方法拦截器 - end :  "+method.getName());return res;}
}

获取代理对象的类（代理的主要逻辑）

可以不写这个类，直接在使用代理对象的地方将 getProxy 方法中的逻辑写出来即可。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;public class CommonHelperProxy<T>{/*** 子类的 拦截器 的对象，增强的时候用*/private MethodInterceptor methodInterceptor;public CommonHelperProxy(MethodInterceptor methodInterceptor) {this.methodInterceptor = methodInterceptor;}/*** 获取代理对象 : 根据类型参数创建的代理对象* @return*/public T getProxy() {Enhancer enhancer = new Enhancer();// 设置目标类的类型enhancer.setSuperclass(UserHelper.class);// 设置回调函数enhancer.setCallback(methodInterceptor);// 创建代理对象return (T) enhancer.create();}
}

客户端

public class UserHelperProxyClient {public static void main(String[] args) {// 创建拦截器对象UserHelperInterceptor userHelperInterceptor = new UserHelperInterceptor();// 获取代理对象CommonHelperProxy<UserHelper> proxy = new CommonHelperProxy<>(userHelperInterceptor);UserHelper proxyObject = proxy.getProxy();// 通过代理对象执行方法String s = proxyObject.queryUserInfoWithReturn("10001");System.out.println("s = " + s);}
}

运行结果：方法拦截器 - begin :  queryUserInfoWithReturn模拟查询用户信息的数据库-带返回值 ： 查询的是 ： 10001方法拦截器 - end :  queryUserInfoWithReturn
s = 被代理类的返回值-helloworld

以上就是代理模式的三种写法。