Json的封装与解析

最新推荐文章于 2023-02-01 11:25:13 发布
最新推荐文章于 2023-02-01 11:25:13 发布
阅读量902 收藏 1
点赞数 1
分类专栏： 软件测试 文章标签： json java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44483977/article/details/125552453
版权

一、JSON简介

1、什么是json

  • 中文含义：Javascript对象表示法
  • 轻量级数据交换格式
  • 基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据

2、JSON的特点

  • 轻量级的文本数据交换格式
  • 具有自我描述性，更易理解
  • 采用完全独立于语言的文本格式：JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言
  • 是存储和交换文本信息的一种语法，它与XML具有相同的特性，是一种数据存储格式，却比 XML 更小、更快、 更易于人编写和阅读、更易于生成和解析

3、JSON与XML的相同与不同

（1）相似之处：

  • JSON 是纯文本
  • JSON 具有“自我描述性”（人类可读）
  • JSON 具有层级结构（值中存在值）
  • JSON 可通过 JavaScript 进行解析
  • JSON 数据可使用 AJAX 进行传输

（2）不同之处

  • 没有结束标签
  • 比XML更短
  • 读写速度更快
  • 能够使用内建的 JavaScript eval() 方法进行解析
  • 使用数组
  • 不使用保留字

二、JSON语法

  • JSON 语法是 JavaScript 对象表示法的子集：
    • 数据在键/值对中，键/值对可以嵌套
    • 数据由逗号分隔
    • 花括号{}保存对象，对象可以包含多个键/值对
    • 方括号[]保存数组，数组可以包含多个对象
  • 注意：
    • JSON不是JavaScript语句
    • 对象的末尾没有分号
    • 对象和数组的最后一个成员后面，不能加逗号

1、JSON的键/值对

  • JSON键/值对由键和值组成
    • 键必须是字符串
    • 值可以是字符串（string）、数值(number) 、对象（object）、数组（array）、true、false、 null
  • JSON键/值格式，先是键名，后面写一个冒号，然后是值，如下：
"github": "https://github.com/leiqikui"

2、JSON字符串

  • JSON 的字符串（string），是由双引号包围的任意数量Unicode字符的集合，使用反斜线转义
  • 由于JSON 字符串不能使用单引号，因此一个字符（character）就是一个单独的字符串（character string）

3、JSON数值

  • JSON 数值（number），支持整型、浮点型，浮点型也可以用指数表示
  • JSON不支持八进制和十六进制， 数值必须以十进制表示，且不能使用NaN和Infinity

4、JSON对象

  • JSON 对象是一个无序的key/value对的集合
  • 一个对象以 ‘{’ 开始，以 ‘}’ 结束
  • 每个key 和 value 中使用冒号分隔
  • 每个 key/value 对之间使用逗号分隔
  • JSON 对象语法：
    • 对象在大括号({})中书写
    • 对象可以包含多个 key/value（键/值）对
    • key是字符串，必须放在双引号里面。value 可以是合法的 JSON 数据类型（字符串, 数值, 对象, 数组, 布尔值或 null）
    • 一个 key/value 对内部，key 和 value使用冒号(:)分隔
    • key/value 对之间，使用逗号(,)分隔
    • 对象可以嵌套
      例如：
{
	"weibo": "https://weibo.com/leiqikui" ,
	"github": "https://github.com/leiqikui" ,
	"qq": {
		"number": "123456789",
		"email": "123456789@qq.com"
	}
}

（1）访问对象的值

  • 可以使用点号（.），或中括号（[]）来访问对象的值
  • 使用(.)访问对象时，直接使用对象的 key 来访问， key 无须放在双引号中
<script>
	var myObj, x;
	myObj = { "baidu": "https://www.baidu.com" };
	x = myObj.baidu;
	document.write(x);   //https://www.baidu.com
</script>
  • 使用中括号访问对象时，要把对象的 key 以字符串形式，放在中括号中。也就是说，key 要放在双引号中
<script>
	var myObj, x;
	myObj = { "baidu": "https://www.baidu.com" };
	x = myObj["baidu"];
	document.write(x);   //https://www.baidu.com
</script>
  • JSON 对象中，可以包含另外一个 JSON 对象。如，以下代码在 myObj 对象中，嵌套了一个 qq 对象
{
	"baidu": "https://www.baidu.com" ,
	"google": "https://chrome.google.com/webstore?hl=zh-CN" ,
	"qq": {
		"number": "123456789",
		"email": "123456789@qq.com"
	}
}
document.write(myObj.qq.email);
document.write(myObj["qq"]["email"]);
document.write(myObj.qq["email"]);
//123456789@qq.com

（2）修改对象的值

  • 可以使用点号(.)来修改 JSON 对象的值
	myObj.qq.number= "987654321"
  • 可以使用中括号([])来修改 JSON 对象的值
   myObj["qq"]["number"]= "987654321"

（3）删除对象属性

  • 你可以使用 delete 关键字来删除 JSON 对象的属性
	delete myObject.baidu
	delete myObject["baidu"]

5、JSON数组

  • 数组是值（value）的有序集合
  • 一个数组以“[”（左中括号）开始，“]”（右中括号）结束
  • 值之间使用“,”（逗号）分隔
  • JSON数组格式：
    • 数组在中括号中书写
    • 数组的值必须是合法的 JSON 数据类型（字符串, 数值, 对象, 数组, 布尔值或 null），也可以是 JavaScript 的表达式，包括函数、日期、undefined
  • 对象的属性值也可以是一个JSON数组，例如：
{
	"name": "网站",
	"num": 3,
	"sites": [ "Google.com", "Taobao.com", "weibo.com" ]
}
  • 使用索引值来访问数组的元素：
x = myObj.sites[2]; // "weibo.com"
  • JSON数组的元素也可以是对象
{
	"employees": [
		{ "firstName":"John" , "lastName":"Doe" },
		{ "firstName":"Anna" , "lastName":"Smith" },
		{ "firstName":"Peter" , "lastName":"Jones" }
	]
}

（1）遍历数组

  • 使用for-in循环遍历数组
	for(i in myObiect.sites){
		x += myObject.sites[i] + "<br>";
	}
  • 直接用for循环遍历
	for(i = 0 ; i < myObject.sites.length ; i++){
		x += myObject.sites[i] + "<br>";
	}
  • JSON对象中的数组也可以包含另外一个数组，或者另外一个JSON对象
myObj = {
	"name":"网站",
	"num":3,
	"sites": [
		{ "name":"Google", "info":[ "Android", "Google 搜索", "Google 翻译" ] },
		{ "name":"abc", "info":[ "教程", "工具", "微信" ] },
		{ "name":"Taobao", "info":[ "淘宝", "网购" ] }
	]
}

for (i in myObj.sites) {
	x += "<h1>" + myObj.sites[i].name + "</h1>";
	for (j in myObj.sites[i].info) {
		x += myObj.sites[i].info[j] + "<br>";
	}
}

（2）修改数组

  • 可以使用索引值来修改数组值
	myObject.sites[1] = "Github";

（3）删除数组元素

	delete myObj.sites[1];

6、JSON 布尔值

  • JSON 布尔值可以是 true 或者 false，如：
{"flag":true}

7、JSON null

  • JSON 可以设置 null 值，如：
{"weibo":null}

8、JSON文件

  • JSON 文件的文件类型是 “.json”
  • JSON 文本的 MIME 类型是 “application/json”

三、JSON和JS对象互转

  • JSON本质：字符串

1、JSON.parse()

  • 用于把JSON字符串转换为原生的JavaScript值或对象、
	JSON.parse('1') //1
	JSON.parse('{}')  //{}
	JSON.parse('true') // true
	JSON.parse('"foo"') // "foo"
	JSON.parse('[1, 5, "false"]') // [1, 5, "false"]
	JSON.parse('null') // null
	
	var o = JSON.parse('{"name": "张三"}');
	o.name // 张三
  • 如果传递给JSON.parse()方法的字符串不是有效的JSON格式，JSON.parse()方法将报错
JSON.parse("'String'")
//Uncaught SyntaxError: Unexpected token u in JSON at position 0(…)
JSON.parse("undefined")
//Uncaught SyntaxError: Unexpected token u in JSON at position 0(…)
  • 除了直接进行字符串转换之外，JSON.parse()方法也可以接收一个函数参数，该函数被称为还原函数。
    • 如果提供还原函数，则对象的每个成员都会调用这个函数
    • 还原函数接收两个参数，一个键和一个值，并返回一个值。如果还原函数返回undefined，则表示要从结果中删除相应的键；如果返回其他值，则将该值插入到结果中
var o = JSON.parse('{"a":1,"b":2}', function(key, value) {
	if (key === ''){
		return value;
	}
	if (key === 'a') {
		return value + 10;
	}
});
o.a // 11
o.b // undefined
  • JSON 不能存储 Date 对象
    • 如果需要存储 Date 对象，需要将其转换为字符串，之后再将字符串转换为 Date 对象
    • 在将日期字符串转换为Date对象时，经常要用到还原函数
var book = {
	"title": "javascript",
	"date": new Date(2022,7,1)
}
//JSON对象转换为json字符串
var jsonStr = JSON.stringify(book);
console.log(jsonStr);//'{"title":"javascript","date":"202-07-01T13:00:00.000Z"}'

//字符串转换成json对象
var bookCopy = JSON.parse(jsonStr,function(key,value){
	if(key == 'date'){
		return new Date(value);
	}
	return value;
})
console.log(bookCopy.date.getFullYear()); //2022

说明 JSON.parse() 与 eval()：

  • eval()函数的功能类似于JSON.parse()方法，也可以将json字符串转换为json对象，例如：
	eval('(' + '{"a":1}' + ')').a;  //1
	JSON.parse('{"a":1}').a; //1
  • eval()函数可以执行不符合JSON格式的代码，例如：
	eval('(' + '{"a":alert(1)}'+')').a; //弹出1
	JSON.parse('{"a":alert(1)}').a; //报错
  • 由于 eval() 函数会为恶意代码提供可乘之机，因此应当尽量少使用 eval() 函数，而是使用更安全的 JSON.parse()方法

2、JSON.stringify()

  • JSON.stringify()方法用于把JavaScript值（对象或者数组）序列化为JSON字符串，并返回序列化后的JSON字符串
  • 调用格式：
	JSON.stringify(value[,replacer[,space]])
  • 参数：
    • value：必需。将要序列化为json字符串的值
    • replacer：可选。用于替换结果的函数、或仅包括指定的属性数组
    • space：可选。用于文本添加缩进、空格和换行符

（1）序列化规则

  • 本质：按照JSON的语法规则，把JavaScript值（对象或数组），转换为JSON字符串，以方便存储和数据交换
1）数值、布尔值、字符串的包装对象，会转换成对应的原始值
	JSON.stringify(1) //"1"
	JSON.stringify(false) //"false"
	JSON.stringify('abc') //""abc""
	JSON.stringify([1,"false",false]) //'[1,"false",false]'
2）键和值都被序列化，若键名没有引号，会自动为他添加引号
	JSON.stringify({x: 5, y: 6}); // "{"x":5,"y":6}"
	JSON.stringify({name: "张三"}) // '{"name":"张三"}'
3）数组，会转换成数组格式
	JSON.stringify([]) // "[]"
	JSON.stringify([1, "false", false]) // '[1,"false",false]'
4）对象，会转换成对象格式
	JSON.stringify({}) // "{}"
	JSON.stringify({x: 5, y: 6}); // "{"x":5,"y":6}"
5）正则表达式和数学对象，转换成空对象的字符串形式
	JSON.stringify(/foo/) // "{}"
	JSON.stringify(Math) // "{}"
6）日期对象和包装对象，转换成字符串
	JSON.stringify(new Boolean(true)) //"true"	
	JSON.stringify(new String('123')) //""123""	
	JSON.stringify(new Number(1)) //"1"	
	JSON.stringify(new Date()) //""2022-07-01T13:26:38.294Z""
7） 如果非数组对象的成员是undefined、或任意的函数、或 symbol 值，这个成员会被省略。如果数组对象的成员是undefined、或任意的函数、或 symbol 值，则这些值被转成null
JSON.stringify({
	a: function(){},
	b: undefined,
	c: [ function(){}, undefined ]
});
// "{"c":[null,null]}"
8）不可枚举的属性，会被忽略
var obj = {};
Object.defineProperties(obj, {
	'foo': { value: 1, enumerable: true },
	'bar': { alue: 2, enumerable: false }
});
JSON.stringify(obj); // "{"foo":1}"
9）所有以 symbol 为键的属性都会被完全忽略掉，即便 replacer 参数中强制指定包含了它们
JSON.stringify(
	{[Symbol.for("foo")]: "foo"},
	function (k, v) {
		if (typeof k === "symbol"){
			return "a symbol";
		}
	}
);
// undefined

（2）replacer参数

  • replacer参数可以是一个函数或者一个数组
1）函数
  • 如果replacer参数是一个函数，则对象的每个成员都会调用这个函数。该函数接收两个参数，一个是键（key），一个是值（value），执行序列化时，键和值都会被序列化
function dobule(key, value){
	if (typeof value === "number") {
		value = 2 * value;
	}
	return value;
}
console.log(JSON.stringify({a:1,b:2}, dobule())); // "{"a":2,"b":4}"
  • 如果replacer函数返回的是一个对象，则该对象被递归地序列化成JSON字符串，并且允许键为空
    • 下述代码，对象 jsonObj 一共会被 function函数处理三次。第一次键名为空，键值是整个对象 jsonObj；第二次键名为 a，键值是 {b:1}；第三次键名为 b，键值为 1
var jsonObj = {a: {b: 1}};
JSON.stringify(jsonObj, function(key, value) {
	console.log("["+ key +"]:" + value);
	return value;
});
//[]:[object Object]
//[a]:[object Object]
//[b]:1
  • 如果replacer函数返回了undefined或没有返回值，那么相应的属性会被忽略，这种情况将不会被序列化成JSON字符串
JSON.stringify({ a: "abc", b: 123 }, function (key, value) {
	if (typeof(value) === "string") {
		return undefined;
	}
	return value;
})
//'{"b": 123}'
2）数组
  • 如果replacer是一个数组，数组的值代表将被序列化成JSON字符串的属性名。执行序列化时，则只对数组中所列举的键执行序列化操作，就相当于实现一个过滤器的功能
var jsonObj = {
	"title":"javascript",
	"group":{
		"a":1,
		"b":2
	}
};
console.log(JSON.stringify(jsonObj,["group","b"]))  //{"group":{"b":2}}


//特别说明的是，过滤器功能只适用于对象，对数组无效
var jsonObj = [1,2];
console.log(JSON.stringify(jsonObj,["0"])); // "[1,2]"

3、space参数

  • 默认情况下，JSON.stringify() 输出的JSON字符串不包括任何空格字符或缩进
var jsonObj = {
	"title":"javascript",
	"group":{
		"name":"jia",
		"tel":12345
	}
};
JSON.stringify(jsonObj);
//{"title":"javascript","group":{"name":"jia","tel":12345}}
  • 通过指定space参数，可以在JSON字符串中添加空格或字符串，用于增加返回的JSON字符串的可读性
  • space参数的值可以是数值或字符串
1）数值
  • 如果space参数的值是数值，则序列化的字符串中，每一级别会比上一级别缩进指定数目的空格（不超过10个空格）
console.log(JSON.stringify({p1:1,p2:2},null,2));
//输出结果
{
	"p1": 1,
	"p2": 2
}
2）字符串
  • 如果space参数的值是字符串（字符串不超过10个字符），则序列化的字符串中，每一级别会比上一级别的缩进，使用该字符串填充
console.log(JSON.stringify({p1:1,p2:2},null,'|-'));
//输出结果
{
|-"p1": 1,
|-"p2": 2
}

注意

  • 在序列化一个对象时，如果该对象拥有 toJSON() 方法，那么该 toJSON() 方法就会覆盖该对象默认的序列化行为: 被序列化的不是那个原始对象，而是调用 toJSON() 方法后返回的那个对象
var obj = {
	foo: 'foo',
	toJSON: function () {
		return 'bar';
	}
};
JSON.stringify(obj); // '"bar"'
JSON.stringify({x: obj}); // '{"x":"bar"}'
  • 如果 toJSON() 方法返回 undefined，此时如果包含它的对象嵌入在另一个对象中，会导致该对象的值变成 null。而如果包含它的对象是顶级对象，结果就是 undefined
  • Date 对象拥有自己的 toJSON() 方法，它会自动将 Date 对象转换成日期字符串
JSON.stringify(new Date("2022-07-01"))
// "2022-07-01T00:00:00.000Z"

四、四种JSON解析方式

JSON操作涉及到的类：

public class Student {

    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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 Student(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}


public class Grade {

    private int id;
    private String name;
    private ArrayList<Student> stus;
    public Grade(int id, String name, ArrayList<Student> stus) {
        super();
        this.id = id;
        this.name = name;
        this.stus = stus;
    }
    public Grade() {
        super();
    }
    @Override
    public String toString() {
        return "Grade [id=" + id + ", name=" + name + ", stus=" + stus + "]";
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public ArrayList<Student> getStus() {
        return stus;
    }
    public void setStus(ArrayList<Student> stus) {
        this.stus = stus;
    }

}

1、JSON官方解析

  • 具有通用性，但小麻烦
public class JSONTest{
	//解析JSON
	@Test
	public void test1() throws JSONException{
		//（1）对象嵌套数组嵌套对象
		String json1 = "{'id':1,'name':'JAVAEE','stus':[{'id':101,'name':'张三','age':16}]}";
		//（2）数组
		String json2 = "['北京','天津','成都']";
		//1、对（1）进行解析
		//解析第一层————对象
		//创建JSONObject 对象
		JSONObject jObject1 = new JSONObject(json1); 
		//创建Grade对象
		Grade grade = new Grade(); 
		 //这里的属性值可以从JSONObjec对象中根据key值取出响应的value值
		grade.setId(jObject1.getInt("id"));
		grade.setName(jObject1.getString("name"));
		//用于存储学生对象的集合
		ArrayList<Student> stus = new ArrayList<>(); 
		grade.setStus(stus);
		//解析第二层————数组
		 //这里的getJSONArray("key") 是从JSONObject对象中取出来了stus数组部分的value值
		JSONArray jsonArray2 = jObject1.getJSONArray("stus");
		//遍历数组获取元素————对象
		for(Int i = 0 ; i < jsonArray2.length() ; i++){
			//解析第三层————对象
			
			//从取出的数组对象i中取出对应的value值
			JSONObject jObject3 = jsonArray2.getJSONObject(i);
			Student student = new Student(jObject3.getInt("id"),jObject3.getString("name"),jObject3.getInt("age"));
			grade.getStus().add(student);
		}
		System.out.println(grade);
		  //获取当前对象的所有属性的迭代器对象
//      Iterator<String> iterator=jObject1.keys();
//      while (iterator.hasNext()) {
//          String key = iterator.next();
//          System.out.println("属性："+key);
//      }
		
		//2、对（2）进行解析
		//获取数组对象
		JSONArray jArray = new JSONArray(json2);
		ArrayList<String> list = new ArrayList<>();
		//遍历获取元素
		for(int i = 0 ; i < jArray.length() ; i++){
			//jArray.optString(i);//等价与getXXX
			list.add(jArray.getString(i));
		}
		System.out.println("解析结果：" + list);
	}
	
	//生成JSON
	@Test
	public void test2() throws JSONException{
		JSONObject jo1 = new JSONObject();
		jo1.put("id",1001);
		jo1.put("name","李四");
		jo1.put("age",20);
		
		JSONObject jo2 = new JSONObject();
		jo2.put("id",1002);
		jo2.put("name","王五");
		jo2.put("age",19);
		
		JSONArray ja2 = new JSONArray();
		ja2.put(jo1);
		ja2.put(jo2);
		JSONObject jo3 = new JSONObject();
		jo3.put("id",11);
		jo3.put("name","JAVAEE");
		jo3.put("stus",ja2);
		
		String json = jo3.toString();
		System.out.println(json);
	}
}

2、GSON 谷歌解析

public class GSONTest{
	//解析
	@Test
	public void test1(){
		//（1）对象嵌套数组嵌套对象
		String json1 = "{'id':1,'name':'JAVAEE','stus':[{'id':101,'name':'张三','age':16}]}";
		//（2）数组
		String json2 = "['北京','天津','成都']";

		Gson gson = new Gson();
		//1、
		//解析对象：第一个参数：待解析的字符串
		//         第二个参数：结果数据类型的CLass对象
		Grade grade = gson.fromJson(json1,Grade.class); //fromJson()方法实现从Json相关对象到Java实体的方法
		System.out.println(grade);

		//2、
		//解析数组要用Type
		ArrayList<String> list = gson.fromJson(json2,new TypeToken<ArrayList<String>>(){}.getType());
		System.out.println(list);
	}

	//生成JSON
	@Test
	public void test2(){
		ArrayList<Student> list = new ArrayList<>();
		for(int i = 1 ; i < 3 ; i++){
			list.add(new Student(101 + i) , "小号" , 20 + i);
		}
		Grade grade = new Grade(100001,"lisa",list);
		Gson gson = new Gson();
		//将对象转换成JSON格式
		String json = gson.toJson(grade);
		System.ou.println(json);
	}
}

3、FastJSON解析

  • 效率最高
public class FASTJson(){
	//解析
	@Test
	public void test1(){
		//（1）对象嵌套数组嵌套对象
		String json1 = "{'id':1,'name':'JAVAEE','stus':[{'id':101,'name':'张三','age':16}]}";
		//（2）数组
		String json2 = "['北京','天津','成都']";

		//1、
		//静态方法
		//将Json字符串转换为指定的对象
		Grade grade = JSON.parseObject(json1,Grade.class);
		System.out.println(grade);
		//2、
		// json解析成数组
		List<String> list = JSON.parseArray(json2,String.class);
		System.out.println(list);
	}
	//生成
	@Test
	public void test2(){
		 // 对象转换成json
		 //创建集合，集合名称为list，里面装的都是Student类型
		ArrayList<Student> list = new ArrayList<>();
		for(int i = 1 ; i < 3 ; i++){
			//向集合添加数据
			list.add(new Student(101 + i , "码字" , 20 + i));
		}
		Grade grade = new Grade(100001 , "张三" , list);
		//对象转换为json字符串
		String json = JSON.toJSONString(grade);
		System.out.println(json);
	}
}

4、jackSon解析JSON

  • SpringMVC就是用这个
public class JackSonTest{
	//解析
	@Test
	public void test1() throws Exception{
		// 对象嵌套数组嵌套对象
        String json1 = "{\"id\":1,\"name\":\"JAVAEE-1703\",\"stus\":[{\"id\":101,\"name\":\"刘一\",\"age\":16}]}";
        // 数组
        String json2 = "[\"北京\",\"天津\",\"成都\"]";
		//1、
		//创建ObjectMapper对象
		ObjectMapper mapper = new ObjectMapper();
		//将字符串转换为对象
		Grade grade = mapper.readValue(json1,Grade.class);
		System.out.println(grade);
		//2、 
		// 通过TypeReference将List<String>中泛型映射成List<ArrayList<String>>类型
		ArrayList<String> list = mapper.readValue(json2,new TypeReference<ArrayList<String>>(){
		});
		System.out.println(list);
	}
	
	//生成
	@Test
	public void test2() throws JsonProcessingException{
		ArrayList<Student> list = new ArrayList<>();
		for(int i = 1 ; i < 3 ; i++){
			list.add(new Student(101 + i , "码字" , 20 + i));
		}
		Grade grade = new Grade(100001 , "张三" , list);
		ObjectMapper mapper = new ObjectMapper();
		//将对象转换为JSON格式字符串
		String json = mapper.writeValueAsString(grade);
		System.out.println(json);
	}
}
java中json的封装和解析
08-29
在java中使用json封装数据和解析json数据的DEMO.
Json的封装与解析demo
01-26
本篇主要探讨JSON的封装与解析，帮助你理解并掌握这一关键技能。 一、JSON的结构与语法 1. 对象：JSON对象由大括号 `{}` 包裹，其中存储键值对，键用双引号 "" 括起，冒号 `:` 分隔键和值，各个键值对之间用逗号 `,...
json数据的封装
qq_39513601的博客
04-12 349
package com.ai.kfk.dao; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.json.JSONException; import org.json.JSONObject; public class Te...
JSON封装和解析（通过GSON）
5ingwings(SiHao)的博客
11-16 3105
JSON解析（通过GSON） 在app的build.gradle中 加入 // 添加GSON依赖 compile 'com.google.code.gson:gson:2.8.2' 版本可以在maven库 http://mvnrepository.com/artifact/com.squareup.retrofit2/retrofit 输入gson查看 1 创建一
JSON 简单封装
专栏
08-25 188
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 net.sf.json.JSONArray; imp...
json数据的封装与解析
lengjinghk的博客
09-11 9976
发送给前端的数据封装成json格式，然后前段进行解析。 前端核心代码: function ask(){ //1创建ajax对象 var xhr = null; if(window.XMLHttpRequest){//高版本 xhr = new XMLHttpRequest(); }else{//低版本 xhr = new ActiveXObject
C#中Json封装与解析的实践示例
- 理解和应用JSON封装与解析技术是构建RESTful API的基石。 - 在Web开发中，几乎所有的AJAX调用都涉及JSON数据的发送和接收。 - 在桌面应用中，读写配置文件、读取数据接口等也会使用到JSON数据格式。 5. 代码...
掌握JSON封装与解析的高效方法
- JSON封装与解析在前端与后端交互时应用非常广泛。例如，前后端可以通过HTTP请求发送JSON数据，后端返回的数据（如API响应）通常也是JSON格式，前端接收并解析这些数据以展示在页面上。 7. 安全性考虑： - 在...
C语言实现JSON封装与解析教程
在C语言中实现JSON封装和解析的应用场景非常多，尤其在嵌入式开发、操作系统内核开发、底层网络通信等领域，C语言依然是主流。例如，在开发嵌入式设备与云平台通信的应用时，设备需要发送遥测数据到云端，或者从云端...
QT纯C++实现JSON的封装、解析、修改、删除！
04-08
本文将详细介绍如何在QT框架下，利用纯C++实现JSON的封装、解析、修改和删除。 首先，QT库提供了QJson模块，它包含了QJsonDocument、QJsonObject、QJsonArray、QJsonValue和QJsonParseError等类，这些类为我们处理...
json封装解析cjson
04-15
json的创建和是解析，是c语言的开源代码（cJSON），存储学习用的。关于cJSON网上资料太多，去下载还不用积分……
JavaScript的json封装
06-16
因项目需求，自己拼接麻烦，所以将javascript拼接json封装成和java类似的操作，直接put() 与 get() 就可以使用，支持json数组，使用的时候只需要 创建对象 并赋值 然后调用内部参数即可，源码中有示例。因为删除操作几乎用不到，所以仅仅写了json对象的，没有弄json数组的。仅仅是提供一个较好的解决办法，要是有更好的请留言。如发现什么不对的请留言我会改正。
JSON的封装和解析
08-04
利用JSON的开源库，对数据包进行JSON组装，使其适合Socket的发送，最后再次逆向解析
在JAVA中封装JSON数据
04-09
NULL 博文链接：https://hzywy.iteye.com/blog/1618266
json数据封装与解析
hancongjuan2010的博客
05-26 181
/** * @param args */ public static void main(String[] args) { //testToObject();   //testToArray();   String2Array();   //String2Object(); }   /** * String字符串转换中为JSONObject */ public s...
Json数据封装和解析
yl_99的专栏
09-13 3341
添加dll引用（右键项目--添加引用--.net--选择） C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\v3.0\System.Runtime.Serialization.dll C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\
JSON封装数据和解析数据
螺旋翻转大大雄
02-01 888
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，它基于JavaScript的一个子集，易于人的编写和阅读，也易于机器解析。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。
JSON数据的封装
qq_44831406的博客
04-08 962
JSON数据的封装 前言： 前后端分离已成为互联网项目开发的业界标准使用方式，采用前后端分别部署的方式,前端服务器(Nginx)部署前端页面,后端服务器部署业务逻辑组件,这样做的好处是可以分别搭建服务集群(可以采用分布式架构),以便于提升系统的并发处理能力，并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务（多种客户端，例如：浏览器，车载终端，安卓，IOS等等）打下坚实的...
【json】json与对象之间的封装和解析
qq_36807551的博客
12-27 531
//创建json数组，可以理解成数组 JSONArray jsonArray = new JSONArray(); for(Map.Entry&lt;Integer, Score&gt; mapentry:map.entrySet()){ subject.setScore(Double.valueOf(mapentry.getValue().getScore())); subj...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值