静态代理 动态代理 cglib原理区分 设计模式

本文主要从三个方面介绍代理模式，什么是代理模式，提供了什么好处；代理模式的三种实现方式；三种代理的区别

首先简单说明下为什么需要代理模式：为其他对象提供一种代理以控制对这个对象的访问，可以隔离客户端和委托类的中介。我们还可以借助代理来在增加一些功能，而不需要修改原有代码。

重点是代理模式的三种实现方式：

先给出简单的接口和实现类：

public interface IHello {
    void sayHello();
}
public final class Hello implements IHello{
    @Override
    public void sayHello() {
        System.out.println("hello");

    }
}

1静态代理模式

public class StaticProxy {
    IHello hello;
    public StaticProxy(IHello hello){
        this.hello=hello;
    }
    public void syaHello(){
        System.out.println("before");
        hello.sayHello();
        System.out.println("after");
    }
    public static void  main(String  args[]){
        new StaticProxy(new Hello()).syaHello();
    }
}

输出为：

before
hello
after

2java动态代理实现的动态代理

//java动态代理实现的动态代理
public class DynamicProxy implements InvocationHandler {
    Object target;
    public DynamicProxy(Object target){
        this.target=target;
    }
    // 此处生成接口的实现类，所以需要有接口，无法代理未实现接口的类
    public Object bind(){
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
                    this.target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        method.invoke(this.target,args);
        System.out.println("after");
        return null;
    }

    public static void  main(String  args[]){
        //此处返回的必定是接口，不可以转为具体实体类，所以java反射要求被代理类必须实现了接口；但不要求final
       IHello hello = (IHello) new DynamicProxy(new Hello()).bind();
       hello.sayHello();
    }

}

java动态代理实现代理步骤：

a定义被代理类：接口及接口实现类

b定义代理类，代理类构造器传入被代理类，且需要实现InvocationHandler接口的类并重写invoke方法

c生成被代理的类的实例：调用 Proxy.newProxyInstance(被代理的类.getClass().getClassLoader(),

                                                                                        被代理的类.getClass().getInterfaces(),

                                                                                         InvocationHandler的实现类);

              注意：newProxyInstance返回的是接口类型，所以java动态代理要求被代理类实现接口。

d被代理的类的实例调用需要执行的方法

3cglib实现的动态代理

maven先引入包：

<dependency>

    <groupId>cglib</groupId>

    <artifactId>cglib</artifactId>

    <version>2.2.2</version>

</dependency>

public class CGLibProxy {
    public static void  main(String  args[]){
        Enhancer enhancer = new Enhancer();
        // 此处将目标类设置为父类，生成该类的子类来实现动态代理，所以如果此时将Hello类声明为final，则会报IllegalArgumentException；但不要求实现接口
        enhancer.setSuperclass(Hello.class);
        enhancer.setCallback(new MethodInterceptor(){
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("before");
                Object result = methodProxy.invokeSuper(o,objects);
                System.out.println("after");
                return result;
            }
        });
        Hello hello = (Hello)enhancer.create();
        hello.sayHello();
    }
}

Ehancer介绍：

Enhancer
Enhancer可能是CGLIB中最常用的一个类，和Java1.3动态代理中引入的Proxy类差不多(如果对Proxy不懂，可以参考这里)。和Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对fianl类进行代理操作。这也是Hibernate为什么不能持久化final class的原因。

public class SampleClass {
    public String test(String input){
        return "hello world";
    }
}

下面我们将以这个类作为主要的测试类，来测试调用各种方法

@Test
public void testFixedValue(){
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(SampleClass.class);
    enhancer.setCallback(new FixedValue() {
        @Override
        public Object loadObject() throws Exception {
            return "Hello cglib";
        }
    });
    SampleClass proxy = (SampleClass) enhancer.create();
    System.out.println(proxy.test(null)); //拦截test，输出Hello cglib
    System.out.println(proxy.toString()); 
    System.out.println(proxy.getClass());
    System.out.println(proxy.hashCode());
}

程序的输出为：

Hello cglib
Hello cglib
class com.zeus.cglib.SampleClass$$EnhancerByCGLIB$$e3ea9b7

java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Number

    at com.zeus.cglib.SampleClass$$EnhancerByCGLIB$$e3ea9b7.hashCode(<generated>)
    ...

上述代码中，FixedValue用来对所有拦截的方法返回相同的值，从输出我们可以看出来，Enhancer对非final方法test()、toString()、hashCode()进行了拦截，没有对getClass进行拦截。由于hashCode()方法需要返回一个Number，但是我们返回的是一个String，这解释了上面的程序中为什么会抛出异常。

Enhancer.setSuperclass用来设置父类型，从toString方法可以看出，使用CGLIB生成的类为被代理类的一个子类，形如：SampleClass$$EnhancerByCGLIB$$e3ea9b7

Enhancer.create(Object…)方法是用来创建增强对象的，其提供了很多不同参数的方法用来匹配被增强类的不同构造方法。（虽然类的构造放法只是Java字节码层面的函数，但是Enhancer却不能对其进行操作。Enhancer同样不能操作static或者final类）。我们也可以先使用Enhancer.createClass()来创建字节码(.class)，然后用字节码动态的生成增强后的对象。
 

原理上：

Java动态代理通过创建接口的实现类来完成对目标对象的代理，使用Java原生的反射API进行操作，在生成类上比较高效；但不能代理未实现接口的类；

CGLIB 在运行期间生成的是目标类扩展的子类，直接使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效；不能扩展final修饰的类或方法；

使用上：

Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类，但是不能代理final修改时的类；

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP 
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP ,spring中配置proxy-target-class='true'
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

借鉴：https://blog.csdn.net/danchu/article/details/70238002?utm_source=copy 

性能对比：

关于两者之间的性能的话，JDK动态代理所创建的代理对象，在以前的JDK版本中，性能并不是很高，虽然在高版本中JDK动态代理对象的性能得到了很大的提升，但是他也并不是适用于所有的场景。

主要体现在如下的两个指标中：

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

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

因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。
原文链接：https://blog.csdn.net/qq_35190492/article/details/103795708

什么时候应该使用动态代理？

aop就是一个很好的例子，我执行所有方法都需要记录日志，是不是所有方法都需要修改增加记录日志的逻辑？使用动态代理就不需要，
调用方法需要调用代理，代理除了调用方法会增加日志的逻辑，那么所有原方法就无须修改！！

spring的动态代理是怎么实现的？ 没有继承接口为什么也可以？
若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
优点：因为有接口，所以使系统更加松耦合
缺点：为每一个目标类创建接口
若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。
缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。