Java Map反射到Bean

本人为了获取map集合数据，插入数据库，map集合中涉及到多个表的数据，如果按照传统做法是创建一个对象，map.get一下value值要转换数据类型，还要做非空判断，很是麻烦。代码也看起来很臃肿，所以写一个工具类，学习，理解，并记录。

以下工具类可以直接拿去使用，燕过留痕，记得点赞。

 

实体类

public class NhSysUser extends Model{
	
    private Long userId;	//用户ID
    private String createTime;	//创建时间
    private String loginname;	//用户名
    private String password;	//密码
    private String showname;	//显示名称（用户名称/昵称）
   
    /**以下为get set方法**/
	
}

工具类

package com.test.util;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @描述 : Map转换Bean工具类
 * @版权 : 杨涛
 * @时间 : 2019年12月02日 14:45:45
 */
@SuppressWarnings("unchecked")
public class MapConvertBeanUtil {

	private MapConvertBeanUtil() {
		// 不允许被外部实例化
	}

	private final static String nameFrefix = "set";
	
	public static <T> T mapConvertBean(Map<String, Object> map, Class<T> clazz) throws Exception {
		if (clazz==null) {
			throw new RuntimeException("clazz不能为空！");
		}
		return mapConvertBean(map,clazz.newInstance());
	}

	public static <T> T mapConvertBean(Map<String, Object> map, T t) {
		/*
		 * Class类是反射的入口 一般获得一个Class对象有三种途径： 1.类属性方式，如String.class 2.对象的getClass方法加载，如new
		 * String().getClass(). 3.forName方法加载，如Class.forName("java.lang.String") 用于动态加载
		 * 比如加载驱动 这里我传入一个<T>泛型对象,所以我用的是第2种
		 */
		Class<? extends Object> classz = t.getClass();
		// 得到传入实体类所有的方法(getXxx setXxx ...)
		// Method[] declaredMethods = classz.getDeclaredMethods();

		// 判断map集合参数不能为null
		if (!map.isEmpty()) {
			for (Map.Entry<String, Object> keyValue : map.entrySet()) {
				// 得到map键值
				String propertyName = keyValue.getKey();
				// 得到map-value值
				Object value = keyValue.getValue();
				// 得到回属性名
				Field field = getClassField(classz, propertyName);

				if (field != null) {
					// 获取属性类型
					Class<?> fieldType = field.getType();
					value = cast(value, fieldType);
					Method method = null;
					try {
						// 得到属性set方法名
						String setMethodName = convertKey(propertyName);
						// 得到方法
						method = classz.getMethod(setMethodName, field.getType());
						// 判断是否能够执行（这个可以不要）
						if (!method.isAccessible()) {
							method.setAccessible(true);
						}
						method.invoke(t, value);
					} catch (NoSuchMethodException | SecurityException | IllegalAccessException
							| IllegalArgumentException | InvocationTargetException e) {
						e.printStackTrace();
					}
				}
			}
		}
		return t;
	}

	/**
	 * 注意：转化map集合的key 例如 属性名 xXxx(tNode)类型 Eclipse自动生成get set方法第一个字母是不会大写的
	 * @return
	 */
	public static String convertKey(String propertyName) {
		// 将属性名第一个字母大写然后进行拼接
		String setMethodName = nameFrefix
				.concat(propertyName.substring(0, 1).toUpperCase().concat(propertyName.substring(1)));
		return setMethodName;
	}

	/**
	 * 得到属性名
	 * @param clazz     类
	 * @param fieldName 属性名
	 * @return
	 */
	private static Field getClassField(Class<?> clazz, String fieldName) {
		// 传入类是Object类型或者是null直接return
		if (clazz == null || Object.class.getName().equals(clazz.getName())) {
			return null;
		}
		Field[] declaredFields = clazz.getDeclaredFields();
		for (Field field : declaredFields) {
			if (field.getName().equals(fieldName)) {
				return field;
			}
		}

		Class<?> superClass = clazz.getSuperclass();
		if (superClass != null) {// 简单的递归一下
			return getClassField(superClass, fieldName);
		}
		return null;
	}

	/**
	 * String类型转Date
	 * @param date
	 * @return
	 */
	public static Date strConvertDate(String dateStr) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date parse = null;
		try {
			parse = format.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return parse;
	}
	
	/**
	 * 对象类型转换
	 */
	public static Object cast(Object source,Class<?> dstTypeClass){
		return converType(source, dstTypeClass);
	}
	/**
	 * 对象类型转换
	 * @param source : 源对象
	 * @param converTypeClass : 目标类型Class
	 * @return 返回目标类型对象
	 */
	public static Object converType(Object source,Class<?> dstTypeClass){
		Object dstObj=null;
		if(source!=null && dstTypeClass!=null){
			if(source instanceof Number){
				Number number=(Number)source;
				if(dstTypeClass==Byte.class){
					dstObj=number.byteValue();
				}else if(dstTypeClass==Double.class){
					dstObj=number.doubleValue();
				}else if(dstTypeClass==Float.class){
					dstObj=number.floatValue();
				}else if(dstTypeClass==Integer.class){
					dstObj=number.intValue();
				}else if(dstTypeClass==Long.class){
					dstObj=number.longValue();
				}else if(dstTypeClass==Short.class){
					dstObj=number.shortValue();
				}
			}
			//不是Number、基础数据类型
			if(dstObj==null){
				if (dstTypeClass.isAssignableFrom(source.getClass())){
					dstObj=dstTypeClass.cast(source);
				}else if(dstTypeClass==String.class){
					dstObj=source.toString();
				}else if(dstTypeClass==Integer.class){
					dstObj=Integer.parseInt(source.toString());
				}else if(dstTypeClass==Long.class){
					dstObj=Long.parseLong(source.toString());
				}else if(dstTypeClass==Float.class){
					dstObj=Float.parseFloat(source.toString());
				}else if(dstTypeClass==Double.class){
					dstObj=Double.parseDouble(source.toString());
				}else if(dstTypeClass==Byte.class){
					dstObj=Byte.parseByte(source.toString());
				}else if(dstTypeClass==Short.class){
					dstObj=Short.parseShort(source.toString());
				}else{
					dstObj=source;
				}
			}
		}else{
			dstObj=source;
		}
		return dstObj;
	}

	/**
	 * test
         * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		//用法一
		HashMap<String, Object> hashMap = new HashMap<>();
		hashMap.put("userId", 123456);
		hashMap.put("loginname", "gly");
		hashMap.put("password", "md512-3asdf-asdf1");
		hashMap.put("showname", "管理员");
		hashMap.put("createTime", "2019-12-02 13:59:12");

		if (!hashMap.isEmpty()) {
			NhSysUser info = new NhSysUser();
			NhSysUser mapConvertBean = mapConvertBean(hashMap, info);
			System.out.println(mapConvertBean.toString());
		}

		//用法二
		HashMap<String, Object> hashMap1 = new HashMap<>();
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		list.add(hashMap);
		hashMap1.put("list", list);

		List<Map<String, Object>> object = (List<Map<String, Object>>) hashMap1.get("list");
		if (!object.isEmpty()) {
			NhSysUser info = new NhSysUser();
			NhSysUser mapConvertBean = MapConvertBeanUtil.mapConvertBean(object.get(0), info);
			System.out.println(mapConvertBean.toString());
		}
		
		//用法三
		NhSysUser mapConvertBean = mapConvertBean(hashMap,NhSysUser.class);
		System.out.println(mapConvertBean);
		
		//用法四
		NhSysUser mapConvertBean1 = mapConvertBean(object.get(0), NhSysUser.class);
		System.out.println(mapConvertBean1);
	}
}

 

结果