Spring-BeanUtil使用copyProperties，却遭遇注解失效之谜！

今天线上某个接口返回的时间没有进行格式化了，导致时间显示出现问题。排查的时候发现是某个同事使用Beanutil对复杂对象进行复制，导致复制后的对象有问题。

场景还原

目标对象

java 复制代码

@Data
public class CostAdjustOrderListResult implements Serializable {

    private static final long serialVersionUID = -984768384423076174L;
    private List<CostAdjustOrderResult> list;
    private Integer total;

}

java 复制代码

@Data
public class CostAdjustOrderResult implements Serializable {
    private static final long serialVersionUID = -7512247411179094824L;
    private String adjustOrderSn;
    private String gsStoreName;
    private String creator;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createTime;

}

原对象

java 复制代码

public class CostAdjustOrderListResponse implements Serializable {
    private static final long serialVersionUID = 2668966399381103886L;
    private List<CostAdjustOrderResponse> list;
    private Integer total;

java 复制代码

@Data
public class CostAdjustOrderResponse implements Serializable {
    private static final long serialVersionUID = 934995811237387869L;
    private String adjustOrderSn;
    private String gsStoreName;
    private String creator;
    private Date createTime;
}

调用beanutil进行属性copy，这里的FsBeanUtil.map实际调用的就是BeanUtils.copyProperties

java 复制代码

   @Override
    public CostAdjustOrderListResult queryCostAdjustOrderSn(CostAdjustParam param) {
        CostAdjustRequest request = FsBeanUtil.map(param, CostAdjustRequest.class);
        request.setStoreIdList(getStoreIdListRequest(param));
        CostAdjustOrderListResponse response = costAdjustFacade.queryCostAdjustOrderSn(request);
        return FsBeanUtil.map(response, CostAdjustOrderListResult.class);
    }

java 复制代码

    public static <T> T map(Object source, Class<T> target) {
        if (null == source) {
            return null;
        } else {
            T t = BeanUtils.instantiateClass(target);
            BeanUtils.copyProperties(source, t);
            return t;
        }
    }

请求结果，createTime没有进行格式化

源码分析

其实看到上面的代码，其实就知道肯定有坑，复制的对象里有泛型，且泛型是个复杂对象，而且目标对象和源对象的泛型不一致，这些情况都很有风险。解决方案也很多，这里就不多赘述了。为什么会出现这个原因这次的重点。

点开copyProperties方法，代码还是挺长的。

java 复制代码

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)) {
				。。。。抛异常
			}
			actualEditable = editable;
		}
        // 获取类的所有属性
		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
		//忽略的属性	
         List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
		// 遍历目标对象的所有属性
		for (PropertyDescriptor targetPd : targetPds) {
			// 获取可以写入属性值的方法，如果不可写入则会返回空
			Method writeMethod = targetPd.getWriteMethod();
			// 判断方法是否被忽略
			if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
				// 获取源对象对应的方法
				PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
				if (sourcePd != null) {
					// 获取源对象的值是否可读，不可读则返回空
					Method readMethod = sourcePd.getReadMethod();
					if (readMethod != null &&
							//判断源对象的是否可以赋值给目标对象，5.3之后增加了泛型判断，5.3之前只是对字段的类型进行判断，比如List<aaa>和List<bbb>在5.3之前由于不比较泛型，所以都是List也就能通过校验，       
                                                  //5.3之后由于加了泛型校验，所以这里会直接判断两个字段不相同，无法通过校验
							ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
						try {
							// 如果不是公共方法，则设置setAccessible
							if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
								readMethod.setAccessible(true);
							}
							// 获取要赋值的值对象
							Object value = readMethod.invoke(source);
							if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
								writeMethod.setAccessible(true);
							}
							// 将源对象赋值给目标对象
							writeMethod.invoke(target, value);
						}
						catch (Throwable ex) {
							throw new FatalBeanException(
									"Could not copy property '" + targetPd.getName() + "' from source to target", ex);
						}
					}
				}
			}
		}
	}

点开writeMethod.invoke方法

java 复制代码

   @CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
		// 检查是否有方法的访问权限
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
		// 获取MethodAccessor
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

点开ma.invoke方法会发现有三个实现，只用看NativeMethodAccessorImpl对象就可以了

java 复制代码

    NativeMethodAccessorImpl(Method var1) {
        // 目标对象的method对象
        this.method = var1;
    }

    public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
        if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
            MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
            this.parent.setDelegate(var3);
        }

        return invoke0(this.method, var1, var2);
    }

这里就是赋值方法了，将源对象的属性赋值给目标对象。

流程追踪

当然看代码，其实可能还是不太直观，但是我们debug一下，在根据之前的代码就会十分清晰了

首先代码流转到writeMethod.invoke(target, value)，要写入的方法是CostAdjustOrderResult.setList，他的泛型是要读的方法是CostAdjustOrderResponse.getList

然后经过各种校验流转到NativeMethodAccessorImpl.invoke方法,var1是要目标对象，var2是源目标对象，然后你会发现他method对象的方法是CostAdjustOrderResult.setList且泛型是CostAdjustOrderResult，但是赋值的list对象却是CostAdjustOrderResponse

再执行一步，神奇的事出现了，CostAdjustOrderListResult.getList对象不是泛型指定的CostAdjustOrderResult而是CostAdjustOrderResponse

这时候结果就很明显了，拷贝的成员属性实际类型跟声明的不一致。

回到最开始的问题，接口返回的时间没有进行格式化，就有了解答，我们以为list返回会的对象是声明的CostAdjustOrderListResult实际上返回的是CostAdjustOrderResponse，而CostAdjustOrderResponse对象是没有@JSONFormat注解的，所以导致返回的时间没有格式化。

总结

所以当我们在复杂对象中使用Beanutil复制时，一定要注意泛型不一致的情况，不然会有可能导致拷贝的成员属性实际类型跟声明的类型不一致。但是这个情况目前只会出现在spring5.3之前的Beanutil中，5.3之后会对泛型进行校验，如果泛型不一致则会直接忽略赋值。