返回顶部
首页 > 资讯 > 精选 >JDK中动态代理的示例分析
  • 200
分享到

JDK中动态代理的示例分析

2023-06-15 09:06:09 200人浏览 泡泡鱼
摘要

这篇文章将为大家详细讲解有关jdk中动态代理的示例分析,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。动态代理步骤创建一个实现接口InvocationHandler的类,它必须实现invoke方法创建被代理

这篇文章将为大家详细讲解有关jdk中动态代理的示例分析,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。

动态代理步骤

创建一个实现接口InvocationHandler的类,它必须实现invoke方法

创建被代理的类以及接口

通过Proxy的静态方法

通过Proxy的静态方法

ProxyObject proxyObject = new ProxyObject();    InvocationHandler invocationHandler = new DynamicProxy(proxyObject);    ClassLoader classLoader = proxyObject.getClass().getClassLoader();    ProxyObjectInterface proxy = (IRoom) Proxy.newProxyInstance(classLoader,new Class[]    {ProxyObjectInterface.class},invocationHandler);    proxy.execute();    public class DynamicProxy implements InvocationHandler {    private Object object;    public DynamicProxy(Object object){        this.object = object;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object result = method.invoke(object,args);        return result;    }}

创建一个代理 newProxyInstance

public static Object newProxyInstance(ClassLoader loader,                                          Class<?>[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {        //检验h不为空,h为空抛异常        Objects.requireNonNull(h);        //接口的类对象拷贝一份        final Class<?>[] intfs = interfaces.clone();        //进行一些安全性检查        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }                Class<?> cl = getProxyClass0(loader, intfs);                try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }            //得到代理类对象的构造函数,这个构造函数的参数由constructorParams指定            //参数constructorParames为常量值:            private static final Class<?>[] constructorParams = { InvocationHandler.class };            final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction<Void>() {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            //这里生成代理对象,传入的参数new Object[]{h}后面讲            return cons.newInstance(new Object[]{h});        } catch (IllegalAccessException|InstantiationException e) {            throw new InternalError(e.toString(), e);        } catch (InvocationTargetException e) {            Throwable t = e.getCause();            if (t instanceof RuntimeException) {                throw (RuntimeException) t;            } else {                throw new InternalError(t.toString(), t);            }        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString(), e);        }    }

先对h进行判空处理。
这段代码核心就是通过getProxyClass0(loader, intfs)得到代理类的Class对象,然后通过Class对象得到构造方法,进而创建代理对象。下一步看getProxyClass0这个方法。从1可知,先接口得到接口类,当接口的数量超过65535,则报异常。

//此方法也是Proxy类下的方法    private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }        // If the proxy class defined by the given loader implementing        // the given interfaces exists, this will simply return the cached copy;        // otherwise, it will create the proxy class via the ProxyClassFactory        //意思是:如果代理类被指定的类加载器loader定义了,并实现了给定的接口interfaces,        //那么就返回缓存的代理类对象,否则使用ProxyClassFactory创建代理类。        return proxyClassCache.get(loader, interfaces);    }

proxyClassCache 是一个弱引用的缓存
这里看到proxyClassCache,有Cache便知道是缓存的意思,正好呼应了前面Look up or generate the designated proxy class。查询(在缓存中已经有)或生成指定的代理类的class对象这段注释。

在进入get方法之前,我们看下 proxyClassCache是什么?高能预警,前方代码看起来可能有乱,但我们只需要关注重点即可。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());//K代表key的类型,P代表参数的类型,V代表value的类型。// WeakCache<ClassLoader, Class<?>[], Class<?>>  proxyClassCache  说明proxyClassCache存的值是Class<?>对象,正是我们需要的代理类对象。final class WeakCache<K, P, V> {    private final ReferenceQueue<K> refQueue        = new ReferenceQueue<>();    // the key type is Object for supporting null key    private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map        = new ConcurrentHashMap<>();    private final ConcurrentMap<Supplier<V>, Boolean> reverseMap        = new ConcurrentHashMap<>();    private final BiFunction<K, P, ?> subKeyFactory;    private final BiFunction<K, P, V> valueFactory;    public WeakCache(BiFunction<K, P, ?> subKeyFactory,                     BiFunction<K, P, V> valueFactory) {        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);        this.valueFactory = Objects.requireNonNull(valueFactory);    }

其中map变量是实现缓存的核心变量,他是一个双重的Map结构: (key, sub-key) -> value。其中key是传进来的Classloader进行包装后的对象,sub-key是由WeakCache构造函数传人的KeyFactory()生成的。value就是产生代理类的对象,是由WeakCache构造函数传人的ProxyClassFactory()生成的。如下,回顾一下:

proxyClassCache是个WeakCache类的对象,调用proxyClassCache.get(loader, interfaces); 可以得到缓存的代理类或创建代理类(没有缓存的情况)。

说明WeakCache中有get这个方法。先看下WeakCache类的定义(这里先只给出变量的定义和构造函数),继续看它的get();

//K和P就是WeakCache定义中的泛型,key是类加载器,parameter是接口类数组public V get(K key, P parameter) {        //检查parameter不为空        Objects.requireNonNull(parameter);         //清除无效的缓存        expungeStaleEntries();        // cacheKey就是(key, sub-key) -> value里的一级key,        Object cacheKey = CacheKey.valueOf(key, refQueue);        // lazily install the 2nd level valuesMap for the particular cacheKey        //根据一级key得到 ConcurrentMap<Object, Supplier<V>>对象。如果之前不存在,则新建一个ConcurrentMap<Object, Supplier<V>>和cacheKey(一级key)一起放到map中。        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);        if (valuesMap == null) {            ConcurrentMap<Object, Supplier<V>> oldValuesMap                = map.putIfAbsent(cacheKey,                                  valuesMap = new ConcurrentHashMap<>());            if (oldValuesMap != null) {                valuesMap = oldValuesMap;            }        }        // create subKey and retrieve the possible Supplier<V> stored by that        // subKey from valuesMap        //这部分就是调用生成sub-key的代码,上面我们已经看过怎么生成的了        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));        //通过sub-key得到supplier        Supplier<V> supplier = valuesMap.get(subKey);        //supplier实际上就是这个factory        Factory factory = null;        while (true) {            //如果缓存里有supplier ,那就直接通过get方法,得到代理类对象,返回,就结束了,一会儿分析get方法。            if (supplier != null) {                // supplier might be a Factory or a CacheValue<V> instance                V value = supplier.get();                if (value != null) {                    return value;                }            }            // else no supplier in cache            // or a supplier that returned null (could be a cleared CacheValue            // or a Factory that wasn't successful in installing the CacheValue)            // lazily construct a Factory            //下面的所有代码目的就是:如果缓存中没有supplier,则创建一个Factory对象,把factory对象在多线程的环境下安全的赋给supplier。            //因为是在while(true)中,赋值成功后又回到上面去调get方法,返回才结束。            if (factory == null) {                factory = new Factory(key, parameter, subKey, valuesMap);            }            if (supplier == null) {                supplier = valuesMap.putIfAbsent(subKey, factory);                if (supplier == null) {                    // successfully installed Factory                    supplier = factory;                }                // else retry with winning supplier            } else {                if (valuesMap.replace(subKey, supplier, factory)) {                    // successfully replaced                    // cleared CacheEntry / unsuccessful Factory                    // with our Factory                    supplier = factory;                } else {                    // retry with current supplier                    supplier = valuesMap.get(subKey);                }            }        }    }

所以接下来我们看Factory类中的get方法。接下来看supplier的get()

public synchronized V get() { // serialize access            // re-check            Supplier<V> supplier = valuesMap.get(subKey);            //重新检查得到的supplier是不是当前对象            if (supplier != this) {                // something changed while we were waiting:                // might be that we were replaced by a CacheValue                // or were removed because of failure ->                // return null to signal WeakCache.get() to retry                // the loop                return null;            }            // else still us (supplier == this)            // create new value            V value = null;            try {                 //代理类就是在这个位置调用valueFactory生成的                 //valueFactory就是我们传入的 new ProxyClassFactory()                //一会我们分析ProxyClassFactory()的apply方法                value = Objects.requireNonNull(valueFactory.apply(key, parameter));            } finally {                if (value == null) { // remove us on failure                    valuesMap.remove(subKey, this);                }            }            // the only path to reach here is with non-null value            assert value != null;            // wrap value with CacheValue (WeakReference)            //把value包装成弱引用            CacheValue<V> cacheValue = new CacheValue<>(value);            // put into reverseMap            // reverseMap是用来实现缓存的有效性            reverseMap.put(cacheValue, Boolean.TRUE);            // try replacing us with CacheValue (this should always succeed)            if (!valuesMap.replace(subKey, this, cacheValue)) {                throw new AssertionError("Should not reach here");            }            // successfully replaced us with new CacheValue -> return the value            // wrapped by it            return value;        }    }

拨云见日,来到ProxyClassFactory的apply方法,代理类就是在这里生成的。

首先看proxyClassCache的定义WeakCache<ClassLoader, Class<?>[], Class<?>>,泛型里面第一个表示加载器K,第二个表示接口类P,第三个则是生成的代理类V。而V的生成则是通过ProxyClassFactory生成的。调用其apply();

//这里的BiFunction<T, U, R>是个函数式接口,可以理解为用T,U两种类型做参数,得到R类型的返回值private static final class ProxyClassFactory        implements BiFunction<ClassLoader, Class<?>[], Class<?>>    {        // prefix for all proxy class names        //所有代理类名字的前缀        private static final String proxyClassNamePrefix = "$Proxy";        // next number to use for generation of unique proxy class names        //用于生成代理类名字的计数器        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;     // package to define proxy class in            //代理类访问控制符: public ,final            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;                        //验证所有非公共的接口在同一个包内;公共的就无需处理            //生成包名和类名的逻辑,包名默认是com.sun.proxy,            // 类名默认是$Proxy 加上一个自增的整数值            //如果被代理类是 non-public proxy interface ,则用和被代理类接口一样的包名            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) {                // if no non-public proxy interfaces, use com.sun.proxy package                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }                        long num = nextUniqueNumber.getAndIncrement();            //代理类的完全限定名,如com.sun.proxy.$Proxy0.calss            String proxyName = proxyPkg + proxyClassNamePrefix + num;                        //核心部分,生成代理类的字节码            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);            try {                //把代理类加载到JVM中,至此动态代理过程基本结束了                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFORMatError e) {                                throw new IllegalArgumentException(e.toString());            }        }    }

然后调用getMethod(),将equals(),hashcode(),toString()等方法添加进去。然后遍历所有接口的方法,添加到代理类中。最后将这些方法进行排序

private static List<Method> getMethods(Class<?>[] interfaces) {        List<Method> result = new ArrayList<Method>();        try {            result.add(Object.class.getMethod("equals", Object.class));            result.add(Object.class.getMethod("hashCode", EmptyArray.CLASS));            result.add(Object.class.getMethod("toString", EmptyArray.CLASS));        } catch (NoSuchMethodException e) {            throw new AssertionError();        }        getMethodsRecursive(interfaces, result);        return result;    }private static void getMethodsRecursive(Class<?>[] interfaces, List<Method> methods) {        for (Class<?> i : interfaces) {            getMethodsRecursive(i.getInterfaces(), methods);            Collections.addAll(methods, i.getDeclaredMethods());        }    }

最后输出相关proxy class

package com.zhb.jdk.proxy;import java.io.FileOutputStream;import java.io.IOException;import java.lang.reflect.Proxy;import com.zhb.jdk.dynamicProxy.HelloworldImpl;import sun.misc.ProxyGenerator;public class DynamicProxyTest {    public static void main(String[] args) {        IUserService target = new UserServiceImpl();        MyInvocationHandler handler = new MyInvocationHandler(target);        //第一个参数是指定代理类的类加载器(我们传入当前测试类的类加载器)        //第二个参数是代理类需要实现的接口(我们传入被代理类实现的接口,这样生成的代理类和被代理类就实现了相同的接口)        //第三个参数是invocation handler,用来处理方法的调用。这里传入我们自己实现的handler        IUserService proxyObject = (IUserService) Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(),                target.getClass().getInterfaces(), handler);        proxyObject.add("陈粒");        String path = "D:/$Proxy0.class";        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", HelloworldImpl.class.getInterfaces());        FileOutputStream out = null;        try {            out = new FileOutputStream(path);            out.write(classFile);            out.flush();        } catch (Exception e) {            e.printStackTrace();        } finally {            try {                out.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.// Jad home page: Http://kpdus.tripod.com/jad.html// Decompiler options: packimports(3) fieldsfirst ansi spaceimport com.zhb.jdk.proxy.IUserService;import java.lang.reflect.*;public final class $Proxy0 extends Proxy    implements IUserService{    private static Method m1;    private static Method m2;    private static Method m3;    private static Method m0;    //代理类的构造函数,其参数正是是InvocationHandler实例,    //Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的    public $Proxy0(InvocationHandler invocationhandler)    {        super(invocationhandler);    }     // Object类中的三个方法,equals,toString, hashCode    public final boolean equals(Object obj)    {        try        {            return ((Boolean)super.h.invoke(this, m1, new Object[] {                obj            })).booleanValue();        }        catch (Error ) { }        catch (Throwable throwable)        {            throw new UndeclaredThrowableException(throwable);        }    }    public final String toString()    {        try        {            return (String)super.h.invoke(this, m2, null);        }        catch (Error ) { }        catch (Throwable throwable)        {            throw new UndeclaredThrowableException(throwable);        }    }    //接口代理方法    public final void add(String s)    {        try        {            // invocation handler的 invoke方法在这里被调用            super.h.invoke(this, m3, new Object[] {                s            });            return;        }        catch (Error ) { }        catch (Throwable throwable)        {            throw new UndeclaredThrowableException(throwable);        }    }    public final int hashCode()    {        try        {            // 在这里调用了invoke方法。            return ((Integer)super.h.invoke(this, m0, null)).intValue();        }        catch (Error ) { }        catch (Throwable throwable)        {            throw new UndeclaredThrowableException(throwable);        }    }    // 静态代码块对变量进行一些初始化工作    static     {        try        {            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {                Class.forName("java.lang.Object")            });            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);            m3 = Class.forName("com.zhb.jdk.proxy.IUserService").getMethod("add", new Class[] {                Class.forName("java.lang.String")            });            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);        }        catch (NoSuchMethodException nosuchmethodexception)        {            throw new NoSuchMethodError(nosuchmethodexception.getMessage());        }        catch (ClassNotFoundException classnotfoundexception)        {            throw new NoClassDefFoundError(classnotfoundexception.getMessage());        }    }}

关于“JDK中动态代理的示例分析”这篇文章就分享到这里了,希望以上内容可以对大家有一定的帮助,使各位可以学到更多知识,如果觉得文章不错,请把它分享出去让更多的人看到。

--结束END--

本文标题: JDK中动态代理的示例分析

本文链接: https://lsjlt.com/news/279443.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • JDK中动态代理的示例分析
    这篇文章将为大家详细讲解有关JDK中动态代理的示例分析,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。动态代理步骤创建一个实现接口InvocationHandler的类,它必须实现invoke方法创建被代理...
    99+
    2023-06-15
  • Spring中JDK和cglib动态代理原理的示例分析
    这篇文章给大家分享的是有关Spring中JDK和cglib动态代理原理的示例分析的内容。小编觉得挺实用的,因此分享给大家做个参考,一起跟随小编过来看看吧。Java代理介绍Java中代理的实现一般分为三种:JDK静态代理、JDK动态代理以及C...
    99+
    2023-06-02
  • Java中动态代理和静态代理的示例分析
    这篇文章主要介绍了Java中动态代理和静态代理的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。0、代理模式为什么要学习代理模式?这是SpringAOP的底层【Spri...
    99+
    2023-06-29
  • Java动态代理示例分析
    这篇文章主要讲解了“Java动态代理示例分析”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java动态代理示例分析”吧!定义动态代理指的是,代理类和目标类的关系在程序运行的时候确定的,客户通...
    99+
    2023-06-29
  • Java中引用和动态代理的示例分析
    这篇文章主要介绍了Java中引用和动态代理的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。JDK中的引用类型不同引用类型对GC行为的影响引用类型的实现ThreadLo...
    99+
    2023-05-30
    java
  • Java JDK 动态代理的使用方法示例
    本文主要和大家分享介绍了关于Java JDK 动态代理使用的相关内容,分享出来供大家参考学习,下面来一起看看详细的介绍:前言代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤...
    99+
    2023-05-31
    java jdk 动态代理
  • Java反射机制中动态代理的示例分析
    这篇文章主要介绍了Java反射机制中动态代理的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。1. 代理模式代理模式就是为其他对象提供一种代理来控制对这个对象的访问。其...
    99+
    2023-06-17
  • Java中反射机制和动态代理的示例分析
    这篇文章主要介绍了Java中反射机制和动态代理的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。一、反射概述反射机制指的是Java在运行时候有一种自观的能力,能够了解自...
    99+
    2023-06-15
  • JDK动态代理步骤详解(源码分析)
    动态代理步骤 1.创建一个实现接口InvocationHandler的类,它必须实现invoke方法 2.创建被代理的类以及接口 3.通过Proxy的静态方法 通过Proxy的静态方...
    99+
    2024-04-02
  • 深入浅析java 中JDK的动态代理类
    这期内容当中小编将会给大家带来有关深入浅析java 中JDK的动态代理类,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。详解java JDK 动态代理类分析(java.lang.reflect.Proxy)...
    99+
    2023-05-31
    java jdk 动态代理类
  • Java动态代理与静态代理实例分析
    这篇文章主要介绍了Java动态代理与静态代理实例分析的相关知识,内容详细易懂,操作简单快捷,具有一定借鉴价值,相信大家阅读完这篇Java动态代理与静态代理实例分析文章都会有所收获,下面我们一起来看看吧。一、静态代理静态代理的使用静态代理,代...
    99+
    2023-07-02
  • 基于JDK动态代理原理解析
    目录1、回顾一下JDK动态代理的核心参数2、实现一个简单的动态代理①、定义接口Subject②、定义接口的实现类RealSubject③、定义代理对象创建工厂④、创建测试类,为tar...
    99+
    2023-05-18
    JDK动态代理原理 JDK动态代理 动态代理原理
  • Java——JDK动态代理
    1.动态代理 1.1什么是动态代理? 动态代理(理解) 基于反射机制 举个例子,生活中一般在打官司的时候都会请代理律师,为什么要请律师呢?是因为开庭的时候大部人对于打官司没有经验,只会说出自己案件的陈述,并不会根据法律等争取自己权益...
    99+
    2023-08-31
    java 开发语言
  • 深入浅析java 中的JDK与cglib动态代理
    这篇文章将为大家详细讲解有关深入浅析java 中的JDK与cglib动态代理,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。java 动态代理实例详解1.jdk动态代理 package com...
    99+
    2023-05-31
    java jdk cglib
  • 深度剖析java中JDK动态代理机制
    摘要相比于静态代理,动态代理避免了开发人员编写各个繁锁的静态代理类,只需简单地指定一组接口及目标类对象就能动态的获得代理对象。代理模式使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用...
    99+
    2023-05-31
    jdk 动态代理 ava
  • jdk动态代理和cglib动态代理详解
    目录静态代理基于继承的方式实现静态代理基于聚合的方式实现静态代理继承与聚合方式实现的静态代理对比动态代理JDK动态代理如何实现一个HashMap的动态代理类?Cglib动态代理JDK...
    99+
    2024-04-02
  • jdk动态代理使用实例详解
    目录前言为什么需要代理java中常用的代理模式一、JDK 动态代理二、cglib静态代理三、spring中代理的使用总结前言 代理模式不管是JDK,spring框架,还是日常的开发中...
    99+
    2024-04-02
  • Hive中静态分区与动态分区的示例分析
    这篇文章给大家分享的是有关Hive中静态分区与动态分区的示例分析的内容。小编觉得挺实用的,因此分享给大家做个参考,一起跟随小编过来看看吧。  分区是hive存放数据的一种方式。将列值作为目录来存放数据,就是一个分区。这样查询时使用分区列进行...
    99+
    2023-06-02
  • java动态代理(jdk与cglib)详细解析
    JAVA的动态代理 代理模式 代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息...
    99+
    2022-11-15
    java jdk cglib
  • C语言中动态内存管理的示例分析
    这篇文章主要介绍了C语言中动态内存管理的示例分析,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。什么是动态内存分配我们都知道在C语言中,定义变量的时候,系统就会为这个变量分配内...
    99+
    2023-06-25
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作