设计模式系列：行为型-代理模式（Proxy Pattern））
简介
代理模式（Proxy Pattern）是一种行为型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。通过使用代理，可以在客户端和目标对象之间起到中介的作用，这样既可以扩展目标对象的功能，又可以保护目标对象。
代理模式有不同的形式，主要有三种：
-
静态代理
-
动态代理：JDK 代理、接口代理
-
Cglib 代理：可以在内存动态的创建对象，而不需要实现接口，它是属于动态代理的范畴
结构
代理（Proxy）模式分为三种角色：
- 抽象主题（Subject）类： 通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题（Real Subject）类： 实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理（Proxy）类 ： 提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
案例准备
-
1）定义一个接口：
Calculator -
2）目标对象
CalculatorImpl实现接口Calculator
Calculator.java
package com.mcode.api.proxy;
/**
* ClassName: Calculator
* Package: com.mcode.api.proxy
* Description:
*
* @Author: robin
* @Version: v1.0
*/
/**
* 目标接口
*/
public interface Calculator {
int add(int a, int b);
}
CalculatorImpl.java
package com.mcode.api.proxy;
import com.mcode.api.proxy.Calculator;
/**
* ClassName: CalculatorImpl
* Package: com.mcode.api.proxy
* Description:
*
* @Author: robin
* @Version: v1.0
*/
/**
* 目标对象
*/
public class CalculatorImpl implements Calculator {
/**
* 相加方法
* @param a
* @param b
* @return
*/
@Override
public int add(int a, int b) {
int result = a + b;
System.out.println("方法内部 result = " + result);
return result;
}
}
静态代理
基本介绍
静态代理在使里时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现租同的接口或者是继承和同父类—
应用实例
应用实例
-
1）使用静态代理方式，就需要在代理对象
CalculatorStaticProxy中也实现Calculator -
2）调用的时候通过调用代理对象的方法来调用目标对象
-
3）特别提醒：代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法
核心代码
CalculatorStaticProxy.java
package com.mcode.api.proxy.staticproxy;
import com.mcode.api.proxy.Calculator;
/**
* ClassName: CalculatorStaticProxy
* Package: com.mcode.api.proxy.staticproxy
* Description:
*
* @Author: robin
* @Version: v1.0
*/
public class CalculatorStaticProxy implements Calculator {
private Calculator target;
public CalculatorStaticProxy(Calculator target) {
this.target = target;
}
@Override
public int add(int a, int b) {
// 附加功能由代理类中的代理方法来实现
System.out.println("[日志] add 方法开始了，参数是：" + a + "," + b);
// 通过目标对象来实现核心业务逻辑
int addResult = target.add(a, b);
System.out.println("[日志] add 方法结束了，结果是：" + addResult);
return addResult;
}
}
调用代理
CalculatorTest.java
package com.mcode.api.proxy.staticproxy;
import com.mcode.api.proxy.CalculatorImpl;
/**
* ClassName: CalculatorTest
* Package: com.mcode.api.proxy.staticproxy
* Description:
*
* @Author: robin
* @Version: v1.0
*/
public class CalculatorTest {
public static void main(String[] args) {
//创建被代理对象
CalculatorImpl calculator = new CalculatorImpl();
//创建代理对象，聚合被代理对象
CalculatorStaticProxy proxy = new CalculatorStaticProxy(calculator);
//通过代理对象，调用被代理对象的方法
proxy.add(1, 2);
}
}
执行结果
静态代理优缺点
-
1）优点：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展
-
2）缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类
-
3）缺点：一旦接口增加方法，目标对象与代理对象都要维护
动态代理
基本介绍
-
1）代理对象不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
-
2）代理对象的生成，是利用 JDK 的 APl，动态的在内存中构建代理对象
-
3）动态代理也叫做：JDK 代理、接口代理
JDK 中生成代理对象的 API
1）代理类所在包：java.lang.reflect.Proxy
● 2）JDK 实现代理只需要使用 newProxyInstance 方法，但是该方法需要接收三个参数，完整的写法是：
static Object newProxylnstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
核心代码
ProxyFactory.java
package com.mcode.api.proxy.dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
* ClassName: ProxyFactory
* Package: com.mcode.api.proxy.dynamic
* Description:
*
* @Author: robin
* @Version: v1.0
*/
/**
* 代理工厂
*/
public class ProxyFactory {
/**
* 目标对象
*/
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
public Object getProxy() {
/**
* newProxyInstance()：创建一个代理实例
* 其中有三个参数：
* 1、classLoader：加载动态生成的代理类的类加载器
* 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
* 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
*/
ClassLoader classLoader = target.getClass().getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();
InvocationHandler invocationHandler = (proxy, method, args) -> {
/**
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数
*/
Object result = null;
System.out.println("[动态代理][日志] " + method.getName() + "，参数：" + Arrays.toString(args));
result = method.invoke(target, args);
System.out.println("[动态代理][日志] " + method.getName() + "，结果：" + result);
return result;
};
return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}
其中几个参数
-
1）
ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法固定 -
2）
Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型 -
3）
InvocationHandler h：事情处理，执行目标对象的方法时触发事情处理器方法，把当前执行的目标对象方法作为参数传入
调用代理
CglibProxyTest.java
package com.mcode.api.proxy.dynamic;
import com.mcode.api.proxy.Calculator;
import com.mcode.api.proxy.CalculatorImpl;
/**
* ClassName: DynamicProxyTest
* Package: com.mcode.api.proxy.dynamic
* Description:
*
* @Author: robin
* @Version: v1.0
*/
public class DynamicProxyTest {
public static void main(String[] args) {
//创建目标对象
CalculatorImpl calculator = new CalculatorImpl();
//通过代理工厂创建代理对象
ProxyFactory proxyFactory = new ProxyFactory(calculator);
//通过代理对象调用目标对象方法
Calculator proxy = (Calculator)proxyFactory.getProxy();
proxy.add(1,2);
}
}
执行结果
Cglib 代理
基本介绍
-
1）静态代理和 JDK 代理模式都要求目标对象是实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可使用目标对象子类来实现代理——这就是 Cglib 代理
-
2）Cglib 代理也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，有些书也将 Cglib 代理归属到动态代理。
-
3）Cglib 是一个强大的高性能的代码生成包，它可以在运行期扩展 java 类与实现 java 接口。它广泛的被许多 AOP 的框架使用，例如 Spring AOP，实现方法拦截
-
4）在 AOP 编程中如何选择代理模式：
-
- 目标对象需要实现接口，用 JDK 代理
-
- 目标对象不需要实现接口，用 Cglib 代理
-
5）Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类
实现步骤
-
1）需要引入
cglib的 jar 文件 -
<!-- https://mvnrepository.com/artifact/cglib/cglib --> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.3.0</version> </dependency> -
2）在内存中动态构建子类，注意代理的类不能为
final，否则报错java.lang.IllegalArgumentException -
3）目标对象的方法如果为
final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
核心代码
ProxyFactory.java
package com.mcode.api.proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* ClassName: ProxyFactory
* Package: com.mcode.api.proxy.cglib
* Description:
*
* @Author: robin
* @Version: v1.0
*/
/**
* 代理工厂
*/
public class ProxyFactory implements MethodInterceptor {
/**
* 目标对象
*/
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
public Object getProxy(){
// 1、创建工具类
Enhancer enhancer = new Enhancer();
// 2、设置父类
enhancer.setSuperclass(target.getClass());
// 3、设置回调函数,需要实现MethodInterceptor接口
enhancer.setCallback(this);
// 4、创建子类对象，即代理对象
return enhancer.create();
}
/**
*
* @param o 代理对象
* @param method 目标方法
* @param args 目标方法参数
* @param methodProxy 代理对象生成的代理方法
* @return
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object result = null;
System.out.println("[cglib代理][日志] " + method.getName() + "，参数：" + Arrays.toString(args));
result = method.invoke(target, args);
System.out.println("[cglib代理][日志] " + method.getName() + "，结果：" + result);
return result;
}
}
调用代理
CglibProxyTest.java
package com.mcode.api.proxy.cglib;
import com.mcode.api.proxy.CalculatorImpl;
/**
* ClassName: CglibProxyTest
* Package: com.mcode.api.proxy.cglib
* Description:
*
* @Author: robin
* @Version: v1.0
*/
public class CglibProxyTest {
public static void main(String[] args) {
//创建目标对象
CalculatorImpl calculator = new CalculatorImpl();
//通过代理工厂创建代理对象
ProxyFactory proxyFactory = new ProxyFactory(calculator);
//通过代理对象调用目标对象方法
CalculatorImpl proxy = (CalculatorImpl)proxyFactory.getProxy();
proxy.add(1,2);
}
}
执行报错
Caused by: net.sf.cglib.core.CodeGenerationException: java.lang.reflect.InaccessibleObjectException-->Unable to make protected final java.lang.Class.
运行时增加 vm 环境变量
--add-opens java.base/java.lang=ALL-UNNAMED
执行结果
优缺点
优点：
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
- 代理对象可以扩展目标对象的功能；
- 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；
缺点：
- 增加了系统的复杂度；
使用场景
-
远程（Remote）代理
本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。
-
防火墙（Firewall）代理
当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。
-
保护（Protect or Access）代理
控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
源码中的应用
Spring
Spring AOP（面向切面编程）
- Spring AOP 使用代理模式实现了切面（Aspect）的横切关注点，比如日志、事务、安全等功能。Spring 使用 JDK 动态代理和 CGLIB（Code Generation Library）来创建代理对象，根据被代理的目标对象是否实现了接口来决定使用哪种代理方式。
- 当目标对象实现了接口时，Spring 使用 JDK 动态代理来创建代理对象，代理对象实现了与目标对象相同的接口，并将方法调用委托给 Advice（通知）链。
- 当目标对象未实现接口时，Spring 使用 CGLIB 动态生成子类来创建代理对象，通过继承目标对象的子类并重写方法来实现代理逻辑。
事务管理
- Spring 的事务管理机制也是基于代理模式实现的。通过 @Transactional 注解或者编程式事务管理，Spring 在方法调用前后开启、提交或回滚事务。
- 当类或方法被 @Transactional 注解标记时，Spring 会在运行时为这些类或方法创建代理对象，代理对象负责管理事务的边界。
远程访问和调用
- Spring 中的远程访问和调用，比如使用 RMI、Hessian、Burlap、HTTP、Web services 等，通常也会使用代理模式。Spring 为远程服务创建代理对象，代理对象封装了远程调用的细节，使得客户端可以像调用本地方法一样调用远程服务。
Lazy initialization（延迟初始化）
- Spring 中的一些 bean 可能被标记为延迟初始化，这意味着它们只有在第一次使用时才会被实例化。Spring 使用代理模式来延迟初始化这些 bean，当第一次访问这些 bean 时才真正创建它们的实例。
.Net Core
远程调用和通信
- 在 .NET Core 中，使用远程过程调用（RPC）或远程服务调用（RSC）时，代理模式非常常见。通过代理对象，客户端可以透明地调用远程服务而无需了解底层通信细节。例如，ASP.NET Core 中的 gRPC 就使用了代理模式来进行远程过程调用。
实现延迟加载
- 与 Java 中的 Hibernate 类似，在 .NET Core 中的 ORM（对象关系映射）框架，比如 Entity Framework Core，通常使用代理模式来实现延迟加载。当访问实体对象的导航属性时，代理对象会负责在需要时加载相关的数据。
WCF（Windows Communication Foundation）代理
- 在 .NET Framework 中，WCF 提供了一种通用的通信机制，可以通过各种传输协议进行通信。WCF 代理对象充当客户端和服务之间的中介，隐藏了通信细节，并提供了一种简单的方式来调用远程服务。
透明代理
- .NET Core 中的 Remoting 技术允许对象在不同的应用域（AppDomain）和进程之间进行通信。透明代理是 Remoting 中的核心概念之一，它允许客户端像调用本地对象一样调用远程对象，而代理对象负责处理实际的通信。
动态代理
- .NET Core 中的 Castle DynamicProxy 等第三方库提供了动态代理功能，可以在运行时动态地创建代理对象。这在实现 AOP（面向切面编程）和其他需要在运行时生成代理的场景中非常有用。
微信：17873041739
