[分享]Java之Bean、Map、Json之间的互相转换工具类

因为最近做到的项目服务器会大量和app进行json数据交互，总结了一下工具类方便开发。

1、Bean和Bean的转换：

public static <T> T parserObjToT(Object obj,Class<T> clazz) throws InstantiationException, IllegalAccessException{
		Class oclz=obj.getClass();
		T t=clazz.newInstance();
		Field[] ofields=oclz.getDeclaredFields();
		Field[] tfields=clazz.getDeclaredFields();
		for(Field of:ofields){
			of.setAccessible(true);
			String oname=of.getName();
			for(Field tf:tfields){
				tf.setAccessible(true);
				String tname=tf.getName();
				if(oname.equalsIgnoreCase(tname)){
					if(of.getType().isAssignableFrom(tf.getType())){
						tf.set(t, of.get(obj));
						continue;
					}
					continue;
				}else{
					continue;
				}
			}
		}
		return t;
	}

2、Bean和Map的转换

/**
	 * 将一个 JavaBean对象转化为一个 Map
	 * @param bean	要转化的JavaBean 对象
	 * @return 		转化出来的 Map 对象
	 * @throws IntrospectionException		如果分析类属性失败
	 * @throws IllegalAccessException		如果实例化 JavaBean 失败
	 * @throws InvocationTargetException	如果调用属性的 setter 方法失败
	 */
	public static Map<String, Object> convertBean(Object bean) {
		Class<? extends Object> type = bean.getClass();
		Map<String, Object> returnMap = new HashMap<String, Object>();
		BeanInfo beanInfo;
		try {
			beanInfo = Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (int i = 0; i < propertyDescriptors.length; i++) {
				PropertyDescriptor descriptor = propertyDescriptors[i];
				String propertyName = descriptor.getName();
				if (!propertyName.equals("class")) {
					Method readMethod = descriptor.getReadMethod();
					Object result = readMethod.invoke(bean, new Object[0]);
					if (result != null) {
						returnMap.put(propertyName, result);
					} else {
						returnMap.put(propertyName, "");
					}
				}
			}
		} catch (IntrospectionException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return returnMap;
	}	
	/**
	 * 讲一个map转换成一个指定类型的对象
	 * @param map
	 * @param clazz
	 * @return
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	@SuppressWarnings("unchecked")
	public static <T> T convertMapToBean(Map<String,Object> map,Class<T> clazz) 
				throws InstantiationException, IllegalAccessException, InvocationTargetException{
		T t=clazz.newInstance();
		Field[] fields=clazz.getDeclaredFields();
		Set<Entry<String,Object>> set=map.entrySet();
		
		for(Entry<String,Object> entry:set){
			String key=entry.getKey();
			Object value=entry.getValue();
			
			for (Field field : fields) {
				field.setAccessible(true);
				if (key.equalsIgnoreCase(field.getName())) {// 如果字段相同，则判断类型
					try{
						if(Integer.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("int")||
								Double.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("double")||
								Character.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("char")||
								Short.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("short")||
								Float.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("float")||
								Long.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("long")||
								Byte.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("byte")||
								Boolean.class.isAssignableFrom(field.getType())||field.getType().getName().equalsIgnoreCase("boolean")||
								String.class.isAssignableFrom(field.getType())||
								java.util.Date.class.isAssignableFrom(field.getType())||
								java.sql.Date.class.isAssignableFrom(field.getType())||
								Timestamp.class.isAssignableFrom(field.getType())
								){
							field.set(t, value);
							continue;
							
						}else if(List.class.isAssignableFrom(field.getType())&&List.class.isAssignableFrom(value.getClass())){//处理List字段值
							List vlist=(List) value;
							if(vlist!=null&&vlist.size()>0){
								if(Map.class.isAssignableFrom(vlist.get(0).getClass())){
									Type fc=field.getGenericType();
									if(fc instanceof ParameterizedType){
										ParameterizedType pt=(ParameterizedType) fc;
										Class cl=(Class) pt.getActualTypeArguments()[0];
										List<Map> lm=(List<Map>) value;
										List vl=new ArrayList();
										for(Map m:lm){
											vl.add(convertMapToBean((HashMap<String,Object>)m,cl));
										}
										field.set(t, vl);
									}
								}else{
									field.set(t, value);
								}
							}
							continue;
						}else if(Map.class.isAssignableFrom(value.getClass())){//处理对象值
							field.set(t, convertMapToBean((Map<String,Object>)value,field.getType()));
							continue;
						}else{
							continue;
						}
					}catch(Exception e){
						//容错处理
					}
				}else{
					continue;
				}
				
			}
		}
		
		
		return t;
	}

3、Json部分

JsonUtil.class：

/**
 * 将json字符串转成json对象 建议都用 com.fasterxml.jackson库
 * 
 * @author 高攀
 */
public class JsonUtil {
	// 日志对象
	private static Logger log = Logger.getLogger(JsonUtil.class);

	/**
	 * 字符串转换对象,
	 * @param <T>
	 * @param json 将要解析成json对象的字符串
	 * @param type 将要转换成的类型
	 * @return
	 */
	public static <T> T parseObject(String json, Class<T> type) {
		ObjectMapper objectMapper = new ObjectMapper();
		try {
			return (T) objectMapper.readValue(json, type);
		} catch (JsonParseException e) {
			log.error(type + "-->" + json + "转换出错" + e);
		} catch (JsonMappingException e) {
			log.error(type + "-->" + json + "转换出错" + e);
		} catch (IOException e) {
			log.error(type + "-->" + json + "转换出错" + e);
		}
		return null;
	}

	/**
	 * 对象转换字符串
	 * 
	 * @param <T>
	 * @param json json对象
	 * @return
	 */
	public static String ObjectToString(Object json) {
		ObjectMapper objectMapper = new ObjectMapper();
		try {
			String jsonStr = objectMapper.writeValueAsString(json);
			log.info("对象转换成字符串:"+jsonStr);
			return jsonStr;
		} catch (JsonParseException e) {
			log.error(json + "转换出错" + e);
		} catch (JsonMappingException e) {
			log.error(json + "转换出错" + e);
		} catch (IOException e) {
			log.error(json + "转换出错" + e);
		}
		return null;
	}
	
	/**
	 * 字符串转换List,
	 * @param <T>
	 * @param json 将要解析成jsonList的字符串
	 * @param type 将要转换成的类型
	 * @return
	 */
    @SuppressWarnings("unchecked")
	public static <T> List<T> parseList (String jsonString ,Class<T> type)throws Exception{  
    	ObjectMapper mapper=new ObjectMapper();
		JavaType javaType = getCollectionType(ArrayList.class,type); 
		return (List<T>)mapper.readValue(jsonString, javaType); 
    }  
    
       /**   
        * 获取泛型的Collection Type  
        * @param collectionClass 泛型的Collection   
        * @param elementClasses 元素类   
        * @return JavaType Java类型   
        * @since 1.0   
        */   
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {   
        ObjectMapper objectMapper = new ObjectMapper();
		return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);   
    }
	
    public static void logInfo(String message){
    	log.info(message);
    }
}