您的位置:

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

java如何使用json序列化,jdk序列化和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反射机制进行。

以上代码运行结果:

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

本文目录一览: 1、java 怎么把字典怎么封装json格式 2、java怎么把对象序列化成.json文件 3、Jackson序列化&&FastJson序列化API使用 4、Java怎么把JSON数据

2023-12-08
java对象转json是序列化吗(jdk序列化和json序列

本文目录一览: 1、redis 存储java对象是json字符串还是序列化 2、(JSON) 序列化和反序列化,这个是什么意思呀? 3、java怎么把对象序列化成.json文件 4、java序列化和反

2023-12-08
java中json对象序列化,java序列化和json序列化

2022-11-24
java如何使用json序列化,json序列化是什么意思

2022-11-25
Java Json序列化详解

2023-05-22
java反序列化,java反序列化创建对象

2022-11-26
java反序列化php,JAVA反序列化漏洞

2023-01-07
java反序列化,java反序列化漏洞

2022-11-27
快速上手com.fasterxml.jackson:处理JS

2023-05-16
什么是Json序列化

2023-05-18
javajson与序列化(Java实现序列化)

本文目录一览: 1、java怎么把对象序列化成.json文件 2、Java的json反序列化:Java数据类可以和json数据结构不一致吗? 3、java生成json算是序列化吗 4、(JSON) 序

2023-12-08
C# JSON序列化和反序列化教程

2023-05-19
androidjson反序列化,json 反序列化

本文目录一览: 1、如何在android中使用jackson做json序列化和反序列化 2、如何:对 JSON 数据进行序列化和反序列化 3、Android Gson 使用详解 4、如何反序列化动态J

2023-12-08
java对象序列化,java对象序列化json

2023-01-06
java序列化,Java序列化和反序列化

2023-01-07
JSON序列化和反序列化最好的C#库——Newtonsoft

2023-05-19
python文件序列化(python 类序列化)

2022-11-15
如何使用omitempty进行JSON序列化

2023-05-20
序列化指定json格式的文件(序列化指定json格式的文件是

本文目录一览: 1、c#如何序列化与反序列化json文件 2、java怎么把对象序列化成.json文件 3、json格式是什么? c#如何序列化与反序列化json文件 使用Newtonsoft.Jso

2023-12-08
序列化的概念和应用

2023-05-18