java 对象之间属性值复制

最新推荐文章于 2024-08-26 03:28:29 发布
最新推荐文章于 2024-08-26 03:28:29 发布
阅读量522 收藏
点赞数

Java对象之间属性值复制在许多开源框架中也有实现，在这里介绍下自己的实现、apache commons-beanutils、spring三种方式实现。

1 自己实现。采用反射，通过源对象getter 方法获取属性值，并通过目标对象的setter方法设置到目标对象中去。没有考虑太多性能，如果需要批量或者经常性执行该操作，建议不采用此种实现。下面给出源码：

[java] view plain copy
print ?
  1. /** 
  2.      * 利用反射实现对象之间属性复制 
  3.      * @param from 
  4.      * @param to 
  5.      */  
  6.     public static void copyProperties(Object from, Object to) throws Exception {  
  7.         copyPropertiesExclude(from, to, null);  
  8.     }  
  9.       
  10.     /** 
  11.      * 复制对象属性 
  12.      * @param from 
  13.      * @param to 
  14.      * @param excludsArray 排除属性列表 
  15.      * @throws Exception 
  16.      */  
  17.     @SuppressWarnings("unchecked")  
  18.     public static void copyPropertiesExclude(Object from, Object to, String[] excludsArray) throws Exception {  
  19.         List<String> excludesList = null;  
  20.         if(excludsArray != null && excludsArray.length > 0) {  
  21.             excludesList = Arrays.asList(excludsArray); //构造列表对象  
  22.         }  
  23.         Method[] fromMethods = from.getClass().getDeclaredMethods();  
  24.         Method[] toMethods = to.getClass().getDeclaredMethods();  
  25.         Method fromMethod = null, toMethod = null;  
  26.         String fromMethodName = null, toMethodName = null;  
  27.         for (int i = 0; i < fromMethods.length; i++) {  
  28.             fromMethod = fromMethods[i];  
  29.             fromMethodName = fromMethod.getName();  
  30.             if (!fromMethodName.contains("get"))  
  31.                 continue;  
  32.             //排除列表检测  
  33.             if(excludesList != null && excludesList.contains(fromMethodName.substring(3).toLowerCase())) {  
  34.                 continue;  
  35.             }  
  36.             toMethodName = "set" + fromMethodName.substring(3);  
  37.             toMethod = findMethodByName(toMethods, toMethodName);  
  38.             if (toMethod == null)  
  39.                 continue;  
  40.             Object value = fromMethod.invoke(from, new Object[0]);  
  41.             if(value == null)  
  42.                 continue;  
  43.             //集合类判空处理  
  44.             if(value instanceof Collection) {  
  45.                 Collection newValue = (Collection)value;  
  46.                 if(newValue.size() <= 0)  
  47.                     continue;  
  48.             }  
  49.             toMethod.invoke(to, new Object[] {value});  
  50.         }  
  51.     }  
  52.       
  53.     /** 
  54.      * 对象属性值复制，仅复制指定名称的属性值 
  55.      * @param from 
  56.      * @param to 
  57.      * @param includsArray 
  58.      * @throws Exception 
  59.      */  
  60.     @SuppressWarnings("unchecked")  
  61.     public static void copyPropertiesInclude(Object from, Object to, String[] includsArray) throws Exception {  
  62.         List<String> includesList = null;  
  63.         if(includsArray != null && includsArray.length > 0) {  
  64.             includesList = Arrays.asList(includsArray); //构造列表对象  
  65.         } else {  
  66.             return;  
  67.         }  
  68.         Method[] fromMethods = from.getClass().getDeclaredMethods();  
  69.         Method[] toMethods = to.getClass().getDeclaredMethods();  
  70.         Method fromMethod = null, toMethod = null;  
  71.         String fromMethodName = null, toMethodName = null;  
  72.         for (int i = 0; i < fromMethods.length; i++) {  
  73.             fromMethod = fromMethods[i];  
  74.             fromMethodName = fromMethod.getName();  
  75.             if (!fromMethodName.contains("get"))  
  76.                 continue;  
  77.             //排除列表检测  
  78.             String str = fromMethodName.substring(3);  
  79.             if(!includesList.contains(str.substring(0,1).toLowerCase() + str.substring(1))) {  
  80.                 continue;  
  81.             }  
  82.             toMethodName = "set" + fromMethodName.substring(3);  
  83.             toMethod = findMethodByName(toMethods, toMethodName);  
  84.             if (toMethod == null)  
  85.                 continue;  
  86.             Object value = fromMethod.invoke(from, new Object[0]);  
  87.             if(value == null)  
  88.                 continue;  
  89.             //集合类判空处理  
  90.             if(value instanceof Collection) {  
  91.                 Collection newValue = (Collection)value;  
  92.                 if(newValue.size() <= 0)  
  93.                     continue;  
  94.             }  
  95.             toMethod.invoke(to, new Object[] {value});  
  96.         }  
  97.     }  
  98.       
  99.       
  100.   
  101.     /** 
  102.      * 从方法数组中获取指定名称的方法 
  103.      *  
  104.      * @param methods 
  105.      * @param name 
  106.      * @return 
  107.      */  
  108.     public static Method findMethodByName(Method[] methods, String name) {  
  109.         for (int j = 0; j < methods.length; j++) {  
  110.             if (methods[j].getName().equals(name))  
  111.                 return methods[j];  
  112.         }  
  113.         return null;  
  114.     }  
/**
	 * 利用反射实现对象之间属性复制
	 * @param from
	 * @param to
	 */
	public static void copyProperties(Object from, Object to) throws Exception {
		copyPropertiesExclude(from, to, null);
	}
	
	/**
	 * 复制对象属性
	 * @param from
	 * @param to
	 * @param excludsArray 排除属性列表
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public static void copyPropertiesExclude(Object from, Object to, String[] excludsArray) throws Exception {
		List<String> excludesList = null;
		if(excludsArray != null && excludsArray.length > 0) {
			excludesList = Arrays.asList(excludsArray);	//构造列表对象
		}
		Method[] fromMethods = from.getClass().getDeclaredMethods();
		Method[] toMethods = to.getClass().getDeclaredMethods();
		Method fromMethod = null, toMethod = null;
		String fromMethodName = null, toMethodName = null;
		for (int i = 0; i < fromMethods.length; i++) {
			fromMethod = fromMethods[i];
			fromMethodName = fromMethod.getName();
			if (!fromMethodName.contains("get"))
				continue;
			//排除列表检测
			if(excludesList != null && excludesList.contains(fromMethodName.substring(3).toLowerCase())) {
				continue;
			}
			toMethodName = "set" + fromMethodName.substring(3);
			toMethod = findMethodByName(toMethods, toMethodName);
			if (toMethod == null)
				continue;
			Object value = fromMethod.invoke(from, new Object[0]);
			if(value == null)
				continue;
			//集合类判空处理
			if(value instanceof Collection) {
				Collection newValue = (Collection)value;
				if(newValue.size() <= 0)
					continue;
			}
			toMethod.invoke(to, new Object[] {value});
		}
	}
	
	/**
	 * 对象属性值复制，仅复制指定名称的属性值
	 * @param from
	 * @param to
	 * @param includsArray
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public static void copyPropertiesInclude(Object from, Object to, String[] includsArray) throws Exception {
		List<String> includesList = null;
		if(includsArray != null && includsArray.length > 0) {
			includesList = Arrays.asList(includsArray);	//构造列表对象
		} else {
			return;
		}
		Method[] fromMethods = from.getClass().getDeclaredMethods();
		Method[] toMethods = to.getClass().getDeclaredMethods();
		Method fromMethod = null, toMethod = null;
		String fromMethodName = null, toMethodName = null;
		for (int i = 0; i < fromMethods.length; i++) {
			fromMethod = fromMethods[i];
			fromMethodName = fromMethod.getName();
			if (!fromMethodName.contains("get"))
				continue;
			//排除列表检测
			String str = fromMethodName.substring(3);
			if(!includesList.contains(str.substring(0,1).toLowerCase() + str.substring(1))) {
				continue;
			}
			toMethodName = "set" + fromMethodName.substring(3);
			toMethod = findMethodByName(toMethods, toMethodName);
			if (toMethod == null)
				continue;
			Object value = fromMethod.invoke(from, new Object[0]);
			if(value == null)
				continue;
			//集合类判空处理
			if(value instanceof Collection) {
				Collection newValue = (Collection)value;
				if(newValue.size() <= 0)
					continue;
			}
			toMethod.invoke(to, new Object[] {value});
		}
	}
	
	

	/**
	 * 从方法数组中获取指定名称的方法
	 * 
	 * @param methods
	 * @param name
	 * @return
	 */
	public static Method findMethodByName(Method[] methods, String name) {
		for (int j = 0; j < methods.length; j++) {
			if (methods[j].getName().equals(name))
				return methods[j];
		}
		return null;
	}

2 利用apache commons-beanutils的开源实现。

BeanUtils.copyProperties(dst, src)。方法能够将源对象和目标对象中相同名称的属性值复制过去。注意的是参数前面的是目标对象，后面是源对象。使用该方法需要注意：不能将入口方法与源对象、目标对象之一放在同一源文件之内，否者将没有任何效果。

PropertyUtils.copyProperties(dst, src)。功能与BeanUtils.copyProperties类似，只是在同属性名称的类型参数之间可以执行转换操作。

3 利用Spring实现属性之间的复制。spring内部自有实现方法，如果我们需要在外面采用spring的托管复制，需要修改spring的源码，将spring中的org.springframework.beans.CachedIntrospectionResults类的forClass、getPropertyDescriptor、getBeanInfo改为可见的后重新打包。然后将Spring中关于复制的代码提取出来，最后修改成代码如下：

[java] view plain copy
print ?
  1. /** 
  2.      * 利用spring实现bean之间属性复制 
  3.      * @param source 
  4.      * @param target 
  5.      */  
  6.     @SuppressWarnings("unchecked")  
  7.     public static void copyPropertiesBySpring(Object source, Object target) throws Exception {  
  8.         Class actualEditable = target.getClass();  
  9.         PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);  
  10.         for (int i = 0; i < targetPds.length; i++) {  
  11.             PropertyDescriptor targetPd = targetPds[i];  
  12.             if (targetPd.getWriteMethod() != null) {  
  13.                 PropertyDescriptor sourcePd = getPropertyDescriptor(source  
  14.                         .getClass(), targetPd.getName());  
  15.                 if (sourcePd != null && sourcePd.getReadMethod() != null) {  
  16.                     try {  
  17.                         Method readMethod = sourcePd.getReadMethod();  
  18.                         if (!Modifier.isPublic(readMethod.getDeclaringClass()  
  19.                                 .getModifiers())) {  
  20.                             readMethod.setAccessible(true);  
  21.                         }  
  22.                         Object value = readMethod.invoke(source, new Object[0]);  
  23.                         if(value == null)  
  24.                             continue;  
  25.                         //集合类判空处理  
  26.                         if(value instanceof Collection) {  
  27. //                          Collection newValue = (Collection)value;  
  28. //                          if(newValue.size() <= 0)  
  29.                                 continue;  
  30.                         }  
  31.                         Method writeMethod = targetPd.getWriteMethod();  
  32.                         if (!Modifier.isPublic(writeMethod.getDeclaringClass()  
  33.                                 .getModifiers())) {  
  34.                             writeMethod.setAccessible(true);  
  35.                         }  
  36.                         writeMethod.invoke(target, new Object[] { value });  
  37.                     } catch (Throwable ex) {  
  38.                     }  
  39.                 }  
  40.             }  
  41.         }  
  42.     }     
  43.     /** 
  44.      * 获取指定类指定名称的属性描述符 
  45.      * @param clazz 
  46.      * @param propertyName 
  47.      * @return 
  48.      * @throws BeansException 
  49.      */  
  50.     @SuppressWarnings("unchecked")  
  51.     public static PropertyDescriptor getPropertyDescriptor(Class clazz,  
  52.             String propertyName) throws BeansException {  
  53.         CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);  
  54.         return cr.getPropertyDescriptor(propertyName);  
  55.     }  
  56.       
  57.       
  58.     /** 
  59.      * 获取指定类得所有属性描述符 
  60.      * @param clazz 
  61.      * @return 
  62.      * @throws BeansException 
  63.      */  
  64.     @SuppressWarnings("unchecked")  
  65.     public static PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws BeansException {  
  66.         CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);  
  67.         return cr.getBeanInfo().getPropertyDescriptors();  
  68.     }  
豆丁
关注
MyBatisDemo && JAVA把一个对象的全部属性复制到另一个相同的对象
03-30
NULL 博文链接：https://ollevere.iteye.com/blog/1323205
Java 对象拷贝复制，对象属性拷贝复制
最新发布
西凉的悲伤博客
08-30 961
之前写了一篇文章java浅拷贝与深拷贝讲了如何深拷贝对象。本文讲解如何通过第三方库来拷贝复制对象的属性值。
将一个Java对象的属性值拷贝到另一个Java对象中
weixin_42165980的博客
08-26 148
我整理的一些关于【Java】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/bLN8S1将一个Java对象的属性值拷贝到另一个Java对象中 在开发过程中，常常需要将一个对象的属性值拷贝到另一个对象里。这在业务逻辑中非常常见，比如说从DTO（数据传输对象）拷贝到实体类，或是从...
JAVA对象属性复制
zxygww的专栏
07-30 1296
需求：在不同类之间直接拷贝所有属性名称相同的属性值。 例如： public class Class1 { public int i; public long l; public String s; public List ls; } public class Class2{ public int i; public long l; public
Java开发：对象间复制属性，方法归纳
weixin_44107140的博客
03-09 1181
选择哪种方法取决于你的具体需求和项目环境。如果你已经在使用Spring，那么Spring的BeanUtils可能是一个方便的选择。如果你需要更灵活的映射策略，ModelMapper是一个很好的选择。对于简单的用例，手动设置属性或使用Apache Commons BeanUtils也完全足够。
Java的属性拷贝工具类
Gamble6
11-13 2352
BeanUtils.copyProperties的使用场景：DO、DTO、VO之间的转换 BeanUtils.copyProperties的避坑 BeanUtils的替代工具类——Mapstruct
利用Java反射机制实现对象相同字段的复制操作
08-24
这个方法可以将一个对象的属性值复制到另一个对象中，实现对象相同字段的复制操作。该方法的参数包括源对象、目标对象、Editable对象和忽略的属性名数组。 四、自己动手丰衣足食 除了使用别人的工具，我们也可以...
java不同对象之间及集合的复制
04-24
2. **值复制**: 值复制是指复制一个对象时，创建一个新的对象并复制原对象的所有属性值。在Java中，如果类的属性都是基本类型，可以通过构造函数或克隆方法实现浅复制。但如果属性包含引用类型，就需要深复制以确保...
Java对象的复制三种方式(小结)
08-25
Java对象的复制是Java编程中的一种常见操作，主要是将一个对象的值复制到另一个对象中，使得两个对象独立，但具有相同的初始值。在实际编程过程中，我们常常需要复制对象，以便于对象之间的独立操作。下面是Java对象...
Java实现不同的类的属性之间相互赋值
08-26
在开发过程中，我们经常会遇到将一个类的属性值复制给另外一个类的属性值，特别是在有继承关系的类的时候。例如，我们有两个类，ClassTestCopy1 和 ClassTestCopy2，它们之间有相同的属性名和类型，也有不同的属性名...
两个对象属性值的拷贝和文件的拷贝
07-28
实现了两个对象之间属性值的拷贝，只要具有相同的属性名就可以拷贝，还有两个file对象的拷贝，实现文件的复制功能
对象属性值的复制工具类
09-03
对象属性值的复制工具类 1.全复制 2.部分复制 3.部分不复制
java属性复制
weixin_40549738的博客
07-15 99
Java属性复制 在Java编程中，我们经常会遇到需要将一个对象的属性复制到另一个对象的情况。这种操作通常被称为属性复制，是一种常用的编程技巧。在本文中，我们将介绍如何在Java中实现属性复制，并给出具体的代码示例。 为什么需要属性复制 属性复制在Java编程中非常常见，有很多场景需要用到。比如，在Spring框架中，我们...
Java对象属性拷贝常用方法总结
weixin_42564451的博客
07-24 625
选择哪种方法取决于具体需求，比如是否需要深拷贝，对象的复杂性，以及你是否愿意引入额外的依赖库。在处理包含复杂对象结构的情况时，序列化/反序列化或第三方库可能更加方便。而对于简单的对象，手动拷贝或使用构造器拷贝则更为直接和高效。深拷贝与浅拷贝相关解释:深拷贝和浅拷贝↩︎。
java 对象属性复制
hutongling的博客
04-16 1276
java 对象属性复制 将一个对象的属性值赋值给另一个对象, 属性名需要相同 import org.springframework.beans.BeanUtils; BeanUtils.copyProperties(源对象, 目标对象);
Silverlight--DependencyProperty 类(一)
weixin_30919429的博客
08-16 114
DependencyProperty在Silverlight中是一个很有用的类，DependencyProperty是为值表达式、数据绑定、动画和属性更改通知提供支持，比如通常我们希望当进行数据修改时，一个控件的属性与一个对象绑定，实现数据一致性，DependencyProperty就可以帮我们完成。 首先我们了解一下DependencyProperty类方法，重要的方法有Ge...
Java对象属性复制的几种方法
Crazy_young_man的博客
02-08 3049
对比Java中几种对象复制方法的区别和速度
java 属性复制_对象属性复制几种方式
weixin_28900989的博客
02-12 2950
以下几个方法的效率由高到低1.Apache提供的BeanUtil.copyProperties和PropertyUtil.copyProperties两种方式BeanUtils.copyProperties("转换后的类","要转换的类"); //多一步类型转换，比PropertyUtils效率还差PropertyUtils.copyProperties("转换后的类","要转换的类");口诀...
Java把一个对象的属性值复制到另一个对象
07-08
在Java中，要将一个对象的属性值复制到另一个对象，你有几种选择： 1. 手动复制：你可以通过逐个访问源对象的属性，并将其值分配给目标对象的对应属性来手动复制属性值。这需要你编写一些代码来处理每个属性。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值