我想你可以试试推土机。它对bean到bean的转换有很好的支持。它也很容易使用。您可以将它注入到spring应用程序中，也可以在类路径中添加jar并完成它。
举个例子：

DozerMapper mapper = new DozerMapper();
A a= new A();
CopyA copyA = new CopyA();
a.set... // set fields of a.
mapper.map(a,copyOfA); // will copy all fields from a to copyA

我在kotlin中解决了上述问题，这对我的android应用程序开发非常有用：

object FieldMapper {

fun <T:Any> copy(to: T, from: T) {
    try {
        val fromClass = from.javaClass

        val fromFields = getAllFields(fromClass)

        fromFields?.let {
            for (field in fromFields) {
                try {
                    field.isAccessible = true
                    field.set(to, field.get(from))
                } catch (e: IllegalAccessException) {
                    e.printStackTrace()
                }

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

}

private fun getAllFields(paramClass: Class<*>): List<Field> {

    var theClass:Class<*>? = paramClass
    val fields = ArrayList<Field>()
    try {
        while (theClass != null) {
            Collections.addAll(fields, *theClass?.declaredFields)
            theClass = theClass?.superclass
        }
    }catch (e:Exception){
        e.printStackTrace()
    }

    return fields
}

}

如果您不介意使用第三方库，apachecommons中的beanutils将使用 copyProperties(Object, Object) .

不使用beanutils或apache commons

public static <T1 extends Object, T2 extends Object>  void copy(T1     
origEntity, T2 destEntity) throws IllegalAccessException, NoSuchFieldException {
    Field[] fields = origEntity.getClass().getDeclaredFields();
    for (Field field : fields){
        origFields.set(destEntity, field.get(origEntity));
     }
}

public static <T> void copyAvalableFields(@NotNull T source, @NotNull T target) throws IllegalAccessException {
    Field[] fields = source.getClass().getDeclaredFields();
    for (Field field : fields) {
        if (!Modifier.isStatic(field.getModifiers())
                && !Modifier.isFinal(field.getModifiers())) {
            field.set(target, field.get(source));
        }
    }
}

我们阅读全班所有的领域。从结果中筛选非静态和非最终字段。但访问非公共字段时可能会出错。例如，如果此函数在同一类中，并且要复制的类不包含公共字段，则会发生访问错误。解决方案可能是将此函数放在同一个包中，或者将访问权限更改为public，或者将此代码中的内容更改为loop call field.setaccessible（true）；是什么使这些字段可用

Spring有一个内置的 BeanUtils.copyProperties 方法。但是它不适用于没有getter/setter的类。json序列化/反序列化可以是复制字段的另一个选项。Jackson可以用于此目的。如果您在大多数情况下使用spring，那么jackson已经在您的依赖列表中了。

ObjectMapper mapper     = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Clazz        copyObject = mapper.readValue(mapper.writeValueAsString(sourceObject), Clazz.class);

因为这个原因，我不想给另一个jar文件添加依赖项，所以写了一些适合我需要的东西。我遵循峡湾的惯例https://code.google.com/p/fjorm/ 这意味着我的一般可访问字段是公共的，我不必费心编写setter和getter(在我看来，代码更易于管理，实际上更具可读性）
所以我写了一些适合我需要的东西（实际上并不难）（假设类有没有参数的公共构造函数），并且可以将它提取到实用类中

public Effect copyUsingReflection() {
    Constructor constructorToUse = null;
    for (Constructor constructor : this.getClass().getConstructors()) {
      if (constructor.getParameterTypes().length == 0) {
        constructorToUse = constructor;
        constructorToUse.setAccessible(true);
      }
    }
    if (constructorToUse != null) {
      try {
        Effect copyOfEffect = (Effect) constructorToUse.newInstance();
        for (Field field : this.getClass().getFields()) {
          try {
            Object valueToCopy = field.get(this);
            //if it has field of the same type (Effect in this case), call the method to copy it recursively
            if (valueToCopy instanceof Effect) {
              valueToCopy = ((Effect) valueToCopy).copyUsingReflection();
            }
            //TODO add here other special types of fields, like Maps, Lists, etc.
            field.set(copyOfEffect, valueToCopy);
          } catch (IllegalArgumentException | IllegalAccessException ex) {
            Logger.getLogger(Effect.class.getName()).log(Level.SEVERE, null, ex);
          }
        }
        return copyOfEffect;
      } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
        Logger.getLogger(Effect.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    return null;
  }

第一个论点 tooF.set() 应该是目标对象( too )，而不是字段，第二个参数应该是值，而不是值来自的字段(要获得价值，你需要打电话 fromF.get() --在本例中，再次传入目标对象 from .)
大多数反射api都是这样工作的。你得到了吗 Field 物体， Method 对象等，所以要使用它们（除了静态），通常需要向它们传递一个示例。

public <T1 extends Object, T2 extends Object> void copy(T1 origEntity, T2 destEntity) {
        DozerBeanMapper mapper = new DozerBeanMapper();
        mapper.map(origEntity,destEntity);
    }

 <dependency>
            <groupId>net.sf.dozer</groupId>
            <artifactId>dozer</artifactId>
            <version>5.4.0</version>
        </dependency>

如果依赖项中有spring，那么也可以使用org.springframework.beans.beanutils。
https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/beanutils.html

推土机
2012年11月19日更新：现在还有一个新的modelmapper项目。

我的解决方案：

public static <T > void copyAllFields(T to, T from) {
        Class<T> clazz = (Class<T>) from.getClass();
        // OR:
        // Class<T> clazz = (Class<T>) to.getClass();
        List<Field> fields = getAllModelFields(clazz);

        if (fields != null) {
            for (Field field : fields) {
                try {
                    field.setAccessible(true);
                    field.set(to,field.get(from));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

public static List<Field> getAllModelFields(Class aClass) {
    List<Field> fields = new ArrayList<>();
    do {
        Collections.addAll(fields, aClass.getDeclaredFields());
        aClass = aClass.getSuperclass();
    } while (aClass != null);
    return fields;
}

这是一个工作和测试的解决方案。可以控制类层次结构中Map的深度。

public class FieldMapper {

    public static void copy(Object from, Object to) throws Exception {
        FieldMapper.copy(from, to, Object.class);
    }

    public static void copy(Object from, Object to, Class depth) throws Exception {
        Class fromClass = from.getClass();
        Class toClass = to.getClass();
        List<Field> fromFields = collectFields(fromClass, depth);
        List<Field> toFields = collectFields(toClass, depth);
        Field target;
        for (Field source : fromFields) {
            if ((target = findAndRemove(source, toFields)) != null) {
                target.set(to, source.get(from));
            }
        }
    }

    private static List<Field> collectFields(Class c, Class depth) {
        List<Field> accessibleFields = new ArrayList<>();
        do {
            int modifiers;
            for (Field field : c.getDeclaredFields()) {
                modifiers = field.getModifiers();
                if (!Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers)) {
                    accessibleFields.add(field);
                }
            }
            c = c.getSuperclass();
        } while (c != null && c != depth);
        return accessibleFields;
    }

    private static Field findAndRemove(Field field, List<Field> fields) {
        Field actual;
        for (Iterator<Field> i = fields.iterator(); i.hasNext();) {
            actual = i.next();
            if (field.getName().equals(actual.getName())
                && field.getType().equals(actual.getType())) {
                i.remove();
                return actual;
            }
        }
        return null;
    }
}

这是一个迟到的职位，但仍然可以有效的人在未来。
spring提供了一个实用程序 BeanUtils.copyProperties(srcObj, tarObj) 当两个类的成员变量的名称相同时，将值从源对象复制到目标对象。
如果存在日期转换（例如，字符串到日期），则“null”将复制到目标对象。然后，我们可以根据需要显式地设置日期的值。
小海狸 Apache Common 当数据类型不匹配时抛出错误（特别是转换为和转换自日期）
希望这有帮助！

你为什么不用gson图书馆https://github.com/google/gson
您只需将类a转换为json字符串。然后将jsonstring转换为子类（copya）

Gson gson= new Gson();
String tmp = gson.toJson(a);
CopyA myObject = gson.fromJson(tmp,CopyA.class);