（java反射-JDK动态代理）+CGLIB动态代理

一、动态代理的定义

代理类在程序运行时创建的代理方式被成为动态代理。静态代理是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

二、动态代理的两种方式：JDK动态代理和CGLIB动态代理

1、JDK动态代理

（1）实现方式

JDK是基于反射机制。

通过java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

最主要的特点就是，代理类必须和被代理类实现相同的接口，也就是说被代理类一定要有实现的接口，否则不可以使用JDK动态代理。

（2）代码如下：

接口：

/**
 * 
 * @version: 1.1.0
 * @Description: 食物接口
 * @author: wsq
 * @date: 2020年6月21日下午2:28:56
 */
public interface Food {
public void printName();
public void printPrice();
}

实现类：

/**
 * 
 * @version: 1.1.0
 * @Description: 实现类
 * @author: wsq
 * @date: 2020年6月21日下午9:10:17
 */
public class Fruit implements Food {

    @Override
    public void printName() {
        // TODO Auto-generated method stub
        System.out.println("My name is fruit!");
    }

    @Override
    public void printPrice() {
        // TODO Auto-generated method stub
        System.out.println("My price is the fruitPrice!");
    }

}

代理类：

/**
 * 
 * @version: 1.1.0
 * @Description: jdk动态代理类
 * @author: wsq
 * @date: 2020年6月21日下午2:32:03
 */
public class FruitProxy {
    private Fruit fruit;

    public FruitProxy(Fruit fruit) {
        this.fruit = fruit;
    }

    public Food getFruitProxy() {
        return (Food) Proxy.newProxyInstance(Fruit.class.getClassLoader(), Fruit.class.getInterfaces(),
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // TODO Auto-generated method stub
                        if (method.getName().equals("printName")) {
                            System.out.println("This is targetMethod printName!");
                        }
                        if (method.getName().equals("printPrice")) {
                            System.out.println("This is targetMethod printPrice!");
                        }
                        return method.invoke(fruit, args);
                    }
                });
    }
}

测试类：

/**
 * 
 * @version: 1.1.0
 * @Description: 测试类
 * @author: wsq
 * @date: 2020年6月21日下午2:45:53
 */
public class Test {
    public static void main(String[] args) {
        // 创建对象
        Fruit fruit = new Fruit();
        // 获取代理对象
        Food foodProxy = new FruitProxy(fruit).getFruitProxy();
        // 执行相应的方法
        foodProxy.printName();
        foodProxy.printPrice();
    }
}

2、CGLIB动态代理

（1）实现方式

利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理。

cglib代理的类，无需强制实现接口，其生成的代理类 是 被代理类的子类，并且重写的被代理类的方法，只需引包即可

<dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.2.12</version>
</dependency>

（2）代码如下：

实体类：

/**
 * 
 * @version: 1.1.0
 * @Description: 实体类
 * @author: wsq
 * @date: 2020年6月21日下午5:58:33
 */
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

代理类：

/**
 * 
 * @version: 1.1.0
 * @Description: 实体类的代理类
 * @author: wsq
 * @date: 2020年6月21日下午6:00:16
 */
public class PersonProxy {
    public Person getPersonProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Person.class);
        enhancer.setCallback(new MethodInterceptor() {

            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("This is cglibProxy!");
                // TODO Auto-generated method stub
                return proxy.invokeSuper(obj, args);
            }
        });
        return (Person) enhancer.create();
    }
}

测试类：

/**
 * 
 * @version: 1.1.0
 * @Description: 测试类
 * @author: wsq
 * @date: 2020年6月21日下午9:17:43
 */
public class Test {
public static void main(String[] args) {
    Person person = new PersonProxy().getPersonProxy();
    person.toString();
}
}

三、JDK动态代理和CGLIB动态代理的区别

1、JDK动态代理只能对实现了接口的类生成代理，而不能针对类；CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承）

2、JDK动态代理需要传入被代理的对象（聚合）；CGLIB动态代理不用；

3、CGLIB动态代理不可对final修饰的类进行代理

四、spring中的处理

1、当Bean实现接口时，Spring就会用JDK的动态代理

2、当Bean没有实现接口时，Spring使用CGlib是实现

五、效率

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

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

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