代理模式实现 on 菜鸟程序员

ByteBuddy动态代理

Mon, 01 Jan 0001 00:00:00 +0000

pom文件添加依赖

 <dependency>
 <groupId>net.bytebuddy</groupId>
 <artifactId>byte-buddy</artifactId>
 <!-- 我用的最新的， 一般1.14.0以上都没问题 -->
 <version>1.15.1</version>
 </dependency>

先创建要被代理的类

public class TargetClass {
 public void performAction() {
 System.out.println("原始方法: performAction");
 }

 public String sayHello(String name) {
 return "Hello, " + name;
 }
}

创建拦截器

import net.bytebuddy.implementation.bind.annotation.*;

import java.lang.reflect.Method;
import java.util.concurrent.Callable;

/**
 * 通用方法拦截器
 */
public class GenericInterceptor {

 @RuntimeType
 public static Object intercept(@Origin Method method,
 @AllArguments Object[] args,
 @This Object obj,
 @SuperCall Callable<?> callable) throws Exception {
 // 获取动态添加的字段值
 String proxyField = (String) obj.getClass().getField("proxyField").get(obj);
 System.out.println("[拦截] proxyField 值: " + proxyField);

 // 修改字段值
 System.out.println("[通用拦截] 修改字段proxyField值: Modified by interceptor" );
 obj.getClass().getField("proxyField").set(obj, "Modified by interceptor");

 System.out.println("[通用拦截] 方法开始: " + method.getName());
 Object result = callable.call(); // 执行原始方法
 System.out.println("[通用拦截] 方法结束: " + method.getName());
 return result;
 }
}

代理工具

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.modifier.Visibility;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 通用 Byte Buddy 动态代理工具类
 */
public class ByteBuddyProxy {

 /**
 * 创建一个代理对象
 *
 * @param targetClass 目标类类型
 * @param interceptor 拦截器类（需使用 Byte Buddy 注解定义逻辑）
 * @param <T> 泛型
 * @return 代理实例
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 public static <T> T createProxy(Class<T> targetClass, Class<?> interceptor) throws Exception {

 Class<?> dynamicType = new ByteBuddy()
 .subclass(targetClass)
 // ElementMatchers.any() 拦截所有方法
 .method(ElementMatchers.any())
 // MethodDelegation.to(interceptor) 拦截器类 方法增强
 .intercept(MethodDelegation.to(interceptor))
 // 动态的添加字段。这里可以放到参数里面，然后由调用方传递进来要添加什么参数
 .defineField("proxyField", String.class, Visibility.PUBLIC) // 可选：添加字段
 .defineField("abc", String.class, Visibility.PUBLIC) // 可选：添加字段
 .make()
 .load(targetClass.getClassLoader())
 .getLoaded();
 // 支持构造实例
// .getDeclaredConstructor()
// .newInstance();

 Constructor<?> constructor = dynamicType.getDeclaredConstructor();
 Object instance = constructor.newInstance();

 // 现在就可以 调用方法触发拦截逻辑 了
 // ((TargetClass) instance).performAction();
 // 设置字段值
 System.out.println("[通用拦截] 设置字段proxyField值: Hello Dynamic Field" );
 dynamicType.getField("proxyField").set(instance, "Hello Dynamic Field");

 System.out.println("[通用拦截] 设置字段abc值: def" );
 dynamicType.getField("abc").set(instance, "def");
 return (T) instance;

 }
}

一个测试类用来测试动态代理

public class ByteBuddyGenericExample {
 public static void main(String[] args) throws Exception {
 // 创建代理对象
 TargetClass proxyInstance = ByteBuddyProxy
 .createProxy(TargetClass.class, GenericInterceptor.class);

 // 调用方法
 proxyInstance.performAction();
 String result = proxyInstance.sayHello("World");
 System.out.println("返回值: " + result);

 String abc = (String) proxyInstance.getClass().getField("abc").get(proxyInstance);
 System.out.println("last在打印一遍proxyField: " + abc);
 }
}

CGLIB动态代理

Mon, 01 Jan 0001 00:00:00 +0000

maven项目需要添加依赖

 <!-- https://mvnrepository.com/artifact/cglib/cglib -->
 <dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>3.3.0</version>
 </dependency>

1 0.1 CGLIB包结构

*net.sf.cglib.core *底层字节码处理类。
*net.sf.cglib.transform *该包中的类用于class文件运行时转换或编译时转换。
*net.sf.cglib.proxy *该包中的类用于创建代理和方法拦截。
*net.sf.cglib.reflect *该包中的类用于快速反射，并提供了C#风格的委托。
*net.sf.cglib.util *集合排序工具类。
*net.sf.cglib.beans *JavaBean工具类。

1 使用CGLIB实现动态代理

2 1.1 CGLIB代理相关的类

net.sf.cglib.proxy.Enhancer 主要的增强类。
net.sf.cglib.proxy.MethodInterceptor 主要的方法拦截类，它是Callback接口的子接口，需要用户实现。
net.sf.cglib.proxy.MethodProxy JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用。

cglib是通过动态的生成一个子类去覆盖所要代理类的非final方法，并设置好callback，则原有类的每个方法调用就会转变成调用用户定义的拦截方法（interceptors）。

CGLIB代理相关的常用API如下图所示：

net.sf.cglib.proxy.Callback接口在CGLIB包中是一个重要的接口，所有被net.sf.cglib.proxy.Enhancer类调用的回调（callback）接口都要继承这个接口。

net.sf.cglib.proxy.MethodInterceptor能够满足任何的拦截（interception ）需要。对有些情况下可能过度。为了简化和提高性能，CGLIB包提供了一些专门的回调（callback）类型：

net.sf.cglib.proxy.FixedValue 为提高性能，FixedValue回调对强制某一特别方法返回固定值是有用的。
net.sf.cglib.proxy.NoOp NoOp回调把对方法调用直接委派到这个方法在父类中的实现。
net.sf.cglib.proxy.LazyLoader 当实际的对象需要延迟装载时，可以使用LazyLoader回调。一旦实际对象被装载，它将被每一个调用代理对象的方法使用。
net.sf.cglib.proxy.Dispatcher Dispathcer回调和LazyLoader回调有相同的特点，不同的是，当代理方法被调用时，装载对象的方法也总要被调用。
net.sf.cglib.proxy.ProxyRefDispatcher ProxyRefDispatcher回调和Dispatcher一样，不同的是，它可以把代理对象作为装载对象方法的一个参数传递。

3 1.2 CGLIB动态代理的基本原理

CGLIB动态代理的原理就是用Enhancer生成一个原有类的子类，并且设置好callback到proxy，则原有类的每个方法调用都会转为调用实现了MethodInterceptor接口的proxy的intercept() 函数，如图

在intercept()函数里，除执行代理类的原因方法，在原有方法前后加入其他需要实现的过程，改变原有方法的参数值，即可以实现对原有类的代理了。这似于AOP中的around advice。

4 1.3 使用MethodInterceptor接口实现方法回调

当对代理中所有方法的调用时，都会转向MethodInterceptor类型的拦截（intercept）方法,在拦截方法中再调用底层对象相应的方法。下面我们举个例子，假设你想对目标对象的所有方法调用进行权限的检查，如果没有经过授权，就抛出一个运行时的异常。

动态代理

Mon, 01 Jan 0001 00:00:00 +0000

定义一个接口

public interface IRegisterService {
 void register(String name, String pwd);
}

一个接口的实现类

public class RegisterServiceImpl implements IRegisterService {
 @Override
 public void register(String name, String pwd) {
 System.out.println(String.format("【向数据库中插入数据】name：%s，pwd：%s", name, pwd));
 }
}

一个实现了InvocationHandler接口的类


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class InsertDataHandler implements InvocationHandler {

 // 持有一个被代理类的引用， 但是这个被代理类不是具体的类。而是超类
 Object obj;

 public Object getProxy(Object obj){
 this.obj = obj;
 return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 doBefore();
 // 在这里调用被代理的方法
 Object result = method.invoke(obj, args);
 doAfter();
 return result;
 }
 private void doBefore() {
 System.out.println("[Proxy]一些前置处理");
 }
 private void doAfter() {
 System.out.println("[Proxy]一些后置处理");
 }

}

测试

public class DynamicProxy {
 public static void main(String[] args) {
 // 实例化被代理类
 IRegisterService iRegisterService = new RegisterServiceImpl();

 // 实例化代理类
 InsertDataHandler insertDataHandler = new InsertDataHandler();

 // 通过Proxy获取代理类
 IRegisterService proxy = (IRegisterService)insertDataHandler.getProxy(iRegisterService);

 // 执行方法
 proxy.register("RyanLee", "123");
 }
}

静态代理

Mon, 01 Jan 0001 00:00:00 +0000

定义一个接口 IRegisterService

public interface IRegisterService {
 void register(String name, String pwd);
}

创建被代理的类，并实现接口

public class RegisterServiceImpl implements IRegisterService {
 @Override
 public void register(String name, String pwd) {
 System.out.println(String.format("【向数据库中插入数据】name：%s，pwd：%s", name, pwd));
 }
}

创建代理类，并实现接口

class RegisterServiceProxy implements IRegisterService {
 // 代理类持有被代理类对象的引用
 IRegisterService iRegisterService;

 public RegisterServiceProxy(IRegisterService iRegisterService) {
 this.iRegisterService = iRegisterService;
 }

 @Override
 public void register(String name, String pwd) {
 System.out.println("[Proxy]一些前置处理");
 //这里调用被代理类的方法，也是静态指定的
 iRegisterService.register(name, pwd);
 System.out.println("[Proxy]一些后置处理");

 }
}

测试

public class StaticProxy {
 public static void main(String[] args) {
 IRegisterService iRegisterService = new RegisterServiceImpl();
 IRegisterService proxy = new RegisterServiceProxy(iRegisterService);
 proxy.register("RyanLee", "123");
 }
}