JDK静态代理与JDK动态代理你真的需要了解一下了！

最新推荐文章于 2024-09-28 12:58:43 发布
最新推荐文章于 2024-09-28 12:58:43 发布
阅读量603 收藏 2
点赞数 4
分类专栏： Java基础 文章标签： java aop 反射 jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wodeshenni/article/details/108555267
版权

文章目录

前言

说到动态代理不得不说AOP(Aspect-Oriented Programming)面向切面编程，它是OOP（Object Oriented Programming）的补充，通过AOP思想我们可以把公共部分抽取出来（比如权限控制、日志打印、任务执行耗时等等），一方面减少了代码污染，另一方面也降低了各业务逻辑之间的耦合度。Spring中的AOP就是基于CGLIB与JDK动态代理实现的。

1. 静态代理

静态代理就是目标类与代理类是相对确定的，因此称作静态代理。

看到代理时，我们会想到代理模式，什么是代理模式呢？代理模式即为其他对象提供对目标对象另外的访问方式，也就是通过代理对象访问目标对象。

接下来我们通过一个例子来了解什么是静态代理以及优点和缺点：

public interface Business {
    void transfer();
}

public class Bank implements Business {
    @Override
    public void transfer() {
        System.out.println("给目标账户执行转账中···");
    }
}

public class ATM implements Business {
    private Business business;
    ATM(Business business) {
        this.business = business;
    }
    @Override
    public void transfer() {
        check(false);
        this.business.transfer();
        check(true);
    }
    private void check(boolean finishFlag) {
        String currentStatus = finishFlag ? "转账完毕，收起银行卡。" : "从票夹中取出取款卡，插入ATM，开始转账操作···";
        System.out.println(currentStatus);
    }
}

public class Consumer {
    public static void main(String[] args) {
        Bank bank = new Bank();
        Business transfer = new ATM(bank);
        transfer.transfer();
    }
}

输出结果：

从票夹中取出取款卡，插入ATM，开始转账操作···
给目标账户执行转账中···
转账完毕，收起银行卡。

代码示例中，ATM（代理类）与Bank（目标类）都可以进行转账操作，ATM则在转账前后增加了一些额外的处理。
如果Business增加了一些新的业务比如取款、存款接口，那么目标类与代理类都需要去实现相应的业务接口。

静态代理的优缺点：

  • 优点：隐藏了目标类接口的实现类提高安全性，在特定场景下实现了解耦。
  • 缺点：代理类需要实现目标类的接口，灵活性差，例如：当目标类增加了某些接口，并且存在多个代理类，这将会导致目标类的所有代理类都需要做出相应修改。

2. 动态代理

2.1 JDK动态代理

JDK动态代理是通过拦截器加反射机制生成代理接口的匿名类。

public interface Business {

    void transfer(String transferAmount);

    void withdraw(String withdrawAmount);

}

public class Bank implements Business {

    @Override
    public void transfer(String transferAmount) {
        System.out.println("给目标账户执行转账" + transferAmount + "元···");
    }

    @Override
    public void withdraw(String withdrawAmount) {
        System.out.println("给客户取款" + withdrawAmount + "···");
    }
}

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

public class ATM implements InvocationHandler {

    private Object target;

    public ATM(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        operation(false);
        Object result = method.invoke(target, args);
        operation(true);
        return result;
    }

    Object getJdkProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    private void operation(boolean finishFlag) {
        String currentStatus = finishFlag ? "业务处理完毕，收起银行卡。" : "开始业务操作···";
        System.out.println(currentStatus);
    }
}

public class Consumer {
    public static void main(String[] args) {
        ATM atm = new ATM(new Bank());
        Business business = (Business) atm.getJdkProxy();
        business.transfer("100");
        business.withdraw("1000000000");
    }
}

开始业务操作···
给目标账户执行转账100元···
业务处理完毕，收起银行卡。
开始业务操作···
给客户取款1000000000···
业务处理完毕，收起银行卡。

2.1.1 探究JDK动态代理如何实现

2.1.1.1 java.lang.reflect.Proxy
	···
	 /**
	  * 代理类的构造参数类型
	  */
	 private static final Class<?>[] constructorParams = { InvocationHandler.class };

    /**
     * 代理类缓存
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    /**
     * 代理实例的调用处理器
     * InvocationHandler是由代理实例的调用处理程序实现的接口。
     * 每个代理实例都有一个关联的调用处理器。 
     * 当通过代理实例调用方法时，该方法的调用将被编码并分配到其调用处理程序的invoke方法。
     */
    protected InvocationHandler h;

    /**
     * Prohibits instantiation.
     */
    private Proxy() {
    }
	···

	/**
	 * 创建代理类实例
	 * @param loader 	 创建代理类的加载器
	 * @param interfaces 代理类需要实现的接口数组
	 * @param h			 调用处理器
	 */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
        Objects.requireNonNull(h);
		// 克隆目标类实现的所有接口
        final Class<?>[] intfs = interfaces.clone();
        
        // 省略
        
        // 查找或生成代理类
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * 通过指定的InvocationHandler调用它的构造
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
			// 获得构造器
            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;
                    }
                });
            }
            // 返回代理类示例
            return cons.newInstance(new Object[]{h});
        }
        
        // 省略
        
    }

我们调用Proxy.newProxyInstance()大致经过一下三个步骤：

  • Class<?> cl = getProxyClass0(loader, intfs) 得到代理类；
  • final Constructor<?> cons = cl.getConstructor(constructorParams)获得代理类构造；
  • return cons.newInstance(new Object[]{h})返回代理类实例。

第一步很关键，怎么得到代理类呢？

 	/**
     * 获取代理类
     */
    private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        //  如果实现接口的加载器的代理类存在，返回缓存的副本；否则通过代理类工厂创建代理类
        return proxyClassCache.get(loader, interfaces);
    }

我们看到proxyClassCache.get(loader, interfaces);看命名是从代理类缓存中根据目标类加载器与代理类需要实现的接口数组获取到对应代理类，那么具体步骤呢 ？
下面我们来看看proxyClassCache.get(loader, interfaces);是如何获取到代理类的。

2.1.1.2 java.lang.reflect.WeakCache
/**
 1. K : 键
 2. P : 参数
 3. V : 值
 4. K & V是弱引用
 5. P	是强引用
 */
final class WeakCache<K, P, V> {

    private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();
    // Object：key，第二个Object：subKey，Supplier< V >:value
    // 缓存
    private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();
    // 存在标注CacheValue<V>的可用性
    private final ConcurrentMap<Supplier<V>, Boolean> reverseMap = new ConcurrentHashMap<>();
    // 用于生成子键
    private final BiFunction<K, P, ?> subKeyFactory;
    // 用于生成值
    private final BiFunction<K, P, V> valueFactory;

    /**
     * 构造WeakCache的实例
     *
     * @param subKeyFactory subKeyFactory函数从键和参数计算subKey
     * @param valueFactory  valueFactory函数根据键和参数计算value。
     */
    public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

    /**
     * 通过缓存查找值。 
     * 如果给定的（key，subKey）对在缓存中没有任何条目，
     * 或者该条目已被清除，则这将始终评估subKeyFactory函数，并可选地评估valueFactory函数。
     *
     * @param key       创建代理类的加载器
     * @param parameter 代理类需要实现的接口数组(与key一起使用,创建子键和值的参数)
     * @return 缓存的值
     */
    public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);
		// 通过弱引用机制清理过期缓存
        expungeStaleEntries();
		// 根据key（ClassLoader）生成cacheKey,一级key
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // 获取二级缓存
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
        	/*
        	 * putIfAbsent() 并发场景下提高性能，保证线程安全:
        	 * 1.如果传入key对应的value已经存在，就返回存在的value;
        	 * 2.如果不存在，就添加key和value，返回null。
        	 */
            ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }
        // 根据目标类接口数组生成subKey 
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        // 通过subkey获取supplier(二级缓存的值)
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
		// 无限循环找到对应的代理类return
        while (true) {
        	// 通过subkey从缓存中获取到supplier
            if (supplier != null) {
                // supplier 可能是Factory 或者 CacheValue<V>
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            
            // 二级缓存里面supplier不存在
            // 或者supplier返回null，(可能由于CacheValue是弱引用，若代理类不再使用被GC回收了，对应CacheValue的get值 == null）
            // 懒加载的方式重新构造factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

			// 二级缓存中通过subkey未获取到supplier
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                // supplier == null 缓存加入成功 supplier = factory,再次循环后返回
                if (supplier == null) {
                    supplier = factory;
                }
            } else {
            	// 若supplier不为空且supplier.get() == null则supplier是无效的
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // 成功替换后，supplier = factory，再次循环后返回
                    supplier = factory;
                } else {
                    // 通过subkey重新尝试获取supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }
   ···

WeakCache.get()大致经过以下五步：

  1. CacheKey.valueOf(key, refQueue)通过目标类生成cacheKey作为一级Key;
  2. map.get(cacheKey)获取二级缓存，若为空则通过putIfAbsent()的方式放入new ConcurrentHashMap<>();
  3. Objects.requireNonNull(subKeyFactory.apply(key, parameter));获取二级key；
  4. valuesMap.get(subKey)然后通过二级缓存key获取二级缓存的值;
  5. valuesMap.putIfAbsent(subKey, factory)二级缓存的值就是WeakCache$Factory实例，然后通过supplier.get()，返回生成的代理类；

接下来我们再看看V value = supplier.get();是怎么生成代理类的呢？

2.1.1.3 WeakCache$Factory
	private final class Factory implements Supplier<V> {
        private final K key;
        private final P parameter;
        private final Object subKey;
        private final ConcurrentMap<Object, Supplier<V>> valuesMap;

        Factory(K key, P parameter, Object subKey, ConcurrentMap<Object, Supplier<V>> valuesMap) {
            this.key = key;
            this.parameter = parameter;
            this.subKey = subKey;
            this.valuesMap = valuesMap;
        }

        @Override
        public synchronized V get() {
            // 重新检查
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // 可能是supplier被CacheValue替换了，或者因为失败而被删除，返回null
                // WeakCache.get()来重试循环
                // if (supplier == null) {
                //    supplier = factory;
                // }
                return null;
            }
            // 创建新值
            V value = null;
            try {
            	//  通过ProxyClassFactory生成代理类
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) {
                	// 移除subKey与this
                    valuesMap.remove(subKey, this);
                }
            }
            assert value != null;
            // 使用CacheValue包装value
            CacheValue<V> cacheValue = new CacheValue<>(value);
            // reverseMap中标记Value可用
            reverseMap.put(cacheValue, Boolean.TRUE);
            // 尝试使用this替换cacheValue
            // subKey key, supplier oldValue, cacheValue newValue
            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }
            // 返回代理类
            return value;
        }
    }

WeakCache$Factory.get()大致经过以下步骤：

  1. 通过二级key获取supplier，检查supplier是否等于this，false：重新通过WeakCache.get()来重试，true：继续；
  2. return通过valueFactory.apply(key, parameter)生成的代理类；

总结

通过上面的源码阅读我们不难发现：JDK动态代理基于反射机制实现，只对基于接口进行代理，且生成的代理类继承Proxy；通过拦截器，在目标类的接口被调用的基础上，增加切面进行功能增强。在Spring中Jdk动态代理的应用也很广泛。

【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
静态代理 动态代理 jdk Proxy
08-16
自己写的小例子，供学习参考。 public class StaticProxy implements Hello{ private HelloSpecker helloSpecker; public StaticProxy() { } public StaticProxy(HelloSpecker helloSpecker) { super(); this.helloSpecker = helloSpecker; } @Override public void hello(String say) { System.out.println("执行前"); helloSpecker.hello(say); System.out.println("执行后"); } }
java静态代理与动态代理简单分析
weixin_30758821的博客
09-10 88
原创作品，可以转载，但是请标注出处地址http://www.cnblogs.com/V1haoge/p/5860749.html 1、动态代理（Dynamic Proxy） 　　代理分为静态代理和动态代理，静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代...
详解代理模式-【静态代理与JDK动态代理】（非常的斯国一）
最新发布
Blue的博客
09-28 1976
静态代理相当于是多写了一个代理类，在调用的时候调用的是代理类，在代理类中的处理还是原生的处理逻辑，不过在前后添加上需要添加的代码。动态代理，我个人认为就是java自己给了你一个可以创建代理类的类，然后通过反射之内的，然后再你执行某方法时候，有一步，调用处理机制，对其增强。其实也很像静态代理的。
jdk静态代理和动态代理
qiaziliping的博客
08-11 470
jdk静态代理和jdk动态代理
jdk的静态代理和动态代理
hewenjing8168的博客
08-24 312
1.静态代理 接口 Moveable package com.hwj.Daili; /** * @Auther: hwj * @Date: 2018/8/24 14:44 * @Description: */ public interface Moveable { void move(); } Car实现了Moveale接口 package com.hwj.Dail...
JAVA中基于JDK的静态代理和动态代理
dimu9293的博客
08-02 298
JAVA中基于JDK的静态代理和动态代理 1. 什么是代理 代理在我们生活中也就是所谓的中介。那么为什么我们需要中介呢？ 举个例子来说： 我现在想买二手房，但是要面临很多问题。比如找房源，房子质量测评，房子过户合同要如何编写等一系列繁琐的事情。这个时候就需要中介出场了，他们可以帮我们把其他需要事前和事后处理的事情都帮我们做了。 2. 代理的功能 1.只要关注接口本身的功能而不用过多关注具体如何实现。具体的实现由代理类来进行操作。 2.遵循开闭原则，在不修改需求的情况下可以增加很多的功能。 3. 如何实现 代
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
静态代理、jdk动态代理、cglib动态代理
02-27
在 JDK 动态代理中，我们不需要在编译时创建代理类，而是使用 Java 反射机制在运行时动态创建代理对象。 JDK 动态代理的实现方式是：我们首先需要定义一个接口，然后创建一个实现该接口的类，该类将作为被代理的...
Java基础-动态代理(JDK与CGLIB)与静态代理
子悠のziyou
11-23 1082
JDK之动态代理(JDK与CGLIB)与静态代理，带你十分钟快速理解JDK与Cglib以及他们之间的区别与联系
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）具有相同的接口，通过代理类调用实际对象的方法。代理类通常会增加一些额外的操作，如日志记录、权限检查等。静态代理的主要缺点是代码冗余，...
静态代理和jdk动态代理
weixin_51687691的博客
05-19 184
静态代理和jdk动态代理 1.静态代理 1.1共有接口 1.2目标类（实现共有接口） 1.3静态代理类（实现共有接口）:在实现接口的方法中增加功能 2.jdk动态代理（invocationhandler和proxy） //接口 public interface Student { public void say(); } //接口的实现类 public class StudentImpl implements Student { @Override public void s.
08-动态代理是如何实现的？JDK Proxy 和 CGLib 有什么区别？
cenghaihengliu的博客
06-20 382
90% 的程序员直接或者间接的使用过动态代理，无论是日志框架或 Spring 框架，它们都包含了动态代理的实现代码。动态代理是程序在运行期间动态构建代理对象和动态调用代理方法的一种机制。 我们本课时的面试题是，如何实现动态代理？JDK Proxy 和 CGLib 有什么区别？ 典型回答 动态代理的常用实现方式是反射。反射机制是指程序在运行期间可以访问、检测和修改其本身状态或行为的一种能力，使用反射我们可以调用任意一个类对象，以及类对象中包含的属性及方法。 但动态代理不止有反射一种实现方式，例如，动态代理可以
静态代理和JDK动态代理
qq_36806831的博客
12-29 275
1.代理模式的介绍 定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 以一个简单的例子：当我们打游戏的时候，找代练，需要给代练自己的帐号。代练就是一个代理，这里的重点的是需要将自己的帐号给代练， 也就是需要将被代理对象要执行的方法传给代理者去执行。 2.实现上面简单的例子（静态代理） public interface IGamePlayer { boolean login(Str
静态代理与JDK动态代理
FromZeroJiYuan的博客
12-10 526
文章目录概述定义与结构静态代理软件设计原则动态代理JDK动态代理的一个简单例子JDK动态代理源码分析总结 概述 代理模式是一种常用的设计模式，在AOP、RPC等诸多框架中均有它的身影。 根据代理类的创建时机和创建方式的不同，可以将其分为静态代理和动态代理两种形式：在程序运行前就已经存在的编译好的代理类是为静态代理，在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能是为动态代理。 代理模式的目的就是为真实业务对象提供一个代理对象以控制对真实业务对象的访问，代理对象的作用有： 代理对象存在的价值主要
Java中静态代理与JDK动态代理
qq_52971866的博客
12-27 194
代理模式目的： 代理就是对目标方法(例如业务的处理)进行增强(例如增删改中事务的开启与提交)，让专业的人干专业的事情。实现解耦过程，让业务层只关心业务，而无需考虑例如事务的开启与提交，日志管理等等这些增强的动作我都不关注了，在业务类里只写业务！最后在代理类里把增强的动作和目标动作结合起来就ok了。 静态代理缺点 静态代理是程序运行前，代理类的.class文件已经存在了。 静态代理的缺点： 1、由于静态代理中的代理类是针对某一个类去做代理的，那么假设一个系统中有100个Service，则需要创建
设计模式——代理模式：JDK静态代理和动态代理的实例和实现
长臂人猿的博客
08-22 691
前言   代理模式，我们这里结合JAVA的静态代理和动态代理来说明，类比Spring AOP面向切面编程：增强消息，也是代理模式。   而我们的静态代理和动态代理，与（service）接口和（serviceImpl）接口实现类有什么区别呢？静态代理的概念与其在理解上类似，可以说静态代理是实现类的增强消息。而且，静态代理针对的是所以实现接口的实现类（通过向上转型实现）。 静态代理 实现简述   本质上是一接口一代理，对该接口的所有实现类进行"增强"（额外）操作：   如下例：human接口有两个实现类：m
JAVA静态代理与JDK动态代理
SagarZhang的博客
05-04 186
目录前言静态代理JDK动态代理 前言 本文将简要介绍java的静态代理与JDK动态代理。 本人最近在学习JAVA相关知识，发现网上对于代理的相关解释过于杂乱，故整理在此以供参考。 本人的工程经验甚少，所以对为什么使用代理模式也不知从何讲起，本文主要是阐述如何使用动态与静态代理。 静态代理 假设有一个接口Interface1，其规定了实现这个接口必须有两个函数void fun1()和void fun2() interface Interface1 { void fun1(); int fun2(); }
深度解析：代理模式与JDK动态代理实战指南
2. 静态代理与动态代理示例： - 静态代理：作者通过一个简单的游戏者（GamePlayer）接口和实现来展示静态代理，代练者（GamePlayerProxy）作为静态代理，直接扩展了游戏者接口并封装额外功能。 - 动态代理：动态...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人生逆旅我亦行人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值