Java 代理

1.动态代理

动态代理比较常用的两种实现  JDK动态代理,CGLIB 动态代理

JDK 是基于接口实现的方式,所以只能代理实现了接口的类， CGLIB是以实现子类的形式实现，所以被代理的类用final 修饰，因为final类不能被继承

 

 

jdk的核心实现代码

public class ArithmeticCalculatorLoggingProxy {
	//要代理的对象
	private ArithmeticCalculator target;//ArithmeticCalculator 用户计算 + - * / ，实现了对应的接口
	public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
		super();
		this.target = target;
	}
	//返回代理对象
	public ArithmeticCalculator getLoggingProxy(){
		ArithmeticCalculator proxy = null;
		
		ClassLoader loader = target.getClass().getClassLoader();
		Class [] interfaces = new Class[]{ArithmeticCalculator.class};
		InvocationHandler h = new InvocationHandler() {
			/**
			 * proxy: 代理对象。 一般不使用该对象
			 * method: 正在被调用的方法
			 * args: 调用方法传入的参数
			 */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				String methodName = method.getName();
				//打印日志
				System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));
				//调用目标方法
				Object result = null;
				try {
					//前置通知
					result = method.invoke(target, args);
					//返回通知, 可以访问到方法的返回值
				} catch (NullPointerException e) {
					e.printStackTrace();
					//异常通知, 可以访问到方法出现的异常
				}
				//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
				//打印日志
				System.out.println("[after] The method ends with " + result);
				return result;
			}
		};
		
		/**
		 * loader: 代理对象使用的类加载器。 
		 * interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法. 
		 * h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法
		 */
		proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
		
		return proxy;
	}

 

CGLIB 代码

public class UserService {  
    public void add() {  
        System.out.println("This is add service");  
    }  
    public void delete(int id) {  
        System.out.println("This is delete service：delete " + id );  
    }  
}

2、实现接口，定义方法的拦截器

public class MyMethodInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable {
        System.out.println("Before:" + method);  
        Object object = proxy.invokeSuper(obj, arg);
        System.out.println("After:" + method); 
        return object;
    }
}

3、利用Enhancerde类生成代理类；

Enhancer enhancer = new Enhancer();  
enhancer.setSuperclass(UserService.class);  
enhancer.setCallback(new MyMethodInterceptor());  
UserService userService = (UserService)enhancer.create();

4、执行结果：

Before: add
This is add service
After: add

代理对象的生成过程由Enhancer类实现，大概步骤如下：
1、生成代理类Class的二进制字节码；
2、通过de style="margin: 0px; padding: 0px;" >Class.forNamede>加载二进制字节码，生成Class对象；
3、通过反射机制获取实例构造，并初始化代理类对象。

 

2.静态代理

所谓的静态代理就是 AOP 框架会在编译阶段生成 AOP 代理类，因此也称为编译时增强。典型代表 AspectJ

编写AspectJ静态代理代码时，需要使用aspectj 特定的语法，然后使用使用 AspectJ 的编译器编译，反编译出class文件即可看到在便宜过程中，class文件已经被增强。

 

3.Spring AOP的代理实现

spring 根据需要代理的对象是否实现接口来选择代理的实现方式，正如上面说到的，如果被代理类实现了接口，哪怕是一个什么方法都没有的接口，Spring也将使用JDK方式实现代理，否则使用CGLIB实现。

可以强制使用CGLIB 使用注解开启代理时 使用 

@EnableAspectJAutoProxy(proxyTargetClass = true)

其中 proxyTargetClass = true 即为强制使用CGLIB代理

 

可能遇到的问题: 同一个被代理类中,方法间的调用不能触发

解决方法:

1. 不出现“自调用”的情况，Spring文档推荐使用此“最佳”方案；
2. 或在this.doXXX()替换为：((XxxService) AopContext.currentProxy()).doXXX()；同时修改spring的aop配置：

<aop:aspectj-autoproxy expose-proxy="true" />

或使用注解方式 @EnableAspectJAutoProxy(exposeProxy = true)