利用反射封装参数的对象处理工具

因为工作中的一个业务场景，需要把Map中的参数包装成不同的对象，所以写了一个处理工具，目前能满足功能需求，但是测试的不够多，可能会有没有发现的问题，谨慎使用。 ## 1.工具类

代码如下（示例）：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 
 * @author 
 * @version v1.0
 * @date 2020年9月8日
 * @title &nbsp对象处理工具
 */
public class ObjUtil {

	/**
	 * 获取对象并赋值 <br>
	 * (注：<s>此方法不适用于成员属性包含类对象的类 </s> <br>
	 * 1、此方法不适用于成员属性包含自定义类且该成员属性类中还包含其他自定义类的类。 <br>
	 * 2、如果成员属性类型为char或Character，则赋值参数map中对应字段属性字符串的第一个字符。 <br>
	 * )
	 * 
	 * @param <T>          泛型
	 * @param clazz        具体类的class
	 * @param parameterMap 参数map
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getObjInstance(Class<T> clazz, Map<String, String> parameterMap) throws Exception {
		T obj = clazz.newInstance();
		List<Field> list = new ArrayList<Field>();
		while (clazz != null) {
			Field[] fields = clazz.getDeclaredFields();
			list.addAll(new ArrayList<Field>(Arrays.asList(fields)));
			clazz = (Class<T>) clazz.getSuperclass();
		}
		for (Field f : list) {
			f.setAccessible(true);
			f.set(obj, parseValueStr(f.getType(), parameterMap.get(f.getName())));
			if (!f.getType().isPrimitive() && !f.getType().getName().startsWith("java.lang")) {
				if (verifyInnerObj(f.getType(), parameterMap)) {
					Object o = f.getType().newInstance();
					Field[] fields = f.getType().getDeclaredFields();
					for (Field ff : fields) {
						ff.setAccessible(true);
						ff.set(o, parseValueStr(ff.getType(), parameterMap.get(ff.getName())));
					}
					f.set(obj, o);
				}
			}
		}
		return obj;
	}

	@SuppressWarnings("rawtypes")
	private static boolean verifyInnerObj(Class obj, Map<String, String> parameterMap) {
		boolean flag = false;
		Field[] fields = obj.getDeclaredFields();
		for (Field f : fields) {
			if (parameterMap.containsKey(f.getName())) {
				flag = true;
				break;
			}
		}
		return flag;
	}

	@SuppressWarnings("rawtypes")
	private static Object parseValueStr(Class type, String valueStr) {
		Object obj = null;
		// 是否是基础类型
		if (type.isPrimitive()) {
			switch (type.getName()) {
			case "short":
				obj = valueStr == null ? (short) 0 : Short.parseShort(valueStr);
				break;
			case "int":
				obj = valueStr == null ? (int) 0 : Integer.parseInt(valueStr);
				break;
			case "double":
				obj = valueStr == null ? (double) 0 : Double.parseDouble(valueStr);
				break;
			case "long":
				obj = valueStr == null ? (long) 0 : Long.parseLong(valueStr);
				break;
			case "float":
				obj = valueStr == null ? (float) 0 : Float.parseFloat(valueStr);
				break;
			case "byte":
				obj = valueStr == null ? (byte) 0 : Byte.parseByte(valueStr);
				break;
			case "boolean":
				obj = valueStr == null ? false : Boolean.parseBoolean(valueStr);
				break;
			case "char":
				obj = valueStr == null ? '\u0000' : valueStr.charAt(0);
				break;
			default:
				break;
			}
		} else {
			String[] arr = type.getTypeName().split("\\.");
			String fieldType = arr[arr.length - 1];
			switch (fieldType) {
			case "Short":
				obj = valueStr == null ? null : Short.parseShort(valueStr);
				break;
			case "Integer":
				obj = valueStr == null ? null : Integer.parseInt(valueStr);
				break;
			case "Double":
				obj = valueStr == null ? null : Double.parseDouble(valueStr);
				break;
			case "Long":
				obj = valueStr == null ? null : Long.parseLong(valueStr);
				break;
			case "Float":
				obj = valueStr == null ? null : Float.parseFloat(valueStr);
				break;
			case "Byte":
				obj = valueStr == null ? null : Byte.parseByte(valueStr);
				break;
			case "Boolean":
				obj = valueStr == null ? null : Boolean.parseBoolean(valueStr);
				break;
			case "String":
				obj = valueStr;
				break;
			case "Character":
				obj = valueStr == null ? null : valueStr.charAt(0);
				break;
			default:
				break;
			}
		}
		return obj;
	}
}