谈谈对Spring的动态代理机制

①：JDK动态代理

//接口
interface Demo{
    void buyCar();
}
//要被代理的类
public class PersonBuy implements Demo{
    @Override
    public void buyCar() {
        System.out.println("去4s店提车");
    }
}

//JDK代理类
class JDKProxy implements InvocationHandler {

private PersonBuy target;

    public  JDKProxy(PersonBuy target){
        this.target=target;
    }

    //重写invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("先看看卡里有没有钱");
        Object returnValue= method.invoke(target,args);
        System.out.println("到了店里发现没卡里没钱");
        return returnValue;
    }
}

测试一下

class test {
    public static void main(String[] args) {
        PersonBuy dede=new PersonBuy();
        JDKProxy dedede= new JDKProxy(dede);
        Demo demo =(Demo)Proxy.newProxyInstance(dede.getClass().getClassLoader(),dede.getClass().getInterfaces(),dedede);
        demo.buyCar();
    }
}

JDK原生的动态代理有一个弊端，只能代理实现接口的类。
其代理类要是实现InvocationHandler接口，并重写invoke方法做切面处理。

②：CGLIB动态代理

    class Buy{
        public void buyCar (){
            System.out.println("今天非要买车不可");
        }
    }
     class CGlib implements MethodInterceptor{
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("先看看卡里有没有钱");
            Object returnResult=methodProxy.invokeSuper(o,objects);
            System.out.println("到了店里发现没卡里没钱");
            return  returnResult;
        }
    }

测试一下
 

class dded {
    public static void main2(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Buy.class);
        enhancer.setCallback(new CGlib());
        Buy buy=(Buy)enhancer.create();
        buy.buyCar();
    }
}

JDK动态代理只能对实现了接口的类生成代理，而不能针对类 ，使用的是 Java反射技术实现，生成类的过程比较高效。
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 ，使用asm字节码框架实现，相关执行的过程比较高效，因为是继承，所以该类或方法不要声明成final 

Spring首先找到被代理的类是否实现接口，如果实现接口走JDK原生动态代理，如果没实现接口，走的就是CGLIB动态代理