系统架构设计——设计模式之代理模式（二）CGLIB动态代理实现

最新推荐文章于 2024-03-01 08:00:00 发布
最新推荐文章于 2024-03-01 08:00:00 发布
阅读量1.2w 收藏 10
点赞数 3
分类专栏： java 架构设计 设计模式 文章标签： 系统架构 设计模式 设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25689397/article/details/51427164
版权
架构设计 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
java
11 篇文章 1 订阅
订阅专栏
设计模式
7 篇文章 0 订阅
订阅专栏

像上一篇所说的代理模式其实是静态代理，在实际开发中其实应用不大，因为他需要事先知道被代理对象是谁，而且被代理对象和代理对象实现了公共的接口。实际情况往往并不能满足这些条件，我们往往在写代理模式的时候并不知道到时候被代理的对象是谁。解决办法就是——动态代理。以下我们将使用CGLIB实现动态代理。

一、动态代理概述

程序在运行期而不是编译器，生成被代理对象的代理对象，并且被代理对象并不需要和代理对象实现共同的接口。基于此，我们可以利用代理对象，提供一种以控制对被代理对象的访问。

1.1 动态代理的原理

基于CGLIB的动态代理，其实就是利用了CGLIB，在运行时期生成被代理对象的子类，来作为代理对象。同时重写了被代理对象的所有方法。当我们用代理对象调用方法的时候，其实是调用的重写后的方法。该方法实际调用的是callback中的用户自定义的代码逻辑，例如权限验证。当验证通过了，则通过反射，反射出父类（被代理对象）的方法并调用（invoke）。
那么问题来了，如何生成被代理对象的子类呢？我们事先并不知道谁是代理对象啊？而且我们在重写调用自定义逻辑呢？

1.2 CGLIB动态代理的底层实现

CGLIB是一个强大的高性能的代码生成包。
1. 它广泛的被许多AOP的框架使用，例如：Spring AOP和dynaop，为他们提供方法的interception（拦截）；
2. hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联（对集合的延迟抓取，是采用其他机制实现的）；
3. EasyMock和jMock是通过使用模仿（moke）对象来测试Java代码的包。
它们都通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架)，来转换字节码并生成新的类。他其实就像JVM一样，可以加载一个指定的类。这样我们就可以实现在运行时期生成我们自定义的class了。下图为cglib与一些框架和语言的关系（CGLIB Library and ASM Bytecode Framework）
CGLIB结构

二、应用场景

  1. 远程代理：也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在不同地址空间的事实。例如：WebService、RPC、RMI(Remote Method Invocation)等。
  2. 虚拟代理：是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象。例如：利用虚拟代理来优化页面的打开速度。
  3. 安全代理：用来控制真实对象访问时的权限。一般用户对象应该在不同访问权限的时候。
  4. 智能指引：是指当调用真实的对象时，代理处理另外一些事情。例如：Spring AOP、Hibernate等。

三、结构图

这里写图片描述

四、实际例子

4.1 需求：为自定义的BookServiceBean动态生成代理对象，实现权限管理，只允许姓名为张三的对象可以操作。

4.2 代码示例

被代理对象

package com.xiaocao.proxy.cglib;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class BookServiceBean {

    private Logger log = LogManager.getLogger();
    public BookServiceBean() {
        log.info("this is bookservicebean 的构造方法");
    }
    public void create() {
        System.out.println("create() is running!");
    }
    public void query() {
        System.out.println("query() is running!");
    }
}

代理类

package com.xiaocao.proxy.cglib;

import java.lang.reflect.Method;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MyCglibProxy implements MethodInterceptor{

    private Logger log = LogManager.getLogger(MyCglibProxy.class);

    private String name;

    public MyCglibProxy(String name) {
        this.name = name;
    }

    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        log.info("调用的方法是：" + method.getName());
        log.info("实际调用者是： " + object.getClass());
        for (Object obj : objects) {
            log.info("方法参数类型为：" + obj.getClass());
        }

        if (!name.equals("张三")) {
            System.out.println("权限不够");
            return null;
        }
        Object result = methodProxy.invokeSuper(object, objects);
        System.out.println("这是方法后");
        return result;
    }
}

代理对象工厂

package com.xiaocao.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;

public class BookServiceFactory {

    private BookServiceFactory() {

    }
    public static BookServiceBean getProxyInstance(MyCglibProxy myProxy) {
        Enhancer enhancer = new Enhancer();
        // 将Enhancer中的superclass属性赋值成BookServiceBean
        enhancer.setSuperclass(BookServiceBean.class);
        // 将Enhancer中的callbacks属性赋值成myProxy
        enhancer.setCallback(myProxy);
        return (BookServiceBean) enhancer.create();
    }
}

测试类

测试类的主题部分很简单，只是通过工厂方法得到代理对象，然后调用，即可通过姓名判断是否有权限执行目标方法。
之后我用了许多反射机制来验证我之前想法，包括
1. 得到的代理对象其实是被代理对象的子类
2. 代理对象重写了被代理对象的所有方法，我们调用的时候其实是调用的被代理对象的重写方法

具体代码如下：

package com.xiaocao.proxy.cglib;

import java.io.File;
import java.io.FileOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Test {
    public static void main(String[] args) {
        Logger log = LogManager.getLogger();
        BookServiceBean service = BookServiceFactory.getProxyInstance(new MyCglibProxy("张三"));  
        service.create(); 

        log.info("我们得到的bean是：" + service.getClass());
        System.out.println("实际调用者的父类：" + service.getClass().getSuperclass());
        try {
            Class<?> c = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6");
            Class<?> beanc = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean");

            Method[] beanc_method = beanc.getMethods();
            int i = 1;
            System.out.println("原始的bean的方法总共" + beanc_method.length + "个");
            for (Method method : beanc_method) {

                System.out.println("原始的bean方法" + i++ + method.getName());

            }
            i = 1;
            Method[] methods = c.getMethods();
            System.out.println("我们得到的bean的方法总共" + methods.length + "个");
            for (Method method : methods) {
                System.out.println("我们得到的bean的方法" + i++ + method.getName());
            }
            System.out.println("原始的bean的父类：" + beanc.getSuperclass());
            System.out.println("我们得到的bean的父类：" + c.getSuperclass());

            Field[] bean_fields = beanc.getDeclaredFields();
            i = 1;
            for (Field field : bean_fields) {
                System.out.println("原始bean的属性 " + i++ + field);
            }

            Field[] fields = c.getDeclaredFields();
            i=1;
            for (Field field : fields) {
                System.out.println("我们得到的bean的属性 " + i++ + field);
            }
            Class proxyGenerator = Class.forName("sun.misc.ProxyGenerator");
            Method[] methods2 = proxyGenerator.getMethods();
            for (Method method : methods2) {
                System.out.println(method);
                byte[] TempProxySuper = (byte[]) method.invoke(proxyGenerator,"TempProxySuper", new Class[]{c.getSuperclass()});
                byte[] TempProxy = (byte[]) method.invoke(proxyGenerator,"TempProxy", new Class[]{c});
                byte[] TempBean = (byte[]) method.invoke(proxyGenerator,"TempBean", new Class[]{beanc});
                createClassFile("TempProxy",TempProxy);
                createClassFile("TempProxySuper",TempProxySuper);
                createClassFile("TempBean", TempBean);
                break;
            }

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
    /**
     * 生成class文件
     * @param fileName
     * @param classFile
     */
    public static void createClassFile(String fileName,byte[] classFile) {
        try {
            File file;
            FileOutputStream fos = new FileOutputStream(file = new File(fileName+".class"));
        fos.write(classFile);
            fos.flush();
            fos.close();
    System.out.println(file.getAbsolutePath());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

注意：代码中的com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6，是我之前测试得到代理类名称。

4.3 测试结果

这里写图片描述
这里写图片描述

测试代码的剩下部分是用来生成被代理类、代理类和代理类父类的class，其中用到了sun.misc.ProxyGenerator类的静态方法proxyGenerator,他需要的参数有
1. 生成的类名
2. 需要生成的class对象
返回值则是byte[]是java的bytecode，可以用来生成class文件。之后就是调用createClassFile生成class了。最后再**反编译（jd-gui反编译软件）**calss文件即可看到具体的类结构了。如下如（有删减）：

import com.xiaocao.proxy.cglib.BookServiceBean..EnhancerByCGLIB..f2cd59c6;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.MethodProxy;

public final class TempProxy extends Proxy
  implements BookServiceBean..EnhancerByCGLIB..f2cd59c6
{
  private static Method m1;
  private static Method m3;
  private static Method m7;
  private static Method m2;
  private static Method m9;
  private static Method m18;
  private static Method m20;
  private static Method m0;
  private static Method m15;
  private static Method m11;
  private static Method m14;
  private static Method m13;
  private static Method m19;
  private static Method m12;
  private static Method m4;
  private static Method m17;
  private static Method m6;
  private static Method m16;
  private static Method m8;
  private static Method m10;
  private static Method m5;

  public TempProxy(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final Object newInstance(Callback[] paramArrayOfCallback)
    throws 
  {
    try
    {
      return (Object)this.h.invoke(this, m3, new Object[] { paramArrayOfCallback });
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final void query()
    throws 
  {
    try
    {
      this.h.invoke(this, m7, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final void create()
    throws 
  {
    try
    {
      this.h.invoke(this, m6, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

    ......

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("newInstance", new Class[] { Class.forName("[Lnet.sf.cglib.proxy.Callback;") });
      m7 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("query", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m9 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("getCallback", new Class[] { Integer.TYPE });
      m18 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("getClass", new Class[0]);
      m20 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("notifyAll", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m15 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("wait", new Class[0]);
      m11 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("CGLIB$SET_STATIC_CALLBACKS", new Class[] { Class.forName("[Lnet.sf.cglib.proxy.Callback;") });
      m14 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("setCallbacks", new Class[] { Class.forName("[Lnet.sf.cglib.proxy.Callback;") });
      m13 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("setCallback", new Class[] { Integer.TYPE, Class.forName("net.sf.cglib.proxy.Callback") });
      m19 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("notify", new Class[0]);
      m12 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("CGLIB$SET_THREAD_CALLBACKS", new Class[] { Class.forName("[Lnet.sf.cglib.proxy.Callback;") });
      m4 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("newInstance", new Class[] { Class.forName("[Ljava.lang.Class;"), Class.forName("[Ljava.lang.Object;"), Class.forName("[Lnet.sf.cglib.proxy.Callback;") });
      m17 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("wait", new Class[] { Long.TYPE });
      m6 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("create", new Class[0]);
      m16 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("wait", new Class[] { Long.TYPE, Integer.TYPE });
      m8 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("CGLIB$findMethodProxy", new Class[] { Class.forName("net.sf.cglib.core.Signature") });
      m10 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("getCallbacks", new Class[0]);
      m5 = Class.forName("com.xiaocao.proxy.cglib.BookServiceBean$$EnhancerByCGLIB$$f2cd59c6").getMethod("newInstance", new Class[] { Class.forName("net.sf.cglib.proxy.Callback") });
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

4.4 补充

现在，如果我们需要进行半开放的权限验证，也就是对于create需要权限验证，而对已query则不需要。
当然，我们完全可以在MyCglibProxy的intercept方法进行判断，如果是create方法才进行验证。这样做是可行的，但是似乎有点违反单一职责的编程原则，更好的方法应该是引入filter机制，实现过滤验证。下面我们将引入一个MyProxyFilter 类。

package com.xiaocao.proxy.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.CallbackFilter;

public class MyProxyFilter implements CallbackFilter{

    @Override
    public int accept(Method method) {
        if(!"query".equalsIgnoreCase(method.getName()))     
            return 0;     
        return 1;  
    }   
}

另外，我们需要将此拦截器应用到工厂方法中，让其生效。

Enhancer enhancer = new Enhancer();
        // 将Enhancer中的superclass属性赋值成BookServiceBean
        enhancer.setSuperclass(BookServiceBean.class);
        // 将Enhancer中的callbacks属性赋值成myProxy
        enhancer.setCallbacks(new Callback[]{myProxy,NoOp.INSTANCE});
        // 将Enhancer中的callbackfilter属性赋值成MyProxyFilter
        enhancer.setCallbackFilter(new MyProxyFilter());
        return (BookServiceBean) enhancer.create();

接下来就是测试了

BookServiceBean service = BookServiceFactory.getProxyInstance(new MyCglibProxy("张三"));  
        service.create(); 

        BookServiceBean service2 = BookServiceFactory.getProxyInstance(new MyCglibProxy("李四"));  
        service2.create();
        service2.query();

输出结果为：
这里写图片描述

注意: setCallbacks中定义了所使用的拦截器，其中NoOp.INSTANCE是CGlib所提供的实际是一个没有任何操作的拦截器，
他们是有序的,一定要和CallbackFilter里面的顺序一致。上面return返回(0/1)的就是返回的顺序。也就是说如果调用query方法就使用NoOp.INSTANCE进行拦截。

五、动态代理的认识

动态代理的实现可以说是一个比较综合的Java技术应用实现，他的作用是显著的，完全提供了一种AOP面向切面编程的可行性，也为远程过程调用提供了基础支持。总结一下运用的知识：
1. 多态和继承。代理对象和被代理对象的继承关系，实现了重写被代理对象所有方法，有选择性的运行逻辑代码。另外，工厂返回的是子类，让使用者就像调用被代理对象一样方便，这也是多态的体现。
2. 反射机制。动态代理里面大量运用了反射机制，比如对被代理对象的反射，对代理对象的class进行反射，对调用父类方法的反射等等。
3. 动态生成class。这里需要了解JVM生成calss很多细节，好在CGLIB做到了很好的封装底层的ASM实现。这也是实现动态代理的核心。

六、优缺点

优点

有点是显然的，这里就不在赘述了，前面提到很多次了。
缺点
1. 因为动态代理的底层实现需要用到反射机制和动态生成并加载class，所以效率会大打折扣。
所以，在我们实际应用中，应该谨慎使用。
2. 应为需要重写被代理对象的所有方法，且需要继承被代理对象。所以被代理对象必须不能是fianl修饰的，属性方法都不可以。另外，java也有一套实现动态代理的机制，这里就不在赘述了。需要注意的是，java的动态代理与CGLIB不同，java的实现需要被代理对象实现指定的接口。

在此感谢山的那边——cglib动态代理介绍（一）。

注意：转载请标明，转自itboy-木小草。
尊重原创，尊重技术。

木小草
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态代理模式，Cglib的依赖包
04-29
和设计模式，代理模式博客有关联（https://blog.csdn.net/qq_41037075/article/details/124500915?spm=1001.2014.3001.5502）需要大家建立一个目录lib(命名随意)，将jar包拷贝进去，然后右击进行add as library导入。
Java设计模式及应用场景之《代理模式》
12-21
文章目录一、代理模式定义二、代理模式的结构和说明三、代理模式的分类四、代理模式示例五、动态代理1、JDK动态代理JDK动态代理使用步骤JDK动态代理示例JDK动态代理实现原理JDK动态代理局限性2、CGLIB动态代理CGLIB动态代理使用步骤CGLIB动态代理示例CGLIB动态代理实现原理CGLIB动态代理注意事项六、三种代理方式的对比七、代理模式的应用场景及案例 一、代理模式定义 Provide a surrogate or placeholder for another object to control access to it. 为其它对象提供一种代理以控制对这个对象的访问。   代理
CGLIB实现动态代理详解！！！
最新发布
程序员阿皓的博客
03-01 629
使用CGLIB比原生动态代理更加灵活，不需要代理实现接口的类。希望对看到本文的你有帮助。上一篇Java静态代理和动态代理详解！！下一篇Java SPI机制详解Java SPI机制详解。
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
动态代理的代码例子 里面敲好了注释 搭配文章观看更好
java设计模式【之】Cglib动态代理【源码】【场景：帮爸爸买菜】
03-31
java设计模式【之】Cglib动态代理【源码】【场景：帮爸爸买菜】 /** * 代理模式 * 在开发者的角度来看，创建一个代理对象，提供给用户使用，避免用户直接访问真正的对象 * 在用户角度来看，就是普通的类方法调用 * <p> * 作用 * 1.保护被代理对象 * 2.增强被代理对象 * 3.完全替换被代理对象 * <p> * Cglib代理（子类代理） * 可以在运行期，扩展java类与实现接口，在内存中创建一个子类对象，实现代理功能 * 底层通过字节码处理框架ASM,转换字节码并生成新的类 * 被代理类都不需要实现接口 * 代理类需要实现 MethodInterceptor（方法拦截器） * <p> * 1.创建被代理类、创建代理类、代理类内部聚合被代理类 * 2.创建返回代理类实例方法 Enhancer.create(object.getClass(), this); * (1.创建工具类，2.设置工具类的父类为被代理类 3.设计监听回调为当前this 4.return 创建代理类实例对象) * 3.实现接口方法（调用 method.
设计模式之代理模式proxy.zip
12-29
代码仅供参考学习 。
动态代理模式详解
qq_43814760的博客
04-20 6568
目录 （一）什么是动态代理模式 （二）动态代理模式入门案例 1.完成一个账户转账的功能 2.v1.0版本为转账添加一个事务 3.v2.0将事务从业务层和从持久层剥离 4.v3.0将事务使用动态代理完成 （一）什么是动态代理模式 动态代理是java的一种设计模式。它的特征就是委托类和代理类具有相同的接口，代理类是在委托类的代码基础上添加了其他功能，比如消息预处理、消息过滤和事后处理消息等。但是实际上业务逻辑还是有委托类去完成的，简单来说，调用委托类的时候是通过代理对象来实现的。 代.
CGLIB动态代理详解分析
weixin_43397326的博客
07-06 4758
CGLIB是强大的、高性能的代码生成库，被广泛应用于AOP框架，它底层使用ASM来操作字节码生成新的类，为对象引入间接级别，以控制对象的访问。CGLIB相比于JDK动态代理更加强大，JDK动态代理只能对接口进行代理，而CGLIB既可以代理普通类，也能够代理接口。
动态代理模式
qq_38526245的博客
06-30 2994
代理图解 客户端需要使用业务A，正常操作是new 接口，通过对象调用业务A 代理模式：代理类拿到接口对象（委托类对象），并对委托类的实现类进行封装，同时可以对业务进行前置增强和后置增强 1.静态代理 用代码来解释上图 接口（委托类） public interface Person { void findLove(); } 实现类 public class PersonImpl implements Person { @Override public void fin
动态代理模式 -- Cglib代理
weixin_43739348的博客
03-19 1143
静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个 单独的对象,并没 有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是 Cglib 代理Cglib代理也叫作 子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的框架使用,例如 SpringAOP，实现方法拦截。
动态代理的理解及入门
黄帅帅的博客
04-09 2211
动态代理
spring AOP
CloudLai的博客
05-25 260
1.前置知识讲解： a)什么是动态代理：相对于静态代理 b)Jdk动态代理： i.新建接口Task如下： public interface Task { public void doSomeThing(); } ii.新建类Person实现Task接口，并覆盖抽象方法doSomething如下： public class Person implements Task{ publi...
cglib之Enhancer
weixin_30591551的博客
09-20 180
1. 背景 cglib库的Enhancer在Spring AOP中作为一种生成代理的方式被广泛使用。本文针对Enhancer的用法以实际代码为例作一些介绍。 2. Enhancer是啥 Enhancer是cglib中使用频率很高的一个类，它是一个字节码增强器，可以用来为无接口的类创建代理。它的功能与java自带的Proxy类挺相似的。它会根据某个给定的类创建子类，并且所有非final的方法都带有回...
cglib动态代理
热门推荐
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
CGLIB 动态代理
m0_61609890的博客
03-11 6886
目录 CGLIB 动态代理 简单结构: 添加依赖 定义类 CGLIB 动态代理 JDK的动态代理机制只能代理实现了接口的类。而不能实现接口的类就不能使用JDK的动态代理，CGLIB是针对类来实现代理的，它的原理是对指定目标类生成一个子类，并覆盖其中的方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 简单结构: 实现原理:继承思想 代理类继承目标类，重写目标类中的方法， CGLIB像是一个拦截器，在调用我们的代...
代理模式：一文彻底搞懂静态代理和动态代理
qq_36756227的博客
06-11 8433
代理模式（Proxy Pattern）是一种结构型设计模式，它的概念很简单，它通过创建一个代理对象来控制对原始对象的访问。代理模式主要涉及两个角色：代理角色和真实角色。代理类负责代理真实类，为真实类提供控制访问的功能，真实类则完成具体的业务逻辑。这样，当我们不方便或者不能直接访问真实对象时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。代理模式的原理是将真实类的功能封装在代理类中，最基本的方式就是创建一个代理类，代理类实现和真实类相同的接口，并且在代理类中引用真
【cglib实现动态代理】
edwer93的博客
11-29 1012
cglib是是第三方的工具库。其原理是继承，cglib通过继承目标类，创建他的子类，在子类当中重写父类的相关方法，实现功能的增强。
动态代理实现的两种方式
itbird的专栏
09-28 1710
我们知道不管静态代理还是动态代理，实际上都是对于源对象的一种控制，通过代理对象来间接访问目标对象。但是静态代理有以下两个问题静态代理存在的问题是：1）一旦接口新增或者修改，那么代理对象和被代理对象就得去适配修改2）静态代理是在代码编写时，去生成的，class文件必然会造成类爆炸的风险有没有方案解决以上的问题呢？显然是有的，那就是动态代理。动态代理，顾名思义，就是在运行时去动态生成代理，我们下面分别说两种实现方式，分别为JDK和Cglib。
代理模式jdk和cglib代理模式对比
06-10
代理模式是一种结构型设计模式，它允许你提供一个代替另一个对象的替身或占位符，以便控制对原对象的访问。Java中有两种代理模式：JDK动态代理和CGLIB代理。 JDK动态代理和CGLIB代理的主要区别在于代理对象的创建方式不同。JDK动态代理是基于接口的代理，它是通过反射机制在运行时生成代理类，而CGLIB代理则是基于类的代理，它是通过继承原始类并重写其方法来生成代理类。 JDK动态代理优点在于可以代理任意实现了接口的类，而CGLIB代理则可以代理没有实现接口的类。另外，JDK动态代理的代理类更加轻量级，不会在内存中生成过多的代理类，而CGLIB代理则会在内存中生成大量的代理类。 总的来说，JDK动态代理适用于代理接口，而CGLIB代理适用于代理类。选择哪种代理方式取决于具体的需求和场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值