更快的BeanUtil（对比BeanUtils，Cglib）

已于 2024-04-22 10:04:52 修改
阅读量2.6k 收藏 3
点赞数 2
分类专栏： 工具类 文章标签： java bean 反射 spring
于 2020-09-28 10:35:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZDLW5/article/details/108844127
版权

基于缓存和反射的高效BeanUtil

BeanUtil算是个高频使用工具类了，很多地方都用得到，大家常用的BeanUtil大概有Spring的BeanUtils以及cglib的BeanCopier，前者使用反射进行getter、setter方法调用，后者使用CGLIB代理直接操作字节码调用getter、setter方法。

BeanCopier的性能要高出Spring的BeanUtils很多，我实测大概有5倍多的差距，但是BeanCopier用起来也更加繁琐一些，需要先传入source类和target类创建一个beanCopier实例，相比Spring的BeanUtils要多一个步骤，当然封装一下之后用起来都一样方便，问题是，这两个BeanUtil实际上都有个问题，强依赖于Getter、Setter方法，如果Bean没有Getter、Setter方法，或者重写了Getter、Setter方法，这两个工具类都会失效。

反射之所以慢，主要在于使用反射获取类的Method对象、Field对象时候慢，所以加快基于反射的Beanutil的一个简单思路，就是把需要用反射来获取的对象缓存起来，下次要用的时候就不用再一次获取了，效率会快很多，

通过起100个线程，每个线程跑100万次，测试发现，多线程环境下BeanCopier性能衰减的厉害，比单线程测试时候效率低了很多，实测我手写的BeanUtil在多线程环境下性能达到了BeanCopier的1.5倍左右，当然这是未封装过的BeanCopier的性能，用起来很麻烦，一旦封装性能差距会更大。

package com.tsd.dlmPlatform_common.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 
 * @author HeJun
 * @date 2020年9月28日
 * @Version V1.4
 * @Description JavaBean工具类，通过反射结果缓存机制，可以实现source类对象与target类对象间，同名字段值的高效率、线程安全复制
 * 
 */
@SuppressWarnings("unchecked")
public class HjBeanUtil {
	// 构造器对象的key值
	private static final String CONSTRUCT_KEY = "CONSTRUCT_KEY";
	// 字段对象list的key值
	private static final String FIELDS_LIST_KEY = "FIELDS_LIST_KEY";
	// 创建反射元素缓存池单例对象，饿汉式
	private volatile static CachePool CACHE_POOL = new CachePool();

	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月28日
	 * @Version V1.3
	 * @Description 将source对象的同名字段值复制给targetClazz类的实例并返回
	 * @param <T>
	 * @param source
	 * @param targetClazz
	 * @return
	 * @throws Exception
	 */
	public static <T> T copy(Object source, Class<T> targetClazz, String...ignoreFields) {
		T target = null;
		// 获取source的类对象
		if(source != null) {
			Class<?> sourceClazz = source.getClass();
			try {
				// 如果缓存池中没有source的缓存就添加，并返回source缓存
				ClazzCache sourceCache = getCacheFromPool(sourceClazz);
				// 实例化target类对象
				target = getInstance(targetClazz);
				// 获得target类的字段List
				List<Field> targetFieldsList = getFieldsList(targetClazz);
				// 遍历targetFieldsList中所有的字段
				for (Field targetField : targetFieldsList) {
					if(ignoreFieldsInvoke(targetField, ignoreFields)) {
						continue;
					}
					// 通过target字段的名字，从sourceCache缓存中获得source的字段（target字段需为source字段的子集）
					Field sourceField = (Field) sourceCache.get(targetField.getName());
					if (sourceField != null) {
						Object value = sourceField.get(source);
						targetField.set(target, value);
					}
				}
			} catch (Exception e) {
				throw new RuntimeException(
						sourceClazz.getName() + " 转 " + targetClazz.getName() + " 失败\n" + e.getMessage(),e);
			}

		}
		
		return target;

	}
	
	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月28日
	 * @Version V1.3
	 * @Description 将source对象的同名字段值复制给targetClazz类的实例并返回
	 * @param <T>
	 * @param source
	 * @param targetClazz
	 * @return
	 * @throws Exception
	 */
	public static <T> T copy(Object source, Class<T> targetClazz) {
		return copy(source, targetClazz, null);
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月28日
	 * @Version V1.0
	 * @Description 将source对象的同名字段值复制给target对象
	 * @param source
	 * @param target
	 */
	public static void copy(Object source, Object target, String...ignoreFields) {
		if(source != null) {
			// 获取类对象
			Class<?> sourceClazz = source.getClass();
			Class<?> targetClazz = target.getClass();
			try {
				// 如果缓存池中没有source的缓存就添加，并返回source缓存
				ClazzCache sourceCache = getCacheFromPool(sourceClazz);
				// 获得target类的字段List
				List<Field> targetFieldsList = getFieldsList(targetClazz);
				// 遍历targetFieldsList中所有的字段
				for (Field targetField : targetFieldsList) {
					if(ignoreFieldsInvoke(targetField, ignoreFields)) {
						continue;
					}
					// 通过target字段的名字，从sourceCache缓存中获得source的字段（target字段需为source字段的子集）				
					Field sourceField = (Field) sourceCache.get(targetField.getName());
					if (sourceField != null) {
						Object value = sourceField.get(source);
						targetField.set(target, value);
					}
				}
			} catch (Exception e) {
				throw new RuntimeException(
						sourceClazz.getName() + " 转 " + targetClazz.getName() + " 失败\n" + e.getMessage(),e);
			}
		}
	}

	/**
	 *
	 * @author HeJun
	 * @date 2020年9月28日
	 * @Version V1.0
	 * @Description 将source对象的同名字段值复制给target对象
	 * @param source
	 * @param target
	 *
	 */
	public static void copy(Object source, Object target) {
		copy(source, target, null);
	}

	private static boolean ignoreFieldsInvoke(Field targetField,String...ignoreFields) {
		boolean flag = false;
		if(ignoreFields != null && ignoreFields.length > 0) {
			String name = targetField.getName();
			for (int i = 0; i < ignoreFields.length; i++) {
				if(name.equals(ignoreFields[i])) {
					flag = true;
					break;
				}
			}						
		}
		return flag;
	}
	
	/**
	 * 
	 * @author HeJun
	 * @date 2021年4月17日
	 * @Version V1.0
	 * @Description 将sourceList内的元素对象的同名字段值复制给targetList
	 * @param <T>
	 * @param sourceList
	 * @param targetClazz
	 * @return
	 */
	public static <T> List<T> copyList(List<?> sourceList, Class<T> targetClazz, String...ignoreFields) {
		List<T> targetList = null;
		if(sourceList != null) {
			targetList = new ArrayList<T>();
			for (Object source : sourceList) {
				targetList.add(copy(source, targetClazz,ignoreFields));
			}
		}		
		return targetList;
	}

	/**
	 *
	 * @author HeJun
	 * @date 2021年4月17日
	 * @Version V1.0
	 * @Description 将sourceList内的元素对象的同名字段值复制给targetList
	 * @param <T>
	 * @param sourceList
	 * @param targetClazz
	 * @return
	 */
	public static <T> List<T> copyList(List<?> sourceList, Class<T> targetClazz) {
		return copyList(sourceList, targetClazz, null);
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月29日
	 * @Version V1.0
	 * @Description 将map转换成targetClazz类的实例
	 * @param <T>
	 * @param sourceMap
	 * @param targetClazz
	 * @return
	 */
	public static <T> T mapToObect(Map<String, ?> sourceMap, Class<T> targetClazz, String...ignoreFields) {
		T target = null;
		if(!HjBeanUtil.isEmpty(sourceMap)) {
			try {
				// 实例化target类对象
				target = getInstance(targetClazz);
				// 获得target类的字段List
				List<Field> targetFieldsList = getFieldsList(targetClazz);
				// 遍历targetFieldsList中所有的字段
				for (Field targetField : targetFieldsList) {
					if(ignoreFieldsInvoke(targetField, ignoreFields)) {
						continue;
					}
					// 通过target字段的名字，从sourceCache缓存中获得source的字段（target字段需为source字段的子集）
					Object value = sourceMap.get(targetField.getName());
					targetField.set(target, value);
				}
			} catch (Exception e) {
				
				throw new RuntimeException("sourceMap" + " 转 " + targetClazz.getName() + " 失败\n" + e.getMessage(),e);
			}
		}
		
		return target;
		
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月29日
	 * @Version V1.0
	 * @Description source对象转有序map
	 * @param source
	 * @return
	 */
	public static LinkedHashMap<String, Object> objectToMap(Object source, String...ignoreFields) {
		LinkedHashMap<String, Object> targetMap = null;
		if(source != null) {
			targetMap = new LinkedHashMap<>();
			// 获取类对象
			Class<?> sourceClazz = source.getClass();
			try {
				// 获得source类的字段List
				List<Field> sourceFieldsList = getFieldsList(sourceClazz);
				// 遍历sourceFieldsList中所有的字段
				for (Field sourceField : sourceFieldsList) {
					Object value = sourceField.get(source);
					if(!ignoreFieldsInvoke(sourceField, ignoreFields) && value != null) {
						targetMap.put(sourceField.getName(), value);
					}
				}
			} catch (Exception e) {
				throw new RuntimeException(sourceClazz.getName() + " 转 " + "targetMap" + " 失败\n" + e.getMessage(),e);
			}
		}
				
		return targetMap;
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年9月27日
	 * @Version V1.2
	 * @Description 向缓存池添加反射元素缓存
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	private static ClazzCache getCacheFromPool(Class<?> clazz) throws Exception {
		ClazzCache clazzCache = CACHE_POOL.get(clazz);
		// 如果缓存中没有clazz的缓存就添加
		if (clazzCache == null) {
			clazzCache = addClazzCache(clazz);
		}
		return clazzCache;
	}

	/**
	 * @author HeJun
	 * @date 2020年9月27日
	 * @Version V1.0
	 * @Description 向缓存池添加ClazzCache缓存，并返回ClazzCache对象
	 * @param clazz
	 * @return
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 */
	private static ClazzCache addClazzCache(Class<?> clazz)
			throws NoSuchMethodException, SecurityException {
		ClazzCache clazzCache = CACHE_POOL.get(clazz);
		if (clazzCache == null) {
			clazzCache = new ClazzCache();
			List<Field> fieldsList = new ArrayList<>();
			Set<String> fieldNamesSet = new HashSet<>();
			for (Class<?> currentClazz = clazz; currentClazz != Object.class; currentClazz = currentClazz
					.getSuperclass()) {
				// 获得当前clazz的字段数组
				Field[] fields = currentClazz.getDeclaredFields();
				for (Field field : fields) {
					// 判断是否是final修饰的字段，如果是就不添加进clazzFields
					if (!Modifier.isFinal(field.getModifiers())) {
						field.setAccessible(true);
						// 判断字段名是否重复，如果重复就不添加
						if (fieldNamesSet.add(field.getName())) {
							fieldsList.add(field);
							clazzCache.put(field.getName(), field);
						}
					}
				}
				// 将类字段list放入clazzCache中
				clazzCache.put(FIELDS_LIST_KEY, fieldsList);
				// 将类的构造器放入clazzCache中
				clazzCache.put(CONSTRUCT_KEY, clazz.getDeclaredConstructor());
			}
			// 将clazzCache反射元素缓存放入缓存池中
			clazzCache = CACHE_POOL.putIfAbsent(clazz, clazzCache);
		}
		
		return clazzCache;
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年10月20日
	 * @Version V1.0
	 * @Description 根据类对象返回该类实例
	 * @param <T>
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	private static <T> T getInstance(Class<T> clazz) throws Exception {
		ClazzCache cache = getCacheFromPool(clazz);
		Constructor<T> constructor = (Constructor<T>) cache.get(CONSTRUCT_KEY);
		return constructor.newInstance();
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年10月20日
	 * @Version V1.0
	 * @Description 从缓存池中获取clazz类的Field对象List
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	public static List<Field> getFieldsList(Class<?> clazz) throws Exception {
		// 如果缓存池中没有source的缓存就添加，并返回source缓存
		ClazzCache sourceCache = getCacheFromPool(clazz);
		// 从sourceCache中获得sourceFieldsList
		return (List<Field>) sourceCache.get(FIELDS_LIST_KEY);

	}

	/**
	 * 类字节码对象缓存类
	 * 
	 * @author HeJun
	 *
	 */
	static class ClazzCache extends ConcurrentHashMap<String, Object> {

		private static final long serialVersionUID = 688480073708628721L;

	}

	/**
	 * 类字节码对象缓存类的缓存池
	 * 
	 * @author HeJun
	 *
	 */
	static class CachePool extends ConcurrentHashMap<Class<?>, ClazzCache> {

		private static final long serialVersionUID = -6321066791324989547L;

	}

	public static boolean isEmpty(Collection<?> collection) {
		if (collection == null || collection.size() == 0) {
			return true;
		}
		return false;
	}

	/**
	 * 
	 * @author HeJun
	 * @date 2020年8月13日
	 * @Version V1.0
	 * @Description str为null或者去掉字符串两端的空格后，与""比较是否为空字符串
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(String str) {
		if (str == null || "".equals(str.trim())) {
			return true;
		}
		return false;
	}

	public static boolean isEmpty(Object[] array) {
		if (array == null || array.length == 0) {
			return true;
		}
		return false;
	}

	public static boolean isEmpty(Map<?, ?> map) {
		if (map == null || map.size() == 0) {
			return true;
		}
		return false;
	}

使用方法：

TeacherDto teacherDto =  new TeacherDto("老王","语文",47);
Teacher teacher = HjBeanUtil.copy(teacherDto,Teacher.class);

注意：

  1. 如果子类中有和父类同名的字段，将会优先使用子类的字段对象进行操作，而不会对父类同名字段对象做操作
  2. 如果source类与targe类中，同名字段的类型不一致，将会抛出RuntimeException
  3. 显而易见的，只有同名同类型的字段才会复制成功
战斗力为5
关注
专栏目录
【Java基础知识 55】跟同事杠上了，Apache Beanutils为什么被禁止使用？
学Java，找哪吒
02-12 8013
性能走势 --> spring cglib BeanCopier > spring copyProperties > apache PropertyUtils > apache BeanUtils
Bean复制的几种框架性能比较（Apache BeanUtils、PropertyUtils、Spring BeanUtils、Cglib BeanCopier）
@龙猫的博客
07-25 7601
文章转载自：Bean复制的几种框架性能比较 Bean复制的几种框架性能比较： 测试结果： 10次测验 第一次 第二次 第三次 平均值 每次平均值 BeanUtil.copyProperties 54 57 50 53.66667 5.366666667 PropertyUtils.copyProperties 4 4 4 4 0.4 org.springframework....
BeanUtil的常用方法总结：
最新发布
qq_57828911的博客
08-08 337
BeanUtils 是 Spring 框架提供的一个工具类，用于操作 JavaBeans。它提供了一系列的方法来简化 JavaBeans 的操作，尤其是在复制对象属性时非常有用（日常crud开发少不了的工具）。以下是 BeanUtils 中一些常用的方法。这个方法用的频率很高，主要用于将一个 JavaBean 的属性值复制到另一个 JavaBean 中。如果两个 JavaBean 有相同的属性名，则可以轻松地复制属性值。在dto pojo vo等等之间的转换非常有用。
beanutils类
06-26
这个包主要提供用于操作JavaBean的工具类，Jakarta-Common-BeanUtils的主要功能都在这个包里实现。
12种 vo2dto 方法，就 BeanUtils.copyProperties 压测最拉胯！【快双11了，别用错喽】
bugstack虫洞栈
10-11 2116
作者：小傅哥 博客：https://bugstack.cn 原文：https://mp.weixin.qq.com/s/Xq7oQg7dYESMYxHVnxX8Dw 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 为哈么，你的代码也就仅仅是能用而已？ 没有技术深度、短缺知识储备、匮乏经验积累的前提下，怎么写代码？百度呀，遇到问题这搜一点，那查一块，不管它是什么原理还是适合哪种场景，先粘贴到自己的工程里，看，能跑了，能跑就行。那这样的代码也就仅仅是能用程度的交付，根本没有一定的质量保证，也
Apache的BeanUtils和PropertyUtils,Spring的BeanUtils,Cg
weixin_34235105的博客
07-10 153
2019独角兽企业重金招聘Python工程师标准>>> ...
BeanUtils该用哪个
loet6010的博客
09-04 528
在日常开发中，我们经常需要给对象进行赋值，通常会调用其set/get 方法，有些时候，如果我们要转换的两个对象之间属性大致相同，会考虑使用属性拷贝工具进行。 如我们经常在代码中会对一个数据结构封装成DO、SDO、DTO、VO 等，而这些Bean中的大部分属性都是一样的，所以使用属性拷贝类工具可以帮助我们节省大量的set和get操作。 市面上有很多类似的工具类，在开发中比较常用的有Spring BeanUtils和Apache BeanUtils。那么，我们到底应该选择哪种工具类更加合适呢？下面通过代码来比较
Apache BeanUtils 和 Spring BeanUtils，用哪个好？
m0_64363449的博客
08-08 342
在我们实际项目开发过程中，我们经常需要将不同的两个对象实例进行属性复制，从而基于源对象的属性信息进行后续操作，而不改变源对象的属性信息,比如DTO数据传输对象和数据对象DO，我们需要将DO对象进行属性复制到DTO，但是对象格式又不一样，所以我们需要编写映射代码将对象中的属性值从一种类型转换成另一种类型。
为什么不推荐使用BeanUtils属性转换工具示例详解
08-18
"BeanUtils属性转换工具的局限性和风险" BeanUtils是一个常用的Java属性转换工具，但是它存在一些局限性和风险，...因此，在实际开发中，我们需要小心使用BeanUtils，或者选择其他更好的属性转换工具，例如mapstruct。
spring.BeanUtils与apache.BeanUtils对象属性copy的性能对比以及源码分析
alleyz
12-05 5755
文章目录1. 对象属性拷贝的常见方式及其性能2. Introspector3. 源码：apache.BeanUtils3.1 针对标准JavaBean进行属性copy时的步骤3.2 判断属性是否可读/可写3.3 读取原始Bean的属性值、设置目标Bean的属性值4. 源码: spring.BeanUtils4.1 获取Bean的PropertyDescriptor4.2 属性值copy5. 总结5...
危险，请马上替换代码中的BeanUtils
JAVAQXQ的博客
08-06 383
首先公司内部就遇到过 commons 包的 BeanUtils 进行属性拷贝性能较差的真实案例，然后该同事换成了 Spring 的 BeanUtils 性能好了很多，感兴趣大家可以使用性能测试框架或者基准测试框架去对比，这里就不对比了。因此慎用属性转换工具，如果可能建议自定义转换类，使用 IDEA插件自动填充，效率也挺高， A 或 B 中任何属性类型不匹配，甚至删除一个属性， 编译阶段即可报错，而且直接调用 get set 的效率也是非常高的。这就导致在使用很多属性映射工具时，编译时不容易明显的错误。...
BeanUtils工具类
01-19
提供了很多方便的将数据封装成javaBean(符合一定规范的java类)的方法,不需要繁琐的setXXX()了.java学习开发必备
BeanUtils 是用 Spring 的还是 Apache ，那个效率更好。
houxian1103的博客
08-03 1546
说明： 在我们实际项目开发过程中，我们经常需要将不同的两个对象实例进行属性复制，从而基于源对象的属性信息进行后续操作，而不改变源对象的属性信息,比如DTO数据传输对象和数据对象DO，我们需要将DO对象进行属性复制到DTO，但是对象格式又不一样，所以我们需要编写映射代码将对象中的属性值从一种类型转换成另一种类型。 这种转换最原始的方式就是手动编写大量的get/set代码，当然这是我们开发过程不愿意去做的，因为它确实显得很繁琐。为了解决这一痛点，就诞生了一些方便的类库，常用的有 apache的BeanU..
Bean映射工具之Apache BeanUtils VS Spring BeanUtils
weixin_43960684的博客
01-02 222
前言 在我们实际项目开发过程中，我们经常需要将不同的两个对象实例进行属性复制，从而基于源对象的属性信息进行后续操作，而不改变源对象的属性信息,比如DTO数据传输对象和数据对象DO，我们需要将DO对象进行属性复制到DTO，但是对象格式又不一样，所以我们需要编写映射代码将对象中的属性值从一种类型转换成另一种类型。 对象拷贝 在具体介绍两种 BeanUtils 之前，先来补充一些基础知识。它们两种工具本...
BeanUtil最强搭档-BeanUtilsHelper,让 BeanUtil想用就用,随心所欲
weixin_43112950的博客
03-20 645
BeanUtilsHelper 解决 BeanUtil 烦恼,让 BeanUtil想用就用,随心所欲
Java beanutils对比,使用JMH对比BeanUtils和BeanCopier
weixin_32009069的博客
03-13 188
背景许多时候需要对比不同的框架或工具或算法， 选择使用性能更优的那一个。通常的做法是long start = System.currentTimeMillis();for(int i=0; idoSomeWork();}long end = System.currentTimeMillis();System.out.println("took time : "+(end-start));但这样的做...
更快的BeanUtil（对比BeanUtils，BeanCopier）
m0_51141627的博客
09-30 922
更快的BeanUtil（原创） BeanUtil算是个高频使用工具类了，很多地方都用得到，大家常用的BeanUtil大概有Spring的BeanUtils以及cglib的BeanCopier，前者使用反射进行getter、setter方法调用，后者使用CGLIB代理直接操作字节码调用getter、setter方法。 BeanCopier的性能要高出Spring的BeanUtils很多，我实测大概有5倍多的差距，但是BeanCopier用起来也更加繁琐一些，需要先传入source类和target类创建一个
Spring 中的BeanUtils与apache中的BeanUtils用法与比较-(拷贝对象)
龙的传人
05-13 1131
文章目录前言由來阿里代码规约spring包下apache包下apache下的BeanUtils最常用的方法为：Apache Common BeanUtil的常见使用场景。 前言 BeanUtil是一个常用的在对象之间复制数据的工具类，著名的web开发框架struts就是依赖于它进行ActionForm的创建。 其中一个是apache包下的 一个是spring包下的 由來 有一次开发过程中，刚好看到小伙伴在调用 set 方法，将数据库中查询出来的 Po 对象的属性拷贝到 Vo 对象中, 这种操作非常容易出错，
java beanutil 工具类_BeanUtil工具类的使用
weixin_39580041的博客
02-13 1224
BeanUtils的使用1.commons-beanutils的介绍commons-beanutils是Apache组织下的一个基础的开源库，它提供了对Java反射和内省的API的包装，依赖内省，其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道一个JavaBean通常包含了大量的属性，很多情况下，对JavaBean的处理导致了大量的get/set代码堆积，增加了代码长度和阅读代码...
beanutil beanutils copyproperties
10-13
这是一个 Java 工具类库 Apache Commons BeanUtils 中的一个方法，用于将一个 JavaBean 对象的属性值复制到另一个 JavaBean 对象中对应的属性中。 具体来说，BeanUtils.copyProperties(Object dest, Object orig) 方法会将 orig 对象中的属性值复制到 dest 对象中对应的属性中。这个方法会自动匹配两个对象中属性名相同的属性，并将 orig 对象中的属性值复制到 dest 对象中对应的属性中。 需要注意的是，这个方法只会复制两个对象中属性名相同的属性，如果两个对象中存在属性名不同但类型相同的属性，那么这些属性的值不会被复制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值