spring 动态代理

Spring AOP的底层实现有两种方式：一种是JDK动态代理，另一种是CGLib的方式。

一、基本概念

JDK动态代理主要涉及java.lang.reflect包下边的两个类：Proxy和InvocationHandler。其中，InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑贬值在一起。

JDK动态代理的话，他有一个限制，就是它只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，如何创建动态代理实例哪？答案就是CGLib。

CGLib采用底层的字节码技术，全称是：Code Generation Library，CGLib可以为一个类创建一个子类，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。

二、实现原理

1. jdk动态代理原理

通过实现InvocationHandlet接口创建自己的调用处理器；

通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；

通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；

通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；

JDK动态代理是面向接口的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。

• CGLib代理原理

CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过 CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程呢。

三、比较

JDK动态代理是面向接口的。 

CGLib动态代理是通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，那么抱歉会失败）

 四、性能比较

JDK 和 CGLib动态代理性能对比-教科书上的描述
我们不管是看书还是看文章亦或是我那个上搜索参考答案，可能很多时候，都可以找到如下的回答：

关于两者之间的性能的话，JDK动态代理所创建的代理对象，在以前的JDK版本中，性能并不是很高，虽然在高版本中JDK动态代理对象的性能得到了很大的提升，但是他也并不是适用于所有的场景。主要体现在如下的两个指标中：

1、CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，有研究表明，大概要高10倍；

2、但是CGLib在创建对象的时候所花费的时间却比JDK动态代理要多很多，有研究表明，大概有8倍的差距；

3、因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。

五、实现参考代码

public class CglibProxyTest implements MethodInterceptor{

	private CglibProxyTest() {
    }

    public static <T extends Target> Target newProxyInstance(Class<T> targetInstanceClazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetInstanceClazz);
        enhancer.setCallback(new CglibProxyTest());
        return (Target) enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("jdk 代理前");
		Object super1 = proxy.invokeSuper(obj, args);
		System.out.println("jdk 代理后");
        return super1;
    }
}

public class JDKDynamicProxyTest implements InvocationHandler {
	
	 private Target target;

	    JDKDynamicProxyTest(Target target) {
	        this.target = target;
	    }

	    public static Target newProxyInstance(Target target) {
	        return (Target) Proxy.newProxyInstance(JDKDynamicProxyTest.class.getClassLoader(),
	                new Class<?>[]{Target.class},
	                new JDKDynamicProxyTest(target));

	    }

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		System.out.println("jdk 代理前");
		Object invoke = method.invoke(target, args);
		System.out.println("jdk 代理后");
		return invoke;
	}

}

public interface Target {
	
	int test(int a);

}

public class TargetImp implements Target {

	@Override
	public int test(int a) {
		return a;
	}

}

public static void main(String[] args) {
		
		TargetImp targetImp = new TargetImp();
		Target dynamicProxy = JDKDynamicProxyTest.newProxyInstance(targetImp);
		int test = dynamicProxy.test(888);
		System.out.println(test);
		Target target = CglibProxyTest.newProxyInstance(TargetImp.class);
		
		int test1 = target.test(8882);
		System.out.println(test1);
		
	}

 

 参考 ：https://www.cnblogs.com/xuliugen/p/10422339.html