【java】--- 静态代理、jdk动态代理和cglib剖析

Git地址：https://github.com/BeatBoxerLrd/MySSM

一、静态代理

代理类和被代理类实现同一接口，在编译之后，运行之前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了

缺点：如果接口增加一个方法，业务类实现之外，所有的代理类也需要实现此方法

1.首先定义一个接口，说明业务逻辑;

package com.derry.proxy;

/**
 * @Author:derry
 * @Description: 定义业务逻辑接口
 * @Date: Created in 15:13 2019/2/19
 * @Modified By:
 */
public interface Book {
    public void  addBook();
}

2.定义业务实现类，实现业务逻辑接口;

package com.derry.proxy.impl;

import com.derry.proxy.Book;

/**
 * @Author:derry
 * @Description:
 * @Date: Created in 15:26 2019/2/19
 * @Modified By:
 */
public class BookImpl implements Book {
    @Override
    public void addBook() {
        System.out.println("新增图书方法！");
    }
}

3：定义业务代理类：

通过组合，在代理类中创建一个业务实现类对象来调用具体的业务方法；

通过实现业务逻辑接口，来统一业务方法；

在代理类中实现业务逻辑接口中的方法时，进行预处理操作、通过业务实现类对象调用真正的业务方法、进行调用后操作的定义;

package com.derry.proxy.impl;

import com.derry.proxy.Book;

/**
 * @Author:derry
 * @Description:
 * 代理类和被代理类实现同一接口，在编译之后，运行之前就已经存在代理类的字节码文件，        
 * 代理类和委托类的关系在运行前就确定了
 * 缺点：如果接口增加一个方法，业务类实现之外，所有的代理类也需要实现此方法
 * @Date: Created in 15:29 2019/2/19
 * @Modified By:
 */
public class BookProxy implements Book {
    private BookImpl bookImpl;

    public BookProxy(BookImpl bookImpl) {
        this.bookImpl = bookImpl;
    }

    @Override
    public void addBook() {
        System.out.println("代理过程开始-------------");
        bookImpl.addBook();
        System.out.println("代理过程结束-------------");

    }
}

4.调用示例；

/**
 * @Author:derry
 * @Description:
 * 定义业务代理类：通过组合，在代理类中创建一个业务实现类对象来调用具体的业务方法；
 * 通过实现业务逻辑接口，来统一业务方法；
 * 在代理类中实现业务逻辑接口中的方法时，进行预处理操作、通过业务实现类对象调用真正的业务方法、进行调用后操作的定义。
 * @Date: Created in 15:32 2019/2/19
 * @Modified By:
 */
public class TestProxy {
    public static void main(String[] args) {
        Book bookProxy = new BookProxy(new BookImpl());
        bookProxy.addBook();
    }
}

5.调用结果；

jd

二、jdk动态代理

        JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的 业务实现类对象 以及 方法名 ，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。

       优点：解决了静态代理中，代理必须要实现接口中的方法。
       缺点：需要提供接口。

 1：首先，定义业务逻辑接口;

package com.derry.JdkProxy;

/**
 * @Author:derry
 * @Description: 业务类接口
 * @Date: Created in 16:04 2019/2/19
 * @Modified By:
 */
public interface Book {
    public void addBook();
}

2：然后，实现业务逻辑接口创建业务实现类;

package com.derry.JdkProxy.impl;

import com.derry.JdkProxy.Book;

/**
 * @Author:derry
 * @Description: 业务的真实实现类
 * @Date: Created in 16:05 2019/2/19
 * @Modified By:
 */
public class BookImpl implements Book {
    @Override
    public void addBook() {
        System.out.println("新增图书的方法！");
    }
}

3：最后,实现调用管理接口InvocationHandler(反射包下的),创建动态代理类;

package com.derry.JdkProxy.impl;



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Author:derry
 * @Description: jdk动态代理
 *  JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，
 *  JVM根据传进来的业务实现类对象以及方法名 ，
 *  动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。
 *  优点：解决了静态代理中，代理必须要实现接口中的方法
 *  缺点：需要提供接口
 * @Date: Created in 16:07 2019/2/19
 * @Modified By:
 */
public class JdkBookProxy implements InvocationHandler {
    //用于表示业务实现类对象，用来调用真正的实现方法
    private Object target;
    //绑定业务对象，并返回一个代理类
    public Object bind(Object target){
        this.target = target;
        //通过反射机制，创建一个代理类对象实例并返回。用户进行方法调用时使用
        /**三个参数，详细说明
          * 1.一个ClassLoader loader,定义了他由那个classLoader对象生成代理类进行加载
          * 2.一个Class<?>[] interfaces,定义了代理对象所提供的接口
          * 3.一个InvocationHandler h，表示当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象
          */
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),this.target.getClass().getInterfaces(),this);
    }



    //返回的代理类调用方法时，会执行到这里，最终通过反射完成调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        System.out.println("调用开始--------");
        //通过反射调用真正的业务实现方法
        result = method.invoke(target,args);
        System.out.println("调用完成----------");
        return result;
    }
}

4.调用示例；

package com.derry.Test;

import com.derry.JdkProxy.Book;
import com.derry.JdkProxy.impl.BookImpl;
import com.derry.JdkProxy.impl.JdkBookProxy;

/**
 * @Author:derry
 * @Description:
 * 在使用时，首先创建一个业务实现类对象和一个代理类对象，
 * 然后定义接口引用（这里使用向上转型）并用代理对象.bind(业务实现类对象)的返回值进行赋值。
 * 最后通过接口引用调用业务方法即可。
 * （接口引用真正指向的是一个绑定了业务类的代理类对象，所以通过接口方法名调用的是被代理的方法们）
 * @Date: Created in 16:23 2019/2/19
 * @Modified By:
 */
public class TestJdkProxy  {
    public static void main(String[] args) {
        BookImpl bookImpl = new BookImpl();
        JdkBookProxy proxy = new JdkBookProxy();
        Book book = (Book) proxy.bind(bookImpl);
        book.addBook();
    }
}

5.调用结果；

三、cglib动态代理

       解决了jdk动态代理必须提供接口的这个缺陷，但是对final修饰的类无法代理；因为其要为代理类生成父类，final无法被继承，enhancer.setSuperclass(this.target.getClass());

       cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理。

       注意：测试cglib代理，首先需要添加spring-core依赖；

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.0.1.RELEASE</version>
</dependency>

 1：首先定义业务类，无需实现接口（当然，实现接口也可以，不影响的，是由于setSuperclass源码）

public void setSuperclass(Class superclass) {
        if (superclass != null && superclass.isInterface()) {
            this.setInterfaces(new Class[]{superclass});
        } else if (superclass != null && superclass.equals(Object.class)) {
            this.superclass = null;
        } else {
            this.superclass = superclass;
        }

    }

package com.derry.CglibProxy.impl;

/**
 * @Author:derry
 * @Description:
 * @Date: Created in 17:32 2019/2/19
 * @Modified By:
 */
public class BookImpl {
    public void addBook(){
        System.out.println("新增图书！");
    }
}

2：实现 MethodInterceptor方法代理接口，创建代理类；

package com.derry.CglibProxy.impl;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Author:derry
 * @Description:
 * 解决了jdk动态代理必须提供接口的这个缺陷，但是对final修饰的类无法代理
 * cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。
 * 因为采用的是继承，所以不能对final修饰的类进行代理。
 * @Date: Created in 17:33 2019/2/19
 * @Modified By:
 */
public class CglibBookProxy implements MethodInterceptor {
    //业务类对象，供代理方法中进行真正的业务方法调用
    private Object target;

    //创建代理类对象
    public Object getInstance(Object target){
        this.target = target;
        //创建增强器，用来创建动态代理类
        Enhancer enhancer  = new Enhancer();
        //为加强器指定要代理的业务类，即为代理类指定父类
        enhancer.setSuperclass(this.target.getClass());
        //设置回调：用于代理类上所有方法的调用，都会调用callback
        enhancer.setCallback(this);
        //创建并返回动态代理类对象并返回
        return enhancer.create();
    }

    //回调方法的调用
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用开始-----");
        methodProxy.invokeSuper(o,objects);
        System.out.println("调用结束-----");
        return null;
    }
}

3.测试示例；

package com.derry.Test;

import com.derry.CglibProxy.impl.BookImpl;
import com.derry.CglibProxy.impl.CglibBookProxy;

/**
 * @Author:derry
 * @Description:
 * 创建业务类和代理类对象，然后通过代理类对象.getInstance(业务类对象)
 * 返回一个动态代理类对象（它是业务类的子类，可以用业务类引用指向它）。
 * 最后通过动态代理类对象进行方法调用。
 * @Date: Created in 18:06 2019/2/19
 * @Modified By:
 */
public class TestCglibProxy {
    public static void main(String[] args) {
        BookImpl bookImpl = new BookImpl();
        CglibBookProxy cglibBookProxy = new CglibBookProxy();
        BookImpl book = (BookImpl) cglibBookProxy.getInstance(bookImpl);
        book.addBook();
    }
}

4.完成调用；