在进行企业应用的开发过程中,我们经常会遇到原因而必须要从一个对象中拷贝值到另一个对象中,这两个对象有部份相同的字段,必须将这些相同字段的值从源对象拷贝到目标对象中,因此,一个值拷贝的实用类就变得很必要了,下面我们就用JAVA范型与JAVA影射去实现这样一个实用类吧,也算是JAVA范型的一个应用实例了,同时也是一个JAVA影身的简单应用实例。
package common;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
*
* @author Dao
*/
public class ValueCopyUtil
{
public static <T> T copyValue(T sourceObject)
{
return (T) copyValue(sourceObject, sourceObject.getClass());
}
public static <T> T copyValue(Object sourceObject, Class<T> targetObjectClass)
{
return copyValue(sourceObject, targetObjectClass, null);
}
public static <T> T copyValue(Object sourceObject, Class<T> targetObjectClass, HashMap classMap)
{
try
{
Object targetObject = targetObjectClass.newInstance();
return (T) copyValue(sourceObject, targetObject, classMap);
}
catch (Exception e)
{
return null;
}
}
public static <T> T copyValue(Object sourceObject, Object targetObject, HashMap classMap)
{
Class sourceObjectClass = sourceObject.getClass();
Class targetObjectClass = targetObject.getClass();
List<String> sourceClassFieldNameList = getClassFieldNameList(sourceObjectClass);
List<String> targetClassFieldNameList = getClassFieldNameList(targetObjectClass);
List<String> fieldNameList = getSameFieldNameList(sourceClassFieldNameList, targetClassFieldNameList);
try
{
for (String fieldName : fieldNameList)
{
Field sourceField = sourceObjectClass.getDeclaredField(fieldName);
Field targetField = targetObjectClass.getDeclaredField(fieldName);
Class sourceFieldType = sourceField.getType();
Class targetFieldType = targetField.getType();
if (sourceFieldType == targetFieldType)
{
sourceField.setAccessible(true);
targetField.setAccessible(true);
Object sourceValue = sourceField.get(sourceObject);
if (sourceValue != null)
{
if (isSimpleType(sourceFieldType))
{
targetField.set(targetObject, sourceValue);
}
else
{
Object copiedObject = copyComplicatedType(sourceValue, classMap);
targetField.set(targetObject, copiedObject);
}
}
}
}
return (T) targetObject;
}
catch (Exception e)
{
return null;
}
}
private static List<String> getClassFieldNameList(Class cla)
{
Field[] fields = cla.getDeclaredFields();
List<String> fieldNameList = new ArrayList();
for (int i = 0; i < fields.length; i++)
{
Field field = fields[i];
String fieldName = field.getName();
fieldNameList.add(fieldName);
}
return fieldNameList;
}
private static List<String> getSameFieldNameList(List<String> sourceList, List<String> targetList)
{
List<String> resultList = new ArrayList();
for (String source : sourceList)
{
for (String target : targetList)
{
if (source.equals(target))
{
resultList.add(source);
}
}
}
return resultList;
}
private static boolean isSimpleType(Class cla)
{
if (cla.isPrimitive())
{
return true;
}
if (cla == Date.class)
{
return true;
}
return false;
}
private static Object copyComplicatedType(Object sourceObject, HashMap classMap)
{
// System.out.println("========= copyComplicatedType =========");
Class sourceClass = sourceObject.getClass();
if (sourceClass.isArray())
{
return copyArray(sourceObject, classMap);
}
else if (sourceObject instanceof List)
{
return copyList(sourceObject, classMap);
}
else if (sourceObject instanceof Map)
{
return copyMap(sourceObject, classMap);
}
return copySubObject(sourceObject, classMap);
}
private static Object copySubObject(Object subSourceObject, HashMap classMap)
{
// System.out.println("========= copySubobject =========");
Object mapClassObject = classMap.get(subSourceObject.getClass());
if (mapClassObject != null)
{
Class mapClass = (Class) mapClassObject;
Object subTargetObject = copyValue(subSourceObject, mapClass, classMap);
return subTargetObject;
}
return subSourceObject;
}
private static Object copyArray(Object sourceObjectArray, HashMap classMap)
{
// System.out.println("========= copyArray =========");
int arraySize = Array.getLength(sourceObjectArray);
if (arraySize > 0)
{
Object testObject = Array.get(sourceObjectArray, 0);
Object targetObjectArray = Array.newInstance(testObject.getClass(), arraySize);
for (int i = 0; i < arraySize; i++)
{
Object subSourceObject = Array.get(sourceObjectArray, i);
Object subTargetObject = copySubObject(subSourceObject, classMap);
Array.set(targetObjectArray, i, subTargetObject);
}
}
return sourceObjectArray;
}
private static Object copyMap(Object sourceObject, HashMap classMap)
{
// System.out.println("========= copyMap =========");
try
{
Class sourceObjectClass = sourceObject.getClass();
Map targetObjectMap = (Map) sourceObjectClass.newInstance();
Map sourceObjectMap = (Map) sourceObject;
Set set = sourceObjectMap.entrySet();
Iterator<Entry> iterator = set.iterator();
while (iterator.hasNext())
{
Entry sourceEntry = iterator.next();
Object subSourceObject = sourceEntry.getValue();
Object subTargetObject = copySubObject(subSourceObject, classMap);
targetObjectMap.put(sourceEntry.getKey(), subTargetObject);
}
return targetObjectMap;
}
catch (Exception e)
{
e.printStackTrace();
}
return sourceObject;
}
private static Object copyList(Object sourceObject, HashMap classMap)
{
// System.out.println("========= copyList =========");
try
{
Class sourceObjectClass = sourceObject.getClass();
List targetObjectList = (List) sourceObjectClass.newInstance();
List sourceObjectList = (List) sourceObject;
for (Object subObject : sourceObjectList)
{
Object subTargetObject = copySubObject(subObject, classMap);
targetObjectList.add(subTargetObject);
}
return targetObjectList;
}
catch (Exception e)
{
e.printStackTrace();
}
return sourceObject;
}
}
分享到:
- 2008-10-25 13:51
- 浏览 769
- 评论(0)
- 论坛回复 / 浏览 (0 / 1804)
- 查看更多
相关推荐
Java 范型Java 范型
Java 范型攻略篇
JAVA范型指南:讲述范型,范型通配符,范型方法,范型与久代码(无范型)的融合,范型的擦除与翻译等...
java1.5范型编程指南.docjava1.5范型编程指南.docjava1.5范型编程指南.docjava1.5范型编程指南.docjava1.5范型编程指南.doc
C++ 设计新思维 范型编程与设计模式之应用 pdf
java范型[参考].pdf
java范型[参照].pdf
Java范型机制 Java范型机制 Java范型机制 Java范型机制Java范型机制 Java范型机制
java范型学习.............
深入探讨范型编程思想及C++语言中范型设计的应用
并且通过运用这些模板技术(例如元编程等),实现了多个设计模式的代码框架的自动生成,书不厚,正文内容不过300页,但是书中没有废话,每一章的内容都很精彩,值得仔细推敲和研究,虽然里面有少量错误(有些可能是...
在实际应用中,如果能够灵活应用范型和反射,那么该Java程序员可以设计出非常好的东西来,从而解决实际开发简化开发过程的目的。比如,在EJB 2.0开发客户端应用时,如果使用范型和反射,可以把EJB 2.0的标准使用...
C++ 设计新思维:范型编程与设计模式之应用
消息传递范型与C/S范型双范型的主数据管理机制,陈晓云,邢乔金,本文针对主数据管理(MDM)存在的问题提出了一种基于消息传递机制范型与C/S范型双范型的主数据管理机制,当各个分系统的数据有所变化�
c++ 设计新思维:范型编程与设计模式之应用
c++范型编程与设计模式应用,脱离菜鸟,进阶高手的一本很好的参考书。
C++ 设计新思维:范型编程与设计模式之应用2
《分布式系统原理与范型》第一版.中文版,影印版。