spring aop 动态代理 两种方式实现动态代理

1）jdk Proxy.newInstance(ClassLoader loader,Interface[] interfaces,Class clazz);

这种方法主要是代理接口，不能代理类。

第一步实现invocationHandler接口

public class Proxy implements InvocationHandler{

    private TestInterface object;

    public Proxy(TestInterface testItf){
        this.object = testItf;
    }

    public PersonAction getInstace(){
        return (TestInterface) Proxy.newProxyInstance(this.getClass().getClassLoader(),new Class[]{TestInterface.class},this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("args are "+method.getName());
        // 在调用实际方法之前可以做很多前置操作
        return method.invoke(pa,args);
    }
}

然后就是写一个TestInterface的接口和两个实现了该接口的实现类，

public interface TestInterface {
    void bigAct();
}

public class Programmer implements TestInterface {
    public void bigAct(){
        println("i do program every day.i can be a great programmer.");
    }
}

public class Dancer implements TestInterface {
    public void bigAct(){
        println("i dance every day.i can be a great dancer.");
    }
}

测试代理类

public class ActionMain {

        public static void main(String[] args) {
            Programmer p2 = new Programmer();

            TestInterface p = new Proxy(p2).getInstace();
            p.bigAct();
            //这里看到p2注入到Proxy中，并返回了一个Instance对象，然后再执行p的bigAct方法。
            //具体Proxy.newInstance()实现是通过        
            //class.getConstructor().newInstance(Invocationhandler);
            //即 ConstructorAccessor.newInstance(Object[] var1);
            //我们可以在调用具体的方法前，做很多前置或者是后置操作，这也是aop的思想。
        }
}


public interface ConstructorAccessor {
    Object newInstance(Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException;
}

 

2）CGLib动态代理

第一步实现代理类

public class ProxyCglib implements MethodInteceptor{

    Object obj;

    public Object newInstance(Object object){
        this.obj = object;
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperClass(object.getClass());
        return enhancer.create();
    }

    @Override
    public void intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)throws Throwable {
        return method.invoke(obj,args);//两种方式都是通过反射来实现方法的调用。
    }
}

和jdk动态代理的区别就是cglib可以代理类，而jdk只能代理接口，如果没有实现接口，就代理不了，springboot动态代理自动在两者之间切换，如果类实现了接口就用jdk如果没有就用cglib。当然cglib动态代理还要引入asm的jar包。

两者代理的原理区别是：反射调用和fastclass引用

https://www.cnblogs.com/monkey0307/p/8328821.html   这篇文章给出了原理。

cglib 调用过程：代理对象执行 MethodA() ->拦截器methodInterceptor ->methodProxy.invokeSuper() ->被代理对象 执行方法，

之所以快就是因为asm包为代理类和被代理类的方法生成的fastClass，对应的是一个index，这样就可以根据这个index执行对应的方法，而j'd'k是使用反射调用。

> 原文如下：

调用过程：代理对象调用this.setPerson方法->调用拦截器->methodProxy.invokeSuper->CGLIB$setPerson$0->被代理对象setPerson方法

Cglib动态代理执行代理方法效率之所以比JDK的高是因为Cglib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个Class，
这个Class会为代理类或被代理类的方法分配一个index(int类型)。这个index当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，
这样省去了反射调用，

 

https://blog.csdn.net/yhl_jxy/article/details/80633194  这篇文章亦然。