【Java】深入理解动态代理：JDK、CGLIB

最新推荐文章于 2021-02-21 10:29:59 发布
最新推荐文章于 2021-02-21 10:29:59 发布
阅读量259 收藏 1
点赞数
分类专栏： Java 文章标签： java proxy 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beFocused/article/details/107876211
版权

代理模式

     日常生活中代理司空见惯的，比如某地区总代理，直白点就是中间商。在代码的世界里也有这种“中间商”，不过这个“中间商”不收差价，有时候甚至给你点额外的“小惊喜”。

    代理模式有3个要素：接口、目标类(委托人)、代理类(中间商)。目标类、代理类都实现同一个接口，代理类有一个目标类的属性。客户所有的请求都是到代理类对象，代理对象转发到目标对象。

  

那么前面说的“小惊喜”是什么呢？ 代理对象在找目标对象之前，可以自己做一些扩展。

  • 代理商可以提前备一些货，直接给到你，无需找厂家 ---- 缓存
  • 如果某个品牌货厂家不生产了，可直接告诉你，无需你去厂家确认 ---- 扩展限制条件

所以代理模式有以下好处：

  1. 屏蔽底层的实现；
  2. 遵守设计模式的开闭原则，欢迎扩展、拒绝修改。

动态代理

    一般情况要实现代理模式，开发者需要显示创建代理类，然后编译打包运行，我们称为静态代理。不过，由于jvm类加载的机制，允许开发者主动加载某个类，开发者可以在程序运行时动态创建代理类，然后通过类加载器加载到jvm，实例化代理对象，这就是动态代理。动态代理的核心是如何生成代理类。目前，有两种方式生成动态代理：JDK动态代理、CGLIB动态代理。

JDK动态代理

    jdk动态代理是jdk自带的动态代理方式，核心组件有java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler(接口)。jdk动态代理稍微修改了代理模式模型-引入了InvocationHandler。jdk动态代理生成代理类之后的类图模型如下：

    jdk生成的代理类ProxyClass继承java.lang.reflect.Proxy，后者有个成员变量h(java.lang.reflect.InvocationHandler)，开发者可以在InvocationHandler实现类中关联目标对象(TargetClass)。创建代理对象的实现需要传入InvocationHandler的实现类。引入InvocationHandler有两点作用：

  • 创建代理类更简单，直接把所有的请求转发到InvocationHandler#invoke即可，由InvocationHandler#invoke完成分发调用目标对象的方法；
  • 让开发者可以非常方便实现扩展功能，InvocationHandler#invoke在分发请求之前、之后、异常等位置扩展功能。

    jdk动态代理使用起来很简单，直接拿例子说吧。如下图，假设有LocalWriterPrinter实现3个接口Priter、Writer、WriterPrinter，我们对目标对象(LocalWriterPrinter)做动态代理，在方法前后加上额外的信息。

目标类LocalWriterPrinter实现3个接口： 

public class LocalWriterPrinter implements Writer, Printer, WriterPrinter {
    public String print(String text) {
         System.out.println(this.getClass().getSimpleName() + " print:" + text);
         return text;
    }

    public String write(String text) {
        System.out.println(this.getClass().getSimpleName() + " write:" + text);
        return text;
    }
}

Jdk动态代理是通过InvocationHandler#invoke分发代理请求，所以需要一个InvocationHandler实现类WriterPrinterInvocationHandler，目标类对象printer是其成员变量。我们在调用目标类对象之前、之后还有finlly都做一个额外的事情(例子只打个日志)

public class WriterPrinterInvocationHandler implements InvocationHandler {

    private Object printer;

    public WriterPrinterInvocationHandler(Object writerPrinter) {
        this.printer = writerPrinter;
    };

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            System.out.println("before advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
            Object ret = method.invoke(printer, args);
            System.out.println("after advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
            return ret;
        } finally {
            System.out.println("finally advice:" + method.getDeclaringClass().getSimpleName() + "." +  method.getName());
        }
    }
}
public class JdkDynamicDemo {

    public static void main(String... args) {
        //创建目标类对象
        LocalWriterPrinter target= new LocalWriterPrinter();
        //创建InvocationHander，并将目标类对象作为属性
        WriterPrinterInvocationHandler handler = new WriterPrinterInvocationHandler(target);
  
        Class<?>[] infs = {Printer.class, WriterPrinter.class, Writer.class};
        //调用Proxy.newProxyInstance创建代理类对象
        Object writerPrinter = Proxy.newProxyInstance(JdkDynamicDemo.class.getClassLoader(), infs, handler);
        //执行代理类对象的print方法
        Printer printer = (Printer)writerPrinter;
        printer.print("jdk dynamic");
        //执行代理类对象的write方法
        Writer writer = (Writer) writerPrinter;
        writer.write("jdk dynamic");
    }
}

运行结果如下：

我们看以下生成的代理类是什么样的（用jdk的HSDB工具导出代理类）

package com.sun.proxy;

import com.focuse.dynamicdemo.jdkproxy.Printer;
import com.focuse.dynamicdemo.jdkproxy.Writer;
import com.focuse.dynamicdemo.jdkproxy.WriterPrinter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Printer, WriterPrinter, Writer {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;
    private static Method m4;

    public $Proxy0(InvocationHandler var1) {
        super(var1);
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.focuse.dynamicdemo.jdkproxy.Printer").getMethod("print", Class.forName("java.lang.String"));
            //笔者注：write方法来源于WritePrinter，因为传入的接口数组中WritePrinter接口在前,Writer接口在后
            m4 = Class.forName("com.focuse.dynamicdemo.jdkproxy.WriterPrinter").getMethod("write", Class.forName("java.lang.String"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    public final boolean equals(Object var1) {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String write(String var1) {
        try {
            return (String)super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String print(String var1) {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
}

h就是创建代理对象时传入的InvocationHandler实例，看到代理类的代码一切都清晰了，所的请求的都转到InvocationHandler实例h处理。InvocationHandler#invoke第一个参数是代理对象，第二个参数是被代理接口的method，第三个参数请求的实际参数。显而易见，jdk动态代理有以下特点：

  • JDK动态代理支持对Interface生成代理类，不支持对Class生成代理类；
  • 所有的代理请求都是通过InvocationHandler#invoke转发，开发者可以在这里干任何想干的事情；
  • 如果多个接口类中有相同签名的方法(名称、参数个数、参数类型)，代理类传给InvocationHandler#invoke的method参数来源于第一个接口类，例如本例中write方法就是来源于WritePrinter接口。

CGLIB动态代理

    不同于JDK动态代理，CGLIB是通过生成目标类的子类实现的。核心组件是net.sf.cglib.proxy.Enhancer和net.sf.cglib.proxy.Callback。Callback相当于JDK动态代理中的InvocationHandler。其实，CGLIB的功能只是增强父类的逻辑，要用它实现代理模式，需要在Callback里关联目标对象。子类的逻辑是如果Callback不为空执行Callback，否则执行父类方法。

    CGLIB提供四种Callback子类型，一般做动态代理的是net.sf.cglib.proxy.MethodInterceptor：

咋一看这个类图看不出是代理模式，我们转换一下画一个对象图就看得明白了。我们用黑心圆点表示实例关系，如下图，代理对象和目标对象都是目标类的实例，代理对象实际是目标类子类(代理类)的实例。

同样，我们举个小栗子，对Printer类做动态代理，并在print方法之前、之后、finally位置做一些扩展(本例仅仅打个日志)。首先看一下原来的Printer类

public class Printer {

    public String print(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }

    protected String print22(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }

    private String print33(String text) {
        System.out.println("Local Printer:" + text);
        return text;
    }
}

其次，实现一个MethodInterceptor，目标对象作为其成员变量，并在调用目标对象方法之前、之后、finally位置加上相应日志。

public class LocalPrinterCallback implements MethodInterceptor {

    Object target;

    public LocalPrinterCallback(Object target) {
        this.target = target;
    }
    //代理
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                            MethodProxy proxy) throws Throwable{
        try {
            System.out.println("before advice");
            //请求目标对象方法
            Object ret = method.invoke(target, args);
            System.out.println("after advice");
            return ret;
        }finally {
            System.out.println("finally advice");
        }
    }

}

接下来就是开始用CGLIB进行动态代理 

public class CglibDynamicDemo {

    public static void main(String... args) {
        //目标对象
        Printer target = new Printer();
        //callback  目标对象作为其成员变量
        LocalPrinterCallback localCallback = new LocalPrinterCallback(target);
        //创建enhancer类
        Enhancer enhancer = new Enhancer();
        //设置需要增强的类Printer
        enhancer.setSuperclass(Printer.class);
        //设置callback 相当于jdk动态代理的InvocationHandler
        enhancer.setCallback(localCallback);
        //创建代理类并返回代理对象
        Object object = enhancer.create();
        Printer proxy = (Printer)object; 
        //执行print方法
        proxy.print("cglib demo");
    }
}

运行结果如下，期望在增强的位置打出相应的信息：

我们看一下CGLIB生成的代理类是什么样的(也是用jdk的HSDB工具导出代理类) 。cglib生成的代理类比jdk动态代理生成的代理类相对复杂一些。不过，我们主要看一下print方法的实现，不难看出，print方法的逻辑是当callback不为空null时就去调用callback的net.sf.cglib.proxy.MethodInterceptor#intercept方法(本例中callback是MethodInterceptor类型)。同时，我们也看到cglib只对public和protected修饰的方法做代理，private方法则不做。

package com.focuse.dynamicdemo.cglibproxy;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class Printer$$EnhancerByCGLIB$$9402db17 extends Printer implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$print$0$Method;
    private static final MethodProxy CGLIB$print$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$print22$1$Method;
    private static final MethodProxy CGLIB$print22$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;

    public Printer$$EnhancerByCGLIB$$9402db17() {
        CGLIB$BIND_CALLBACKS(this);
    }

    static {
        CGLIB$STATICHOOK1();
    }

    ......(略)

    public final String print(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$print$0$Method, new Object[]{var1}, CGLIB$print$0$Proxy) : super.print(var1);
    }

   

    protected final String print22(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$print22$1$Method, new Object[]{var1}, CGLIB$print22$1$Proxy) : super.print22(var1);
    }

    

    ......（略）


    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer$$EnhancerByCGLIB$$9402db17");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"print", "(Ljava/lang/String;)Ljava/lang/String;", "print22", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer")).getDeclaredMethods());
        CGLIB$print$0$Method = var10000[0];
        CGLIB$print$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print", "CGLIB$print$0");
        CGLIB$print22$1$Method = var10000[1];
        CGLIB$print22$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print22", "CGLIB$print22$1");
        var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$2$Method = var10000[0];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[1];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[2];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[3];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    }

    final String CGLIB$print$0(String var1) {
        return super.print(var1);
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Printer$$EnhancerByCGLIB$$9402db17 var1 = (Printer$$EnhancerByCGLIB$$9402db17)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    final String CGLIB$print22$1(String var1) {
        return super.print22(var1);
    }

}

总结

这里介绍代理模式、动态代理以及动态代理的两种方式：JDK自带方式动态代理、CGLIB创建动态代理，总结一下

  • 代理模式三要素：代理类(代理对象)、目标类(目标对象)、二者共同的接口
  • JDK动态代理引入了InvocationHandler接管并分发所有的请求
  • JDK动态代理只能对Interface做动态代理，不能对Class做代理
  • CGLIB对Class做代理，其实现方式是生成目标类的子类
  • CGLIB实现请求转发到目标对象是通过Callback接口，CGLIB提供了6中Callback子类型，常用做动态代理的是net.sf.cglib.proxy.MethodInterceptor

 

 

北堂桓禧
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java--JDK动态代理核心源码解析
weixin_30564785的博客
12-06 60
1、首先我们了解一下JDK动态代理的使用方法： public static void main(String[] args) { /** * 创建一个Bean对象，该对象实现BeanInterFace接口 */ BeanInterFace bean = new Bean(); /** ...
JDK动态代理详解
chengnuan3219的博客
12-31 96
要了解JDK动态代理，首先要了解代理，以及代理的用途，下面就稍微简单说一下。 什么是代理？？？ 先百度一下代理。。。 ps:当然没人不知道代理的意思，但是在了解一件事情的时候，必须搞清楚事情的概念，也就是定义，世界上的任何可知的事物都有定义，我们需要知道的是被绝大多数人认可...
JDK动态代理(介绍理解，如何实现)
热门推荐
TxCode的博客
01-26 2万+
动态代理（理解）： 基于反射机制 1.什么是动态代理 ？ 使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。 动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。 jdk动态代理，必须有接口，目标类必须实现接口， 没有接口时，需要使用cglib动态代理 2.知道动态代理能做什么 ？ 可以在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码。 程序开发中的意思。 比如：你所在的项目中，有一个功能是其他人（公司的其它部门，其它小组的人
一文理解JDK静态代理、JDK动态代理、Cglib动态代理
July的博客
10-23 3593
代理模式 通过代理来访问真实的对象，而不是直接去访问真正干活的对象，比如二房东租房，二房是代理者，而一房东才是真正的房东 适用场景 需要动态修改方法参数 方法执行日志功能，比如AOP实现方法拦截记录日志 安全检查，比如方法执行时的权限校验 角色说明 抽象角色：声明代理对象和真实的对象的共同接口（接口或抽象类） 代理角色：代理角色内部包含对真实对象的引用，从而可以操作真实的对象，同时代理对象与真实对象拥有同样的接口以便在任何时候都能够替代真实对象。并且代理对象可以对真实对象附加操作，相当于对真实对
java method方法_Java Method getDeclaringClass()方法
weixin_32060735的博客
02-21 4313
Java Method getDeclaringClass()方法java.lang.reflect.Method.getDeclaringClass()方法返回表示声明由此Method对象表示的方法的类的Class对象。1 语法public Class getDeclaringClass()2 参数无3 返回值一个表示底层成员声明类的对象。4 示例package com.yiidian;/***...
JDK动态代理和Cglib动态代理实例源码
最新发布
01-04
通过分析`DynamicProxyTest`源码，我们可以更深入地理解JDK和Cglib动态代理的工作原理，以及它们在实际应用中的用法。动态代理在AOP（面向切面编程）、缓存、日志记录、事务管理等多个场景中都有广泛应用，是Java...
浅谈JDK动态代理与CGLIB代理去区别
03-01
本篇文章将深入探讨JDK动态代理和CGLIB代理的区别，以及它们在实际应用中的选择。 首先，JDK动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类用于创建一个代理对象...
java 动态代理实例（JDK代理与CGLIB代理）
08-09
通过阅读和理解这些代码，你可以更深入地了解Java动态代理的工作原理和实际应用。 Java动态代理广泛应用于AOP（面向切面编程），例如Spring AOP框架，日志记录，性能监控，事务管理等场景。通过动态代理，我们可以...
基于MAVEN项目的CGLib动态代理原理及实现
01-15
本文将深入探讨如何在基于Maven的项目中利用CGLib库实现动态代理。CGLib（Code Generation Library）是Java中一个高性能的代码生成库，它在运行期通过字节码技术为类创建子类，以此实现动态代理。 1. Maven项目配置...
jdk与cglib动态代理与底层实现
12-21
在Java编程领域，代理模式...了解并掌握JDK和CGLIB动态代理的原理及使用，对于深入理解Spring框架和提升Java开发能力至关重要。通过实践案例，你可以进一步探索这两个代理机制的实现细节，从而更好地应用在实际项目中。
关于this.getClass().getSuperClass().getName()与super.getClass()
kenzyq的博客
10-09 1267
直接看代码的打印输出： /** * Created by TK on 2016/9/24. */ public class Son extends Father { public void getSuperClass(){ System.out.println(this.getClass().getSuperclass().getName());
使用CGLib实现动态代理
HHHheziyan的博客
07-09 366
CGLib动态代理 程序执行时通过ASM（开源的Java字节码编辑库，操作字节码）jar包动态地为被代理类生成一个代理子类，通过该代理子类创建代理对象，由于存在继承关系，所以父类不能使用final修饰。CGLib动态代理实现 1、导入两个架包 package com.zzu.cglib; public class CalculatorService { p...
Java中关于类.Class()、对象.getCalss、对象.getClass().getName()的区别
呵呵喝何何
09-07 6027
1.获取Class对象的三种方式     ①通过类名获取       类名.class     ②通过对象获取      对象名.getClass()     ③通过全限定类名获取（必须添加完整包名） public static void main(String[] args) { List list = new ArrayList(); System.out.prin...
整理Java反射常用方法
Rukey7的博客
07-26 2085
整理常用的Java反射相关的方法，方便查询记忆。
RequestBodyAdvice和RequestBodyAdvice在SpringMVC项目中的使用
pongandnoon的博客
11-26 1万+
在实际项目中，我们常常需要在请求前后进行一些操作，比如：参数解密/返回结果加密，打印请求参数和返回结果的日志等。这些与业务无关的东西，我们不希望写在controller方法中，造成代码重复可读性变差。这里，我们讲讲使用@ControllerAdvice和RequestBodyAdvice、RequestBodyAdvice来对请求前后进行处理（本质上就是AOP），来实现日志记录每一个请求的参数和返...
SpringAop在项目中的一些巧妙使用（一）---方法执行时间记录
有时很滑稽
12-27 166
      从事java行业已经半年，项目不大不小算做了两个了，这两天正在进行简单的总结，发现AOP是结合动态代理是在某些时候能发挥很神奇的作用，就拿出来跟大家分享一年。      AOP的概念大家应该都知道吧，Aspect Oriented Programming的缩写，意为：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种...
java 反射示例（内部类操作）
weixin_43931625的博客
11-14 510
java反射内部类相关操作 *************************************** 相关方法 public final class Class<T> implements java.io.Serializable, GenericDeclaration, ...
spring小结(6)-细看@Configuration的appconfig代理类
xiaoza7的博客
04-04 749
之前提过@Configuration的appconfig会被cglib代理，生存代理类，然后是对象，在进行含有@Bean方法调用进项1拦截， 这里需要细看详细的代理类和拦截细节
Class对象的getXXXClass和getXXXName
翻身已碰头的博客
10-29 930
getXXXClass方法获取class对象 在讲解具体的方法之前，我们先介绍一下java类（接口）的划分方法。 java的class对象分为5种，这一点在getEnclosingClass方法的注释中有写明，分别是： a. Top类 b. Nested类：嵌套类，即静态成员类 c. Inner类：内部类，即普通成员类 d. Local类：局部类，在方法中定义的类 e. Anonymous：匿...
深入理解Spring AOP：JDK与CGLIB代理的拦截处理
Spring支持两种代理方式：JDK动态代理和CGLIB代理。这两种代理方式在处理拦截时有所不同。 **JDK动态代理** JDK动态代理依赖于Java的反射机制，适用于目标类实现了接口的情况。在Spring中，`JdkDynamicAopProxy`是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值