Android中的JSON解析方式：json; Gson ; Fastjson
2014-09-09 23:01
447 查看
本文主要介绍Json数据的解析
----a，json数据的介绍
----b，json数据的解析
----c，gson数据的解析，谷歌公司的一种格式
----d，fastjson数据的解析，阿里巴巴的一种格式
通过本文的学习能掌握json数据格式的解析，为以后json格式数据的解析做到熟练于心。
Json的全称：JavaScript Object Notation
JSON的定义：
一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org
Json建构于两种结构：
“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash
table），有键列表（keyed list），或者关联数组 （associative array）。
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）
JSON对象是一个无序的“‘名称/值’对”集合。
一个对象以“{”（左括号）开始，“}”（右括号）结束。
每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。
如： {
“name”:”jackson”,
“age”:100
数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔
如：{
“students”:
[
{“name”:”jackson”,“age”:100},
{“name”:”michael”,”age”:51}
]
Gson这个Java类库可以把Java对象转换成JSON，也可以把JSON字符串转换成一个相等的Java对象。
二。阿里巴巴FastJson技术的介绍
FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：
速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser。包括自称最快的JackJson。
功能强大，完全支持Java Bean、集合、Map、日期、Enum，支持范型，支持自省。
无依赖，能够直接运行在Java SE 5.0以上版本
支持Android。
三。JSON Vs XML
1.JSON和XML的数据可读性基本相同
2.JSON和XML同样拥有丰富的解析手段
3.JSON相对于XML来讲，数据的体积小
4.JSON与JavaScript的交互更加方便
5.JSON对数据的描述性比XML较差
四。android2.3提供的json解析类
android的json解析部分都在包org.json下，主要有以下几个类：
JSONObject ：可以看作是一个json对象, 这是系统中有关 JSON 定义的基本单元，其包含一对儿 (Key/Value) 数值。它对外部 (External ： 应用 toString() 方法输出的数值 ) 调用的响应体现为一个标准的字符串（例如： {"JSON":
"Hello, World"} ，最外被大括号包裹，其中的 Key 和Value 被冒号 ":" 分隔）。其对于内部 (Internal) 行为的操作格式略微，例如：初始化一个JSONObject 实例，引用内部的 put() 方法添加数值： new
JSONObject().put("JSON", "Hello, World!") ，在 Key 和 Value 之间是以逗号 "," 分隔。 Value 的类型包括： Boolean 、 JSONArray、 JSONObject 、 Number 、 String 或者默认值 JSONObject.NULL
object 。
JSONStringer ：json文本构建类 ，根据官方的解释，这个类可以帮助快速和便捷的创建JSON text。其最大的优点在于可以减少由于 格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。。其最大的优点在于可以减少由于格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON
text。
JSONArray ： 它代表一组有序的数值。将其转换为String输出(toString)所表现的形式是用方括号包裹，数值以逗号”,”分隔（例如： [value1,value2,value3]，大家可以亲自利用简短的代码更加直观的了解其格式）。这个类的内部同样具有查询行为， get()和opt()两种方法都可以通过index索引返回指定的数值，put()方法用来添加或者替换数值。 同样这个类的value类型可以包括：Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL
object。
JSONTokener ：json解析类
JSONException ：json中用到的异常
首先建立一个公共的Bean
[java] view plaincopy
package com.qianfeng.domain;
public class Person {
private int age;
private String name;
public Person( int age, String name) {
super ();
this .age = age;
this .name = name;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]" ;
}
public int getAge() {
return age;
}
public void setAge( int age) {
this .age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this .name = name;
}
public Person() {
// TODO Auto-generated constructor stub
}
}
作者：admin发表时间：2013-05-20 09:04:00
客户端与服务器进行数据交互时，常常需要将数据在服务器端将数据转化成字符串并在客户端对json数据进行解析生成对象。但是用jsonObject和jsonArray解析相对麻烦。Gson和fastjson可以很方便的将下面四种常用的数据转换成json字符串，并将其解析成原数据对象
类型一：JavaBean
类型二：List<JavaBean>
类型三:List<String>
类型四:List<Map<Object,Object>>
一、Gson的使用
1、将上面的四种数据对象转换成json字符串的方法
Gson gson = new Gson();
String jsonString = gson.toJson(obj);
2、将上面的四种类型生成的json字符串分别解析成数据对象的方法
publicstatic <T> T getPerson(String
jsonString , Class<T>cls) {
Gson gson = new Gson();
T t = null ;
try{
t = gson.fromJson(jsonString, cls);
}catch(Exception e){
System.out.println(111);
}
return t ;
}
publicstatic <T>
List<T> getPersons(StringjsonString,Class<T> cls){
List<T> list = new ArrayList<T>();
Gson gson = new Gson();
list = gson.fromJson(jsonString, newTypeToken<List<T>>(){}.getType());
return list ;
}
publicstatic List<String>
getStringList(String jsonString){
List<String> list = newArrayList<String>();
Gson gson = new Gson();
list = gson.fromJson(jsonString, newTypeToken<List<String>>(){}.getType());
return list ;
}
publicstatic List<Map<String,Object>>
getMapList(String jsonString){
List<Map<String,Object>> list = newArrayList<Map<String,Object>>();
Gson gson = new Gson();
list = gson.fromJson(jsonString,newTypeToken<List<Map<String,Object>>>(){}.getType());
return list ;
}
二、Alibaba fastjson的使用
1、将上面的四种数据对象转换成json字符串的方法
String jsonString = JSON.toJSONString(obj);
2、将上面的四种类型生成的json字符串分别解析成数据对象的方法
publicstatic <T> T getPerson(String
jsonString ,Class<T>cls){
T t = null ;
t = JSON.parseObject(jsonString,cls);
return t;
}
publicstatic <T>
List<T> getPersons(StringjsonString ,Class<T> cls){
List<T> personList= new ArrayList<T>();
personList = JSON.parseArray(jsonString,cls);
return personList;
}
publicstatic List<String>
getStringList(StringjsonString){
List<String> list = newArrayList<String>();
list = JSON.parseObject(jsonString,newTypeReference<List<String>>(){});
return list;
}
publicstatic List<Map<String
,Object>>getMapList(String jsonString){
List<Map<String ,Object>> mapList = newArrayList<Map<String,Object>>();
mapList = JSON.parseObject(jsonString,newTypeReference<List<Map<String,Object>>>(){});
return mapList ;
}
第一种方式：
Json方式：
[java] view plaincopy
public class JsonList {
public JsonList() {
// TODO Auto-generated constructor stub
}
public static List<Person> getList() {
List<Person> list = new ArrayList<Person>();
list.add( new Person( 1002 , "李四2" ));
list.add( new Person( 1003 , "李四3" ));
list.add( new Person( 1001 , "李四1" ));
return list;
}
public static Person getPerson(){
return new Person( 1002 , "李四2" );
}
}
[java] view plaincopy
import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
public class JsonTools {
public JsonTools() {
// TODO Auto-generated constructor stub
}
public static String getString(Person person) {
JSON json = JSONSerializer.toJSON(JsonList.getPerson());
return json.toString();
}
/**
*
* @param msgString
* @return
*/
public static Person getPerson(String msgString) {
Person person = new Person();
JSONArray array = new JSONArray();
array.add(msgString);
JSONObject obj = array.getJSONObject( 0 );
// System.out.println(obj.get("age"));
// System.out.println(obj.get("name"));
person.setAge(obj.getInt( "age" ));
person.setName(obj.getString( "name" ));
return person;
}
public static String getListString(List<Person> listPersons) {
JSON json = JSONSerializer.toJSON(listPersons);
return json.toString();
}
/**
* 将一个json格式的字符串转换成行对应的对象
* @param str
* @return
*/
public static List<Person> getPersons(String str) {
List<Person> list = new ArrayList<Person>();
JSONArray array = new JSONArray();
array.add(str);
JSONArray array2 = array.getJSONArray( 0 );
for ( int i = 0 ; i <array2.size(); i++) {
JSONObject jsonObject = array2.getJSONObject(i);
Person person = new Person();
person.setAge(jsonObject.getInt( "age" ));
person.setName(jsonObject.getString( "name" ));
list.add(person);
}
return list;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// JSON json = JSONSerializer.toJSON(JsonList.getList());
// System.out.println(getString(new Person(23,"jack")));
// System.out.println(getListString(JsonList.getList()));
String msgString = "[{'age':1002,'name':'李四2'},{'age':1003,'name':'李四3'},{'age':1001,'name':'李四1'}]" ;
List<Person> lPersons = getPersons(msgString);
for (Person p:lPersons){
System.out.println(p.toString());
}
}
}
第二种方式：
Gson方式
[java] view plaincopy
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.android.domain.Person;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
public class GsonTools {
public GsonTools() {
// TODO Auto-generated constructor stub
}
public static String createGsonString(Object object) {
Gson gson = new Gson();
String gsonString = gson.toJson(object);
return gsonString;
}
public static <T> T changeGsonToBean(String gsonString, Class<T> cls) {
Gson gson = new Gson();
T t = gson.fromJson(gsonString, cls);
return t;
}
public static <T> List<T> changeGsonToList(String gsonString, Class<T> cls) {
Gson gson = new Gson();
List<T> list_person = gson.fromJson(gsonString,
new TypeToken<List<T>>() {
}.getType());
return list_person;
}
public static List<Map<String, Object>> changeGsonToListMaps(String gsonString) {
List<Map<String, Object>> list = null ;
Gson gson = new Gson();
list = gson.fromJson(gsonString,
new TypeToken<List<Map<String, Object>>>() {
}.getType());
return list;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// Person person1 = new Person("张三1", 24, "北京1");
// Person person2 = new Person("张三2", 23, "北京2");
// List<Person> list = new ArrayList<Person>();
// list.add(person1);
// list.add(person2);
//
// String gsonString = createGsonString(list);
// System.out.println(gsonString);
// Gson gson = new Gson();
// System.out.println(list_person.toString());
// Person pp = changeGsonToBean(gsonString,Person.class);
// System.out.println(pp);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put( "name" , "jack" );
map.put( "age" , 23 );
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put( "name" , "rose" );
map2.put( "age" , 24 );
list.add(map);
list.add(map2);
String gsonString = createGsonString(list);
System.out.println(gsonString);
List<Map<String, Object>> list2 = changeGsonToListMaps(gsonString);
System.out.println(list2.toString());
}
}
第三种方式：
fastJosn方式
[java] view plaincopy
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.asm.Type;
import com.alibaba.fastjson.util.TypeUtils;
public class FastJsonTools {
public FastJsonTools() {
// TODO Auto-generated constructor stub
}
public static String createJsonString(Object object) {
String jsonString = JSON.toJSONString(object);
return jsonString;
}
public static <T> T createJsonBean(String jsonString, Class<T> cls) {
T t = JSON.parseObject(jsonString, cls);
return t;
}
public static <T> List<T> createJsonToListBean(String jsonString,
Class<T> cls) {
List<T> list = null ;
list = JSON.parseArray(jsonString, cls);
return list;
}
/**
* @param jsonString
* @return
*/
public static List<Map<String, Object>> createJsonToListMap(
String jsonString) {
List<Map<String, Object>> list2 = JSON.parseObject(jsonString,
new TypeReference<List<Map<String, Object>>>() {
});
return list2;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// Person person1 = new Person("张三1", 24, "北京1");
// Person person2 = new Person("张三2", 23, "北京2");
// List<Person> list = new ArrayList<Person>();
// list.add(person1);
// list.add(person2);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put( "name" , "jack" );
map.put( "age" , 23 );
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put( "name" , "rose" );
map2.put( "age" , 24 );
list.add(map);
list.add(map2);
String jsonString = JSON.toJSONString(list);
System.out.println(jsonString);
// JSON.parseArray(arg0, arg1)
List<Map<String, Object>> list2 = JSON.parseObject(jsonString,
new TypeReference<List<Map<String, Object>>>() {
});
// List<Person> lists = JSON.parseArray(arg0, arg1);
System.out.println(list2.toString());
}
}
示例下载
示例下载
参考网址
json官网
google-gson
博客一
=======================================================================================================================
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
[java] view plaincopy
/**
* 获取"数组形式"的JSON数据，
* @param path 网页路径
* @return 返回JSONArray
* @throws Exception
*/
public static String getJSONArray(String path) throws Exception {
String json = null ;
URL url = new URL(path);
// 利用HttpURLConnection对象,我们可以从网络中获取网页数据.
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 单位是毫秒，设置超时时间为5秒
conn.setConnectTimeout( 5 * 1000 );
conn.setRequestMethod( "GET" );
if (conn.getResponseCode() == 200 ) { // 判断请求码是否是200码，否则失败
InputStream is = conn.getInputStream(); // 获取输入流
byte [] data = readStream(is); // 把输入流转换成字符数组
json = new String(data); // 把字符数组转换成字符串
}
return json;
}
该方法返回解析到的json数据（例：[{"ID":11,"uid":67,"carNo":"豫A000V1"},{"ID":12,"uid":67,"carNo":"豫A9E592"},{"ID":16,"uid":67,"carNo":"豫A1E238"}]）
然后就可以解析你想要的字段了
[java] view plaincopy
JSONArray jsonArray = new JSONArray(carIdJSON);
for ( int i = 0 ; i < jsonArray.length(); i++) {
JSONObject jsonObject = jsonArray.getJSONObject(i);
jsonObject.getString( "carNo" );
jsonObject.getString( "ID" );
}
有解析就有上传了（POST上传），json的上传要用NameValuePairs，大家可以查看jdk关于NameValuePairs的解释
NameValuePairs只能传String类型的值
nameValuePairs.add(new BasicNameValuePair("xxx", xxx));
复制代码
可以上传很多字段（按需求上传就行了）
下面就是上传的方法
// 1. 使用POST方式时，传递参数必须使用NameValuePair数组
// 2. 使用GET方式时，通过URL传递参数，注意写法
// 3. 通过setEntity方法来发送HTTP请求
// 4. 通过DefaultHttpClient 的 execute方法来获取HttpResponse
// 5. 通过getEntity()从Response中获取内容
public static int httpPostData(String urlString,List<NameValuePair> nameValuePairs){
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(urlString);
try{
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
int statusCode = response.getStatusLine().getStatusCode();
return statusCode;
}catch(Exception e){
e.printStackTrace();
}
return 0;
}
复制代码
方法返回请求服务器，返回的响应参数
200成功
200服务器出错
404服务器没响应（服务器有问题）
1.FastJson主要类
2.常见应用 java代码
public class JsonTest {
public static void main(String[] args) throws IOException, Exception {
/*
* 1.将指定的 JavaBean对象解析成Json字符串
*/
Person p1 = new Person("zhangsan", 22, 1332117);
System.out.println(JSON.toJSONString(p1)); // 字段的get属性
/*
* 2.将封装了javaBean对象的集合解析成json字符串,并对该数据进行过滤
*/
ValueFilter valueFilter = new ValueFilter() {
@Override
public Object process(Object source, String name, Object value) {
if (value.equals("lisi")) {
return "**敏感词汇**";
}
return value;
}
};
List list = new ArrayList();
list.add(new Person("lisi", 19, 159785));
list.add(new Person("wangwu", 10, 113123213));
list.add(new Person("zhaoliu", 29, 1444785));
System.out.println(JSON.toJSONString(list, valueFilter));
/*
* 3.将List>集合 转换为json字符串
*/
List> list2 = new ArrayList>();
Map map1 = new HashMap();
map1.put("001", new Person("wangwu", 19, 159785));
map1.put("002", new Person("lisi", 19, 159785));
map1.put("003", new Person("lisi", 19, 159785));
Map map2 = new HashMap();
map2.put("001", new Person("zhaoliu", 19, 159785));
map2.put("002", new Person("lisi", 19, 159785));
map2.put("003", new Person("lisi", 19, 159785));
list2.add(map1);
list2.add(map2);
System.out.println(JSON.toJSONString(list2));
/*
* 4.将指定的字符串解析成 指定的javaBean对象(使用泛型)
*/
Person p2 = JSON.parseObject(Person.getUtil(1), Person.class); //
字段的set属性
/*
* 5.将指定的字符串解析成 封装了指定javaBean对象的集合
*/
// 方法一：
List list1 = JSON.parseArray(Person.getUtil(2), Person.class);
// 方法二：
List list4 = JSON.parseObject(Person.getUtil(2), new
TypeReference>(){});
/*
* 6.将json字符串 解析成 List>集合 ，注意Type类型的定义
*/
// 关键type类型
List> list3 = JSON.parseObject(Person.getUtil(3),new
TypeReference>>(){});
/*
* 7.将json字符串解析为 JsonObject对象， 由于该对象继承了map，可以得到键值对
*/
JSONObject object = (JSONObject) JSON.parse(Person.getUtil(1));
System.out.println("name:" + object.getString("name"));
System.out.println("age:" + object.getIntValue("age"));
System.out.println("number:" + object.getIntValue("number"));
/*
* 8.name过滤器，只能对name进行更新,不管是否显示
*/
NameFilter filter = new NameFilter() {
@Override
public String process(Object source, String name, Object value) {
// source是当前对象， name是key， value实在值
if ("age".equals(name)) {
return "AGE";
}
return name;
// {"age":22,"name":"zhangsan","number":1332117} //过滤前
// {"AGE":22,"name":"zhangsan","number":1332117} //过滤后
}
};
JSONSerializer jsonSerializer = new JSONSerializer();
jsonSerializer.getNameFilters().add(filter); // 通过增加一个过滤器，为name和值进行过滤
jsonSerializer.write(p1);
System.out.println(jsonSerializer.toString());
/*
* 9.属性过滤器PropertyFilter，满足要求的可以不做显示
*/
PropertyFilter propertyFilter = new PropertyFilter() {
@Override
public boolean apply(Object source, String name, Object value) {
if ("age".equals(name)) {
return true;
}
return false;
}
};
JSONSerializer jsonSerializer2 = new JSONSerializer();
jsonSerializer2.getPropertyFilters().add(propertyFilter);
jsonSerializer2.write(list);
System.out.println(jsonSerializer2.toString());
/*
* 10.值过滤器ValueFilter，对满足要求的可以不做显示
*/
ValueFilter valueFilter2 = new ValueFilter() {
@Override
public Object process(Object source, String name, Object value) {
if (value.equals(10)) {
return null;
}
return value;
}
};
JSONSerializer jsonSerializer3 = new JSONSerializer();
jsonSerializer3.getValueFilters().add(valueFilter2);
jsonSerializer3.write(list);
System.out.println(jsonSerializer3.toString());
/*
* 11.在本地路径下读取文件的json字符串信息，得到数据并赋值javaBean对象
*/
JSONReader reader = new JSONReader(new FileReader("c:\\1.txt"));
// 注意type的使用
List list10 = reader.readObject(new
TypeReference>() {}.getType());
reader.close();
/*
* 12.将Object对象保存至本地路径中，保存为json字符串
*/
JSONWriter writer = new JSONWriter(new FileWriter("c:\\2.txt"));
writer.writeObject(list10);
writer.close();
/*
* 13.在网络上获取json数据，并保存为对应的javaBean对象信息
*/
List list11 = null;
URL url = new URL("http://192.168.117.114:8080/Test/My");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(3000);
if (conn.getResponseCode() == 200) {
InputStream in = conn.getInputStream();
// 通过JsonReader类得到发出的输出流对象
JSONReader reader2 = new JSONReader(new InputStreamReader(in));
// 得到Object对象
list11 = reader2.readObject(new
TypeReference>(){}.getType());
}
for (Person p : list11) {
System.out.println(p);
}
/*
* 14.将客户端的javaBean对象，上传至服务器
*/
byte[] bytes = JSON.toJSONBytes(list11);
URL url2 = new URL("http://192.168.117.114:8080/Test/My");
HttpURLConnection conn2 = (HttpURLConnection) url2.openConnection();
conn2.setRequestMethod("POST");
conn2.setConnectTimeout(3000);
conn2.setRequestProperty("content-length",
String.valueOf(bytes.length));
conn2.setRequestProperty("content-type","application/x-www-form-urlencoded");
conn2.setDoOutput(true);
OutputStream os = conn2.getOutputStream();
os.write(bytes, 0, bytes.length);
os.close();
if (conn2.getResponseCode() == 200) {
System.out.println("上传成功! ");
}
}
//////////////////////22222222
// SerialFeature 字段详细用法
}
class Person {
public static String getUtil(int type) {
switch (type) {
case 1:
return new String(
"{\"ag\te\":22,\"name\":\"zhangsan\",\"number\":1332117}");
case 2:
return new String(
"[{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "{\"age\":10,\"name\":\"wangwu\",\"number\":113123213},"
+ "{\"age\":29,\"name\":\"zhaoliu\",\"number\":1444785}]");
case 3:
return new String(
"[{\"001\":{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "\"002\":{\"age\":19,\"name\":\"wangwu\",\"number\":159785},"
+ "\"003\":{\"age\":19,\"name\":\"lisi\",\"number\":159785}},"
+ "{\"001\":{\"age\":23,\"name\":\"lisi\",\"number\":159785},"
+ "\"002\":{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "\"003\":{\"age\":19,\"name\":\"lisi\",\"number\":159785}}]");
}
return null;
}
private String name;
private int age;
private int number;
public Person() {
super();
}
public Person(String name, int age, int number) {
super();
this.name = name;
this.age = age;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + ", number=" + number +
"]";
}
}
复制代码
3.SerialFeature的说明
(1).SerialFeature类的定义
java代码
// 在枚举中SerializerFeature有如下部分定义
public enum SerializerFeature {
QuoteFieldNames,
UseSingleQuotes,
WriteMapNullValue,
WriteEnumUsingToString,
UseISO8601DateFormat,
SkipTransientField
}
复制代码
(2).SerialFeature类的使用
java代码
Date date = new Date(1308841916550L);
// 缺省输出 System.out.println(JSON.toJSONString(date)); // 1308841916550
// 使用特性 UseISO8601DateFormat
System.out.println(JSON.toJSONString(date,
SerializerFeature.UseISO8601DateFormat));// "2011-06-23T23:11:56.550"
// 组合两个Feature(UseISO8601DateFormat和UseSingleQuotes)输出日期
SerializerFeature[] features = {SerializerFeature.UseISO8601DateFormat,
SerializerFeature.UseSingleQuotes };
System.out.println(JSON.toJSONString(date, features)); //
'2011-06-23T23:11:56.550'
复制代码
(3).详细说明
----a，json数据的介绍
----b，json数据的解析
----c，gson数据的解析，谷歌公司的一种格式
----d，fastjson数据的解析，阿里巴巴的一种格式
通过本文的学习能掌握json数据格式的解析，为以后json格式数据的解析做到熟练于心。
Json的全称：JavaScript Object Notation
JSON的定义：
一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org
Json建构于两种结构：
“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash
table），有键列表（keyed list），或者关联数组 （associative array）。
值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）
JSON对象是一个无序的“‘名称/值’对”集合。
一个对象以“{”（左括号）开始，“}”（右括号）结束。
每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。
如： {
“name”:”jackson”,
“age”:100
数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔
如：{
“students”:
[
{“name”:”jackson”,“age”:100},
{“name”:”michael”,”age”:51}
]
Gson这个Java类库可以把Java对象转换成JSON，也可以把JSON字符串转换成一个相等的Java对象。
二。阿里巴巴FastJson技术的介绍
FastJson是一个Json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：
速度最快，测试表明，fastjson具有极快的性能，超越任其他的Java Json parser。包括自称最快的JackJson。
功能强大，完全支持Java Bean、集合、Map、日期、Enum，支持范型，支持自省。
无依赖，能够直接运行在Java SE 5.0以上版本
支持Android。
三。JSON Vs XML
1.JSON和XML的数据可读性基本相同
2.JSON和XML同样拥有丰富的解析手段
3.JSON相对于XML来讲，数据的体积小
4.JSON与JavaScript的交互更加方便
5.JSON对数据的描述性比XML较差
四。android2.3提供的json解析类
android的json解析部分都在包org.json下，主要有以下几个类：
JSONObject ：可以看作是一个json对象, 这是系统中有关 JSON 定义的基本单元，其包含一对儿 (Key/Value) 数值。它对外部 (External ： 应用 toString() 方法输出的数值 ) 调用的响应体现为一个标准的字符串（例如： {"JSON":
"Hello, World"} ，最外被大括号包裹，其中的 Key 和Value 被冒号 ":" 分隔）。其对于内部 (Internal) 行为的操作格式略微，例如：初始化一个JSONObject 实例，引用内部的 put() 方法添加数值： new
JSONObject().put("JSON", "Hello, World!") ，在 Key 和 Value 之间是以逗号 "," 分隔。 Value 的类型包括： Boolean 、 JSONArray、 JSONObject 、 Number 、 String 或者默认值 JSONObject.NULL
object 。
JSONStringer ：json文本构建类 ，根据官方的解释，这个类可以帮助快速和便捷的创建JSON text。其最大的优点在于可以减少由于 格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON text。。其最大的优点在于可以减少由于格式的错误导致程序异常，引用这个类可以自动严格按照JSON语法规则（syntax rules）创建JSON text。每个JSONStringer实体只能对应创建一个JSON
text。
JSONArray ： 它代表一组有序的数值。将其转换为String输出(toString)所表现的形式是用方括号包裹，数值以逗号”,”分隔（例如： [value1,value2,value3]，大家可以亲自利用简短的代码更加直观的了解其格式）。这个类的内部同样具有查询行为， get()和opt()两种方法都可以通过index索引返回指定的数值，put()方法用来添加或者替换数值。 同样这个类的value类型可以包括：Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL
object。
JSONTokener ：json解析类
JSONException ：json中用到的异常
首先建立一个公共的Bean
[java] view plaincopy
package com.qianfeng.domain;
public class Person {
private int age;
private String name;
public Person( int age, String name) {
super ();
this .age = age;
this .name = name;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]" ;
}
public int getAge() {
return age;
}
public void setAge( int age) {
this .age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this .name = name;
}
public Person() {
// TODO Auto-generated constructor stub
}
}
Google Gson和alibaba FastJson的使用
作者：admin发表时间：2013-05-20 09:04:00客户端与服务器进行数据交互时，常常需要将数据在服务器端将数据转化成字符串并在客户端对json数据进行解析生成对象。但是用jsonObject和jsonArray解析相对麻烦。Gson和fastjson可以很方便的将下面四种常用的数据转换成json字符串，并将其解析成原数据对象
类型一：JavaBean
类型二：List<JavaBean>
类型三:List<String>
类型四:List<Map<Object,Object>>
一、Gson的使用
1、将上面的四种数据对象转换成json字符串的方法
Gson gson = new Gson();
String jsonString = gson.toJson(obj);
2、将上面的四种类型生成的json字符串分别解析成数据对象的方法
publicstatic <T> T getPerson(String
jsonString , Class<T>cls) {
Gson gson = new Gson();
T t = null ;
try{
t = gson.fromJson(jsonString, cls);
}catch(Exception e){
System.out.println(111);
}
return t ;
}
publicstatic <T>
List<T> getPersons(StringjsonString,Class<T> cls){
List<T> list = new ArrayList<T>();
Gson gson = new Gson();
list = gson.fromJson(jsonString, newTypeToken<List<T>>(){}.getType());
return list ;
}
publicstatic List<String>
getStringList(String jsonString){
List<String> list = newArrayList<String>();
Gson gson = new Gson();
list = gson.fromJson(jsonString, newTypeToken<List<String>>(){}.getType());
return list ;
}
publicstatic List<Map<String,Object>>
getMapList(String jsonString){
List<Map<String,Object>> list = newArrayList<Map<String,Object>>();
Gson gson = new Gson();
list = gson.fromJson(jsonString,newTypeToken<List<Map<String,Object>>>(){}.getType());
return list ;
}
二、Alibaba fastjson的使用
1、将上面的四种数据对象转换成json字符串的方法
String jsonString = JSON.toJSONString(obj);
2、将上面的四种类型生成的json字符串分别解析成数据对象的方法
publicstatic <T> T getPerson(String
jsonString ,Class<T>cls){
T t = null ;
t = JSON.parseObject(jsonString,cls);
return t;
}
publicstatic <T>
List<T> getPersons(StringjsonString ,Class<T> cls){
List<T> personList= new ArrayList<T>();
personList = JSON.parseArray(jsonString,cls);
return personList;
}
publicstatic List<String>
getStringList(StringjsonString){
List<String> list = newArrayList<String>();
list = JSON.parseObject(jsonString,newTypeReference<List<String>>(){});
return list;
}
publicstatic List<Map<String
,Object>>getMapList(String jsonString){
List<Map<String ,Object>> mapList = newArrayList<Map<String,Object>>();
mapList = JSON.parseObject(jsonString,newTypeReference<List<Map<String,Object>>>(){});
return mapList ;
}
第一种方式：
Json方式：
[java] view plaincopy
public class JsonList {
public JsonList() {
// TODO Auto-generated constructor stub
}
public static List<Person> getList() {
List<Person> list = new ArrayList<Person>();
list.add( new Person( 1002 , "李四2" ));
list.add( new Person( 1003 , "李四3" ));
list.add( new Person( 1001 , "李四1" ));
return list;
}
public static Person getPerson(){
return new Person( 1002 , "李四2" );
}
}
[java] view plaincopy
import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
public class JsonTools {
public JsonTools() {
// TODO Auto-generated constructor stub
}
public static String getString(Person person) {
JSON json = JSONSerializer.toJSON(JsonList.getPerson());
return json.toString();
}
/**
*
* @param msgString
* @return
*/
public static Person getPerson(String msgString) {
Person person = new Person();
JSONArray array = new JSONArray();
array.add(msgString);
JSONObject obj = array.getJSONObject( 0 );
// System.out.println(obj.get("age"));
// System.out.println(obj.get("name"));
person.setAge(obj.getInt( "age" ));
person.setName(obj.getString( "name" ));
return person;
}
public static String getListString(List<Person> listPersons) {
JSON json = JSONSerializer.toJSON(listPersons);
return json.toString();
}
/**
* 将一个json格式的字符串转换成行对应的对象
* @param str
* @return
*/
public static List<Person> getPersons(String str) {
List<Person> list = new ArrayList<Person>();
JSONArray array = new JSONArray();
array.add(str);
JSONArray array2 = array.getJSONArray( 0 );
for ( int i = 0 ; i <array2.size(); i++) {
JSONObject jsonObject = array2.getJSONObject(i);
Person person = new Person();
person.setAge(jsonObject.getInt( "age" ));
person.setName(jsonObject.getString( "name" ));
list.add(person);
}
return list;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// JSON json = JSONSerializer.toJSON(JsonList.getList());
// System.out.println(getString(new Person(23,"jack")));
// System.out.println(getListString(JsonList.getList()));
String msgString = "[{'age':1002,'name':'李四2'},{'age':1003,'name':'李四3'},{'age':1001,'name':'李四1'}]" ;
List<Person> lPersons = getPersons(msgString);
for (Person p:lPersons){
System.out.println(p.toString());
}
}
}
第二种方式：
Gson方式
[java] view plaincopy
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.android.domain.Person;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
public class GsonTools {
public GsonTools() {
// TODO Auto-generated constructor stub
}
public static String createGsonString(Object object) {
Gson gson = new Gson();
String gsonString = gson.toJson(object);
return gsonString;
}
public static <T> T changeGsonToBean(String gsonString, Class<T> cls) {
Gson gson = new Gson();
T t = gson.fromJson(gsonString, cls);
return t;
}
public static <T> List<T> changeGsonToList(String gsonString, Class<T> cls) {
Gson gson = new Gson();
List<T> list_person = gson.fromJson(gsonString,
new TypeToken<List<T>>() {
}.getType());
return list_person;
}
public static List<Map<String, Object>> changeGsonToListMaps(String gsonString) {
List<Map<String, Object>> list = null ;
Gson gson = new Gson();
list = gson.fromJson(gsonString,
new TypeToken<List<Map<String, Object>>>() {
}.getType());
return list;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// Person person1 = new Person("张三1", 24, "北京1");
// Person person2 = new Person("张三2", 23, "北京2");
// List<Person> list = new ArrayList<Person>();
// list.add(person1);
// list.add(person2);
//
// String gsonString = createGsonString(list);
// System.out.println(gsonString);
// Gson gson = new Gson();
// System.out.println(list_person.toString());
// Person pp = changeGsonToBean(gsonString,Person.class);
// System.out.println(pp);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put( "name" , "jack" );
map.put( "age" , 23 );
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put( "name" , "rose" );
map2.put( "age" , 24 );
list.add(map);
list.add(map2);
String gsonString = createGsonString(list);
System.out.println(gsonString);
List<Map<String, Object>> list2 = changeGsonToListMaps(gsonString);
System.out.println(list2.toString());
}
}
第三种方式：
fastJosn方式
[java] view plaincopy
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.asm.Type;
import com.alibaba.fastjson.util.TypeUtils;
public class FastJsonTools {
public FastJsonTools() {
// TODO Auto-generated constructor stub
}
public static String createJsonString(Object object) {
String jsonString = JSON.toJSONString(object);
return jsonString;
}
public static <T> T createJsonBean(String jsonString, Class<T> cls) {
T t = JSON.parseObject(jsonString, cls);
return t;
}
public static <T> List<T> createJsonToListBean(String jsonString,
Class<T> cls) {
List<T> list = null ;
list = JSON.parseArray(jsonString, cls);
return list;
}
/**
* @param jsonString
* @return
*/
public static List<Map<String, Object>> createJsonToListMap(
String jsonString) {
List<Map<String, Object>> list2 = JSON.parseObject(jsonString,
new TypeReference<List<Map<String, Object>>>() {
});
return list2;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// Person person1 = new Person("张三1", 24, "北京1");
// Person person2 = new Person("张三2", 23, "北京2");
// List<Person> list = new ArrayList<Person>();
// list.add(person1);
// list.add(person2);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put( "name" , "jack" );
map.put( "age" , 23 );
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put( "name" , "rose" );
map2.put( "age" , 24 );
list.add(map);
list.add(map2);
String jsonString = JSON.toJSONString(list);
System.out.println(jsonString);
// JSON.parseArray(arg0, arg1)
List<Map<String, Object>> list2 = JSON.parseObject(jsonString,
new TypeReference<List<Map<String, Object>>>() {
});
// List<Person> lists = JSON.parseArray(arg0, arg1);
System.out.println(list2.toString());
}
}
示例下载
示例下载
参考网址
json官网
google-gson
博客一
=======================================================================================================================
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
[java] view plaincopy
/**
* 获取"数组形式"的JSON数据，
* @param path 网页路径
* @return 返回JSONArray
* @throws Exception
*/
public static String getJSONArray(String path) throws Exception {
String json = null ;
URL url = new URL(path);
// 利用HttpURLConnection对象,我们可以从网络中获取网页数据.
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 单位是毫秒，设置超时时间为5秒
conn.setConnectTimeout( 5 * 1000 );
conn.setRequestMethod( "GET" );
if (conn.getResponseCode() == 200 ) { // 判断请求码是否是200码，否则失败
InputStream is = conn.getInputStream(); // 获取输入流
byte [] data = readStream(is); // 把输入流转换成字符数组
json = new String(data); // 把字符数组转换成字符串
}
return json;
}
该方法返回解析到的json数据（例：[{"ID":11,"uid":67,"carNo":"豫A000V1"},{"ID":12,"uid":67,"carNo":"豫A9E592"},{"ID":16,"uid":67,"carNo":"豫A1E238"}]）
然后就可以解析你想要的字段了
[java] view plaincopy
JSONArray jsonArray = new JSONArray(carIdJSON);
for ( int i = 0 ; i < jsonArray.length(); i++) {
JSONObject jsonObject = jsonArray.getJSONObject(i);
jsonObject.getString( "carNo" );
jsonObject.getString( "ID" );
}
有解析就有上传了（POST上传），json的上传要用NameValuePairs，大家可以查看jdk关于NameValuePairs的解释
NameValuePairs只能传String类型的值
nameValuePairs.add(new BasicNameValuePair("xxx", xxx));
复制代码
可以上传很多字段（按需求上传就行了）
下面就是上传的方法
// 1. 使用POST方式时，传递参数必须使用NameValuePair数组
// 2. 使用GET方式时，通过URL传递参数，注意写法
// 3. 通过setEntity方法来发送HTTP请求
// 4. 通过DefaultHttpClient 的 execute方法来获取HttpResponse
// 5. 通过getEntity()从Response中获取内容
public static int httpPostData(String urlString,List<NameValuePair> nameValuePairs){
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(urlString);
try{
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
int statusCode = response.getStatusLine().getStatusCode();
return statusCode;
}catch(Exception e){
e.printStackTrace();
}
return 0;
}
复制代码
方法返回请求服务器，返回的响应参数
200成功
200服务器出错
404服务器没响应（服务器有问题）
1.FastJson主要类
| JSON | 主要类，一般使用静态方法，序列化java bean序列化为json文本或者json字符串反序列化为相应对象 |
| JSONObject | Json对象 |
| JSONReader | JsonReader，可以在本地读取或者网络读取数据并可以反序列化 |
| JSONWriter | JsonWriter，可以将对象序列化Json字符串，写入本地或者发送至服务器 |
| TypeReference | ***重要， 类型引用在反序列化化很常用 |
public class JsonTest {
public static void main(String[] args) throws IOException, Exception {
/*
* 1.将指定的 JavaBean对象解析成Json字符串
*/
Person p1 = new Person("zhangsan", 22, 1332117);
System.out.println(JSON.toJSONString(p1)); // 字段的get属性
/*
* 2.将封装了javaBean对象的集合解析成json字符串,并对该数据进行过滤
*/
ValueFilter valueFilter = new ValueFilter() {
@Override
public Object process(Object source, String name, Object value) {
if (value.equals("lisi")) {
return "**敏感词汇**";
}
return value;
}
};
List list = new ArrayList();
list.add(new Person("lisi", 19, 159785));
list.add(new Person("wangwu", 10, 113123213));
list.add(new Person("zhaoliu", 29, 1444785));
System.out.println(JSON.toJSONString(list, valueFilter));
/*
* 3.将List>集合 转换为json字符串
*/
List> list2 = new ArrayList>();
Map map1 = new HashMap();
map1.put("001", new Person("wangwu", 19, 159785));
map1.put("002", new Person("lisi", 19, 159785));
map1.put("003", new Person("lisi", 19, 159785));
Map map2 = new HashMap();
map2.put("001", new Person("zhaoliu", 19, 159785));
map2.put("002", new Person("lisi", 19, 159785));
map2.put("003", new Person("lisi", 19, 159785));
list2.add(map1);
list2.add(map2);
System.out.println(JSON.toJSONString(list2));
/*
* 4.将指定的字符串解析成 指定的javaBean对象(使用泛型)
*/
Person p2 = JSON.parseObject(Person.getUtil(1), Person.class); //
字段的set属性
/*
* 5.将指定的字符串解析成 封装了指定javaBean对象的集合
*/
// 方法一：
List list1 = JSON.parseArray(Person.getUtil(2), Person.class);
// 方法二：
List list4 = JSON.parseObject(Person.getUtil(2), new
TypeReference>(){});
/*
* 6.将json字符串 解析成 List>集合 ，注意Type类型的定义
*/
// 关键type类型
List> list3 = JSON.parseObject(Person.getUtil(3),new
TypeReference>>(){});
/*
* 7.将json字符串解析为 JsonObject对象， 由于该对象继承了map，可以得到键值对
*/
JSONObject object = (JSONObject) JSON.parse(Person.getUtil(1));
System.out.println("name:" + object.getString("name"));
System.out.println("age:" + object.getIntValue("age"));
System.out.println("number:" + object.getIntValue("number"));
/*
* 8.name过滤器，只能对name进行更新,不管是否显示
*/
NameFilter filter = new NameFilter() {
@Override
public String process(Object source, String name, Object value) {
// source是当前对象， name是key， value实在值
if ("age".equals(name)) {
return "AGE";
}
return name;
// {"age":22,"name":"zhangsan","number":1332117} //过滤前
// {"AGE":22,"name":"zhangsan","number":1332117} //过滤后
}
};
JSONSerializer jsonSerializer = new JSONSerializer();
jsonSerializer.getNameFilters().add(filter); // 通过增加一个过滤器，为name和值进行过滤
jsonSerializer.write(p1);
System.out.println(jsonSerializer.toString());
/*
* 9.属性过滤器PropertyFilter，满足要求的可以不做显示
*/
PropertyFilter propertyFilter = new PropertyFilter() {
@Override
public boolean apply(Object source, String name, Object value) {
if ("age".equals(name)) {
return true;
}
return false;
}
};
JSONSerializer jsonSerializer2 = new JSONSerializer();
jsonSerializer2.getPropertyFilters().add(propertyFilter);
jsonSerializer2.write(list);
System.out.println(jsonSerializer2.toString());
/*
* 10.值过滤器ValueFilter，对满足要求的可以不做显示
*/
ValueFilter valueFilter2 = new ValueFilter() {
@Override
public Object process(Object source, String name, Object value) {
if (value.equals(10)) {
return null;
}
return value;
}
};
JSONSerializer jsonSerializer3 = new JSONSerializer();
jsonSerializer3.getValueFilters().add(valueFilter2);
jsonSerializer3.write(list);
System.out.println(jsonSerializer3.toString());
/*
* 11.在本地路径下读取文件的json字符串信息，得到数据并赋值javaBean对象
*/
JSONReader reader = new JSONReader(new FileReader("c:\\1.txt"));
// 注意type的使用
List list10 = reader.readObject(new
TypeReference>() {}.getType());
reader.close();
/*
* 12.将Object对象保存至本地路径中，保存为json字符串
*/
JSONWriter writer = new JSONWriter(new FileWriter("c:\\2.txt"));
writer.writeObject(list10);
writer.close();
/*
* 13.在网络上获取json数据，并保存为对应的javaBean对象信息
*/
List list11 = null;
URL url = new URL("http://192.168.117.114:8080/Test/My");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(3000);
if (conn.getResponseCode() == 200) {
InputStream in = conn.getInputStream();
// 通过JsonReader类得到发出的输出流对象
JSONReader reader2 = new JSONReader(new InputStreamReader(in));
// 得到Object对象
list11 = reader2.readObject(new
TypeReference>(){}.getType());
}
for (Person p : list11) {
System.out.println(p);
}
/*
* 14.将客户端的javaBean对象，上传至服务器
*/
byte[] bytes = JSON.toJSONBytes(list11);
URL url2 = new URL("http://192.168.117.114:8080/Test/My");
HttpURLConnection conn2 = (HttpURLConnection) url2.openConnection();
conn2.setRequestMethod("POST");
conn2.setConnectTimeout(3000);
conn2.setRequestProperty("content-length",
String.valueOf(bytes.length));
conn2.setRequestProperty("content-type","application/x-www-form-urlencoded");
conn2.setDoOutput(true);
OutputStream os = conn2.getOutputStream();
os.write(bytes, 0, bytes.length);
os.close();
if (conn2.getResponseCode() == 200) {
System.out.println("上传成功! ");
}
}
//////////////////////22222222
// SerialFeature 字段详细用法
}
class Person {
public static String getUtil(int type) {
switch (type) {
case 1:
return new String(
"{\"ag\te\":22,\"name\":\"zhangsan\",\"number\":1332117}");
case 2:
return new String(
"[{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "{\"age\":10,\"name\":\"wangwu\",\"number\":113123213},"
+ "{\"age\":29,\"name\":\"zhaoliu\",\"number\":1444785}]");
case 3:
return new String(
"[{\"001\":{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "\"002\":{\"age\":19,\"name\":\"wangwu\",\"number\":159785},"
+ "\"003\":{\"age\":19,\"name\":\"lisi\",\"number\":159785}},"
+ "{\"001\":{\"age\":23,\"name\":\"lisi\",\"number\":159785},"
+ "\"002\":{\"age\":19,\"name\":\"lisi\",\"number\":159785},"
+ "\"003\":{\"age\":19,\"name\":\"lisi\",\"number\":159785}}]");
}
return null;
}
private String name;
private int age;
private int number;
public Person() {
super();
}
public Person(String name, int age, int number) {
super();
this.name = name;
this.age = age;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + ", number=" + number +
"]";
}
}
复制代码
3.SerialFeature的说明
(1).SerialFeature类的定义
java代码
// 在枚举中SerializerFeature有如下部分定义
public enum SerializerFeature {
QuoteFieldNames,
UseSingleQuotes,
WriteMapNullValue,
WriteEnumUsingToString,
UseISO8601DateFormat,
SkipTransientField
}
复制代码
(2).SerialFeature类的使用
java代码
Date date = new Date(1308841916550L);
// 缺省输出 System.out.println(JSON.toJSONString(date)); // 1308841916550
// 使用特性 UseISO8601DateFormat
System.out.println(JSON.toJSONString(date,
SerializerFeature.UseISO8601DateFormat));// "2011-06-23T23:11:56.550"
// 组合两个Feature(UseISO8601DateFormat和UseSingleQuotes)输出日期
SerializerFeature[] features = {SerializerFeature.UseISO8601DateFormat,
SerializerFeature.UseSingleQuotes };
System.out.println(JSON.toJSONString(date, features)); //
'2011-06-23T23:11:56.550'
复制代码
(3).详细说明
| Featurs枚举值 | 缺省值 | 说明 |
| QuoteFieldNames | true | 序列化输出含引号的字段 |
| UseSingleQuotes | false | 使用单引号而不是双引号序列化 |
| WriteMapNullValue | false | 空值是否输出。大多数情况，值为null的属性输出是没有意义的，缺省这个特性是打开的。 {'id':123,birthday : null} <---区别---> {"id":123} |
| WriteEnumUsingToString | false | Enum输出为枚举值还是枚举下标 |
| UseISO8601DateFormat | false | Date使用ISO8601格式输出日期 |
| SkipTransientField | true | 如果是true，类中的Get方法对应的Field是transient，序列化时将会被忽略 |
| WriteNullListAsEmpty | false | list字段如果为null，输出为[]，而不是null |
| WriteNullNumberAsZero | false | 数值字段如果为null，输出为0，而不是null |
| WriteNullBooleanAsFalse | false | Boolean字段如果为null，输出为false，而不是null |
| WriteNullStringAsEmpty | false | 字符类型字段如果为null，输出为""，而不是null |
| SortField | false | 按字段名称排序后输出 |
| WriteTabAsSpecial | false | 把 |
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Android JSON 解析（Android 原生解析 与 FastJson Gson ）性能比较
- Android JSON：Gson,FastJson解析库的使用和对比分析
- Android使用GSON和FASTJSON解析服务器返回的JSON数据
- Android进阶笔记14：3种JSON解析工具（org.json、fastjson、gson）
- Android JSON解析库Gson和Fast-json的使用对比和图书列表小案例
- Android JSON数据解析（GSON方式）
- 解决android使用gson解析json字符串，并使用混淆编译方式打包apk遇到的问题
- Android之json解析（FastJson Gson 对比）
- Android Jackson、Gson、FastJson解析框架对比
- Android学习(二)：解析JSON,GSON,FASTJSON;JDBC编程
- 解决android使用gson解析json字符串，并使用混淆编译方式打包apk遇到的问题
- 【Android】Gson-以类模板的方式解析复杂JSON
- Android中的JSON解析方式：json; Gson ; Fastjson
- Android中Json数据解析(二)--使用Gson、Jackson和FastJson解析Json数据
- Android中解析json数据的方式之一：Gson
- Android常用Json解析框架GSON和FastJson的使用
- Android JSON 解析库的使用 - Gson 和 fast-json
- android Gson解析 （同json解析方式）
- android Json Gson FastJson 解析
- Android中发起网络访问的方式，以及Json、Gson的网络解析