JSON概念
JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation），它 是轻量级的文本数据交换格式，JSON 独立于语言 ， 具有自我描述性，更易理解
json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构
1、对象：对象在js中表示为“{}”扩起来的内容，数据结构为 {key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。
2、数组：数组在js中是中括号“[]”扩起来的内容，数据结构为 ["java","javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。
经过对象、数组2种结构就可以组合成复杂的数据结构了。
再简单点说，json可以将javascript对象和数组解析成字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web 客户机传递给服务器端程序。
序列化对象
对象序列化（serialization）是指将对象的状态转换为字符串，也可以将字符串还原为对象。将JavaScript中的数据转换成 json数据称为对象的序列化，反之则称为反序列化或者还原对象。
json在web应用
json在JavaScript中的转换
JavaScript内置函数：JavaScript提供了内置函数JSON.stringify()和JSON.parse()用来序列化成json对象 和 还原JavaScript对象。
在jQuery中也有将对象序列化的方法:jQuery.param(obj,[traditional]) ，不过这个序列化和JSON.stringify()是两码事，同时拥有解析JSon对象方法jQuery.parseJSON(json)
JSON.stringify()：JSON.stringify()将对象序列化 返回的是json对象
console.log(JSON.stringify(obj)) 输出的是
{"account":"asd","platform":{"platId":"6"},"name":"asd","email":"asd","phone":"asd","rank":"asd","remark":"asd"}
这种格式，同时用ajax传输给后台 必须指明格式为json：contentType : "application/json;charset=utf-8" , 否则后台无法解析
在SpringMVC框架中 可以用@RequestBody（该注解常用来处理Content-Type: 不是application/x-www-form-urlencoded编码的内容，例如application/json, application/xml等；）来方便地解析json对象（）
var json = JSON.stringify({
"account" : account,
"platform": {"platId" : platId},
"name" : name,
"email" : name,
"phone" : name,
"rank" : name,
"remark" : remark
});
$.ajax({
type: "POST",
url: "${ctx}/customer/customer/add",
contentType : "application/json;charset=utf-8" ,
data: json,
success: function(data) {
if(data.success){
dialog.close();//关闭窗口
window.location.href ="${ctx}/customer/customer/list?parentId=${parentId}";
}else{
art.dialog.tips('操作失败，请稍后再试....');
}
}
});jQuery.param(obj,[traditional]) :将表单元素数组或者对象序列化。是jQuery.serialize()的核心方法。 因为有些框架在解析序列化数字的时候能力有限，所以当传递一些含有嵌套对象、数组的对象作为参数时，最好是使用JSON.stringify()；
$.ajax({
type: "POST",
url: "${ctx}/customer/customer/add",
// contentType : "application/x-www-form-urlencoded;charset=UTF-8", 此处默认是这种格式 无需指明
data: json,
success: function(data) {
if(data.success){
dialog.close();//关闭窗口
window.location.href ="${ctx}/customer/customer/list?parentId=${parentId}";
}else{
art.dialog.tips('操作失败，请稍后再试....');
}
}
});json包提供方法：
var last=obj.toJSONString(); //将JSON对象转化为JSON字符
var obj = str.parseJSON(); //由JSON字符串转换为JSON对象
jquery中ajax回调函数解析json对象
在项目中经常会使用ajax异步传输数据，我们经常会使用回调函数中传回的data数据
success: function(data){
//alert(data);
alert(data.name);
}可是在这里有疑问了，json不是经过序列化后的字符串吗 ,假如从后台传过来的json封装的是一个对象，按理说输出来的是一个字符串，可是alert出来的是一个Object，这是为什么呢？
查询jQery API发现 ajax中有一个dataType 参数
dataType ： String 预期服务器返回的数据类型。如果不指定，jQuery 将自动根据 HTTP 包 MIME 信息来智能判断，比如XML MIME类型就被识别为XML。在1.4中，JSON就会生成一个JavaS cript对象，而script则会执行这个脚本。随后服务器端返回的数据会根据这个值解析后，传递给回调函数。可用值: "xml": 返回 XML 文档，可用 jQuery 处理。 "html": 返回纯文本 HTML 信息；包含的script标签会在插入dom时执行。 "script": 返回纯文本 JavaScript 代码。不会自动缓存结果。除非设置了"cache"参数。'''注意：'''在远程请求时(不在同一个域下)，所有POST请求都将转为GET请求 。(因为将使用DOM的script标签来加载) "json": 返回 JSON 数据 。 "jsonp": JSONP 格式。使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数。 "text": 返回纯文本字符串
原来如果不指定dataType格式 ， jQuery 会智能地将分装对象的json数据还原成对象。
ajax回调函数中解析JSON List对象（假设json对象为{"aaa", "bbb", "ccc"}）
$.ajax({
type: "POST",
url: "url",
data: data,
dataType : "json",
success: function(data){
$.each( data, function(index, value){
//当对象为List时，key为对象的下标，value为对应的值
alert( key); //输出0,1,2
alert(value) //输出aaa,bbb,ccc
});
}
});ajax回调函数中解析JSON Map对象（假设json对象为{ one:1, two:2, three:3}）
$.ajax({
type: "POST",
url: "url",
data: data,
dataType : "json",
success: function(data){
$.each( data, function(key, value){
//当对象为List时，key为对象的下标，value为对应的值
alert( key); //输出one,two,three
alert(value) //输出one,1,two,2,three,3
alert(data[key]); //输出1,2,3
});
}
}); 这里alert(key)将输出one two threealert(value)将输出one，1，two，2，three,3这边为何key不是数字而是属性呢，因为json格式内是一组无序的属性-值，既然无序，又何来数字呢。
因此要得到data的value值应该用data[key]
json在服务器端应用
在公版原型项目中，前台使用Ext框架进行数据展示，由于Ext框架的特性是对AJAX的完美支持，所以在项目中前台与后台的交互基本是通过AJAX实现，使页面无刷新。
大多的Ajax框架的数据交互都基于Json，所以本系统在选择前后台交互时也使用的是Json。
后台逻辑在后的前台请求后，进行相应处理，处理后结果为java对象，因为使用的是Json格式的数据交互，所以在后台得到处理结果（java对象）后，还需要再进行一步转换的工作，要将java对象转换为Json对象，然后返回给前台进行结果展示。
在此提供两个工具类JsonUtilsForJsonLib和JsonUtils，这两个类的作用都是将java对象转换为Json对象。只不过一个是使用了官方提供的jar包，将java对象转换为JSONObject或JSONArray对象。另一个是直接将java对象拼接为Json格式的字符串，再进行传递。两个类都可以使用。
下面是两个类的使用说明文档：
JsonUtils
在使用此类时只需使用此类中的一个方法即可，方法如下：
public static StringobjectToJson(Object obj)
参数：Object obj
返回值：String
此方法接收一个参数，参数类型为Object，即任何类型，可以是基本数据类型（即String、int、double、boolean等等），也可以是引用数据类型（对象、数组、集合等等），在方法中会对传入的参数进行判断，然后根据具体的参数类型，调用不同的转换方法，最终返回Json格式字符串。
注意：JsonUtils类返回值为String类型。
下面一一介绍此类中方法：
public static StringstringToJson(String s)
参数：String s
返回值：String
此方法接收一个String类型的参数，返回此参数对应的Json格式字符串，如果参数为null，则调用nullToJson()方法，返回””（空字符串）。返回的Json格式字符串格式为：”abc”（参数s的值）
public static StringnullToJson()
参数：空
返回值：String
此方法返回一个空字符串。返回的Json格式字符串格式为：””
public static StringnumberToJson(Number number)
参数：Number number
返回值：String
此方法接收一个Number类型的参数，返回此参数对应的Json格式字符串。返回的Json格式字符串格式为：123（参数s的值）
public static StringbooleanToJson(Boolean bool)
参数：Boolean bool
返回值：String
此方法接收一个Boolean类型的参数，返回此参数对应的Json格式字符串。返回的Json格式字符串格式为：true（参数s的值）
public static StringbeanToJson(Object bean)
参数：Object bean
返回值：String
此方法接收一个Object类型的参数，返回此参数对应的Json格式字符串，返回的Json格式字符串格式为：{“property1”:”value1”,”property2”:”value2”…}
public static StringlistToJson(List<?> list)
参数：List<?> list
返回值：String
此方法接收一个List类型的参数，返回此参数对应的Json格式字符串，返回的Json格式字符串格式为：[“1”,”2”,{…},[],””]
public static StringarrayToJson(Object[] array)
参数：Object[] array
返回值：String
此方法接收一个Object[]类型的参数，返回此参数对应的Json格式字符串，返回的Json格式字符串格式为：[“1”,”2”,”3”,”json”]
public static StringmapToJson(Map<?, ?> map)
参数：Map<?, ?> map
返回值：String
此方法接收一个Map类型的参数，返回此参数对应的Json格式字符串，返回的Json格式字符串格式为：{“key1”:”value1”,”key2”:”value2”…}
public static StringsetToJson(Set<?> set)
参数：Set<?> set
返回值：String
此方法接收一个Set类型的参数，返回此参数对应的Json格式字符串，返回的Json格式字符串格式为：[“1”,”2”,{…},[],””]
JsonUtilsForJsonLib
对于基本数据类型（即String、int、double、boolean等），统一使用此类中一个方法即可，方法如下：
public static JSONObjectbasicDataTypeToJson(String key, Object obj)
参数：String key, Object obj
返回值：JSONObject
此方法接收两个参数，key参数作为转换后Json对象中的键值，obj参数类型为Object，可以是任何基本数据类型（即String、int、double、boolean等等），在方法中会对传入的参数进行判断，然后根据具体的参数类型，调用不同的转换方法，最终返回JSONObject类型对象。
注意：JsonUtilsForJsonLib类返回值为JSONObject类型。对于基本数据类型的转换，和上面的JsonUtils类返回值的格式有很大不同，请自行选择使用。
下面一一介绍此类中方法：
public static JSONObjectstringToJson(String key, String s)
参数：String key, String s
返回值：JSONObject
此方法接收两个参数，key参数用来作为键，s参数作为值构造JSONObject对象，并返回构造的JSONObject对象。返回的JSONObject对象格式为：{“key值”:”s值”}
public static JSONObjectnumberToJson(String key, Number number)
参数：String key, Number number
返回值：JSONObject
此方法接收两个参数，key参数用来作为键，number参数作为值构造JSONObject对象，并返回构造的JSONObject对象。返回的JSONObject对象格式为：{“key值”:number值}
public static JSONObjectbooleanToJson(String key, Boolean bool)
参数：String key, Boolean bool
返回值：JSONObject
此方法接收两个参数，key参数用来作为键，bool参数作为值构造JSONObject对象，并返回构造的JSONObject对象。返回的JSONObject对象格式为：{“key值”: bool值}
public static JSONObjectnullToJson(String key)
参数：String key
返回值：JSONObject
此方法接收两个参数，key参数用来作为键，””作为值构造JSONObject对象，并返回构造的JSONObject对象。返回的JSONObject对象格式为：{“key值”:””}
public static JSONObjectbeanToJson(Object bean)
参数：Object bean
返回值：JSONObject
此方法接收一个Object类型的参数，返回此参数对象对应的JSONObject对象，返回的JSONObject对象格式为：{“property1”:”value1”,”property2”:”value2”…}
public static JSONArraylistToJson(List<?> list)
参数：List<?> list
返回值：JSONArray
此方法接收一个List类型的参数，返回此集合对应的JSONArray对象，返回的JSONArray对象格式为：[“1”,”2”,{…},[],””]
public static JSONArrayarrayToJson(Object[] array)
参数：Object[] array
返回值：JSONArray
此方法接收一个Object[]类型的参数，返回此对象数组对应的JSONArray对象，返回的JSONArray对象格式为：[“1”,”2”,{…},”json”]
public static JSONObjectmapToJson(Map<?, ?> map)
参数：Map<?, ?> map
返回值：JSONObject
此方法接收一个Map类型的参数，返回此集合对应的JSONObject对象，返回的JSONObject对象格式为：{“key1”:”value1”,”key2”:”value2”…}
public static JSONArraysetToJson(Set<?> set)
参数：Set<?> set
返回值：JSONArray
此方法接收一个Set类型的参数，返回此集合对应的JSONArray对象，返回的JSONArray对象格式为：[“1”,”2”,{…},[],””]
json便捷工具类
package com.baiyyy.polabs.util.json;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.util.CycleDetectionStrategy;
/**
* 处理json的工具类，负责json数据转换成java对象和java对象转换成json
*
* @author yongtree
* @date 2008-11-22 上午10:47:13
* @version 1.0
*/
public class JsonUtil {
/**
* 从一个JSON 对象字符格式中得到一个java对象
*
* @param jsonString
* @param pojoCalss
* @return
*/
public static Object getObject4JsonString(String jsonString, Class pojoCalss) {
Object pojo;
JSONObject jsonObject = JSONObject.fromObject(jsonString);
pojo = JSONObject.toBean(jsonObject, pojoCalss);
return pojo;
}
/**
* 从json HASH表达式中获取一个map，改map支持嵌套功能
*
* @param jsonString
* @return
*/
public static Map getMap4Json(String jsonString) {
JSONObject jsonObject = JSONObject.fromObject(jsonString);
Iterator keyIter = jsonObject.keys();
String key;
Object value;
Map valueMap = new HashMap();
while (keyIter.hasNext()) {
key = (String) keyIter.next();
value = jsonObject.get(key);
valueMap.put(key, value);
}
return valueMap;
}
/**
* 从json数组中得到相应java数组
*
* @param jsonString
* @return
*/
public static Object[] getObjectArray4Json(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
return jsonArray.toArray();
}
/**
* 从json对象集合表达式中得到一个java对象列表
*
* @param jsonString
* @param pojoClass
* @return
*/
public static List getList4Json(String jsonString, Class pojoClass) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
JSONObject jsonObject;
Object pojoValue;
List list = new ArrayList();
for (int i = 0; i < jsonArray.size(); i++) {
jsonObject = jsonArray.getJSONObject(i);
pojoValue = JSONObject.toBean(jsonObject, pojoClass);
list.add(pojoValue);
}
return list;
}
/**
* 从json数组中解析出java字符串数组
*
* @param jsonString
* @return
*/
public static String[] getStringArray4Json(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
String[] stringArray = new String[jsonArray.size()];
for (int i = 0; i < jsonArray.size(); i++) {
stringArray[i] = jsonArray.getString(i);
}
return stringArray;
}
/**
* 从json数组中解析出javaLong型对象数组
*
* @param jsonString
* @return
*/
public static Long[] getLongArray4Json(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
Long[] longArray = new Long[jsonArray.size()];
for (int i = 0; i < jsonArray.size(); i++) {
longArray[i] = jsonArray.getLong(i);
}
return longArray;
}
/**
* 从json数组中解析出java Integer型对象数组
*
* @param jsonString
* @return
*/
public static Integer[] getIntegerArray4Json(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
Integer[] integerArray = new Integer[jsonArray.size()];
for (int i = 0; i < jsonArray.size(); i++) {
integerArray[i] = jsonArray.getInt(i);
}
return integerArray;
}
/**
* 从json数组中解析出java Date 型对象数组，使用本方法必须保证
*
* @param jsonString
* @return
* @throws ParseException
*/
public static Date[] getDateArray4Json(String jsonString, String DataFormat)
throws ParseException {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
Date[] dateArray = new Date[jsonArray.size()];
String dateString;
Date date;
for (int i = 0; i < jsonArray.size(); i++) {
dateString = jsonArray.getString(i);
date = DateUtil.parseDate(dateString, DataFormat);
dateArray[i] = date;
}
return dateArray;
}
/**
* 从json数组中解析出java Integer型对象数组
*
* @param jsonString
* @return
*/
public static Double[] getDoubleArray4Json(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
Double[] doubleArray = new Double[jsonArray.size()];
for (int i = 0; i < jsonArray.size(); i++) {
doubleArray[i] = jsonArray.getDouble(i);
}
return doubleArray;
}
/**
* 将java对象转换成json字符串
*
* @param javaObj
* @return
*/
public static String getJsonString4JavaPOJO(Object javaObj) {
JSONObject json;
json = JSONObject.fromObject(javaObj);
return json.toString();
}
/**
* 将java对象转换成json字符串,并设定日期格式
*
* @param javaObj
* @param dataFormat
* @return
*/
public static String getJsonString4JavaPOJO(Object javaObj,
String dataFormat) {
JSONObject json;
JsonConfig jsonConfig = configJson(dataFormat);
json = JSONObject.fromObject(javaObj, jsonConfig);
return json.toString();
}
/**
* JSON 时间解析器具
*
* @param datePattern
* @return
*/
public static JsonConfig configJson(String datePattern) {
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setExcludes(new String[] { "" });
jsonConfig.setIgnoreDefaultExcludes(false);
jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
jsonConfig.registerJsonValueProcessor(Date.class,
new JsonDateValueProcessor(datePattern));
return jsonConfig;
}
/**
* 除去不想生成的字段（特别适合去掉级联的对象）+时间转换
* @param excludes 除去不想生成的字段
* @param datePattern
* @return
*/
public static JsonConfig configJson(String[] excludes, String datePattern) {
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setExcludes(excludes);
jsonConfig.setIgnoreDefaultExcludes(true);
jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
jsonConfig.registerJsonValueProcessor(Date.class,
new JsonDateValueProcessor(datePattern));
return jsonConfig;
}
}
*******************************************************************************************
日期转换
*******************************************************************************************
package com.baiyyy.polabs.util.json;
import java.text.SimpleDateFormat;
import java.util.Date;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
/**
*
* @author yongtree
* @date 2008-11-22 上午10:54:19
* @version 1.0
*/
public class JsonDateValueProcessor implements JsonValueProcessor {
private String format = "yyyy-MM-dd HH:mm:ss";
public JsonDateValueProcessor() {
}
public JsonDateValueProcessor(String format) {
this.format = format;
}
public Object processArrayValue(Object value, JsonConfig jsonConfig) {
String[] obj = {};
if (value instanceof Date[]) {
SimpleDateFormat sf = new SimpleDateFormat(format);
Date[] dates = (Date[]) value;
obj = new String[dates.length];
for (int i = 0; i < dates.length; i++) {
obj[i] = sf.format(dates[i]);
}
}
return obj;
}
public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
if (value instanceof Date) {
String str = new SimpleDateFormat(format).format((Date) value);
return str;
}
return value == null ? null : value.toString();
}
public String getFormat() {
return format;
}
public void setFormat(String format) {
this.format = format;
}
} 
扫一扫
265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
