动态代理源码分析

最新推荐文章于 2023-05-05 21:19:13 发布
最新推荐文章于 2023-05-05 21:19:13 发布
阅读量116 收藏
点赞数
分类专栏： java设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuxue1989/article/details/103827518
版权

一、JDK动态代理

//首先定义一个接口
public interface IUserSave {
    void save();
}


//被代理的类
public class UserSave implements IUserSave {

    @Override
    public void save() {
        System.out.println("save method invoke");
    }
}

//定义一个InvocationHandler
public class UserSaveInvocationHandler implements InvocationHandler {

    private Object ref;

    public UserSaveInvocationHandler( Object ref){
        this.ref = ref;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy method invoke before");
        return method.invoke(ref,args);
    }
}

调用demo

public static void main(String[] args) {

        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        UserSaveInvocationHandler handler = new UserSaveInvocationHandler(new UserSave());

        IUserSave userSave = (IUserSave) Proxy.newProxyInstance(Main.class.getClassLoader(), new Class[]{IUserSave.class}, handler);

        userSave.save();
    }

1.1、JDK动态代理原理分析【JDK8】

在Pxoxy中的一个静态内部类中ProxyClassFactory（只保留核心代码）

 public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {           
            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");
                    }
                }
            }
			
			//动态的创建代理名称
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 生成字节文件
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
			
			//defineClass0属于本地方法，看不到实现
           return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
           
        }

继续分析generateProxyClass方法

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        final byte[] var4 = var3.generateClassFile();
		//sun.misc.ProxyGenerator.saveGeneratedFiles设为true，会保存到本地，地址 \Workspaces\项目名称\com\sun\proxy
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }

反编译生产的类

package com.sun.proxy;

import com.gupao.proxy.IUserSave;
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 IUserSave {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

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

    public final boolean equals(Object var1) throws  {
        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 void save() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        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() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.gupao.proxy.IUserSave").getMethod("save");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这个类相当的简单，首先实现你传入的接口，然后继承proxy。然后他会重写所有的方法，然后都委托给InvocationHandler去处理。

二、CGLib动态代理

 System.getProperties().put("cglib.debugLocation", "d://");

        Enhancer e = new Enhancer();
        e.setSuperclass(UserSave.class);
        e.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("proxy method invoke before");
                return method.invoke(obj,args);
            }
        });
        UserSave userSave = (UserSave) e.create();
        userSave.save();

2.1 Cglib动态代理原理分析

主要是同通过继承需要代理的类，然后委托给callback进行处理
核心代码 主要是在Enhancer中

下面代码就是形成子类的class文件的过程。

public void generateClass(ClassVisitor v) throws Exception {
        Class sc = (superclass == null) ? Object.class : superclass;

        if (TypeUtils.isFinal(sc.getModifiers()))
            throw new IllegalArgumentException("Cannot subclass final class " + sc.getName());
        List constructors = new ArrayList(Arrays.asList(sc.getDeclaredConstructors()));
        filterConstructors(sc, constructors);

        // Order is very important: must add superclass, then
        // its superclass chain, then each interface and
        // its superinterfaces.
        List actualMethods = new ArrayList();
        List interfaceMethods = new ArrayList();
        final Set forcePublic = new HashSet();
        getMethods(sc, interfaces, actualMethods, interfaceMethods, forcePublic);

        List methods = CollectionUtils.transform(actualMethods, new Transformer() {
            public Object transform(Object value) {
                Method method = (Method)value;
                int modifiers = Constants.ACC_FINAL
                    | (method.getModifiers()
                       & ~Constants.ACC_ABSTRACT
                       & ~Constants.ACC_NATIVE
                       & ~Constants.ACC_SYNCHRONIZED);
                if (forcePublic.contains(MethodWrapper.create(method))) {
                    modifiers = (modifiers & ~Constants.ACC_PROTECTED) | Constants.ACC_PUBLIC;
                }
                return ReflectUtils.getMethodInfo(method, modifiers);
            }
        });

        ClassEmitter e = new ClassEmitter(v);
        if (currentData == null) {
        e.begin_class(Constants.V1_2,
                      Constants.ACC_PUBLIC,
                      getClassName(),
                      Type.getType(sc),
                      (useFactory ?
                       TypeUtils.add(TypeUtils.getTypes(interfaces), FACTORY) :
                       TypeUtils.getTypes(interfaces)),
                      Constants.SOURCE_FILE);
        } else {
            e.begin_class(Constants.V1_2,
                    Constants.ACC_PUBLIC,
                    getClassName(),
                    null,
                    new Type[]{FACTORY},
                    Constants.SOURCE_FILE);
        }
        List constructorInfo = CollectionUtils.transform(constructors, MethodInfoTransformer.getInstance());

        e.declare_field(Constants.ACC_PRIVATE, BOUND_FIELD, Type.BOOLEAN_TYPE, null);
        e.declare_field(Constants.ACC_PUBLIC | Constants.ACC_STATIC, FACTORY_DATA_FIELD, OBJECT_TYPE, null);
        if (!interceptDuringConstruction) {
            e.declare_field(Constants.ACC_PRIVATE, CONSTRUCTED_FIELD, Type.BOOLEAN_TYPE, null);
        }
        e.declare_field(Constants.PRIVATE_FINAL_STATIC, THREAD_CALLBACKS_FIELD, THREAD_LOCAL, null);
        e.declare_field(Constants.PRIVATE_FINAL_STATIC, STATIC_CALLBACKS_FIELD, CALLBACK_ARRAY, null);
        if (serialVersionUID != null) {
            e.declare_field(Constants.PRIVATE_FINAL_STATIC, Constants.SUID_FIELD_NAME, Type.LONG_TYPE, serialVersionUID);
        }

        for (int i = 0; i < callbackTypes.length; i++) {
            e.declare_field(Constants.ACC_PRIVATE, getCallbackField(i), callbackTypes[i], null);
        }
        // This is declared private to avoid "public field" pollution
        e.declare_field(Constants.ACC_PRIVATE | Constants.ACC_STATIC, CALLBACK_FILTER_FIELD, OBJECT_TYPE, null);

        if (currentData == null) {
            emitMethods(e, methods, actualMethods);
            emitConstructors(e, constructorInfo);
        } else {
            emitDefaultConstructor(e);
        }
        emitSetThreadCallbacks(e);
        emitSetStaticCallbacks(e);
        emitBindCallbacks(e);

        if (useFactory || currentData != null) {
            int[] keys = getCallbackKeys();
            emitNewInstanceCallbacks(e);
            emitNewInstanceCallback(e);
            emitNewInstanceMultiarg(e, constructorInfo);
            emitGetCallback(e, keys);
            emitSetCallback(e, keys);
            emitGetCallbacks(e);
            emitSetCallbacks(e);
        }

        e.end_class();
    }

可见CGLIB是通过直接操作字节码的方法来生产class文件，这个效率比JDK的效率更高。

反编译生产的代理类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.gupao.proxy;

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 UserSave$$EnhancerByCGLIB$$b7a8c095 extends UserSave 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$save$0$Method;
    private static final MethodProxy CGLIB$save$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.gupao.proxy.UserSave$$EnhancerByCGLIB$$b7a8c095");
        Class var1;
        Method[] 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$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$save$0$Method = ReflectUtils.findMethods(new String[]{"save", "()V"}, (var1 = Class.forName("com.gupao.proxy.UserSave")).getDeclaredMethods())[0];
        CGLIB$save$0$Proxy = MethodProxy.create(var1, var0, "()V", "save", "CGLIB$save$0");
    }

    final void CGLIB$save$0() {
        super.save();
    }

	//save方法
    public final void save() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
        	//委托给callback进行处理
            var10000.intercept(this, CGLIB$save$0$Method, CGLIB$emptyArgs, CGLIB$save$0$Proxy);
        } else {
            super.save();
        }
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

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

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1872760024:
            if (var10000.equals("save()V")) {
                return CGLIB$save$0$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public UserSave$$EnhancerByCGLIB$$b7a8c095() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

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

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

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        UserSave$$EnhancerByCGLIB$$b7a8c095 var10000 = new UserSave$$EnhancerByCGLIB$$b7a8c095();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        UserSave$$EnhancerByCGLIB$$b7a8c095 var10000 = new UserSave$$EnhancerByCGLIB$$b7a8c095();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        UserSave$$EnhancerByCGLIB$$b7a8c095 var10000 = new UserSave$$EnhancerByCGLIB$$b7a8c095;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}
诛仙89
关注
专栏目录
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
Java中的动态代理——附带动态代理源码跟踪分析
terase梅
11-25 882
代理是基本的设计模式之一，它是为了插入一些额外操作或者不同操作而插入的“实际”对象的对象，它通常在实际被访问对象与访问者之间承当着中间人的职能，代替访问者去访问真实对象。当然有，接下来，我将采用动态代理的方式简化代理类的代码，让一个类实现N个代理类的功能。如果能看到生成的Proxy内部的实现，动态代理的谜团就解开了，继续跟踪Step6。在项目根目录下会生成一个文件夹，java中动态代理生成的类都以$ProxyX命名，调试代码的时候看到这种命名的类，那么这个类就是动态代理生成的。代理类的内部长啥样？
动态代理源码解析(代理类解析)
weixin_43926508的博客
04-12 282
动态代理源码解析 动态代理是什么? 动态代理是一种强大的功能，它可以在运行时动态创建一个类，实现一个或多个接口，可以在不修改原有类的基础上动态为通过该类获取的对象添加方法、修改行为，这么描述比较抽象,但是它实际用在许多的开源框架之中像Spring, Mybtis, Hibernate,等 动态代理剖析 既然这个在运行时动态创建一个类，实现一个或多个接口,那我们就把这个类导出来解析下 对于动态代理(JDK)的写法就不在赘述了,下面是一个很简单的Demo,就是为了引出代理类的: /** * &lt
真正解决方案：Cannot resolve class or package 'mysql’
热门推荐
极客星云-CSDN博客
09-03 7万+
当使用Spring Boot 2.0 整合MySQL的时候配置可能会出现这个故障 spring.datasource.driver-class-name= com.mysql.jdbc.Driver Cannot resolve class or package ‘jdbc’ less… (Ctrl+F1) Inspection info: Checks Spring Boo...
JDK动态代理-超详细源码分析
KHOST的博客
09-05 6601
一、为什么需要动态代理   1.1 从代理模式说起 代理模式是指给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。这种模式有什么用呢？它可以在原对象的基础上增强原对象的功能，比如在原对象调用一个方法的前后进行日志、事务操作等。Spring AOP就使用了代理模式。   1.2 代理模式----静态代理   如何实现代理模式呢？首...
JDK动态代理源码解析
killerofjava的博客
08-08 926
一、基本介绍 1. 代理模式的基本介绍 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 被代理的对象可以是远程对象、创建开销大的对象或者需要安全控制的对象 代理模式有不同的形式，主要有三种静态代理、动态代理（JDK代理、接口代理）和CGLIB代码（可以在内存动态创建对象，而不需要实现接口，他是属于动态代理的范畴） 二、静态代理 1. 静态代理模式代码的基本介绍 静态代理在使用时
关于jdk动态代理的源码剖析
06-18
### 关于JDK动态代理的源码剖析 #### 一、引言 在Java开发过程中，动态代理技术是一项非常实用的技术，它可以帮助我们实现在不修改原有代码的基础上为方法增加额外的功能，比如日志记录、权限校验等。本文将深入...
动态代理及JDK动态代理源码分析
hacke2' Blog
04-14 8931
JAVA的动态代理机制可以动态的创建代理并动态的处理代理方法调用，只要简单指定一组接口及为拖累对象，就能动态的获取代理类
JDK动态代理 Proxy#newProxyInstance源码分析
qq_41697016的博客
05-05 345
从以上分析就可以明白了，为什么在使用代理对象时，执行的是我们实现的InvocationHandler中的逻辑
java子类参数传递给父类_子类传递变量给父类的问题
weixin_28681719的博客
02-13 3107
j2EE，框架采用struts2,spring,hibernate,服务器端处理请求的顺序是action > service > dao .因为所有对象的service都有增删改查操作,所以我们使用一个基类,然后所有的service类都继承这个基类,这个service基类的代码如下:public class BaseServiceImpl {//the class of the be...
JAVA 动态代理（proxy）的实现和源码分析
mantantan的博客
07-10 1万+
JDK动态代理（proxy）可以在运行时创建一个实现一组给定接口的新类。但是略有限制，即被代理的类必须实现某个接口，否则无法使用JDK自带的动态代理，因此，如果不满足条件，就只能使用另一种更加灵活，功能更加强大的动态代理技术—— CGLIB。Spring里会自动在JDK的代理和CGLIB之间切换，同时我们也可以强制Spring使用CGLIB。 闲话少说，下面先用实例介绍使用方式，接着从proxy
JDK动态代理详解(动态代理类源码解析)
NoBug Blog
06-26 3399
简介 JDK动态代理就是在程序运行时，运用反射机制动态创建代理类，实现对目标类代码的增强。动态代理类的字节码在程序运行时由Java反射机制动态生成，不需要去手动开发。相比较静态代理，它更灵活。更容易扩展，代码 开发工作量更小，更容易维护。动态代理又分为JDK动态代理和CGLIB动态代理，一个通过反射生成代理类，一个通过asm开源包，修改字节码生成子类。区别在于JDK只能代理接口，所以有需要代理的类...
【RPC】动态代理及源码分析
一定要站在自己热爱的生活里闪闪发光
06-28 1万+
动态代理及其源码分析 1. 动态代理简介 动态代理在RPC中的应用 2. JDK自带的动态代理方法 通过JDK实现动态代理的原理 3. CGLib动态代理方案 使用CGLib实现动态代理的原理
南京工业大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-04
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）.zip
10-04
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）
基于Java开发的智能文件管家设计源码
最新发布
10-04
该项目是一款基于Java的智能文件管家设计源码，涵盖102个文件，包括29个Java源文件、27个类文件、19个XML配置文件、10个YAML文件、8个列表文件、4个属性文件、4个JAR包文件以及1个Git忽略文件。该系统旨在提供高效便捷的文件管理解决方案。
基于YoloV8的简单目标检测和跟踪，使用KMNET进行鼠标移动（处理多目标移动抖动，处理鼠标平滑移动）.zip
10-04
基于YoloV8的简单目标检测和跟踪，使用KMNET进行鼠标移动（处理多目标移动抖动，处理鼠标平滑移动）
spring动态代理源码分析
10-11
Spring动态代理主要是通过JDK动态代理和CGLIB动态代理两种方式实现的。其中，JDK动态代理是基于接口的代理，而CGLIB动态代理则是基于类的代理。 在使用JDK动态代理时，Spring会根据目标对象实现的接口来创建代理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值