java如何使用json序列化,jdk序列化和json序列化

本文目錄一覽：

• 1、java 怎麼把字典怎麼封裝json格式
• 2、java怎麼把對象序列化成.json文件
• 3、Jackson序列化&&FastJson序列化API使用
• 4、Java怎麼把JSON數據序列化到文本文件中保存？
• 5、序列化json對象的三種方式
• 6、Java的json反序列化：Java數據類可以和json數據結構不一致嗎？

java 怎麼把字典怎麼封裝json格式

java中將數據封裝為JSON包，可以使用java提供的jsonArray這個工具類進行轉換，代碼如下：

package com.json;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import org.apache.commons.beanutils.BeanUtils;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionContext;

public class JSONUtils

{

/**

*

* @author wangwei JSON工具類

* @param T

*

*/

/***

* 將List對象序列化為JSON文本

*/

public static T String toJSONString(ListT list)

{

JSONArray jsonArray = JSONArray.fromObject(list);

return jsonArray.toString();

}

/***

* 將對象序列化為JSON文本

* @param object

* @return

*/

public static String toJSONString(Object object)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return jsonArray.toString();

}

/***

* 將JSON對象數組序列化為JSON文本

* @param jsonArray

* @return

*/

public static String toJSONString(JSONArray jsonArray)

{

return jsonArray.toString();

}

/***

* 將JSON對象序列化為JSON文本

* @param jsonObject

* @return

*/

public static String toJSONString(JSONObject jsonObject)

{

return jsonObject.toString();

}

/***

* 將對象轉換為List對象

* @param object

* @return

*/

public static List toArrayList(Object object)

{

List arrayList = new ArrayList();

JSONArray jsonArray = JSONArray.fromObject(object);

Iterator it = jsonArray.iterator();

while (it.hasNext())

{

JSONObject jsonObject = (JSONObject) it.next();

Iterator keys = jsonObject.keys();

while (keys.hasNext())

{

Object key = keys.next();

Object value = jsonObject.get(key);

arrayList.add(value);

}

}

return arrayList;

}

/***

* 將對象轉換為Collection對象

* @param object

* @return

*/

public static Collection toCollection(Object object)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return JSONArray.toCollection(jsonArray);

}

/***

* 將對象轉換為JSON對象數組

* @param object

* @return

*/

public static JSONArray toJSONArray(Object object)

{

return JSONArray.fromObject(object);

}

/***

* 將對象轉換為JSON對象

* @param object

* @return

*/

public static JSONObject toJSONObject(Object object)

{

return JSONObject.fromObject(object);

}

/***

* 將對象轉換為HashMap

* @param object

* @return

*/

public static HashMap toHashMap(Object object)

{

HashMapString, Object data = new HashMapString, Object();

JSONObject jsonObject = JSONUtils.toJSONObject(object);

Iterator it = jsonObject.keys();

while (it.hasNext())

{

String key = String.valueOf(it.next());

Object value = jsonObject.get(key);

data.put(key, value);

}

return data;

}

/***

* 將對象轉換為ListMapString,Object

* @param object

* @return

*/

// 返回非實體類型(MapString,Object)的List

public static ListMapString, Object toList(Object object)

{

ListMapString, Object list = new ArrayListMapString, Object();

JSONArray jsonArray = JSONArray.fromObject(object);

for (Object obj : jsonArray)

{

JSONObject jsonObject = (JSONObject) obj;

MapString, Object map = new HashMapString, Object();

Iterator it = jsonObject.keys();

while (it.hasNext())

{

String key = (String) it.next();

Object value = jsonObject.get(key);

map.put((String) key, value);

}

list.add(map);

}

return list;

}

/***

* 將JSON對象數組轉換為傳入類型的List

* @param T

* @param jsonArray

* @param objectClass

* @return

*/

public static T ListT toList(JSONArray jsonArray, ClassT objectClass)

{

return JSONArray.toList(jsonArray, objectClass);

}

/***

* 將對象轉換為傳入類型的List

* @param T

* @param jsonArray

* @param objectClass

* @return

*/

public static T ListT toList(Object object, ClassT objectClass)

{

JSONArray jsonArray = JSONArray.fromObject(object);

return JSONArray.toList(jsonArray, objectClass);

}

/***

* 將JSON對象轉換為傳入類型的對象

* @param T

* @param jsonObject

* @param beanClass

* @return

*/

public static T T toBean(JSONObject jsonObject, ClassT beanClass)

{

return (T) JSONObject.toBean(jsonObject, beanClass);

}

/***

* 將將對象轉換為傳入類型的對象

* @param T

* @param object

* @param beanClass

* @return

*/

public static T T toBean(Object object, ClassT beanClass)

{

JSONObject jsonObject = JSONObject.fromObject(object);

return (T) JSONObject.toBean(jsonObject, beanClass);

}

/***

* 將JSON文本反序列化為主從關係的實體

* @param T 泛型T 代表主實體類型

* @param D 泛型D 代表從實體類型

* @param jsonString JSON文本

* @param mainClass 主實體類型

* @param detailName 從實體類在主實體類中的屬性名稱

* @param detailClass 從實體類型

* @return

*/

public static T, D T toBean(String jsonString, ClassT mainClass,

String detailName, ClassD detailClass)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

JSONArray jsonArray = (JSONArray) jsonObject.get(detailName);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

ListD detailList = JSONUtils.toList(jsonArray, detailClass);

try

{

BeanUtils.setProperty(mainEntity, detailName, detailList);

}

catch (Exception ex)

{

throw new RuntimeException(“主從關係JSON反序列化實體失敗！”);

}

return mainEntity;

}

/***

* 將JSON文本反序列化為主從關係的實體

* @param T泛型T 代表主實體類型

* @param D1泛型D1 代表從實體類型

* @param D2泛型D2 代表從實體類型

* @param jsonString JSON文本

* @param mainClass 主實體類型

* @param detailName1 從實體類在主實體類中的屬性

* @param detailClass1 從實體類型

* @param detailName2 從實體類在主實體類中的屬性

* @param detailClass2 從實體類型

* @return

*/

public static T, D1, D2 T toBean(String jsonString, ClassT mainClass,

String detailName1, ClassD1 detailClass1, String detailName2,

ClassD2 detailClass2)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);

JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

ListD1 detailList1 = JSONUtils.toList(jsonArray1, detailClass1);

ListD2 detailList2 = JSONUtils.toList(jsonArray2, detailClass2);

try

{

BeanUtils.setProperty(mainEntity, detailName1, detailList1);

BeanUtils.setProperty(mainEntity, detailName2, detailList2);

}

catch (Exception ex)

{

throw new RuntimeException(“主從關係JSON反序列化實體失敗！”);

}

return mainEntity;

}

/***

* 將JSON文本反序列化為主從關係的實體

* @param T泛型T 代表主實體類型

* @param D1泛型D1 代表從實體類型

* @param D2泛型D2 代表從實體類型

* @param jsonString JSON文本

* @param mainClass 主實體類型

* @param detailName1 從實體類在主實體類中的屬性

* @param detailClass1 從實體類型

* @param detailName2 從實體類在主實體類中的屬性

* @param detailClass2 從實體類型

* @param detailName3 從實體類在主實體類中的屬性

* @param detailClass3 從實體類型

* @return

*/

public static T, D1, D2, D3 T toBean(String jsonString,

ClassT mainClass, String detailName1, ClassD1 detailClass1,

String detailName2, ClassD2 detailClass2, String detailName3,

ClassD3 detailClass3)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);

JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

ListD1 detailList1 = JSONUtils.toList(jsonArray1, detailClass1);

ListD2 detailList2 = JSONUtils.toList(jsonArray2, detailClass2);

ListD3 detailList3 = JSONUtils.toList(jsonArray3, detailClass3);

try

{

BeanUtils.setProperty(mainEntity, detailName1, detailList1);

BeanUtils.setProperty(mainEntity, detailName2, detailList2);

BeanUtils.setProperty(mainEntity, detailName3, detailList3);

}

catch (Exception ex)

{

throw new RuntimeException(“主從關係JSON反序列化實體失敗！”);

}

return mainEntity;

}

/***

* 將JSON文本反序列化為主從關係的實體

* @param T 主實體類型

* @param jsonString JSON文本

* @param mainClass 主實體類型

* @param detailClass 存放了多個從實體在主實體中屬性名稱和類型

* @return

*/

public static T T toBean(String jsonString, ClassT mainClass,

HashMapString, Class detailClass)

{

JSONObject jsonObject = JSONObject.fromObject(jsonString);

T mainEntity = JSONUtils.toBean(jsonObject, mainClass);

for (Object key : detailClass.keySet())

{

try

{

Class value = (Class) detailClass.get(key);

BeanUtils.setProperty(mainEntity, key.toString(), value);

}

catch (Exception ex)

{

throw new RuntimeException(“主從關係JSON反序列化實體失敗！”);

}

}

return mainEntity;

}

/**

* 封裝json數據從後台傳輸

* @param obj

*/

public static void outPutJson(Object obj){

ActionContext context = ActionContext.getContext();

HttpServletResponse response = (HttpServletResponse) context.get(ServletActionContext.HTTP_RESPONSE);

try {

response.getWriter().print(obj);

} catch (IOException e) {

e.printStackTrace();

}

}

}

//測試類

String s1 = “[{id:1, pId:0, name:\”test1\” , open:true}]”;

String s2 = “{id:2, pId:1, name:\”test211\” , open:true}”;

String s3 = “{id:3, pId:2, name:\”test311\” , open:true}”;

String s4 = “{id:4, pId:1, name:\”test411\” , open:true}”;

ListString listZtree = new ArrayListString();

listZtree.add(s1);

listZtree.add(s2);

listZtree.add(s3);

listZtree.add(s4);

System.out.println(JSONUtils.toJSONString(listZtree));

}

java怎麼把對象序列化成.json文件

首先引用json 對應的jar包

1.commons-lang.jar

2.commons-beanutils.jar

3.commons-collections.jar

4.commons-logging.jar

5.ezmorph.jar

6.json-lib-2.2.2-jdk15.jar

實現方法就是 JSONObjectjson = JSONObject.fromObject(map);

Jackson序列化&&FastJson序列化API使用

JDK英文文檔，牆裂不推薦看中文！！！

ObjectMapper的API文檔

1 需要注意的是：

2 Jackson的API： `

3. Jackson提供的註解

Jackson 提供了一系列的註解，方便對 JSON 序列化和反序列化進行控制，下面介紹一些常用的註解：

1. 引入MAVEN依賴：

2. 實體類

3. 測試類：

首先注意的是 JDK1.8 中時間類，採用了一套新的API。

在這裡我們採用是 LocalDate 類，若是 User 類中，沒有使用註解，那麼序列化結果為：

顯然，這不是我們預期的 Json 串。並且，我們在反序列化過程中，會出現異常：

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of java.time.LocalDate (no Creators, like default construct, exist):

cannot deserialize from Object value (no delegate- or property-based Creator)

at [Source: (String)”{“name”:”小胖”,”sports”:[“足球”,”游泳”],”date”:{“year”:2019,”month”:”MARCH”,”chronology”:{“id”:”ISO”,”calendarType”:”iso8601″},”dayOfMonth”:27,”dayOfWeek”:”WEDNESDAY”,”dayOfYear”:86,”era”:”CE”,”monthValue”:3,”leapYear”:false}}”; line: 1, column: 43] (through reference chain: com.JsonSerializer.User[“date”])

大概意思：就是 LocalDate 的沒有參數是 Object 的構造函數。不能實例化對象。

華麗的分割線 SpringBoot的處理

SpringBoot的解決方案：

Java bean的解決方案：

在 Java Bean 中使用註解，就可以進行反序列化和序列化。

執行結果：

FastJson 是性能極好的 JSON 解析器和生成器。

1. FastJson的優點：

2. FastJson的主要類:

1. FastJson的MAVEN依賴：

2. JSON準備：

ARR_JSON格式：

COMPLEX_JSON格式：

使用方式： github的使用文檔

1. 通過 TypeReference 處理泛型對象

2. 使用 getType() 可以獲取更好的性能。

1. TypeRefrence部分源碼分析：

為什麼這裡的構造方法要是 protected 的，即我們無法直接創建該對象，只能使用匿名類創建 子類 對象。

getGenericSuperclass()的API方法

返回 Class 對象（類，接口，基本數據類型，void）的直接父類的 Type 類型。

如果父類是 parameterized [pə’ræmɪtəraɪzd] 類型（也可以理解為 父類是泛型對象 ），那麼返回的參數類型是父類的泛型類型。

基本原理：

使用 public static T T parseObject(String text, ClassT clazz) 方法，邊可完成JSON的反序列化。

1. 特殊JSON反序列化

2. 泛型丟失

我們可以看到，因為返回值需要泛型類型 T 所以我們採用的是 ClassT ，防止返回Object對象，讓用戶強轉。但需要注意： 這種方式在反序列化的時候，會丟失泛型類型。

方式一：TypeReference

方式二：使用parseArray

我們可以通過這個 API ，完成 Bean 對象轉換成 String 類型。

String toJSONString(Object object, SerializerFeature… features)

若是對象的屬性只是簡單數據類型（基本數據類型，或者String類型）那麼可以使用Class方式轉化為Object對象。

若是一個對象裏面的屬性依舊是一個對象，那麼我們就可以使用TypeRefrence進行轉換。

我們在將JSON轉換為對象的時候，就可以保留ListT的泛型。即：

參考文章：

Java下利用Jackson進行JSON解析和序列化

使用FastJson處理JSON數據

fastjson如何json數組串轉換為Object[]時如何指定各個數據項的數據類型

Java怎麼把JSON數據序列化到文本文件中保存？

你既然JSON能解析到了 你就可以用文件輸入輸出流直接寫到文件中 FileWriter即可

序列化json對象的三種方式

序列化json對象即是把json對象轉換成json字符串，通常情況下都是用JSON.stringify方法，其實還有另外兩個庫可以實現此需求，但它們之間有些區別。

上面的json對象qs.stringify序列化結果如下：

而JSON.stringify序列化結果如下：

總結：從以上簡單的對比，我們可以發現qs庫的這個方法用在get請求拼接url時特別好。

Java的json反序列化：Java數據類可以和json數據結構不一致嗎？

由於時間關係我也沒有寫全，這裡提供一個思路吧。代碼如下：

Account.java：

@Data

public class Account {

private int id;

private String name;

// @PowerfulAnnotation註解是我臆想的

@PowerfulAnnotation(“token.id”)

private String tokenId;

@PowerfulAnnotation(“token.key”)

private String key;

}

PowerfulAnnotation.java：

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface PowerfulAnnotation {

String value() default “”;

}

測試類Main.java:

public class Main {

public static void main(String[] args) throws Exception {

Account account = new Account();

String ori = “{\n” +

“\”id\”: 11111,\n” +

“\”name\”: \”小李\”,\n” +

“\”token\”: {\n” +

“\”id\”: 22222222,\n” +

“\”key\”: \”ddddddddd\”\n” +

“}\n” +

“}”;

Gson gson = new Gson();

//字符串json轉JsonObject

JsonObject jsonObject = gson.fromJson(ori, JsonObject.class);

//反射獲取目標對象屬性

for (Field field : account.getClass().getDeclaredFields()) {

String fieldName = field.getName();

Class fieldClass = field.getType();

System.out.print(“當前field名：[” + fieldName + “]，”);

System.out.println(“當前field類型：[” + fieldClass + “]”);

Annotation annotation = field.getDeclaredAnnotation(PowerfulAnnotation.class);

//檢查是否有PowerfulAnnotation註解

if (annotation != null) {

PowerfulAnnotation powerful = (PowerfulAnnotation) annotation;

String powerfulValue = powerful.value();

System.out.println(“發現PowerfulAnnotation註解，值為：[” + powerfulValue + “]”);

String[] tmp = powerfulValue.split(“\\.”);

//聲明一個臨時JsonObject，將用於獲取下一層json對象

JsonObject tmpJson = jsonObject;

for (int i = 0; i tmp.length; i++) {

//目標值是在powerfulValue的最後一個字段，例如powerfulValue為token.id的話，目標的值就是id，所以先獲取token這個jsonObject，並賦值給臨時tmpJson

if (i != tmp.length – 1) {

tmpJson = jsonObject.get(tmp[i]).getAsJsonObject();

} else {

//到達powerfulValue的最後一個字段，檢查其類型，並賦值給目標對象

Object value = checkFieldType(tmpJson, tmp[i], fieldClass);

//從目標對象中獲取目標屬性

Field targetField = account.getClass().getDeclaredField(field.getName());

targetField.setAccessible(true);//解除私有限制

System.out.println(“將[” + powerfulValue + “]的值[” + value + “]賦給目標對象的[” + fieldName + “]”);

//將值賦值給目標屬性

targetField.set(account, value);

}

}

}

//屬性上沒有PowerfulAnnotation註解

else {

//檢查當前屬性的類型

Object value = checkFieldType(jsonObject, fieldName, fieldClass);

//從目標對象中獲取目標屬性

Field targetField = account.getClass().getDeclaredField(field.getName());

targetField.setAccessible(true);//解除私有限制

System.out.println(“直接將值[” + value + “]賦給目標對象的[” + fieldName + “]”);

//將值賦值給目標屬性

targetField.set(account, value);

}

System.out.println(“*********************************************\n”);

}

System.out.println(“目標對象最終值：” + account);

}

/**

* 檢查當前屬性的類型

* （這裡由於時間關係，我沒有寫全，只檢查了String、int、boolean類型，全類型應包括boolean、char、byte、short、int、long、float、double，你有時間自己補充一下）

*

* 如果發現當前屬性是一個對象，那麼應該將JsonObject轉換成對應的對象再返回（由於時間關係，這裡我也沒有試過，總之思路是這樣）

*/

private static Object checkFieldType(JsonObject field, String fieldName, Class fieldClass) {

if (fieldClass == String.class) {

return field.get(fieldName).getAsString();

}

if (fieldClass == int.class) {

return field.get(fieldName).getAsInt();

}

if (fieldClass == boolean.class) {

return field.get(fieldName).getAsBoolean();

}

return new Gson().fromJson(field.get(fieldName), fieldClass);

}

}

代碼還沒寫完，主要集中在沒有對JsonArray進行處理，當json串里包含數組時會報錯，另外一些沒寫完的我在注釋里寫了點，你可以參照一下。整體思路還是利用java反射機制進行。

以上代碼運行結果：