文档章节

Android两个实体关联序列化反序列化,轻量级序列化

悠槿璃
 悠槿璃
发布于 2017/04/19 09:28
字数 3564
阅读 3
收藏 0

一、什么是json

json(Javascript Object Notation)是一种轻量级的数据交换格式,相比于xml这种数据交换格式来说,因为解析xml比较的复杂,而且需要编写大段的代码,所以客户端和服务器的数据交换格式往往通过json来进行交换。尤其是对于web开发来说,json数据格式在客户端直接可以通过javascript来进行解析。

二、JSON 语法规则

JSON 语法是 JavaScript 对象表示语法的子集。
数据在键值对中
数据由逗号分隔
花括号保存对象
方括号保存数组
json一共有两种数据结构,一种是以 (key/value)对形式存在的无序的jsonObject对象,一个对象以“{”(左花括号)开始,“}”(右花括号)结束。每个“名称”后跟一个“:”(冒号);“‘名称/值’ 对”之间使用“,”(逗号)分隔,如图




另一种数据格式就是有序的value的集合,这种形式被称为是jsonArray,数组是值(value)的有序集合。一个数组以“[”(左中括号)开始,“]”(右中括号)结束。值之间使用“,”(逗号)分隔。

图片来源博客园

三、json序列化反序列的两种方法

通过第三方jar包json-lib(http://json-lib.sourceforge.net/)


封装代码直接调用

package com.Platforms.enterprise_Service.Service;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONStringer;

import android.util.Log;


/**
 * @author keane
 * 
 */
public class JSONHelper {
	private static String TAG = "JSONHelper";

	/**
	 * 将对象转换成Json字符串
	 * @param obj
	 * @return json类型字符串
	 */
	public static String toJSON(Object obj) {
		JSONStringer js = new JSONStringer();
		serialize(js, obj);
		return js.toString();
	}

	/**
	 * 序列化为JSON
	 * @param js json对象
	 * @param o	待需序列化的对象
	 */
	private static void serialize(JSONStringer js, Object o) {
		if (isNull(o)) {
			try {
				js.value(null);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			return;
		}

		Class<?> clazz = o.getClass();
		if (isObject(clazz)) { // 对象
			serializeObject(js, o);
		} else if (isArray(clazz)) { // 数组
			serializeArray(js, o);
		} else if (isCollection(clazz)) { // 集合
			Collection<?> collection = (Collection<?>) o;
			serializeCollect(js, collection);
		}else if (isMap(clazz)) { // 集合
			HashMap<?,?> collection = (HashMap<?,?>) o;
			serializeMap(js, collection);
		} else { // 单个值
			try {
				js.value(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 序列化数组 
	 * @param js	json对象
	 * @param array	数组
	 */
	private static void serializeArray(JSONStringer js, Object array) {
		try {
			js.array();
			for (int i = 0; i < Array.getLength(array); ++i) {
				Object o = Array.get(array, i);
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化集合
	 * @param js	json对象
	 * @param collection	集合
	 */
	private static void serializeCollect(JSONStringer js, Collection<?> collection) {
		try {
			js.array();
			for (Object o : collection) {
				serialize(js, o);
			}
			js.endArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 序列化Map
	 * @param js	json对象
	 * @param map	map对象
	 */
	private static void serializeMap(JSONStringer js, Map<?,?> map) {
		try {
			js.object();
			@SuppressWarnings("unchecked")
			Map<String, Object> valueMap = (Map<String, Object>) map;
			Iterator<Map.Entry<String, Object>> it = valueMap.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry<String, Object> entry = (Map.Entry<String, Object>)it.next();
				js.key(entry.getKey());
				serialize(js,entry.getValue());
			}
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 序列化对象
	 * @param js	json对象
	 * @param obj	待序列化对象
	 */
	private static void serializeObject(JSONStringer js, Object obj) {
		try {
			js.object();
			Class<? extends Object> objClazz = obj.getClass();
			//获取所有的数组
			Method[] methods = objClazz.getDeclaredMethods(); 
			//获取所有的字段
	        Field[] fields = objClazz.getDeclaredFields();  
	        //遍历这个对象
	        for (Field field : fields) {   
	            try {   
	                String fieldType = field.getType().getSimpleName();   
	                String fieldGetName = parseMethodName(field.getName(),"get");   
	                if (!haveMethod(methods, fieldGetName)) {   
	                    continue;   
	                }   
	                Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});   
	                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});   
	                Object result = null;   
	                if ("Date".equals(fieldType)) {   
	                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);   
	                    result = sdf.format((Date)fieldVal);  

	                } else {   
	                    if (null != fieldVal) {   
	                        result = fieldVal;   
	                    }   
	                }   
	                js.key(field.getName());
					serialize(js, result);  
	            } catch (Exception e) {   
	                continue;   
	            }   
	        }  
			js.endObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判断是否存在某属性的 get方法
	 * @param methods	引用方法的数组
	 * @param fieldMethod	方法名称
	 * @return true或者false
	 */
	public static boolean haveMethod(Method[] methods, String fieldMethod) {
		for (Method met : methods) {
			if (fieldMethod.equals(met.getName())) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 拼接某属性的 get或者set方法
	 * @param fieldName	字段名称
	 * @param methodType	方法类型
	 * @return 方法名称
	 */
	public static String parseMethodName(String fieldName,String methodType) {
		if (null == fieldName || "".equals(fieldName)) {
			return null;
		}
		return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
	}
	
	/**  
     * 给字段赋值  
     * @param obj  实例对象
     * @param valMap  值集合
     */  
    public static void setFieldValue(Object obj, Map<String, String> valMap) {   
        Class<?> cls = obj.getClass();   
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();   
        Field[] fields = cls.getDeclaredFields();   
  
        for (Field field : fields) {   
            try {     
                String setMetodName = parseMethodName(field.getName(),"set");   
                if (!haveMethod(methods, setMetodName)) {   
                    continue;   
                }   
                Method fieldMethod = cls.getMethod(setMetodName, field   
                        .getType());   
                String value = valMap.get(field.getName());   
                if (null != value && !"".equals(value)) {   
                    String fieldType = field.getType().getSimpleName();   
                    if ("String".equals(fieldType)) {   
                        fieldMethod.invoke(obj, value);   
                    } else if ("Date".equals(fieldType)) {   
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);   
                        Date temp = sdf.parse(value);    
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Integer".equals(fieldType)   
                            || "int".equals(fieldType)) {   
                        Integer intval = Integer.parseInt(value);   
                        fieldMethod.invoke(obj, intval);   
                    } else if ("Long".equalsIgnoreCase(fieldType)) {   
                        Long temp = Long.parseLong(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Double".equalsIgnoreCase(fieldType)) {   
                        Double temp = Double.parseDouble(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                        Boolean temp = Boolean.parseBoolean(value);   
                        fieldMethod.invoke(obj, temp);   
                    } else {   
                        System.out.println("setFieldValue not supper type:" + fieldType);   
                    }   
                }   
            } catch (Exception e) {   
                continue;   
            }   
        }   
  
    } 
    
    /**
     * bean对象转Map
     * @param obj	实例对象
     * @return	map集合
     */
    public static Map<String, String> beanToMap(Object obj) {   
        Class<?> cls = obj.getClass();   
        Map<String, String> valueMap = new HashMap<String, String>();   
        // 取出bean里的所有方法   
        Method[] methods = cls.getDeclaredMethods();   
        Field[] fields = cls.getDeclaredFields();     
        for (Field field : fields) {   
            try {   
                String fieldType = field.getType().getSimpleName();   
                String fieldGetName = parseMethodName(field.getName(),"get");   
                if (!haveMethod(methods, fieldGetName)) {   
                    continue;   
                }   
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});   
                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});   
                String result = null;   
                if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);   
                    result = sdf.format((Date)fieldVal);   

                } else {   
                    if (null != fieldVal) {   
                        result = String.valueOf(fieldVal);   
                    }   
                }   
                valueMap.put(field.getName(), result);   
            } catch (Exception e) {   
                continue;   
            }   
        }   
        return valueMap;   
  
    }   

	/**
	 * 给对象的字段赋值
	 * @param obj	类实例
	 * @param fieldSetMethod	字段方法
	 * @param fieldType	字段类型
	 * @param value
	 */
	public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){
		   
        try {    
            if (null != value && !"".equals(value)) {    
            	if ("String".equals(fieldType)) {   
                	fieldSetMethod.invoke(obj, value.toString());   
                } else if ("Date".equals(fieldType)) {   
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);   
                    Date temp = sdf.parse(value.toString());    
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Integer".equals(fieldType)   
                        || "int".equals(fieldType)) {   
                    Integer intval = Integer.parseInt(value.toString());   
                    fieldSetMethod.invoke(obj, intval);   
                } else if ("Long".equalsIgnoreCase(fieldType)) {   
                    Long temp = Long.parseLong(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Double".equalsIgnoreCase(fieldType)) {   
                    Double temp = Double.parseDouble(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else if ("Boolean".equalsIgnoreCase(fieldType)) {   
                    Boolean temp = Boolean.parseBoolean(value.toString());   
                    fieldSetMethod.invoke(obj, temp);   
                } else {   
                	fieldSetMethod.invoke(obj, value); 
                	Log.e(TAG, TAG  + ">>>>setFiedlValue -> not supper type" + fieldType);   
                } 
			}
                
        } catch (Exception e) {   
//            Log.e(TAG, TAG  + ">>>>>>>>>>set value error.",e);
        	e.printStackTrace();
        }   
    
	}
	
	/**
	 * 反序列化简单对象
	 * @param jo	json对象
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException 
	 */
	public static <T> T parseObject(JSONObject jo, Class<T> clazz) throws JSONException {
		if (clazz == null || isNull(jo)) {
			return null;
		}

		T obj = newInstance(clazz);
		if (obj == null) {
			return null;
		}
		if(isMap(clazz)){ 
			setField(obj,jo);
		}else{
			  // 取出bean里的所有方法   
	        Method[] methods = clazz.getDeclaredMethods();   
	        Field[] fields = clazz.getDeclaredFields();   	        
			for (Field f : fields) {
				String setMetodName = parseMethodName(f.getName(),"set");   
                if (!haveMethod(methods, setMetodName)) {   
                    continue;   
                }                 
				try {
					Method fieldMethod = clazz.getMethod(setMetodName, f.getType());
					setField(obj,fieldMethod,f, jo);
				} catch (Exception e) {
					e.printStackTrace();
				}  
			}
		}
		return obj;
	}
	
	/**
	 * 反序列化简单对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	反序列化后的实例
	 * @throws JSONException 
	 */
	public static <T> T parseObject(String jsonStr, Class<T> clazz) throws JSONException {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		
		JSONObject jo = null;
		jo = new JSONObject(jsonStr);
		if (isNull(jo)) {
			return null;
		}

		return parseObject(jo, clazz);
	}

	/**
	 * 反序列化数组对象
	 * @param ja	json数组
	 * @param clazz	实体类类型
	 * @return	反序列化后的数组
	 */
	public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
		if (clazz == null || isNull(ja)) {
			return null;
		}

		int len = ja.length();

		@SuppressWarnings("unchecked")
		T[] array = (T[]) Array.newInstance(clazz, len);

		for (int i = 0; i < len; ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObject(jo, clazz);
				array[i] = o;
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return array;
	}

	
	/**
	 * 反序列化数组对象
	 * @param jsonStr	json字符串
	 * @param clazz	实体类类型
	 * @return	序列化后的数组
	 */
	public static <T> T[] parseArray(String jsonStr, Class<T> clazz) {
		if (clazz == null || jsonStr == null || jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			jo = new JSONArray(jsonStr);
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (isNull(jo)) {
			return null;
		}

		return parseArray(jo, clazz);
	}

	/**
	 * 反序列化泛型集合
	 * @param ja	json数组
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return
	 * @throws JSONException 
	 */
	@SuppressWarnings("unchecked")
	public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,
			Class<T> genericType) throws JSONException {

		if (collectionClazz == null || genericType == null || isNull(ja)) {
			return null;
		}

		Collection<T> collection = (Collection<T>) newInstance(collectionClazz);

		for (int i = 0; i < ja.length(); ++i) {
			try {
				JSONObject jo = ja.getJSONObject(i);
				T o = parseObject(jo, genericType);
				collection.add(o);
			} catch (JSONException e) {
				e.printStackTrace();
			}
		}

		return collection;
	}

	/**
	 * 反序列化泛型集合
	 * @param jsonStr	json字符串
	 * @param collectionClazz	集合类型
	 * @param genericType	实体类类型
	 * @return	反序列化后的数组
	 * @throws JSONException 
	 */
	public static <T> Collection<T> parseCollection(String jsonStr, Class<?> collectionClazz,
			Class<T> genericType) throws JSONException {
		if (collectionClazz == null || genericType == null || jsonStr == null
				|| jsonStr.length() == 0) {
			return null;
		}
		JSONArray jo = null;
		try {
			//如果为数组,则此处转化时,需要去掉前面的键,直接后面的[]中的值
			int index = jsonStr.indexOf("[");
			String arrayString=null; 
			
			//获取数组的字符串
			if(-1!=index){
				arrayString = jsonStr.substring(index);
			}
			
			//如果为数组,使用数组转化
			if(null!=arrayString){
				jo = new JSONArray(arrayString);
			}
			else{
				jo = new JSONArray(jsonStr);
			}
			
		} catch (JSONException e) {
			e.printStackTrace();
		}

		if (isNull(jo)) {
			return null;
		}

		return parseCollection(jo, collectionClazz, genericType);
	}

	/**
	 * 根据类型创建对象
	 * @param clazz	待创建实例的类型
	 * @return	实例对象
	 * @throws JSONException 
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static <T> T newInstance(Class<T> clazz) throws JSONException {
		if (clazz == null)
			return null;
		T obj = null;
		if (clazz.isInterface()) {
			if (clazz.equals(Map.class)) {
				obj = (T) new HashMap();
			}else if (clazz.equals(List.class)) {
				obj = (T) new ArrayList();
			}else if (clazz.equals(Set.class)) {
				obj = (T) new HashSet();
			}else{
				throw new JSONException("unknown interface: " + clazz);
			}
		}else{
			try {
				obj = clazz.newInstance();
			}catch (Exception e) {
				throw new JSONException("unknown class type: " + clazz);
			}
		}	
		return obj;
	}
	
	/**
	 * 设定Map的值
	 * @param obj	待赋值字段的对象
	 * @param jo	json实例
	 */
	private static void setField(Object obj, JSONObject jo) {
		try {
			@SuppressWarnings("unchecked")
			Iterator<String> keyIter = jo.keys();
			String key;
			Object value;
			@SuppressWarnings("unchecked")
			Map<String, Object> valueMap = (Map<String, Object>) obj;
			while (keyIter.hasNext()) {
				key = (String) keyIter.next();
				value = jo.get(key);				
				valueMap.put(key, value);

			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}	
	
	/**
	 * 设定字段的值
	 * @param obj	待赋值字段的对象
	 * @param fieldSetMethod	字段方法名
	 * @param field	字段
	 * @param jo	json实例
	 */
	private static void setField(Object obj, Method fieldSetMethod,Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();		
		try {
			if (isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object array = parseArray(ja, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);
				}
			} else if (isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}

				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);
				}
			} else if (isList(clazz)) { // 列表
//				JSONObject j = jo.optJSONObject(name);
//				if (!isNull(j)) {
//					Object o = parseObject(j, clazz);
//					f.set(obj, o);
//				}
			} else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 设定字段的值 
	 * @param obj	待赋值字段的对象
	 * @param field	字段
	 * @param jo	json实例
	 */
	@SuppressWarnings("unused")
	private static void setField(Object obj, Field field, JSONObject jo) {
		String name = field.getName();
		Class<?> clazz = field.getType();
		try {
			if (isArray(clazz)) { // 数组
				Class<?> c = clazz.getComponentType();
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object array = parseArray(ja, c);
					field.set(obj, array);
				}
			} else if (isCollection(clazz)) { // 泛型集合
				// 获取定义的泛型类型
				Class<?> c = null;
				Type gType = field.getGenericType();
				if (gType instanceof ParameterizedType) {
					ParameterizedType ptype = (ParameterizedType) gType;
					Type[] targs = ptype.getActualTypeArguments();
					if (targs != null && targs.length > 0) {
						Type t = targs[0];
						c = (Class<?>) t;
					}
				}
				JSONArray ja = jo.optJSONArray(name);
				if (!isNull(ja)) {
					Object o = parseCollection(ja, clazz, c);
					field.set(obj, o);
				}
			} else if (isSingle(clazz)) { // 值类型
				Object o = jo.opt(name);
				if (o != null) {
					field.set(obj, o);
				}
			} else if (isObject(clazz)) { // 对象
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			} else if (isList(clazz)) { // 列表
				JSONObject j = jo.optJSONObject(name);
				if (!isNull(j)) {
					Object o = parseObject(j, clazz);
					field.set(obj, o);
				}
			}else {
				throw new Exception("unknow type!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判断对象是否为空
	 * @param obj	实例
	 * @return
	 */
	private static boolean isNull(Object obj) {
		if (obj instanceof JSONObject) {
			return JSONObject.NULL.equals(obj);
		}
		return obj == null;
	}

	/**
	 * 判断是否是值类型 
	 * @param clazz	
	 * @return
	 */
	private static boolean isSingle(Class<?> clazz) {
		return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
	}

	/**
	 * 是否布尔值
	 * @param clazz	
	 * @return
	 */
	public static boolean isBoolean(Class<?> clazz) {
		return (clazz != null)
				&& ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 是否数值 
	 * @param clazz	
	 * @return
	 */
	public static boolean isNumber(Class<?> clazz) {
		return (clazz != null)
				&& ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))
						|| (Integer.TYPE.isAssignableFrom(clazz))
						|| (Long.TYPE.isAssignableFrom(clazz))
						|| (Float.TYPE.isAssignableFrom(clazz))
						|| (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 判断是否是字符串 
	 * @param clazz	
	 * @return
	 */
	public static boolean isString(Class<?> clazz) {
		return (clazz != null)
				&& ((String.class.isAssignableFrom(clazz))
						|| (Character.TYPE.isAssignableFrom(clazz)) || (Character.class
						.isAssignableFrom(clazz)));
	}

	/**
	 * 判断是否是对象
	 * @param clazz	
	 * @return
	 */
	private static boolean isObject(Class<?> clazz) {
		return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);
	}

	/**
	 * 判断是否是数组 
	 * @param clazz
	 * @return
	 */
	public static boolean isArray(Class<?> clazz) {
		return clazz != null && clazz.isArray();
	}

	/**
	 * 判断是否是集合
	 * @param clazz
	 * @return
	 */
	public static boolean isCollection(Class<?> clazz) {
		return clazz != null && Collection.class.isAssignableFrom(clazz);
	}
		
	/**
	 * 判断是否是Map
	 * @param clazz
	 * @return
	 */
	public static boolean isMap(Class<?> clazz) {
		return clazz != null && Map.class.isAssignableFrom(clazz);
	}
	
	/**
	 * 判断是否是列表 
	 * @param clazz
	 * @return
	 */
	public static boolean isList(Class<?> clazz) {
		return clazz != null && List.class.isAssignableFrom(clazz);
	}
	
}

定义一个关联的的JavaBean对象

package com.Platforms.enterprise_Service.Model;

import java.io.Serializable;

/**
 * 招聘岗位表
 */
public class Mo_RecruitPost implements Serializable{

	private static final long serialVersionUID = -8710264509519802494L;
	/**
	 * 记录编号
	 */
	public int PostID;
	/**
	 * 岗位名称
	 */
	public String PostName;
	/**
	 * 岗位要求描述
	 */
	public String PostIntroduction;
	/**
	 * 工作地点
	 */
	public String RegionName;
	/**
	 * 岗位薪资
	 */
	public String PostSalary;	
	/**
	 * 取系统当前时间
	 * **/
	public String PublishTime;
	
	public int getPostID() {
		return PostID;
	}
	public void setPostID(int postID) {
		PostID = postID;
	}
	public String getPostName() {
		return PostName;
	}
	public void setPostName(String postName) {
		PostName = postName;
	}
	public String getPostIntroduction() {
		return PostIntroduction;
	}
	public void setPostIntroduction(String postIntroduction) {
		PostIntroduction = postIntroduction;
	}
	public String getRegionName() {
		return RegionName;
	}
	public void setRegionName(String regionName) {
		RegionName = regionName;
	}
	public String getPostSalary() {
		return PostSalary;
	}
	public void setPostSalary(String postSalary) {
		PostSalary = postSalary;
	}
	public String getPublishTime() {
		return PublishTime;
	}
	public void setPublishTime(String publishTime) {
		PublishTime = publishTime;
	}
	public boolean isIsClosed() {
		return IsClosed;
	}
	public void setIsClosed(boolean isClosed) {
		IsClosed = isClosed;
	}
	public Mo_EnterpriseInfo getEntID() {
		return EntID;
	}
	public void setEntID(Mo_EnterpriseInfo entID) {
		EntID = entID;
	}
	public String getJobName() {
		return JobName;
	}
	public void setJobName(String jobName) {
		JobName = jobName;
	}
	public String getEducation() {
		return education;
	}
	public void setEducation(String education) {
		this.education = education;
	}
	public String getExperience() {
		return experience;
	}
	public void setExperience(String experience) {
		this.experience = experience;
	}
	public static long getSerialversionuid() {
		return serialVersionUID;
	}
	/**
	 * 招聘信息是否关闭
	 * **/
	public boolean IsClosed;
	
	/**
	 * 招聘企业(外键关联T_EnterpriseInfo)
	 * **/
	public Mo_EnterpriseInfo EntID=new Mo_EnterpriseInfo();	
	/**
	 * 行业名称
	 * **/
	public String JobName;
	/**
	 * 学历
	 * **/
	public String education;
	/**
	 * 工作经验
	 * **/
	public String experience;	
	
	/**
	 * 浏览次数
	 * **/
	public int Count;
	
	public int getCount() {
		return Count;
	}
	public void setCount(int count) {
		Count = count;
	}
	/**
	 * 无参构造
	 */
	public Mo_RecruitPost(){
		
	}
	/**
	 * 有参构造
	 */
	public Mo_RecruitPost(int PostID,String PostName,String PostIntroduction,String RegionName,String PostSalary,String PublishTime,boolean IsClosed,Mo_EnterpriseInfo EntID,String JobName,String education,String experience,int count){
		this.PostID=PostID;
		this.PostName=PostName;
		this.PostIntroduction=PostIntroduction;
		this.RegionName=RegionName;
		this.PostSalary=PostSalary;
		this.PublishTime=PublishTime;
		this.IsClosed=IsClosed;
		this.EntID=EntID;
		this.JobName=JobName;
		this.education=education;
		this.experience=experience;
		this.Count=count;
	}
	public Mo_RecruitPost(String postName, String postIntroduction,
			String regionName, String postSalary, String publishTime,
			String jobName, String education) {
		super();
		this.PostName = postName;
		this.PostIntroduction = postIntroduction;
		this.RegionName = regionName;
		this.PostSalary = postSalary;
		this.PublishTime = publishTime;
		this.JobName = jobName;
		this.education = education;
	}
	


	
}


将对象序列化发送请求给服务器

/**序列化关联对象,向服务器提交数据
	 * @param Mo_RecruitPost recruitPost 需要序列化的JavaBean对象Mo_RecruitPost
	 * @param recruitPost由于前台封装数据传到后台
	 * */
	public String Senddata (Mo_RecruitPost recruitPost) throws ClientProtocolException, IOException
	{ 
		String res=null;
		String url=Urls.SendRecruitAddUrl;
		HttpClient httpclient=new DefaultHttpClient();
		//调用jsonHelper,序列化两个实体对象,定义JSON,用于向服务器提交数据
		String jsonObj = JSONHelper.toJSON(recruitPost);
		
		//指定Post参数
        List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
        nameValuePairs.add(new BasicNameValuePair("data", jsonObj));
        nameValuePairs.add(new BasicNameValuePair("type", "SendRecruitAdd"));
		HttpPost httppost=new HttpPost(url);
		try {
			httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs,"UTF-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//向服务器发送请求
		HttpResponse httpresponse=httpclient.execute(httppost);
		String returnValue = "";
		JSONObject result = null;
		if(httpresponse.getStatusLine().getStatusCode()==HttpStatus.SC_OK)
		{		
			//接收到服务器端返回的值
			returnValue = EntityUtils.toString(httpresponse.getEntity(), "UTF-8");
			try {
				result = new JSONObject(returnValue);
			} catch (JSONException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//判断请求是否成功
				if(result.has("result")){					 
					res=result.optString("result");
					return res;
					
				}
				else{return"fail";}
			}
			else{
				return"fail";
				}
	}
接收到服务器端的值,反序列给前台

/**反序列化关联对象,将数据给前台
	 * @param Mo_RecruitPost recruitPost 需要反序列化的JavaBean对象Mo_RecruitPost
	 * */
	public List<Mo_RecruitPost> ReceiveData() throws ClientProtocolException, IOException
	{
		//请求地址
		String url=Urls.SendAllRecruitUrl;
		HttpClient httpclient=new DefaultHttpClient();
        List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
        nameValuePairs.add(new BasicNameValuePair("data", ""));
        nameValuePairs.add(new BasicNameValuePair("type", "SendAllRecruit"));
        HttpPost httppost=new HttpPost(url);
		try {
			httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs,"utf-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		HttpResponse httpresponse=httpclient.execute(httppost);
		String returnValue = "";
		if(httpresponse.getStatusLine().getStatusCode()==HttpStatus.SC_OK)
		{
			//反序列化对象
			try {
				//得到服务器序列化的对象
				returnValue=EntityUtils.toString(httpresponse.getEntity(),"utf-8");
				try {
					//定义一个JSONObject装结果
					JSONObject result=new JSONObject(returnValue);
					List<Mo_RecruitPost>list=new ArrayList<Mo_RecruitPost>();
					if(result!=null){
						Mo_RecruitPost[] AryrecruitPost = null;
						//反序列化数据
						JSONArray recruitPostjson=result.optJSONArray("data");
						//得到的序列化数据是个数组型字符串
						AryrecruitPost= JSONHelper.parseArray(recruitPostjson, Mo_RecruitPost.class);
						//循环取出数组中的每个对象
						for(int i=0;i<AryrecruitPost.length;i++)
						{
							list.add(AryrecruitPost[i]);
						}
						return list;
					}

				} catch (JSONException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} catch (ParseException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
		return null;
	}
序列化后的对象是如下的json字符串

<span style="color:#FF0000;">recruitPost":{"address":"广州","id":1,"name":"xiaoluo"}}</span>

本文转载自:http://blog.csdn.net/qq_27455063/article/details/52879896

悠槿璃
粉丝 6
博文 20
码字总数 1021
作品 0
深圳
程序员
私信 提问
Android Serializable与Parcelable原理与区别

一、序列化、反序列化是什么? (1) 名词解释 对象的序列化 : 把Java对象转换为字节序列并存储至一个储存媒介的过程。 对象的反序列化:把字节序列恢复为Java对象的过程。 (2) 序列化详细解释 ...

KingMing
2015/04/16
232
0
Android中Parcelable的使用

转载请标明出处 :https://www.cnblogs.com/tangZH/p/10998065.html Parcelable与Serializable Serializable是Java为我们提供的一个标准化的序列化接口。 Parcelable是Android为我们提供的序...

妖久
06/10
0
0
fastjson 1.1.47-android 发布,大幅提升性能

Android环境下性能大幅度提升,减少内存占用,jar包大小不足200k。 1. 性能优化。 1.1.47-android针对android做了很多性能优化,性能优化包括首次序列化/反序列化,在android环境,序列化的次...

wenshao
2016/04/04
3.5K
16
Serializable & Parcelable

对象序列化的简单介绍 所谓对象的序列化其实就是把JVM运行过程中生成的对象通过特殊的处理手段转换为字节形式的文件。转换之后就可以将其永久保存到磁盘中,或者以字节流进行网络传输。 在A...

吴七禁
2017/12/14
0
0
fastjson-1.1.48.android发布,进一步提升在android环境下的性能

进一步提升在android环境下的性能,同时减少内存占用,恢复Stream API,更好兼容之前的版本,jar大小196k,比上一个版本fastjson-1.1.47.android小1k。 Bug Fixed 修复引起的字段类型为java....

wenshao
2016/04/11
0
0

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周六乱弹 —— 早上儿子问我他是怎么来的

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @凉小生 :#今日歌曲推荐# 少点戾气,愿你和这个世界温柔以待。中岛美嘉的单曲《僕が死のうと思ったのは (曾经我也想过一了百了)》 《僕が死の...

小小编辑
今天
2K
14
Excption与Error包结构,OOM 你遇到过哪些情况,SOF 你遇到过哪些情况

Throwable 是 Java 中所有错误与异常的超类,Throwable 包含两个子类,Error 与 Exception 。用于指示发生了异常情况。 Java 抛出的 Throwable 可以分成三种类型。 被检查异常(checked Exc...

Garphy
今天
38
0
计算机实现原理专题--二进制减法器(二)

在计算机实现原理专题--二进制减法器(一)中说明了基本原理,现准备说明如何来实现。 首先第一步255-b运算相当于对b进行按位取反,因此可将8个非门组成如下图的形式: 由于每次做减法时,我...

FAT_mt
昨天
40
0
好程序员大数据学习路线分享函数+map映射+元祖

好程序员大数据学习路线分享函数+map映射+元祖,大数据各个平台上的语言实现 hadoop 由java实现,2003年至今,三大块:数据处理,数据存储,数据计算 存储: hbase --> 数据成表 处理: hive --> 数...

好程序员官方
昨天
61
0
tabel 中含有复选框的列 数据理解

1、el-ui中实现某一列为复选框 实现多选非常简单: 手动添加一个el-table-column,设type属性为selction即可; 2、@selection-change事件:选项发生勾选状态变化时触发该事件 <el-table @sel...

everthing
昨天
20
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部