FastJson在java中的应用

一.简介

        目前常用的数据传输格式主要有:xml与json.无论使用xml还是json传输格式，在实际应用中，都需要将其与对象互相转换，也有响应的转换库，比如：xml有dom4j,json有jackson,FastJson。

   fastjson是一个java语言编写的高性能功能完善的json库，是阿里的开源项目，并且是目前java语言中最快的JSON库，接口简单易用等特点。

                     

二.JSON结构

如果使用Maven，需要在pom.xml文件中引入一下依赖：

 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.1.23</version>
 </dependency>

看看下面这个例子，让我们对json的结构有所了解。

{
   "name":"中国",
   "province":[
     {
        "name":"黑龙江",
        "cities":{
             "city":["哈尔滨","大庆"]
         }
      },
      {
        "name":"广东",
        "cities":{
             "city":["广州","深圳"]
         }
       },
       {
          "name":"台湾",
          "cities":{
              "city":["台北","高雄"]
           }
        },
      ]
}

Json结构主要是两部分：

映射：映射就是冒号那种形式，如-->"name":"中国"

序列：就是并列存在的province里面的大括号是并列的，city里面的城市也是并列的。映射到程序里相当于数组

很多人说json就是键值对，很准确，更准确的是键值对套键值对，通常叫key-value对。Key只能是String类型的,例如上面的name,city,province。Value类型有很多，从简单到复杂,主要有以下几种类型：

A:基本类型：int long String..

B:对象类型：对应程序就是大括号，属于自定义的部分，里面还是Json类型。

C:序列类型：对应程序就是中括号，比如city后面的...里面的属性是Value类型，还可以套Json。

Fastjson是通过java对象来产生json的，我们来一步一步分析这个java对象是怎么产生的。

1:最外层大括号

  指一个对象，包含String类型的name和province，province后面接的是一个中括号，那么这是一个数组对象，我们把它定为List<Province>province;

2:容我懒惰，以此类推

  在对象Province中的city是一个数组：String[] city，当然写成list也没有关系

public class China {    //省去setter()和getter()方法
    private String name;  
    private List<Province>province;  
} 
public class Province {  //省去setter()和getter()方法
    private String name;
    private City citys;
}
public class City {      //省去setter()和getter()方法
    private String[] city;
}

三.序列化

        序列化就是指：把JavaBean对象转换成json格式的字符串

1：基本序列化

    String objJson = JSON.toJSONString(Object object);//传入一个对象，将转成json字符串

  例1：将Map转成JSON

        Map<String, Object> map = new HashMap<String, Object>();  
        map.put("key1", "One");  
        map.put("key2", "Two");   
        String mapJson = JSON.toJSONString(map);  
        //输出结果：  
        {"key1":"One","key2":"Two"}  

      例2：将List<Map>转成JSON

         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();        
         Map<String, Object> map1 = new HashMap<String, Object>();
         map1.put("key1", "One");
         map1.put("key2", "Two");     
         Map<String, Object> map2 = new HashMap<String, Object>();
         map2.put("key1", "Three");
         map2.put("key2", "Four");      
         list.add(map1);
         list.add(map2);
         String listJson = JSON.toJSONString(list);  
         //输出结果   
         [{"key1":"One","key2":"Two"},{"key3":"Three","key4":"Four"}]

      例3：自定义JavaBean User转成JSON

         User user = new User();
         user.setUserName("李四");
         user.setAge(24);   
         String userJson = JSON.toJSONString(user);
         //输出结果
         {"age":24,"userName":"李四"}

2：序列化属性

String objJson = JSON.toJSONString(Object object, SerializerFeature..features) SerializerFeature是一个枚举类型

         例4：指定日期格式

	Student user = new Student();
	user.setAge(11);
	user.setId("11");
	user.setName("名字");
	user.setTime(new Date());
	String jsonData = JSONObject.toJSONStringWithDateFormat(user, "yyyy-MM-DD HH:mm:ss");
        //输出结果：
        {"age":11,"id":"11","name":"名字","time":"2016-05-127 13:53:56"}

         例5：格式化后的JSON字符串(将例2格式化)

        传入一个对象和一个布尔类型（是否格式化），将对象转成格式化后的JSON字符串。

        String listJson = JSON.toJSONString(list, true);
        //输出结果：
        [
          {
            "key1":"One",
            "key2":"Two"
           },
           {
            "key3":"Three",
             "key4":"Four"
            }
         ]

          例6：输出Null字段

              默认情况下FastJSON不输入值为Null字段，可以使用SerializerFeature.WriteMapNullValue输出

         Map<String, Object> map = new HashMap<String,Object>();         
         String b = null;
         Integer i = 1;         
         map.put("a", b);
         map.put("b", i);  
         String listJson = JSON.toJSONString(map, SerializerFeature.WriteMapNullValue);
        //输出结果：
        {"a":null,"b":1}

四.反序列化

  反序列化就是把JSON格式的字符串转化为Java对象，提供了许多方法(多态)实现反序列化。

    例7:指定Class信息反序列化。将例3反序列化

         User user1 = JSON.parseObject(userJson, User.class);
         System.out.println(user1.getUserName());
         输出结果：李四

          例8：集合反序列化。(将例2反序列化)

         List<Map> list1 = JSON.parseArray(listJson, Map.class);
      
         for(Map<String, Object> map : list1) {
               System.out.println(map.get("key1"));
               System.out.println(map.get("key2"));         
         }
        //输出结果：
             One
             Two
             Three
             Four

             例9：泛型的反序列化，使用TypeReference传入类型信息。(将例1反序列化)

         Map<String, Object> map1 = JSON.parseObject(mapJson, new TypeReference<Map<String, Object>>(){});
         System.out.println(map1.get("key1"));
         System.out.println(map1.get("key2"));
        //输出结果：
             One
             Two

五.JSON的子类

         JSONObject ,JSONArray是JSON的两个子类

         JSONObject相当于Map<String,Object>,它的底层源码就是Map

         JSONArray相当于List<Object>

            例10：将Map转成JSONObject

          Map<String, Object> map = new HashMap<String, Object>();
          map.put("key1", "One");
          map.put("key2", "Two");                            
          JSONObject j = new JSONObject(map);                 
          j.put("key3", "Three");  
          System.out.println(j.get("key1"));
          System.out.println(j.get("key2"));
          System.out.println(j.get("key3"));
          //输出结果：
             One
             Two
             Three

             例11：将List对象转成JSONArray

          List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        
          Map<String, Object> map = new HashMap<String, Object>();
          map.put("key1", "One");
          map.put("key2", "Two");
        
          Map<String, Object> map2 = new HashMap<String, Object>();
          map2.put("key1", "Three");
          map2.put("key2", "Four");
        
          list.add(map);
          list.add(map2);
       
          JSONArray j = JSONArray.parseArray(JSON.toJSONString(list));
        
          for(int i=0; i<j.size(); i++) {
                System.out.println(j.get(i));
          }
         //输出结果：
         {"key1":"One","key2":"Two"}
         {"key1":"Three","key2":"Four"}

六.FastJSON的工具类

  Fastjson给我们提供了非常方便，简单易用的API,根据设计模式中的单一原则以及实际应用中的需要，在实际应用当中，我们应该再封装一层，我简单的封装了下面这个工具类，如下:

/**
 * 转换json工具类
 * @author Andy
 *
 */
public class ConvertJsonUtils {
	
	/**
	 * 将java对象转换为json格式的字符串
	 * @param object  带转换的对象
	 * @return	json格式的字符串
	 */
	public static String toJsonString(Object object){
		return JSONObject.toJSONString(object);
	}
	
	/**
	 * 默认日期
	 * @param object
	 * @return
	 */
	public static String toJsonWithDefaultDateFormatString(Object object){
		return toJsonWithDateString(object,"yyyy-MM-DD hh:mm:ss");
	}
	
	/**
	 * 带有日期格式的json格式字符串转换
	 * @param object
	 * @param format
	 * @return
	 */
	public static String toJsonWithDateString(Object object,String format){
		return JSONObject.toJSONStringWithDateFormat(object,format, SerializerFeature.PrettyFormat);
	}
	
	/**
	 * 将对象转换为json格式字符串(包括子类的,与toJsonString具体区别可以参考自定义菜单)
	 * @param object
	 * @return
	 */
	public static String toJSONAndChildStr(Object object){
		return JSONObject.toJSON(object).toString();
	}
	
	/**
	 * 将json格式的数据转换为java对象(不包括数组,集合类型)
	 * @param <T>		
	 * @param jsonData	json格式的字符串
	 * @param t			待转换成的java对象
	 * @return
	 */
	public static <T> T jsonToJavaObject(String jsonData,Class<T> t){
		return JSONObject.parseObject(jsonData, t);
	}
	
	/**
	 * 将json格式的数据转换为java集合对象 ,List集合,map集合
	 * @param jsonData	待转换的json格式的字符串
	 * @param t			泛型集合对象
	 * @return
	 */
	public static <T> List<T> jsonToJavaList(String jsonData,Class<T> t){
		return JSONObject.parseArray(jsonData, t);
	}
	
	/**
	 * 获取json格式数据中的键,将其中的值作为转换为List中的数据
	 * @param jsonData	json格式的数据
	 * @param t			待转换的类型
	 * @param key		json格式中的指定的键
	 * @return			list集合
	 * 示列：
	 * 
	 */
	public static <T> List<T> jsonToJavaListByKey(String jsonData,Class<T> t,String key){
		List<T> result = new ArrayList<T>();
		JSONObject obj = JSONObject.parseObject(jsonData);
		if(null!=obj){
			if(obj.containsKey(key)){
				jsonData = obj.getString(key);
				result = new ArrayList<T>();
				result = JSONObject.parseArray(jsonData,t);
			}
		}
		return result;
	}
}