利用Java反射实现JavaBean对象相同属性复制并初始化目标对象为空的属性的BeanUtils

Posted 2020-08-30

有时遇到将数据传输对象转换成JSON串会将属性值为空的属性去掉，利用Java反射实现JavaBean对象数据传输对象的相同属性复制并初始化数据传输对象属性为空的属性，然后转换成JSON串

package com.banksteel.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

/**
* @description: copy对象属性工具类
* @projectName：banksteel-util
* @className：BeanUtil.java
* @see: com.banksteel.util
* @author：
* @createTime：2017年2月7日 上午9:15:23
* @version 3.0.0
*/
public class BeanUtils
{
private final static String GETTER = "get";
private final static String SETTER = "set";
private final static String IS = "is";
private final static String INTEGER = "java.lang.Integer";
private final static String DOUBLE = "java.lang.Double";
private final static String LONG = "java.lang.Long";
private final static String STRING = "java.lang.String";
private final static String SET = "java.util.Set";
private final static String LIST = "java.util.List";
private final static String MAP = "java.util.Map";

/**
* 对象之间相同属性复制
*
* @param source
* 源对象
* @param target
* 目标对象
*/
public static void copyProperties(Object source, Object target)
{
try
{
copyExclude(source, target, null);
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
initBeanProperties(target);
}
catch (Exception e)
{
e.printStackTrace();
}
}

/**
* @description: 对象之间相同属性复制
* @param source
* 源对象
* @param target
* 目标对象
* @param excludsArray
* 排除属性列表
* @author：
* @createTime：2017年2月8日 下午5:07:11
*/
public static void copyPropertiesExclude(Object source, Object target, String[] excludsArray)
{
try
{
copyExclude(source, target, excludsArray);
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
initBeanProperties(target);
}
catch (Exception e)
{
e.printStackTrace();
}
}

/**
* @description: 对象之间相同属性复制
* @param source
* 源对象
* @param target
* 目标对象
* @param includsArray
* 包含的属性列表
* @author：
* @createTime：2017年2月8日 下午5:07:11
*/
public static void copyPropertiesInclude(Object source, Object target, String[] includsArray)
{
try
{
copyInclude(source, target, includsArray);
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
initBeanProperties(target);
}
catch (Exception e)
{
e.printStackTrace();
}
}

private static boolean isGetter(Method method)
{
String methodName = method.getName();
Class<?> returnType = method.getReturnType();
Class<?> parameterTypes[] = method.getParameterTypes();
if (returnType.equals(void.class))
{
return false;
}
if ((methodName.startsWith(GETTER) || methodName.startsWith(IS)) && parameterTypes.length == 0)
{
return true;
}
return false;
}

private static boolean isSetter(Method method)
{
String methodName = method.getName();
Class<?> parameterTypes[] = method.getParameterTypes();

if (methodName.startsWith(SETTER) && parameterTypes.length == 1)
{
return true;
}
return false;
}

/**
* 复制对象属性
*
* @param source
* @param target
* @param excludsArray
* 排除属性列表
* @throws Exception
*/
private static void copyExclude(Object source, Object target, String[] excludsArray) throws Exception
{
List<String> excludesList = null;

if (excludsArray != null && excludsArray.length > 0)
{
excludesList = Arrays.asList(excludsArray); // 构造列表对象
}
Method[] sourceMethods = source.getClass().getDeclaredMethods();
Method[] targetMethods = target.getClass().getDeclaredMethods();
Method sourceMethod = null, targetMethod = null;
String sourceMethodName = null, targetMethodName = null;

for (int i = 0; i < sourceMethods.length; i++)
{

sourceMethod = sourceMethods[i];
sourceMethodName = sourceMethod.getName();

if (!isGetter(sourceMethod))
{
continue;
}
// 排除列表检测
if (excludesList != null && excludesList.contains(sourceMethodName.substring(3).toLowerCase()))
{
continue;
}
targetMethodName = SETTER + sourceMethodName.substring(3);
targetMethod = findMethodByName(targetMethods, targetMethodName);

if (targetMethod == null)
{
continue;
}

if (!isSetter(targetMethod))
{
continue;
}

Object value = sourceMethod.invoke(source, new Object[0]);

if (value == null)
{
continue;
}
// 集合类判空处理
if (value instanceof Collection)
{
Collection<?> newValue = (Collection<?>) value;

if (newValue.size() <= 0)
{
continue;
}
}

targetMethod.invoke(target, new Object[]
{ value });
}
}

private static void copyInclude(Object source, Object target, String[] includsArray) throws Exception
{
List<String> includesList = null;

if (includsArray != null && includsArray.length > 0)
{
includesList = Arrays.asList(includsArray);
}
else
{
return;
}
Method[] sourceMethods = source.getClass().getDeclaredMethods();
Method[] targetMethods = target.getClass().getDeclaredMethods();
Method sourceMethod = null, targetMethod = null;
String sourceMethodName = null, targetMethodName = null;

for (int i = 0; i < sourceMethods.length; i++)
{
sourceMethod = sourceMethods[i];
sourceMethodName = sourceMethod.getName();

if (!isGetter(sourceMethod))
{
continue;
}

// 排除列表检测
String str = sourceMethodName.substring(3);

if (!includesList.contains(str.substring(0, 1).toLowerCase() + str.substring(1)))
{
continue;
}

targetMethodName = SETTER + sourceMethodName.substring(3);
targetMethod = findMethodByName(targetMethods, targetMethodName);

if (targetMethod == null)
{
continue;
}

if (!isSetter(targetMethod))
{
continue;
}

Object value = sourceMethod.invoke(source, new Object[0]);

if (value == null)
{
continue;
}

// 集合类判空处理
if (value instanceof Collection)
{
Collection<?> newValue = (Collection<?>) value;

if (newValue.size() <= 0)
{
continue;
}
}

targetMethod.invoke(target, new Object[]
{ value });
}
}

/**
* 从方法数组中获取指定名称的方法
*
* @param methods
* @param name
* @return
*/
private static Method findMethodByName(Method[] methods, String name)
{
for (int j = 0; j < methods.length; j++)
{
if (methods[j].getName().equals(name))
{

return methods[j];
}
}
return null;
}

private static boolean isTrimEmpty(String str)
{

return (str == null) || (str.trim().isEmpty());
}

/**
* @description: 初始化对象为空的属性
* @param obj
* @throws Exception
* @author：
* @createTime：2017年2月7日 下午3:31:14
*/
private static void initBeanProperties(Object obj) throws Exception
{
Class<?> classType = obj.getClass();
for (Field field : classType.getDeclaredFields())
{
// 获取对象的get，set方法
String getMethodName = GETTER + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
String setMethodName = SETTER + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
// 调用对象的get方法获取属性值
Method getMethod = classType.getDeclaredMethod(getMethodName, new Class[]
{});
Object value = getMethod.invoke(obj, new Object[]
{});

// String fieldType = field.getType().toString();
String fieldType = field.getType().toString();
if (value == null && !isTrimEmpty(fieldType))
{
// 调用对象的set方法把属性值初始化
if (fieldType.contains(INTEGER))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ 0 });
}
else if (fieldType.contains(DOUBLE))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ 0.0 });
}
else if (fieldType.contains(LONG))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ 0L });
}
else if (fieldType.contains(STRING))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ "" });
}
else if (fieldType.contains(SET))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ new HashSet<Object>() });
}
else if (fieldType.contains(LIST))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ new ArrayList<Object>() });
}
else if (fieldType.contains(MAP))
{
Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]
{ field.getType() });
setMethod.invoke(obj, new Object[]
{ new HashMap<Object, Object>() });
}
}
}
}

}