动态复制原始以及在java中的复杂对象类型字段与自动转换

Question

我想动态复制一个字段从一个java对象到其他java对象。 这些对象的类别不同。

下面是该方案

1. 我有一些领域的一些资源类。每个类别中有几个字段 可由用户修改，但这些字段是 在所有资源类别中都不相同。每个类的可修改字段列表 正在某些数据结构中维护。

2. 大部分字段都是相似的，有些可以转换，就像一个拥有 的原始字体，而其他字体则包装类。有些字段应该是 从数字类型转换为字符串或反之亦然。

3. 大部分字段都是复杂的对象类型。

哪个库可今天会帮我复印带有自动转换这些领域在以往任何时候需要和深拷贝？ 我以前使用BeanUtils但这并不是深拷贝。它都不支持自动转换。

Answer 1

我以为春天框架可能help.Here是我的春天核心4.1.5的例子：

类声明：

public static class A{ 
    private String a; 
    private String b; 
    private String c; 
    private C d; 
    private int e; 
//getter&setter here 

public static class C { 
    private String aa; 
    private String bb; 
    private String cc; 

    //getter&setter here 

public static class B{ 
    private Integer a; 
    private Long b; 
    private Boolean c; 
    private D d; 
    private Integer e; 

    //getter&setter here 

public static class D { 
    private Integer aa; 
    private Long bb; 
    private Boolean cc; 

    //getter&setter here 

class ObjectConverter implements Converter<Object, Object> { 
    private final ConversionService conversionService; 
    private final Class targetClass; 

    public ObjectConverter(ConversionService conversionService, Class targetClass) { 
     this.conversionService = conversionService; 
     this.targetClass = targetClass; 
    } 

    @Override 
    public Object convert(Object source) { 
     Object ret=null; 
     try { 
      ret = targetClass.newInstance(); 

      Field[] fields = targetClass.getDeclaredFields(); 
      for (Field field : fields) { 
       PropertyDescriptor sourceDescriptor = new PropertyDescriptor(field.getName(),source.getClass()); 
       PropertyDescriptor targetDescriptor = new PropertyDescriptor(field.getName(),targetClass); 

       if (sourceDescriptor.getReadMethod()==null || targetDescriptor.getWriteMethod() == null) { 
        //record error here 
        break; 
       } 

       Class<?> sourcePType = sourceDescriptor.getPropertyType(); 
       Class<?> targetPType = targetDescriptor.getPropertyType(); 
       if(conversionService.canConvert(sourcePType,targetPType)){ 
        Object sourceValue = sourceDescriptor.getReadMethod().invoke(source); 
        Object targetValue = conversionService.convert(sourceValue, targetPType); 
        targetDescriptor.getWriteMethod().invoke(ret,targetValue); 
       } 
      } 

     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return ret; 
    } 
} 

主要方法：

A orgA = new A(); 
    orgA.a="123"; 
    orgA.b="1234567"; 
    orgA.c="1"; 
    orgA.d = new C(); 
    orgA.d.aa="321"; 
    orgA.d.bb="7654321"; 
    orgA.d.cc="0"; 
    orgA.e=-99; 

    System.out.println(orgA); 

    try { 
     ConfigurableConversionService conversionService = new DefaultConversionService(); 

     //if you are not satisfied with the final A result, then 
     //customize your own Boolean->String Converter; 
//   conversionService.addConverter(new Converter<Boolean, String>() { 
//    @Override 
//    public String convert(Boolean source) { 
//     return source==null||!source?"0":"1"; 
//    } 
//   }); 

     conversionService.addConverter(A.class, B.class, new ObjectConverter(conversionService, B.class)); 
     conversionService.addConverter(B.class, A.class, new ObjectConverter(conversionService, A.class)); 

     conversionService.addConverter(C.class, D.class, new ObjectConverter(conversionService, D.class)); 
     conversionService.addConverter(D.class, C.class, new ObjectConverter(conversionService, C.class)); 

     B b = conversionService.convert(orgA, B.class); 
     System.out.println(b); 

     A a = conversionService.convert(b, A.class); 
     System.out.println(a); 

    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

结果：

=

A ='123'，b ='1234567'，c ='1'，d = C {aa ='321'，bb ='7654321'，cc ='0'}，e = -99}
A {a ='123'，b = 123}，b = 1234567，c =真，d = D {aa = 321，bb = 7654321，cc =假}，e = -99}
'1234567'，c ='true'，d = C {aa ='321'，bb ='7654321'，cc ='false'}，e = -99}