动态代理的两种实现方式介绍

动态代理demo

分别采用cglib和jdk两种方法对动态代理进行简单说明

1.cglib基于类

目标类UserService

public class UserService {
	public void test() {
		System.out.println("test...");
	}
	public void a() {
		System.out.println("a...");
	}
}

main方法

public static void main(String[] args) {
//		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
//		applicationContext.register(AppConfig.class);
//		applicationContext.refresh();
		// 前三行忽略
		// 创建目标对象target
		UserService target = new UserService();
		// 通过cglib技术
		Enhancer enhancer = new Enhancer();
		// 设置源对象也就是目标对象,被代理类UserService是父类
		enhancer.setSuperclass(UserService.class);
		// 定义代理逻辑
		// MethodInterceptor方法拦截器
		enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
				System.out.println("before");

				// 这里就是在执行被代理对象target的test方法，即下面的userService.test()方法
				// 1.1 o是代理对象即下面的userService，objects便是这个方法的入参
				Object result1 = methodProxy.invoke(target, objects);
				// 1.2 通过反射的方式也可以实现
				Object result2 = method.invoke(target, objects);
				// 1.3 target换成o，即换成代理对象userService，就会报栈溢出(由于在不停的调用代理对象的test()方法)
				Object result3 = methodProxy.invoke(o, objects);
				// 1.4 如果想要使用代理对象，需要使用另外一个api
				Object result4 = methodProxy.invokeSuper(o, objects);

				System.out.println("after");
				return result4;
			}
		}, NoOp.INSTANCE});
		// 对目标对象中的方法进行选择性的拦截，因为springAOP中用到了这个api，所以这里简单介绍下
		enhancer.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
				if (method.getName().equals("test")){
					// 返回0，说明走第一个拦截器
					return 0;
				}else {
					// 返回1，说明走第二个拦截器NoOp.INSTANCE
					// NoOp.INSTANCE是一个空的拦截器
					return 1;
				}
			}
		});
		// 这里再次得到的UserServicee对象，其实已经是代理对象userService
		UserService userService = (UserService) enhancer.create();
		// 执行该test方法时，便会走到代理逻辑intercept中
		userService.test();
	}

2.基于接口的jdk动态代理

接口，接口，顾名思义，被代理类必须要先有一个接口才能利用jdk动态代理机制生成代理对象

 

public class Test {

	public static void main(String[] args) {
		// cglib();
		// 基于接口的动态代理
		// 创建目标类，该类实现了UserInterface接口
		UserService target = new UserService();
		// 注意：这里生成的代理对象的属性是接口代理类
            // 这里的new Class[]必须要是接口，否则就会报错
            // 由于这个限制，产生的代理对象类型是UserInterface，而不是UserService
		UserInterface proxyInstance = (UserInterface) Proxy.newProxyInstance(Test.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {
			@Override
			public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
				System.out.println("before");
				method.invoke(target, objects);
				System.out.println("after");
				return null;
			}
		});
		 proxyInstance.test();
	}
 }

 以上便是动态代理的两种实现方式。