本文目录一览：
- 1、java中如何将数据封装为JSON包？
- 2、Java怎么把JSON数据序列化到文本文件中保存？
- 3、jackson使用入门
- 4、我怎样才能在领域序列化RealmObject以JSON用于Java
- 5、如何：对 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能解析到了 你就可以用文件输入输出流直接写到文件中 FileWriter即可
jackson使用入门
jackson是java中最常用的json处理工具包之一，其他类似功能的包括gson和fastjson等。本文将简单介绍jackson的基础知识，以作为各位读者未来使用的参考。
jackson有三种处理json的方式，分别为
这种方式可以在json字符串和pojo对象之间直接进行转换。比如说我们有一个json字符串
通过这种方式我们可以直接将其转换成一个Person类的实例，其中firstName和lastName是Person类定义的两个成员变量。
这种方式类似于xml的DOM解析，在json字符串和DOM树之间进行转换，DOM树的节点是 JsonNode 类型。其优点在于以统一的方式看待json字符串中的各个部分，使用起来更灵活。
如何构建 JsonNode 的DOM树呢？ JsonNode 是抽象类，需要使用 ObjectNode 和 ArrayNode 等子类。
这种方式类似于xml的SAX解析，每次处理一个事件，或者这里叫token更合适。
反序列化用的是 JsonParser ，它的使用方式和迭代器非常相似。你每次处理的都是一个token，比如说在上面这个json字符串中，包括{、firstName、dizzy、lastName、dwarf、}等6个token，通过调用 nextToken 方法可以获得下一个token。
序列化用的 JsonGenerator ，它的方法都非常直观，比如说 writeStartObject 、 writeStringField 、 writeEndObject 等，这里就不具体介绍了。
通过注解可以定制jackson的各种特性，这里只介绍最常用的几个。
这样一个firstName为"dizzy"的Person序列化后就变成了
一般情况下java变量命名采用驼峰方式，而json字符串可能采用下划线方式。解决方式为在类或者成员变量上增加以下注解
需要注意的是虽然反序列化的时候first_name会对应到firstName变量，但是序列化的时候也会输出为first_name
有时候我们希望根据json字符串中某个字段的取值反序列化成不同的子类，比如说type为1是Student，type为2是Teacher，注意Student和Teacher必须继承同一个父类Person。
如果我们希望ObjectMapper.readValue返回ListPerson或者MapString, Person，由于ListPerson.class和MapString, Person.class在java中是不合法的，需要借助于 TypeReference
Spring提供的 MappingJackson2MessageConverter 类封装了 ObjectMapper ，如果希望对 ObjectMapper 进行定制，可以自己生成一个 MappingJackson2MessageConverter 对象并注册为bean
有时候我们希望只对部分成员变量进行序列化，如果用 @JsonIgnore ，会同时影响反序列化。这个时候我们可以用 @JsonView 注解指定某个视图类的序列化结果包含该成员变量。
我怎样才能在领域序列化RealmObject以JSON用于Java
从境界这里的基督徒。 境界为Android目前没有任何这样的方法，虽然在核心数据库实际上支持JSON序列化，所以现在你要么做手工或使用像GSON（警告第三方工具，我没有带测试的情景还）。
如何：对 JSON 数据进行序列化和反序列化
主要用于存储对象状态为另一种通用格式，比如存储为二进制、xml、json等等，把对象转换成这种格式就叫序列化，而反序列化通常是从这种格式转换回来。 使用序列化主要是因为跨平台和对象存储的需求，因为网络上只允许字符串或者二进制格式，而文...
