代理模式是一种比较好的理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
静态代理
对目标对象（被代理对象）的每个方法都是手动增强的，一旦接口新增了方法，目标对象和代理对象都要进行修改，并且麻烦，需要对每个目标类都单独写一个代理类。
上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class 文件。
静态代理实现步骤:
- 定义一个接口及其实现类；
- 创建一个代理类同样实现这个接口
- 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。
具体例子如下：
- 定义接口
package com.jxz.ProxyPattern.staticProxcy;
public interface SmsService {
// 如果接口中如果新增方法，代理对象和被代理对象都需要进行修改
String send(String s);
}
- 实现接口
package com.jxz.ProxyPattern.staticProxcy;
public class SmsServiceImpl implements SmsService{
// 如果接口中如果新增方法，代理对象和被代理对象都需要进行修改
@Override
public String send(String s) {
System.out.println("send message:"+s);
return s;
}
}
- 创建代理类并同样实现接口
package com.jxz.ProxyPattern.staticProxcy;
// 增强一样的方法，所以实现了接口，要达到相同的结果不实现也可以
// 需要对每个目标类（被代理类）都实现一个代理类
public class SmsServiceProxy implements SmsService{
private final SmsService master;
public SmsServiceProxy(SmsService smsService){
// 将被代理的类传入进来
master=smsService;
}
// 如果接口中如果新增方法，代理对象和被代理对象都需要进行修改
@Override
public String send(String s) {
System.out.println("before send");
master.send(s);
System.out.println("after send");
return null;
}
}
- 实际使用
package com.jxz.ProxyPattern.staticProxcy;
public class Main {
public static void main(String[] args) {
// 还是要创建被代理类
SmsServiceImpl smsService = new SmsServiceImpl();
// 将被代理类对象注入到代理类中，需要对每个目标类都写一个代理类
SmsServiceProxy smsServiceProxy = new SmsServiceProxy(smsService);
// 直接调用代理类的方法，实现增强的效果
smsServiceProxy.send("I'm jiangxuzhao");
}
}
输出结果：
before send
send message:I'm jiangxuzhao
after send
静态代理确实实现了解耦，但是由于代码都写死了（1.静态代理类实现了目标类一样的接口，2.静态代理类中目标对象的成员变量是写死的），完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类（每个类声明一个静态代理类），那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。
动态代理
从JVM层面来看，动态代理是在类运行时动态生成类字节码，并加载到JVM中。
JDK动态代理
关键点：JDK动态代理中实现InvocationHandler接口和调用Proxy类中的newProxyInstance静态方法是核心。
Proxy类中的静态方法newProxyInstance用来生成代理对象。
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) {
Objects.requireNonNull(h);
@SuppressWarnings("removal")
final Class<?> caller = System.getSecurityManager() == null
? null
: Reflection.getCallerClass();
/*
* Look up or generate the designated proxy class and its constructor.
*/
Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
return newProxyInstance(caller, cons, h);
}
需要传入三个参数：
ClassLoader loader： 被代理类加载器，可以传入 target.getClass().getClassLoader()
interfaces：被代理类实现的接口，可以传入 target.getClass().getInterfaces()
InvocationHandler h： 实现InvocationHandler接口的对象，里面会通过重写invoke方法完成我们自定义的逻辑
InvocationHandler接口需要被一个我们自定义的类实现，并且实现其中的invoke方法，最终当我们的代理对象调用它的一个方法的时候，这个方法的调用就会被拦截转发到我们InvocationHandler接口实现类的invoke方法上。
public interface InvocationHandler {
// 被实现类转发到这个方法上来，通常是利用反射增强原生对象的方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
/*
@CallerSensitive
public static Object invokeDefault(Object proxy, Method method, Object... args)
throws Throwable {
Objects.requireNonNull(proxy);
Objects.requireNonNull(method);
return Proxy.invokeDefault(proxy, method, args, Reflection.getCallerClass());
}
*/
}
invoke方法有三个参数：
-
Object proxy：动态生成的代理类，不需要我们改动 -
Method method：与目标类调用的方法相对应，可以通过Object result=method.invoke(target,args)反射调用实现增强 -
Object[] args：调用传入的参数，可以通过Object result=method.invoke(target,args)反射调用实现增强
其中的流程为：
- 通过
Proxy类中的静态方法newProxyInstance生成代理对象，其中传入了实现InvocationHandler接口的自定义类 - 实现
InvocationHandler接口的自定义类需要重写invoke方法，并且由于是有参构造传入了原生对象（类似静态代理），可以在自定义类中通过反射method.invoke调用原生对象方法，达到功能增强。 - 后续只需要用这个代理对象去调用原先目标对象的方法就可以了，在外层调用方式不变的情况下，实现了功能的增强
JDK动态代理使用放在具体的例子中来看：
-
定义我们原先需要被增强的接口及其实现类
-
实现
InvocationHandler接口的自定义类并且重写invoke方法，可以在自定义类中通过反射method.invoke调用原生对象方法，达到功能增强。 -
通过
Proxy类中的静态方法newProxyInstance生成代理对象，其中传入了第二步实现了InvocationHandler接口的自定义类 -
（这里可以用一个工厂类将 通过
Proxy类中的静态方法newProxyInstance生成代理对象 的逻辑进行包装，并将代理对象返回） -
生成的代理对象类型和接口类型相同，可以调用接口中声明的方法，但是效果已经被增强了
-
定义接口
package com.jxz.ProxyPattern.dynamicProxy.jdk;
public interface SmsService {
String send(String s);
}
- 原生类实现接口
package com.jxz.ProxyPattern.dynamicProxy.jdk;
public class SmsServiceImpl implements SmsService {
@Override
public String send(String s) {
System.out.println("send message:"+s);
return s;
}
}
- 实现
InvocationHandler接口的自定义类并且重写invoke方法
package com.jxz.ProxyPattern.dynamicProxy.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class JXZInvocationHandler implements InvocationHandler {
private final Object target; // 被代理类
public JXZInvocationHandler(Object target){
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 实现方法增强
System.out.println("before method:"+method.getName());
Object result=method.invoke(target,args); // 调用原生对象方法
System.out.println("after method:"+method.getName());
return result;
}
}
- 实现工厂类获取代理对象的
package com.jxz.ProxyPattern.dynamicProxy.jdk;
import com.jxz.ProxyPattern.staticProxcy.SmsService;
import java.lang.reflect.Proxy;
// 创建代理类工厂
public class JDKProxyFactory {
// get方法中参数传入原先未被增强的对象,返回代理对象
public static Object getProxy(Object target){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 被代理类的加载器
target.getClass().getInterfaces(), // 被代理类实现的接口
new JXZInvocationHandler(target) // 自定义实现`InvocationHandler接口`的对象
);
}
}
- 进行调用
package com.jxz.ProxyPattern.dynamicProxy.jdk;
public class Main {
public static void main(String[] args) {
// 从工厂中取出代理对象，向上转型，调用接口中定义的方法
SmsService proxy = (SmsService)JDKProxyFactory.getProxy(new SmsServiceImpl());
proxy.send("I'm jiangdazhao");
}
}
输出结果：
before method:send
send message:I'm jiangdazhao
after method:send
通用模版：
上面是将工厂类和invocationHandler实现类分开来写，可以直接合并写出一个可以实现任意对象接口的代理工厂：
package com.jxz.spring.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
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 = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
/**
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数
*/
Object result = null;
try {
System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
result = method.invoke(target, args); //反射调用
System.out.println("[动态代理][日志] "+method.getName()+"，结 果："+ result);
} catch (Exception e) {
e.printStackTrace();
System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage());
} finally {
System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕");
}
return result;
}
};
return Proxy.newProxyInstance(classLoader, interfaces,invocationHandler); //返回代理对象
}
}
CGLIB动态代理
JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。
为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。
CGLIB(Code Generation Library是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。
关键点：在 CGLIB 动态代理机制中实现MethodInterceptor 接口和创建动态代理增强类 Enhancer 是核心。
需要自定义一个类实现MethodInterceptor接口并且实现其中的intercept方法
package net.sf.cglib.proxy;
import java.lang.reflect.Method;
public interface MethodInterceptor extends Callback {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable;
}
intercept方法三个参数：
Object o：被代理的对象（需要被增强）Method method： 被拦截的方法（需要被增强）Object[] objects： 方法入参MethodProxy methodProxy：用于调用原始方法
CGLIB动态代理使用放在具体的例子中来看：
-
不同于JDK 动态代理不需要额外的依赖。CGLIB(Code Generation Library) 实际是属于一个开源项目，需要手动添加相关依赖。
-
只需要定义需要被增强的类，不需要接口
-
实现
MethodInterceptor接口的自定义类并且重写intercept方法，intercept方法用于拦截且增强被代理类的方法，和JDK动态代理中的invoke方法类似。 -
通过创建动态代理增强类
Enhancer和调用create()方法生成代理类 -
（这里可以用一个工厂类将 通过动态代理增强类
Enhancer和调用create()方法生成代理类 的逻辑进行包装，并将代理对象返回） -
生成的代理对象类型和原来的类类型相同，可以调用原来类中的方法，但是效果已经被增强了
-
添加依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
- 定义需要被增强的类
package com.jxz.ProxyPattern.dynamicProxy.cglib;
public class WeakService {
public String send(String s){
System.out.println("send msg:"+s);
return s;
}
}
- 实现
MethodInterceptor接口的自定义类并且重写intercept方法
package com.jxz.ProxyPattern.dynamicProxy.cglib;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
// 自定义类实现MethodInterceptor接口
public class JXZMethodInterceptor implements MethodInterceptor {
/**
* 1. `Object o`：被代理的对象（需要被增强）
* 2. `Method method`： 被拦截的方法（需要被增强）
* 3. `Object[] objects`： 方法入参
* 4. `MethodProxy methodProxy`：用于调用原始方法
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("before send:"+method.getName());
// 进行方法增强,`Method method`： 被拦截的方法（需要被增强）没有用在这一句上
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("after send:"+method.getName());
return result;
}
}
- 工厂类将 通过动态代理增强类
Enhancer和调用create()方法生成代理类 的逻辑进行包装，并将代理对象返回
package com.jxz.ProxyPattern.dynamicProxy.cglib;
import net.sf.cglib.proxy.Enhancer;
//代理类工厂
public class CGLIBProxyFactory {
// 返回代理对象
public static Object getProxy(Object target){
// 创建动态代理增强类
Enhancer enhancer = new Enhancer();
// 设置类加载器
enhancer.setClassLoader(target.getClass().getClassLoader());
// 设置被代理类
enhancer.setSuperclass(target.getClass());
// 设置方法拦截器
enhancer.setCallback(new JXZMethodInterceptor());
// 创建代理类
return enhancer.create();
}
}
- 进行调用
package com.jxz.ProxyPattern.dynamicProxy.cglib;
public class Main {
public static void main(String[] args) {
WeakService weakService = (WeakService)CGLIBProxyFactory.getProxy(new WeakService());
weakService.send("I'm jiangdazhao");
}
}
其中在运行的过程中碰到jdk 19版本过高导致反射不可用的问题，在VM options中添加
--add-opens java.base/java.lang=ALL-UNNAMED
输出结果：
before send:send
send msg:I'm jiangdazhao
after send:send
JDK 动态代理和 CGLIB 动态代理对比
- JDK 动态代理只能只能代理实现了接口的类，而 CGLIB 可以代理未实现任何接口的类。另外，CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final 类型的类和方法。
- jdk动态代理，最终生成的代理类和目标类实现相同的接口，在com.sum.proxy包下，类名为$proxy2； cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
- 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。
静态代理和动态代理的对比
- 灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
- JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到JVM 中的。