备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

自己实现一个JDK动态代理

2019-07-14 854
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 回顾JDK代理Spring AOP 用到了两种动态代理模式：JDK动态代理和CGLIB动态代理，两种动态代理形成互补。今天我们来尝试纯手写一个简版的JDK动态代理，来了解它的底层实现原理。我们先来回顾一下JDK动态代理动态代理的条件两个角色： 代理对象，被代理对象代理对象需要完成被代理对...

回顾JDK代理

Spring AOP 用到了两种动态代理模式：JDK动态代理和CGLIB动态代理，两种动态代理形成互补。今天我们来尝试纯手写一个简版的JDK动态代理，来了解它的底层实现原理。我们先来回顾一下JDK动态代理

动态代理的条件

  1. 两个角色： 代理对象，被代理对象
  2. 代理对象需要完成被代理对象的需要完成的业务操作
  3. 代理对象持有被代理对象的引用
  4. JDK动态代理 被代理对象必须实现接口，CGLIB动态代理被代理类和方法不能用final修饰

实现代码

  1. 被代理对象实现的目标接口
package com.nqmysb.proxy.jdk;


/**
 * 目标接口
 * @author liaocan
 *
 */
public interface Subject {
    
    /*
     * 抽象业务方法
     */
    void businessMethod();

}
  1. 被代理的目标对象
package com.nqmysb.proxy.jdk.impl;

import com.nqmysb.proxy.jdk.Subject;

/**
 * 具体的目标对象，实现目标接口的方法
 * @author liaocan
 *
 */
public class RealSubject implements Subject {

    @Override
    public void businessMethod() {
        System.out.println("我在进行具体的业务操作。。。。。。");
    }

}
  1. 被代理的目标对象
package com.nqmysb.proxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * 代理类，必须实现JDK中的InvocationHandler  这是JDK动态代理的标志
 * 可以理解：需要实现JDK的代理，必须要这个证书 
 * @author liaocan
 *
 */
public class DynamicProxy implements InvocationHandler {
    
    private Subject target; //被代理对象的引用  这里是代理对象的接口  说明 该代理类是可以代理该接口下的所有子类的
    
    //动态生成代理对象
    public Object getInstance(Subject target) throws Exception{
        //获取代理对象
        this.target = target;
        //代理的对象必须是 suject的实现类
        Class<? extends Subject> clazz = target.getClass();
        
        //被代理对象的class是:class com.nqmysb.proxy.jdk.impl.RealSubject
        System.out.println("被代理对象的class是:"+clazz);
        
        //被代理对象的类加载器:sun.misc.Launcher$AppClassLoader@20eb607d
        ClassLoader classLoader = clazz.getClassLoader();
        System.out.println("被代理对象的类加载器:"+classLoader);
        
        //被代理对象的class是:[Ljava.lang.Class;@602f892f  返回所有实现接口的数组 [interface com.nqmysb.proxy.jdk.Subject]
        Class<?>[] classs = clazz.getInterfaces();
        System.out.println("被代理对象实现的接口:"+Arrays.asList(classs));
        //proxy的静态方法 newProxyInstance
        // 参数说明：被代理对象的类加载器 clazz.getClassLoader  ,被代理对象实现的接口 clazz.getInterfaces() ,当前对象 this
        //this 参数传入 把代理类和被代理类产生关联 当要执行被代理对象的方法时 会自动调用代理对象invoke方法进行代理执行
        return Proxy.newProxyInstance(classLoader, classs, this);
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("开始代理...");
        System.out.println("代理之前做的事情...");
        System.out.println("------------"); 
        
        //执行代理方法
        method.invoke(this.target, args);
        
        System.out.println("------------");
        System.out.println("代理之后做的事情...");
        System.out.println("结束代理...");
        return null;
    }
    

}
  1. JDK动态代理测试类
package com.nqmysb.proxy.jdk;

import com.nqmysb.proxy.jdk.impl.RealSubject;
/**
 * JDK动态代理测试类
 * 
 * @author liaocan
 *
 */
public class DynamicProxyTest {

    public static void main(String[] args) {
        
    try {
                    
        Subject subject = (Subject)new DynamicProxy().getInstance(new RealSubject());
        System.out.println(subject.getClass());
        subject.businessMethod();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}
  1. 运行结果如下
被代理对象的class是:class com.nqmysb.proxy.jdk.impl.RealSubject
被代理对象的类加载器:sun.misc.Launcher$AppClassLoader@73d16e93
被代理对象实现的接口:[interface com.nqmysb.proxy.jdk.Subject]
class com.sun.proxy.$Proxy0
开始代理...
代理之前做的事情...
------------
我在进行具体的业务操作。。。。。。
------------
代理之后做的事情...
结束代理...

手写JDK动态代理

JDK做了哪些事？

在自己手写JDK动态代理之前我们分析一下JDK动态代理帮我们做了哪些事情？

  1. 代理类必须实现JDK中的java.lang.reflect.InvocationHandler接口，这个接口中只有一个方法,如下：
/**
 * @param   proxy the proxy instance that the method was invoked on
 * @param   method the {@code Method} instance corresponding to
 * the interface method invoked on the proxy instance.  
 * @param   args an array of objects containing the values of the
 * arguments passed in the method invocation on the proxy instance,
 */
 public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

代理类需要重写和实现该方法，在这个方法里面我们可以进行附加业务操作，再调用被代理对象的方法。从而对被代理对象的方法进行扩展。

  1. 生成代理类对象,代理类中的getInstance(Subject target)方法产生代理对象。关键代码如下：
/**
* 该方法传入三个参数：1.类加载，用于加载动态生成代理类。2.被代理类实现的所有接口 3.代理类对象本身引用，用于回调我们实现的invoke方法 
*/
Proxy.newProxyInstance(classLoader, classs, this)

从上面两点可以得出JDK动态代理帮我们生成了代理类，代理实现了被代理类的所有接口，并将代理类加载到JVM中，生成代理实例，并回调我们实现的invoke方法进行动态代理。
JDK给我们提供了 java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 代理类 其中JDK1.8版本中的Proxy类中有一个私有的静态内部类 private static final class ProxyClassFactory 该类用于生成代理类的class对象。源代码如下：


 private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        //$Proxy 作为代理类的标志
        private static final String proxyClassNamePrefix = "$Proxy";

        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
          
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
          
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
       
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;    
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

 
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

    
            long num = nextUniqueNumber.getAndIncrement();
            //动态生成代理类的全名
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //动态生成代理类class对象
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
           
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

手写JDK动态代理代码实现

前两个要素不变：目标接口和目标实现类。

  1. 被代理对象实现的目标接口
package com.nqmysb.proxy.jdk;


/**
 * 目标接口
 * @author liaocan
 *
 */
public interface Subject {
    
    /*
     * 抽象业务方法
     */
    void businessMethod();

}
  1. 被代理的目标对象
package com.nqmysb.proxy.jdk.impl;

import com.nqmysb.proxy.jdk.Subject;

/**
 * 具体的目标对象，实现目标接口的方法
 * @author liaocan
 *
 */
public class RealSubject implements Subject {

    @Override
    public void businessMethod() {
        System.out.println("我在进行具体的业务操作。。。。。。");
    }

}
  1. 自定义类加载器
package com.nqmysb.myproxy.proxytools;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;


/**
 * 自定义类加载器
 * 
 * 作用：将我们动态生成的class文件生成class对象加载JVM内存中
 * @author liaocan
 *
 */
public class MyClassLoader extends ClassLoader{
    
    private File baseDir;
    
    public MyClassLoader(){
        
        Class<MyClassLoader> clazz = MyClassLoader.class;
        String basePath = clazz.getResource("").getPath();
//        String basePath = clazz.getResource("/").getPath() +"com/nqmysb/myproxy/proxytools";
        this.baseDir = new java.io.File(basePath);
    }
    /**
     * 自定义类加载方法 ，加载自定义类
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //获取需要加载的类的全名  com.nqmysb.myproxy.proxytools.$Proxy0
        String className = MyClassLoader.class.getPackage().getName() + "." + name;
        if(baseDir != null){
            //获取 class文件对象 E:\workspace\spring-source-analysis\spring-source-proxy\bin\com\nqmysb\myproxy\proxytools\$Proxy0.class
            File classFile = new File(baseDir,name.replaceAll("\\.", "/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1) {
                        out.write(buff, 0, len);
                    }
                    //根据class文件和类名生成class对象 并加载到JVM中
                    return defineClass(className, out.toByteArray(), 0,out.size());
                    
                }catch (Exception e) {
                    e.printStackTrace();
                }finally{
                    if(null != in){
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if(null != out){
                        try {
                            out.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    //删除Class文件
                    classFile.delete();
                }
                
            }
        }
        
        return null;
    }
    
    /**
     * 测试了解Java类加载机制
     * 1.类加载器的作用：类加载器负责将class文件读入JVM内存，并为之生成对应的java.lang.Class对象。
     * java类加载器分为三类：
     * （Bootstrap ClassLoader） 启动类加载器 ： 负责加载Java的核心类（如String、System等）, rt.jar
     *                             它比较特殊，因为它是由原生C++代码实现的，并不是java.lang.ClassLoader的子类
     * （Extension ClassLoader ）扩展类加载器：它负责加载JRE的扩展目录（%JAVA_HOME%/jre/lib/ext）中JAR包的类，java实现
     *                             我们可以通过把自己开发的类打包成JAR文件放入扩展目录来为Java扩展核心类以外的新功能。
     * （ApplicationClassLoader）应用程序类加载器：它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，java实现
     *                             或CLASSPATH环境变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader来获取系统类加载器：
     * 
     * 类加载机制之双亲委派
     *        加载类时 会现递归交于父类加载器加载，如果所有父类没有加载才有自己加载，好处防止类的重复加载
     * 
     */
    
    public static void main(String[] args) {
        //（Bootstrap ClassLoader） 启动类加载器 ： 负责加载Java的核心类（如String、System等）rt.jar
        //它比较特殊，因为它是由原生C++代码实现的，并不是java.lang.ClassLoader的子类 所以输出结果为null
        //Returns the class loader for the class.  Some implementations may use
        //null to represent the bootstrap class loader. This method will return
        //null in such implementations if this class was loaded by the bootstrap
        //class loader.
        System.out.println(String.class.getClassLoader());
        System.out.println(HashMap.class.getClassLoader());
        
        //sun.misc.Launcher$AppClassLoader
        System.out.println(MyClassLoader.class.getClassLoader().getClass().getName());

        //sun.misc.Launcher$AppClassLoader
        System.out.println(ClassLoader.getSystemClassLoader().getClass().getName());

        
        
    }

}
  1. 自定义 InvocationHandler 接口
package com.nqmysb.myproxy.proxytools;

import java.lang.reflect.Method;

public interface MyInvocationHandler {

    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

}
  1. 自定义 Proxy 代理类
package com.nqmysb.myproxy.proxytools;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
/**
 * 自己实现的Proxy  对应JDK中的java.lang.reflect.Proxy类
 * 
 * @author liaocan
 *
 */
public class MyProxy {
    
    //换行符
    private static String ln = "\r\n";


    /**
     * 生成代理类对象  
     *  对应JDK中Proxy的newProxyInstance方法生成代理类对象
     *  JDK1.8中的实现是：通过Proxy 中的的静态内部类ProxyClassFactory =>(private static final class ProxyClassFactory)中的apply方法
     *  注意：JDK1.7中是通过getProxyClass()方法实现 有点小区别 但是核心代码大致相同
     *  核心代码如下：
     *      //所有代理类的前缀
     *      private static final String proxyClassNamePrefix = "$Proxy";
     *      //代理类的序号
     *      long num = nextUniqueNumber.getAndIncrement();
     *      //代理类的全名
     *      String proxyName = proxyPkg + proxyClassNamePrefix + num;
     *      //生成代理类class字节码文件 ,反编译生成的class文件可以发现代理类继承Proxy类实现了被代理类的implements的所有接口 =>(public final class $Proxy0 extends Proxy  implements Subject ) 
     *      //generateProxyClass()可以再看看具体实现
     *      byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
     *      try {
     *      //根据class字节码生成实例对象
     *          return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
     *         } 
     *          
     * @param classLoader
     * @param interfaces
     * @param myInvocationHandler
     * @return
     */
    public static Object newProxyInstance(MyClassLoader classLoader,Class<?>[] interfaces,MyInvocationHandler myInvocationHandler){
        
        
        try{
            //1、动态生成代理类的源代码 .java文件
            String proxySrc = generateSrc(interfaces[0]);
            
            
            //2、将生成的源代码输出到磁盘，保存为.java文件
            String filePath = MyProxy.class.getResource("").getPath(); //打jar包之后抛空指针
//            String filePath = MyProxy.class.getResource("/").getPath() +"com/nqmysb/myproxy/proxytools/";
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw = new FileWriter(f);
            fw.write(proxySrc);
            fw.flush();
            fw.close();
        
            //3、编译源代码，并且生成.class文件
            JavaCompiler  compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable<? extends JavaFileObject> iterable = manager.getJavaFileObjects(f);
            
            CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();
        
            //4.将class文件中的内容，动态加载到JVM中来
            
            //5.返回被代理后的代理类class对象
            Class<?> proxyClass = classLoader.findClass("$Proxy0");
            //通过class对象和参数获取指定构造对象 
            Constructor<?> c = proxyClass.getConstructor(MyInvocationHandler.class);
            //删除Java文件
            f.delete();
            
            return c.newInstance(myInvocationHandler);
            
        }catch (Exception e) {
            e.printStackTrace();
        }
        
        
        return null;
    }
    
    /**
     * 
     * 动态生成代理类的.java文件的代码内容
     * @param interfaces
     * @return
     */
    private static String generateSrc(Class<?> interfaces){
        StringBuffer src = new StringBuffer();
        //代理类包名
        src.append("package com.nqmysb.myproxy.proxytools;" + ln);
        //导入反射包method类  
        src.append("import java.lang.reflect.Method;" + ln);
        //声明类名 实现被代理类的接口这里简化处理只实现一个接口, JDK中生成的代理类会继承proxy类 实现被代理类的所有接口
        src.append("public class $Proxy0 implements " + interfaces.getName() + "{" + ln);
        //生成代理类中持有MyInvocationHandler引用
        //JDK中InvocationHandler是Proxy中的成员变量=>(protected InvocationHandler h;)
        //生成的代理类继承Proxy也继承了它的protected的成员变量,我们自己生成的代理类没有继承Proxy 所有需要自己提供
        src.append("MyInvocationHandler h;" + ln);
        //代理类中构造方法中传入MyInvocationHandler给InvocationHandler初始化
        src.append("public $Proxy0(MyInvocationHandler h) {" + ln);
        src.append("this.h = h;" + ln);
        src.append("}" + ln);
        //生成所有代理方法
        for (Method m : interfaces.getMethods()) {
            src.append("public " + m.getReturnType().getName() + " " + m.getName() + "(){" + ln);
            src.append("try{" + ln);
            //通过代理方法对象
            src.append("Method m = " + interfaces.getName() + ".class.getMethod(\"" +m.getName()+"\",new Class[]{});" + ln);
            //调用代理方法
            src.append("this.h.invoke(this,m,null);" + ln);
            src.append("}catch(Throwable e){e.printStackTrace();}" + ln);
            src.append("}" + ln);
        }
        
        src.append("}");
        System.out.println("动态生成的代理类$Proxy0:"+ln+src);
        /*
        生成代理类如下：
        package com.nqmysb.myproxy.proxytools;
        
        import java.lang.reflect.Method;
        
        public class $Proxy0 implements com.nqmysb.myproxy.Subject{
        
        MyInvocationHandler h;
        
        public $Proxy0(MyInvocationHandler h) {
            this.h = h;
        }
        
        public void businessMethod(){
        try{
            
                Method m = com.nqmysb.myproxy.Subject.class.getMethod("businessMethod",new Class[]{});
                //此处调用的其实就是传入的com.nqmysb.myproxy.MyDynamicProxy对象的invoke方法
                //然后再在invoke中对代理对象的方法前后进行业务方法操作
                this.h.invoke(this,m,null);
                
                }catch(Throwable e){
                e.printStackTrace();
                }
            }
        }
        */
        return src.toString();
    }

}
  1. 使用自己手写的动态代理
package com.nqmysb.myproxy;

import java.lang.reflect.Method;
import java.util.Arrays;

import com.nqmysb.myproxy.proxytools.MyClassLoader;
import com.nqmysb.myproxy.proxytools.MyInvocationHandler;
import com.nqmysb.myproxy.proxytools.MyProxy;

/**
 * 代理类，必须实现JDK中的InvocationHandler  这是JDK动态代理的标志
 * 可以理解：需要实现JDK的代理，必须要这个证书 
 * @author liaocan
 *
 */
public class MyDynamicProxy implements MyInvocationHandler {
    
    private Subject target; //被代理对象的引用  这里是代理对象的接口  说明 该代理类是可以代理该接口下的所有子类的
    
    //动态生成代理对象
    public Object getInstance(Subject target) throws Exception{
        //获取代理对象
        this.target = target;
        //代理的对象必须是 suject的实现类
        Class<? extends Subject> clazz = target.getClass();
        //获取被代理类实现的所有接口  从这里可以看出如果被代理类没有实现接口，是无法使用JDK动态代理的
        Class<?>[] classs = clazz.getInterfaces();
        System.out.println("被代理对象实现的接口:"+Arrays.asList(classs));
        return MyProxy.newProxyInstance(new MyClassLoader(), classs, this);
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("开始代理...");
        System.out.println("代理之前做的事情...");
        System.out.println("------------"); 
        
        //执行代理方法
        method.invoke(this.target, args);
        
        System.out.println("------------");
        System.out.println("代理之后做的事情...");
        System.out.println("结束代理...");
        return null;
    }
    

}
  1. 测试动态代理
package com.nqmysb.myproxy;

import com.nqmysb.myproxy.impl.RealSubject;

/**
 * 手写JDK动态代理测试类
 * 
 * 
 * @author liaocan
 *
 */
public class MyDynamicProxyTest {

    public static void main(String[] args) {
        
    try {
            
            Subject subject = (Subject)new MyDynamicProxy().getInstance(new RealSubject());
            System.out.println(subject.getClass());
            subject.businessMethod();


        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}
  1. 运行结果
被代理对象实现的接口:[interface com.nqmysb.myproxy.Subject]
动态生成的代理类$Proxy0:
package com.nqmysb.myproxy.proxytools;
import java.lang.reflect.Method;
public class $Proxy0 implements com.nqmysb.myproxy.Subject{
MyInvocationHandler h;
public $Proxy0(MyInvocationHandler h) {
this.h = h;
}
public void businessMethod(){
try{
Method m = com.nqmysb.myproxy.Subject.class.getMethod("businessMethod",new Class[]{});
this.h.invoke(this,m,null);
}catch(Throwable e){e.printStackTrace();}
}
}
class com.nqmysb.myproxy.proxytools.$Proxy0
开始代理...
代理之前做的事情...
------------
我在进行具体的业务操作。。。。。。
------------
代理之后做的事情...
结束代理...

总结

动态代理的底层实现的原理：

  1. 反射机制：获取被代理类的方法，并实现动态字节码重组生成新的代理类
    值得注意：JDK动态代理和CGLIB动态代理使用的反射机制是不一样的，

分别是：java.lang.reflect.Method和net.sf.cglib.reflect.FastClass 类实现的

  1. 函数回调机制：将代理类需要执行的附加方法传入新生成的代理类中，执行被代理类方法时会回调代理类的方法

代码工程

github地址：https://github.com/nqmysb/spring-source-analysis

文章标签：
Java
前端开发
C++
Spring
移动开发
关键词：
jdk动态代理
nqmysb
目录
相关文章
hsfxuebao
|
4月前
|
缓存 Java 数据库连接
分析JDK动态代理的实现
分析JDK动态代理的实现
hsfxuebao
39 0
java知路
|
7月前
|
Java
jdk动态代理实现原理
jdk动态代理实现原理
java知路
36 0
Sunny_yiyi
|
29天前
|
Java 程序员 API
浅谈JDK动态代理
浅谈JDK动态代理
Sunny_yiyi
31 1
_长银_
|
2月前
|
Java
关于JDK动态代理
关于JDK动态代理的一些理解
_长银_
14 0
进步`于辰
|
2月前
|
设计模式 Java API
[Java]静态代理、动态代理（基于JDK1.8）
本篇文章主要是对静态代理和动态代理实现思路的简述，以示例为主，少涉及理论。 如果文中阐述不全或不对的，多多交流。
进步`于辰
54 1
[Java]静态代理、动态代理（基于JDK1.8）
一只牛博
|
2月前
|
设计模式 安全 Java
深入理解Spring Boot AOP：CGLIB代理与JDK动态代理的完全指南
深入理解Spring Boot AOP：CGLIB代理与JDK动态代理的完全指南
一只牛博
317 1
爱吃糖的范同学
|
3月前
|
Java 数据安全/隐私保护
【面试问题】JDK 动态代理与 CGLIB 区别？
【1月更文挑战第27天】【面试问题】JDK 动态代理与 CGLIB 区别？
爱吃糖的范同学
35 1
hsfxuebao
|
3月前
|
Java Linux iOS开发
Spring5源码（27）-静态代理模式和JDK、CGLIB动态代理
Spring5源码（27）-静态代理模式和JDK、CGLIB动态代理
hsfxuebao
23 0
飞翔的佩奇
|
3月前
|
Java
JDK动态代理笔记整理
JDK动态代理笔记整理
飞翔的佩奇
44 0
四维大脑
|
8月前
|
设计模式 Java 数据安全/隐私保护
设计模式之代理模式(jdk和cglib、手撕源码、自创动态代理) 1
设计模式之代理模式(jdk和cglib、手撕源码、自创动态代理)
四维大脑
57 0