//DO是源數(shù)據(jù)對象,DTO是目標對象,把源類的數(shù)據(jù)拷貝到目標對象
BeanUtils.copyProperties(DO,DTO);

/**
 * Copy the property values of the given source bean into the target bean.
 * <p>Note: The source and target classes do not have to match or even be derived
 * from each other, as long as the properties match. Any bean properties that the
 * source bean exposes but the target bean does not will silently be ignored.
 * <p>This is just a convenience method. For more complex transfer needs,
 * consider using a full BeanWrapper.
 * @param source the source bean
 * @param target the target bean
 * @throws BeansException if the copying failed
 * @see BeanWrapper
 */
public static void copyProperties(Object source, Object target) throws BeansException {
  copyProperties(source, target, null, (String[]) null);
}

private static void copyProperties(Object source, Object target, @Nullable Class<?> editable,
    @Nullable String... ignoreProperties) throws BeansException {
  Assert.notNull(source, "Source must not be null");
  Assert.notNull(target, "Target must not be null");
  //目標Class
  Class<?> actualEditable = target.getClass();
  if (editable != null) {
    if (!editable.isInstance(target)) {
      throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
          "] not assignable to Editable class [" + editable.getName() + "]");
    }
    actualEditable = editable;
  }
    //1.獲取目標Class的屬性描述
  PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
  List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
  //2.遍歷源Class的屬性
  for (PropertyDescriptor targetPd : targetPds) {
        //源Class屬性的寫方法,setXXX
    Method writeMethod = targetPd.getWriteMethod();
        //3.如果存在寫方法,并且該屬性不忽略,繼續(xù)往下走,否則跳過繼續(xù)遍歷
    if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
            //4.獲取源Class的與目標屬性同名的屬性描述
      PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
      //5.如果源屬性描述不存在直接跳過,否則繼續(xù)往下走
            if (sourcePd != null) {
                //獲取源屬性描述的讀方法
        Method readMethod = sourcePd.getReadMethod();
                //6.如果源屬性描述的讀防范存在且返回數(shù)據(jù)類型和目標屬性的寫方法入?yún)㈩愋拖嗤蛘吲缮?
                //繼續(xù)往下走,否則直接跳過繼續(xù)下次遍歷
        if (readMethod != null &&
            ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
          try {
                        //如果源屬性讀方法修飾符不是public,那么修改為可訪問
            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
              readMethod.setAccessible(true);
            }
                        //7.讀取源屬性的值
            Object value = readMethod.invoke(source);
                        //如果目標屬性的寫方法修飾符不是public,則修改為可訪問
            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
              writeMethod.setAccessible(true);
            }
                        //8.通過反射將源屬性值賦值給目標屬性
            writeMethod.invoke(target, value);
          }
          catch (Throwable ex) {
            throw new FatalBeanException(
                "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
          }
        }
      }
    }
  }
}

//獲取目標bean屬性描述
PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
//獲取源bean指定名稱的屬性描述
PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());

/**
 * Retrieve the JavaBeans {@code PropertyDescriptor}s of a given class.
 * @param clazz the Class to retrieve the PropertyDescriptors for
 * @return an array of {@code PropertyDescriptors} for the given class
 * @throws BeansException if PropertyDescriptor look fails
 */
public static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz) throws BeansException {
  CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
  return cr.getPropertyDescriptors();
}

@SuppressWarnings("unchecked")
static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException {
  //1.從強緩存獲取beanClass的內(nèi)省結(jié)果,如果有數(shù)據(jù)直接返回
    CachedIntrospectionResults results = strongClassCache.get(beanClass);
  if (results != null) {
    return results;
  }
    //2.如果強緩存中不存在beanClass的內(nèi)省結(jié)果,則從軟緩存中獲取beanClass的內(nèi)省結(jié)果,如果存在直接返回
  results = softClassCache.get(beanClass);
  if (results != null) {
    return results;
  }
  //3.如果強緩存和軟緩存都不存在beanClass的自省結(jié)果,則創(chuàng)建一個
  results = new CachedIntrospectionResults(beanClass);
  ConcurrentMap<Class<?>, CachedIntrospectionResults> classCacheToUse;
  //4.如果beanClass是緩存安全的,或者beanClass的類加載器是配置可接受的,緩存引用指向強緩存
  if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||
      isClassLoaderAccepted(beanClass.getClassLoader())) {
    classCacheToUse = strongClassCache;
  }
  else {
        //5.如果不是緩存安全,則將緩存引用指向軟緩存
    if (logger.isDebugEnabled()) {
      logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
    }
    classCacheToUse = softClassCache;
  }
  //6.將beanClass內(nèi)省結(jié)果放入緩存
  CachedIntrospectionResults existing = classCacheToUse.putIfAbsent(beanClass, results);
  //7.返回內(nèi)省結(jié)果
    return (existing != null ? existing : results);
}

public static void main(String[] args) {

    Demo1 demo1 = new Demo1(Arrays.asList("1","2","3"));

    Demo2 demo2 = new Demo2();
    BeanUtils.copyProperties(demo1,demo2);
    for (Integer integer : demo2.getList()) {
        System.out.println(integer);
    }
    for (String s : demo1.getList()) {
        demo2.addList(Integer.valueOf(s));
    }
}
@Data
static class Demo1 {
    private List<String> list;
    public Demo1(List<String> list) {
        this.list = list;
    }
}
@Data
static class Demo2 {
    private List<Integer> list;
    public void addList(Integer target) {
        if(null == list) {
            list = new ArrayList<>();
        }
        list.add(target);
    }
}

for (Object obj : demo2.getList()) {
    System.out.println(obj);
}