Json

最新推荐文章于 2024-06-11 23:53:06 发布

Mephisto180502

最新推荐文章于 2024-06-11 23:53:06 发布

阅读量218

点赞数

分类专栏： Web

本文链接：https://blog.csdn.net/qq_33800083/article/details/89339624

版权

Web 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

JSON: 是JavaScript Object Notation(JavaScript 对象表示法)，它是一种数据交换格式。

JSON 是存储和交换文本信息的语法。类似 XML。

JSON 比 XML 更小、更快，更易解析。

JSON基础结构

因为JSON使用JavaScript语法，所以无需额外的软件就能处理JavaScript中的JSON。

JSON还规定了字符集必须是UTF-8 。为了统一解析，JSON的字符串规定必须用双引号""，Object的键也必须用双引号""。

在JSON中，一共就这么几种数据类型：

number：和JavaScript的number完全一致；
boolean：就是JavaScript的true或false；
string：就是JavaScript的string；
null：就是JavaScript的null；
array：就是JavaScript的Array表示方式——[]；
object：就是JavaScript的{ ... }表示方式。

把任何JavaScript对象变成JSON，就是把这个对象序列化成一个JSON格式的字符串，这样才能够通过网络传递给其他计算机。

如果我们收到一个JSON格式的字符串，只需要把它反序列化成一个JavaScript对象，就可以在JavaScript中直接使用这个对象了。

JSON对象结构

语法：var obj = {"键" : "值","键" : "值","键" : "值"}

说明：obj 指的是json对象，对象结构以 { 开头，到 } 结束。其中键名和值之间用冒号构成对，键值对用逗号分隔。

注意，这里的键名是字符串，但是值可以是数字、字符串、布尔值、数组、对象和null。

JSON数组结构

语法：var arr = [ {"键名" : "值","键名" : "值"}, {"键名" : "值","键名" : "值"} ]

说明：arr指的是json数组，数组结构是以 [ 开始，到 ] 结束。在JSON数组中，每一对 { } 相当于一个JSON对象。

特殊情况

1. JSON 不能存储 Date 对象。

① 如果要存储 Date 对象，需要将其转换为字符串。之后再将字符串转换为 Date 对象。

var text = '{ "name":"Runoob", "birthday":"2013-12-14"}';
var obj = JSON.parse(text);
obj.birthday = new Date(obj.birthday); 
$('#demo').text("姓名: " obj.name + "生日: " + obj.birthday);

② js将从后台得到的时间戳（毫秒数）转换为日期格式。

var date = new Date( data.time ) ; //括号里的data就是后端传回来的格式有问题的时间数据
dateFormat= date .toLocaleString(); //默认格式为" 年 / 月 / 日 上/ 下午 时:分:秒 "

如果希望转换为" 年-月-日时:分:秒 "的格式，可以自己定义一个方法。

function add0(m) {
    return m < 10 ? '0' + m : m;
}
function formatDate(timeStamp) {
    let time = new Date(timeStamp),
    y = time.getFullYear(),
    m = time.getMonth() + 1,
    d = time.getDate(),
    h = time.getHours(),
    mm = time.getMinutes(),
    s = time.getSeconds();
    return y + '-' + add0(m) + '-' + add0(d) + ' ' + add0(h) + ':' + add0(mm) + ':' + add0(s); 
    //顾名思义，将小于10的时间前面加个0，即9:5:43改成09:05:43
}
}

2. JSON 不允许包含函数，但你可以将函数作为字符串存储，之后再将字符串转换为函数。

var text = '{ "name":"Runoob", "alexa":"function () {return 10000;}", "site":"www.runoob.com"}';
var obj = JSON.parse(text);
obj.alexa = eval("(" + obj.alexa + ")");
document.getElementById("demo").innerHTML = obj.name + " Alexa 排名：" + obj.alexa();

JSON序列化与反序列化

JSON，大部分是用来处理JavaScript和Web服务端之间的数据交换，把后台Web服务端的数据传递到前台，然后使用JavaScript语法进行处理，例如Ajax等。

由于JSON语法是Javascript语法的子集，JavaScript函数 eval() 可用于将JSON文本转换为JavaScript对象。

前端中的JSON序列化

1. JavaScript对象序列化成JSON格式的字符串

var obj= {
    name: 'mephisto',
    age: 14,
    gender: true,
    height: 1.65,
    grade: null,
    'middle-school': '\"W3C\" Middle School',
    skills: ['JavaScript', 'Java', 'Python', 'Lisp']
};

① var str = obj.toJSONString();
② var str = JSON.stringify(obj);

要输出得好看一些，可以加上参数，按缩进输出：

JSON.stringify(mephisto, null, '  ');

{
  "name": "mephisto",
  "age": 14,
  "gender": true,
  "height": 1.65,
  "grade": null,
  "middle-school": "\"W3C\" Middle School",
  "skills": [
    "JavaScript",
    "Java",
    "Python",
    "Lisp"
  ]
}

第二个参数用于控制如何筛选对象的键值，如果我们只想输出指定的属性，可以传入Array;

JSON.stringify(mephisto, ['name', 'skills'], '  ');

{
  "name": "小明",
  "skills": [
    "JavaScript",
    "Java",
    "Python",
    "Lisp"
  ]
}

还可以传入一个函数，这样对象的每个键值对都会被函数先处理：

function convert(key, value) {
    if (typeof value === 'string') {
        return value.toUpperCase();
    }
    return value;
}

JSON.stringify(xiaoming, convert, '  ');

上面的代码把所有属性值都变成大写：

{
  "name": "mephisto",
  "age": 14,
  "gender": true,
  "height": 1.65,
  "grade": null,
  "middle-school": "\"W3C\" MIDDLE SCHOOL",
  "skills": [
    "JAVASCRIPT",
    "JAVA",
    "PYTHON",
    "LISP"
  ]
}

如果我们还想要精确控制如何序列化，可以给mephisto定义一个toJSON()的方法，直接返回JSON应该序列化的数据：

var xiaoming = {
    name: 'mephisto',
    age: 14,
    gender: true,
    height: 1.65,
    grade: null,
    'middle-school': '\"W3C\" Middle School',
    skills: ['JavaScript', 'Java', 'Python', 'Lisp'],
    toJSON: function () {
        return { // 只输出name和age，并且改变了key：
            'Name': this.name,
            'Age': this.age
        };
    }
};

JSON.stringify(xiaoming); // '{"Name":"mephisto","Age":14}'

2. JSON格式的字符串反序列化成一个JavaScript对象

  var str = '{ "name" : "logo" , "age" : 12}';
                           
① var obj = eval( "(" + str + ")" );    必须把文本包含在括号中，这样才能避免语法错误。
② var obj = JSON.parse(str);
③ var obj = str.parseJSON();    需要JSON.js文件

JSON.parse() 还可以接收一个函数，用来转换解析出的属性：

var obj = JSON.parse('{"name":"小明","age":14}', function (key, value) {
    if (key === 'name') {
        return value + '同学';
    }
    return value;
});
console.log(JSON.stringify(obj)); // {name: '小明同学', age: 14}

net.sf.json-lib 解析

Json-lib 需要的 jar 包：

commons-beanutils-1.8.3.jar
commons-collections-3.2.1.jar
commons-lang-2.6.jar
commons-logging-1.1.1.jar
ezmorph-1.0.6.jar
json-lib-2.4-jdk15.jar

依赖：

<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <!-- 下面两个必须要写，且jdk15不能写成别的 -->
    <version>2.4</version>    
    <classifier>jdk15</classifier>
</dependency>

序列化：

JavaBean →→→→ JSON格式字符串

Object obj = new Object();
JSONObject jsonObj = JSONObject.fromObject(obj);
String str = jsonObj.toString();

Java数组 / List集合 →→→→ JSON格式字符串

Item[] items = {item1,item2,item3};
List<Person> list = new ArrayList<Person>();
JSONArray jsonArr = JSONArray.fromObject(items);
JSONArray jsonArr = JSONArray.fromObject(list);
String str = jsonArr.toString();

Java的Map集合 →→→→ JSON格式字符串

Map<String,Item> map = new HashMap<String,Item>();
JSONObject jsonObject = JSONObject.fromMap(map); //方式一
JSONObject jsonObject = JSONObject.fromObject(map); //方式二
String str = jsonObject.toString();

反序列化：

JSON格式字符串 →→→→ JavaBean / Map

在将 Json 形式的字符串转换为 JavaBean 的时候需要注意 JavaBean 中必须有无参构造函数。
String jsonObject = "{'name':'李书豪','age':24}";
Person person = (Person) JSONObject.toBean(jsonObject, Person.class);
Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);

JSON格式字符串 →→→→ Java数组 / List集合

String jsonStr = " [ …… ] ";
JSONArray jsonArr = JSONArray.fromObject(jsonStr);
List<Person> person = (List<Person>) JSONArray.toCollection(jsonArr,Person.class);

org.json 解析

依赖：

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <!-- 不写下面的版本会报错 -->
    <version>20170516</version>
</dependency>

序列化：

JSONObject strJson = new JSONObject(jsonStr);    // 传入字符串  
JSONObject beanJson = new JSONObject(student);    // 传入Bean类型  
JSONObject mapJson = new JSONObject(map);    // 传入Map类型  

JSONArray strJson = new JSONArray(jsonStr);    // 传入字符串
JSONArray mapJson = new JSONArray(list);    // 传入Collection类型  
JSONArray arrayJson = new JSONArray(numlist);    // 传入Array类型

反序列化：

JSONObject jObject=jsonArray2.getJSONObject(user);
Student student=new Student(jObject.getInt("id"), jObject.getString("name"),jObject.getInt("age"));

JSONArray jsonArray = new JSONArray(json);  
for (int i = 0; i < jsonArray.length(); i++) {  
    jsonObject = jsonArray.getJSONObject(i);  
    String name = jsonObject.getString("name");  
    int age = jsonObject.getInt("age");  
   }

JSONObject 根据Key获取Value值

// 创建JSON解析对象
JSONObject obj = new JSONObject(jsonObj);
// obj.后面有各种数据类型,根据对象来选择使用的数据类型
String name = obj.getString("name");
// 同理如上，这里的age为Int类型，我们就用对应的类型进行解析
int age = obj.getInt("age");

JSONObject 添加JSON

//向json对象中添加JavaBean对象或者任意类型数据
JSONObject testObj2 = jsonObject.put("name", "fyj");

JSONArray 遍历

JSONArray jArray = new JSONArray(jsonArr);
for (int i = 0; i < jArray.length; i++) {
    String string = jArray.getString(i);
}

向JSONArray中添加JSON对象

JSONObject obj1 = new JSONObject(object1);
JSONObject obj2 = new JSONObject(object2);
jArray.add(obj1);
jArray.add(obj2);

Gson 解析

GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象，或者将一个Java转化为Json字符串。

主要特点：

快速、高效
代码量少、简洁
面向对象
数据传递和解析方便

Gson提供了fromJson() 和toJson() 两个直接用于解析和生成的方法，前者实现反序列化，后者实现了序列化。

依赖：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
</dependency>

基本类型的序列化

Gson gson = new Gson();
String jsonNumber = gson.toJson(100);       // 100
String jsonBoolean = gson.toJson(false);    // false
String jsonString = gson.toJson("String"); //"String"

Java Bean、List、Map序列化成 Json字符串

Gson gson = new Gson();
String str = gson.toJson(obj);

List<PersonJson> list = new ArrayList<>();
Map<String,PersonJson> map = new HashMap<>();
String str = gson.toJson(list)；
String str = gson.toJson(map)

基本类型的反序列化

Gson gson = new Gson();
int i = gson.fromJson("100", int.class); //100
double d = gson.fromJson("99.99", double.class);  //99.99
boolean b = gson.fromJson("true", boolean.class);     // true
String str = gson.fromJson("str", String.class);   // String

json字符串反序列化为JavaBean

Gson gson = new GsonBuilder().create();
PersonJson p = gson.fromJson(jsonStr,PersonJson.class);

json字符串反序列化为List集合

Gson gson = new GsonBuilder().create();
List<PersonJson> list = gson.fromJson(listJsonStr,new TypeToken<ArrayList<PersonJson>>(){}.getType());

Jackson 解析

Jackson是一个简单基于Java应用库，Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。Jackson所依赖的jar包较少，简单易用并且性能也要相对高些，并且Jackson社区相对比较活跃，更新速度也比较快。

主要特点：

容易使用 - jackson API提供了一个高层次外观，以简化常用的用例。
无需创建映射 - API提供了默认的映射大部分对象序列化。
性能高 - 快速，低内存占用，适合大型对象图表或系统。
干净的JSON - jackson创建一个干净和紧凑的JSON结果，这是让人很容易阅读。
不依赖 - 库不需要任何其他的库，除了JDK。
开源代码 - jackson是开源的，可以免费使用。

依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

创建实体类：

/**
 * @Description: JSON序列化和反序列化User类
 * 
 */
public class User {

    /**
     * JSON注解 Jackson提供了一系列注解，方便对JSON序列化和反序列化进行控制，下面介绍一些常用的注解。
     * 
     * @JsonIgnore 此注解用于属性上，作用是进行JSON操作时忽略该属性。
     * @JsonFormat 此注解用于属性上，作用是把Date类型直接转化为想要的格式，如@JsonFormat(pattern = "yyyy-MM-dd
     *             HH-mm-ss")。
     * @JsonProperty 此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，如把trueName属性序列化为name，@JsonProperty("name")。
     */

    @JsonIgnore
    private Integer id;
    @JsonProperty("name")
    private String trueName;
    private Integer age;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date birthday;
    private String email;
    。。。省略getset方法、toString()方法等

序列化：

User u1 = new User();
u1.setId(1);
u1.setTrueName("curry");
u1.setAge(30);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
u1.setBirthday(dateFormat.parse("1988-9-21"));
u1.setEmail("138@163.com");
        
/** 
 * ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。 
 * ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。 
 * writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。 
 * writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。 
 * writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。 
 * writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。 
 */
 ObjectMapper mapper = new ObjectMapper();

//User对象转Json,
String jsonValue = mapper.writeValueAsString(u1);
System.out.println(jsonValue);
//输出{"age":30,"birthday":"1988-09-20 16:00:00","email":"138@163.com","name":"curry"}

//List集合转Json
List<User> users = new ArrayList<>();
users.add(u1);
users.add(u2);
String jsonList = mapper.writeValueAsString(users);
System.out.println(jsonList);
//输出[{"age":30,"birthday":"1988-09-20 16:00:00","email":"138@163.com","name":"curry"},{"age":29,"birthday":"1989-09-20 16:00:00","email":"123@qq.com","name":"KD"}]

反序列化：

/** 
 * ObjectMapper支持从byte[]、File、InputStream、字符串等数据的JSON反序列化。 
 */  
String json = " {\"id\":3, \"name\":\"小明\", \"age\":18, \"birthday\":590774400000, \"email\":\"xiaomin@sina.com\"} ";  
ObjectMapper mapper2 = new ObjectMapper();
User user = mapper2.readValue(json, User.class);
System.out.println(user.toString());
//输出User [id=null, trueName=小明, age=18, birthday=Wed Sep 21 00:00:00 CST 1988, email=xiaomin@sina.com]

FastJson 解析

fastJson是由阿里巴巴开发的一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库。fastJson接口简单易用，已经被广泛使用在缓存序列化、协议交互、Web输出、Android客户端等多种应用场景。

主要特点：

快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）
强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）
零依赖（没有依赖其它任何类库除了JDK）

依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.37</version>
</dependency>

序列化：

序列化Java Bean

String objJson = JSON.toJSONString(Object object);

// 缺省情况下fastJSON不序列化值为Null的字段
User user = new User();
user.setTrueName("李四");
user.setAge(24);
String userJson = JSON.toJSONString(user);
System.out.println(userJson); //{"age":24,"trueName":"李四"}
user.setId(111);
userJson = JSON.toJSONString(user);
System.out.println(userJson); //{"age":24,"id":111,"trueName":"李四"}
user.setEmail("98@98");
//传入一个boolean值，可以输出格式化后的 JSON 字符串
userJson = JSON.toJSONString(user,true);
System.out.println(userJson);
{
	"age":24,
	"email":"98@98",
	"id":111,
	"trueName":"李四"
}

序列化list集合

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
         
Map<String, Object> map1 = new HashMap<String, Object>();
map1.put("key1", "One");
map1.put("key2", "Two");
         
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put("key1", "Three");
map2.put("key2", "Four");
         
list.add(map1);
list.add(map2);
String listJson = JSON.toJSONString(list);
//输出 [{"key1":"One","key2":"Two"},{"key3":"Three","key4":"Four"}]

序列化Map

Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "One");
map.put("key2", "Two");
String mapJson = JSON.toJSONString(map,true);

fastJson 的几个常用特性：

日期格式化

fastJson可以直接对日期类型格式化，在缺省的情况下，fastJson会将Date转成long。

String dateJson = JSON.toJSONString(new Date());
System.out.println(dateJson); //1401370199040

使用SerializerFeature特性格式化日期。

String dateJson = JSON.toJSONString(new Date(), SerializerFeature.WriteDateUseDateFormat);
System.out.println(dateJson); //"2014-05-29 21:36:24"

也可以指定输出日期格式。

String dateJson = JSON.toJSONStringWithDateFormat(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
System.out.println(dateJson); //"2014-05-29 21:47:00.154"

使用单引号

String listJson = JSON.toJSONString(list, SerializerFeature.UseSingleQuotes);
// 输出：[{'key1':'One','key2':'Two'},{'key3':'Three','key4':'Four'}]

格式化

String listJson = JSON.toJSONString(list, SerializerFeature.PrettyFormat);

输出null字段

String listJson = JSON.toJSONString(map, SerializerFeature.WriteMapNullValue);
// {"a":null,"b":1}

序列化时写入类型信息

User user = new User();
user.setAge(18);
user.setUserName("李四");
String listJson = JSON.toJSONString(user, SerializerFeature.WriteClassName);
// 输出结果：{"@type":"User","age":18,"userName":"李四"}
// 由于序列化带了类型信息，使得反序列化时能够自动进行类型识别。

将上面的例子反序列化
User user1 = (User) JSON.parse(listJson);
System.out.println(user1.getAge());
// 输出18
// 如果User序列化时没有加入类型信息（SerializerFeature.WriteClassName），按照上面的做法就会报错（java.lang.ClassCastException）。

反序列化：

对象反序列化

User user1 = JSON.parseObject(userJson, User.class);
System.out.println(user1.getTrueName());
System.out.println(user1);
// 李四
// User [id=111, trueName=李四, age=24, birthday=null, email=98@98]

集合反序列化

List<User> list1 = JSON.parseArray(listJson, User.class);

Map反序列化

Map<String, Object> map1 = JSON.parseObject(mapJson, new TypeReference<Map<String, Object>>(){});

Mephisto180502

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Json

JSON: 是JavaScriptObjectNotation(JavaScript 对象表示法)，它是一种数据交换格式。JSON 是存储和交换文本信息的语法。类似 XML。JSON 比 XML 更小、更快，更易解析。JSON基础结构因为JSON使用JavaScript语法，所以无需额外的软件就能处理JavaScript中的JSON。JSON还规定了字符集必须是U...
复制链接

扫一扫