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

谁践踏了优雅 2022-05-09 14:54 175阅读 0赞

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

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

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

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

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先引入包：

<groupId>cglib</groupId>

<artifactId>cglib</artifactId>

</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的动态代理好。

[spring]: http://lib.csdn.net/base/17