分享一个超级好用的实体copy类

超级好用的BeanConvertUtils
并支持Lambda表达式 以下是调用方式

先创建函数式(Functional)接口

/**
 * 对象属性copy回调函数
 * @param <K>
 * @param <V>
 */
@FunctionalInterface
public interface BeanUtilsCallBack<K, V> {
    void callBack(K t, V s);
}

接着在工具类引用它

public class BeanConvertUtils {
	private final static Logger logger = LoggerFactory.getLogger(BeanConvertUtils.class);
	private final static ObjectMapper mapper = new ObjectMapper();

	/**
	 * List 对象属性转换
	 * @param list 源list
	 * @param k 目标类型class
	 * @param <T> 源类型
	 * @param <K> 目标类型
	 *
	 * @return
	 */
	public static <T, K> List<K> listConverter(List<T> list, Class<K> k) {
		if (CollectionUtil.isEmpty(list)) {
			logger.warn("List转换失败，空的源集合");
			return null;
		}
		List<K> result = Lists.newArrayListWithCapacity(list.size());
		list.forEach(t -> {
			result.add(BeanUtil.copyProperties(t, k));
		});
		return result;
	}

	public static <T, K> List<K> listConverter(List<T> list, Class<K> k, BeanUtilsCallBack<T, K> callBack) {
		if (CollectionUtil.isEmpty(list)) {
			logger.warn("List转换失败，空的源集合");
			return null;
		}
		List<K> result = Lists.newArrayListWithCapacity(list.size());
		list.forEach(t -> {
			K k1 = BeanUtil.copyProperties(t, k);
			if (Objects.nonNull(callBack)) {
				callBack.callBack(t, k1);
			}
			result.add(k1);
		});
		return result;
	}

	public static <T, K> K beanConverter(T source, Class<K> kClass, BeanUtilsCallBack<T, K> callBack) {
		K k = BeanUtil.copyProperties(source, kClass);
		if (Objects.nonNull(callBack)) {
			callBack.callBack(source, k);
		}
		return k;
	}

	public static <T, K> String beanConverterToJsonStr(T source, Class<K> kClass, BeanUtilsCallBack<T, K> callBack) {
		K k = BeanUtil.copyProperties(source, kClass);
		if (Objects.nonNull(callBack)) {
			callBack.callBack(source, k);
		}
		if (ObjectUtils.isEmpty(k)){
			return null;
		}
		return JSONUtil.toJsonStr(k);
	}

	public static <T, K> K beanConverter(T source, Class<K> kClass, BeanUtilsCallBack<T, K> callBack,String... ignoreProperties) throws InstantiationException, IllegalAccessException {
		K k = kClass.newInstance();
		BeanUtil.copyProperties(source, kClass,ignoreProperties);
		if (Objects.nonNull(callBack)) {
			callBack.callBack(source, k);
		}
		return k;
	}

	public static <T, K> T beanAssignment(T sourceBean, K targetBean) {
		T result = (T) BeanConvertUtils.beanConverter(sourceBean, sourceBean.getClass());
		Class resultBeanClass = result.getClass();
		Class targetBeanClass = targetBean.getClass();
		Field[] sourceFields = resultBeanClass.getDeclaredFields();
		Field[] targetFields = targetBeanClass.getDeclaredFields();
		for(int i = 0; i < sourceFields.length; i++){
			Field resultField = sourceFields[i];
			Field targetField = targetFields[i];
			if(Modifier.isStatic(resultField.getModifiers()) || Modifier.isStatic(targetField.getModifiers())){
				continue;
			}
			resultField.setAccessible(true);
			targetField.setAccessible(true);
			try {
				if( (targetField.get(targetBean) != null)){
					resultField.set(result,targetField.get(targetBean));
				}
			} catch (IllegalArgumentException | IllegalAccessException e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	/**
	 * 对象属性copy
	 * @param source 源对象
	 * @param kClass 转换类型
	 * @param <T> 源类型
	 * @param <K> 返回类型
	 *
	 * @return
	 */
	public static <T, K> K beanConverter(T source, Class<K> kClass) {
		K k = BeanUtil.copyProperties(source, kClass);
		return k;
	}

	public static <T, K> String beanConverterToJsonStr(T source, Class<K> kClass) {
		K k = BeanUtil.copyProperties(source, kClass);
		if (ObjectUtils.isEmpty(k)){
			return null;
		}
		return JSONUtil.toJsonStr(k);
	}
}