java动态代理和cglib动态代理

概念 

代理是指对类主要负责为委托了（真实对象）预处理消息、过滤消息、传递消息给委托类，代理类不现实具体服务，而是利用委托类来完成服务，并将执行结果封装处理，在spring 中的aop就是采用代理模式

静态代理

// 接口
public interface HelloInterface {
    void sayHello();
}

被代理的类

public class Hello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("Hello world!");
    }
}

代理类

public class HelloProxy implements HelloInterface{

    // 直接私有被代理类的对象，增强其方法
    private HelloInterface helloInterface = new Hello();

    @Override
    public void sayHello() {
        System.out.println("Before invoke sayHello" );
        helloInterface.sayHello();
        System.out.println("After invoke sayHello");
    }
}

调用

 public static void main(String[] args) {
     HelloProxy helloProxy = new HelloProxy();
     helloProxy.sayHello();
 }
    
输出：
Before invoke sayHello
Hello world!
After invoke sayHello

实现方式，私有被代理类对象，直接增强其方法，缺点明显，由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐，下面介绍动态代理

java动态代理

实现方式，利用反射机制在运行时创建代理类

• 通过实现 InvocationHandler 接口创建自己的调用处理器；
• 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
• 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
• 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

类与接口不变使用上述helloword

动态代理类

  invoke()方法的介绍如下：

        A.proxy：代表生成的代理对象

        B.method：代表目标方法

        C.args：代表目标方法的参数

        第一个参数proxy是jdk在运行时赋值的，在方法中直接使用，第二个参数后面介绍，第三个参数是方法执行的参数，这三个参数都是jdk运行时赋值的，无需程序员给出

public class ProxyHandler implements InvocationHandler{

    // 目标对象
    private Object object;

    public ProxyHandler(Object object){
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoke");

        // 调用目标方法
        method.invoke(object, args);

        System.out.println("After invoke");

        return null;
    }
}

调用

    public static void main(String[] args) {

        // 被代理对象
        HelloInterface hello = new Hello();
        // 代理对象
        InvocationHandler handler = new ProxyHandler(hello);
        // 传入被代理类的类加载器，一组接口，和处理器，在这里可以看出jdk动态代理基于接口
        // 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类
        // 反射机制
        HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);

        // 调用方法
        proxyHello.sayHello();
    }
    输出：
    Before invoke
    Hello world!
    After invoke 

JDK动态代理是基于接口的代理，它要求被代理的类必须实现一个接口，代理类实现该接口并在代理类中调用被代理类的方法。JDK动态代理使用Java自带的反射机制实现，因此它的效率比较高

关于jdk动态代理的概念本文介绍的不多，请至传送门详细了解

cglib动态代理

cglib 是一个基于 ASM 的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。cglib 通过继承方式实现代理，也就是基于类，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑

定义类

public class Hello{

    public void sayHello() {
        System.out.println("Hello world!");
    }
}

创建代理类，继承接口MethodInterceptor 

// 代理对象
class CglibInterceptor implements MethodInterceptor{

    //准备一个目标对象
    private Object target;

    //通过构造器传入目标对象
    public CglibInterceptor (Object target) {
        this.target = target;
    }

    /*
    * 用来获取代理对象(创建一个代理对象)
    * */
    public Object getProxy(){
        //可以通过Enhancer对象中的create()方法可以去生成一个类，用于生成代理对象
        Enhancer enhancer=new Enhancer();
        //设置父类(将目标类作为代理类的父类)
        enhancer.setSuperclass(target.getClass());
        //设置拦截器(回调对象为本身对象)
        enhancer.setCallback(this);
        //生成一个代理类对象并返回给调用着
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable{
    // 前置
    System.out.println("before");
    // 目标类的方法
	Object result = methodProxy.invoke(target, objects);
    // 后置
	System.out.println("after");
		
	return null;
    }
}

调用

 public static void main(String[] args) {
     Hello  helloProxy =(Hello)new CglibInterceptor(new Hello()).getProxy()
     helloProxy.sayHello();
 }
    
    
  

我们最终是要通过一个代理对象去调用方法的，那我们就要获取一个代理对象，cglib代理，是通过Enhancer这个类里面对应的一个create()方法，去生成一个代理对象的。

Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对fianl类进行代理操作。这也Hibernate为什么不能持久化final class的原因。

cglib体现的是继承思想，所以我们需要把代理类作为我们目标类的一个子类，也就是把目标类设置为父类，代理类去继承它。

在来个图，更加简单便捷

总结

java动态代理是实现了被代理对象的接口，cglib是继承了被代理对象，java和cglib都是在运行期生成字节码，生成代理对象，java是直接写Class字节码，cglib使用ASM框架写Class字节码，cglib代理实现更复杂，生成代理类比JDK效率低。