JSON基础了解

 

JSON：JavaScript 对象表示法（JavaScript Object Notation）。

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

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

 

每一章中用到的实例

{

"employees": [
{ "firstName":"Bill" , "lastName":"Gates" },
{ "firstName":"George" , "lastName":"Bush" },
{ "firstName":"Thomas" , "lastName":"Carter" }
]
}

这个 employee 对象是包含 3 个员工记录（对象）的数组。

 

什么是 JSON ？

  • JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
  • JSON 是轻量级的文本数据交换格式
  • JSON 独立于语言 *
  • JSON 具有自我描述性，更易理解

* JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。

 

JSON – 转换为 JavaScript 对象

JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。

由于这种相似性，无需解析器，JavaScript 程序能够使用内建的 eval() 函数，用 JSON 数据来生成原生的 JavaScript 对象。

亲自试一试 – 实例

通过我们的编辑器，您可以在线编辑 JavaScript 代码，然后通过点击一个按钮来查看结果：

<html>

<body>
<h2>在 JavaScript 中创建 JSON 对象</h2><p>
Name: <span id="jname"></span><br />
Age: <span id="jage"></span><br />
Address: <span id="jstreet"></span><br />
Phone: <span id="jphone"></span><br />
</p><script type="text/javascript">
var JSONObject= {
"name":"Bill Gates",
"street":"Fifth Avenue New York 666",
"age":56,
"phone":"555 1234567"};
document.getElementById("jname").innerHTML=JSONObject.name
document.getElementById("jage").innerHTML=JSONObject.age
document.getElementById("jstreet").innerHTML=JSONObject.street
document.getElementById("jphone").innerHTML=JSONObject.phone
</script></body>
</html>

亲自试一试

类似 XML

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

相比 XML 的不同之处

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

为什么使用 JSON？

对于 AJAX 应用程序来说，JSON 比 XML 更快更易使用：

使用 XML

  • 读取 XML 文档
  • 使用 XML DOM 来循环遍历文档
  • 读取值并存储在变量中

使用 JSON

  • 读取 JSON 字符串
  • 用 eval() 处理 JSON 字符串

JSON 语法是 JavaScript 语法的子集。

JSON 语法规则

JSON 语法是 JavaScript 对象表示法语法的子集。

  • 数据在名称/值对中
  • 数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组

JSON 名称/值对

JSON 数据的书写格式是：名称/值对。

名称/值对包括字段名称（在双引号中），后面写一个冒号，然后是值：

"firstName" : "John"

这很容易理解，等价于这条 JavaScript 语句：

firstName = "John"

JSON 值

JSON 值可以是：

  • 数字（整数或浮点数）
  • 字符串（在双引号中）
  • 逻辑值（true 或 false）
  • 数组（在方括号中）
  • 对象（在花括号中）
  • null

JSON 对象

JSON 对象在花括号中书写：

对象可以包含多个名称/值对：

{ "firstName":"John" , "lastName":"Doe" }

这一点也容易理解，与这条 JavaScript 语句等价：

firstName = "John"

lastName = "Doe"

JSON 数组

JSON 数组在方括号中书写：

数组可包含多个对象：

{

"employees": [
{ "firstName":"John" , "lastName":"Doe" },
{ "firstName":"Anna" , "lastName":"Smith" },
{ "firstName":"Peter" , "lastName":"Jones" }
]
}

在上面的例子中，对象 "employees" 是包含三个对象的数组。每个对象代表一条关于某人（有姓和名）的记录。

JSON 使用 JavaScript 语法

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

通过 JavaScript，您可以创建一个对象数组，并像这样进行赋值：

例子

var employees = [

{ "firstName":"Bill" , "lastName":"Gates" },
{ "firstName":"George" , "lastName":"Bush" },
{ "firstName":"Thomas" , "lastName": "Carter" }
];

可以像这样访问 JavaScript 对象数组中的第一项：

employees[0].lastName;

返回的内容是：

Gates

可以像这样修改数据：

employees[0].lastName = "Jobs";

亲自试一试

在下面的章节，您将学到如何把 JSON 文本转换为 JavaScript 对象。

JSON 文件

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

 

把 JSON 文本转换为 JavaScript 对象

JSON 最常见的用法之一，是从 web 服务器上读取 JSON 数据（作为文件或作为 HttpRequest），将 JSON 数据转换为 JavaScript 对象，然后在网页中使用该数据。

为了更简单地为您讲解，我们使用字符串作为输入进行演示（而不是文件）。

JSON 实例 – 来自字符串的对象

创建包含 JSON 语法的 JavaScript 字符串：

var txt = '{ "employees" : [' +

'{ "firstName":"Bill" , "lastName":"Gates" },' +
'{ "firstName":"George" , "lastName":"Bush" },' +
'{ "firstName":"Thomas" , "lastName":"Carter" } ]}';

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

eval() 函数使用的是 JavaScript 编译器，可解析 JSON 文本，然后生成 JavaScript 对象。必须把文本包围在括号中，这样才能避免语法错误：

var obj = eval ("(" + txt + ")");

在网页中使用 JavaScript 对象：

例子

<p>

First Name: <span id="fname"></span><br />
Last Name: <span id="lname"></span><br />
</p><script type="text/javascript">
document.getElementById("fname").innerHTML = obj.employees[1].firstName
document.getElementById("lname").innerHTML = obj.employees[1].lastName
</script>

亲自试一试

JSON 解析器

提示：eval() 函数可编译并执行任何 JavaScript 代码。这隐藏了一个潜在的安全问题。

使用 JSON 解析器将 JSON 转换为 JavaScript 对象是更安全的做法。JSON 解析器只能识别 JSON 文本，而不会编译脚本。

在浏览器中，这提供了原生的 JSON 支持，而且 JSON 解析器的速度更快。

较新的浏览器和最新的 ECMAScript (JavaScript) 标准中均包含了原生的对 JSON 的支持。

Web 浏览器支持

Web 软件支持
  • Firefox (Mozilla) 3.5
  • Internet Explorer 8
  • Chrome
  • Opera 10
  • Safari 4
  • jQuery
  • Yahoo UI
  • Prototype
  • Dojo
  • ECMAScript 1.5

亲自试一试

对于较老的浏览器，可使用 JavaScript 库： https://github.com/douglascrockford/JSON-js

JSON 格式最初是由 Douglas Crockford 制定的。

 

jquery解析JSON数据的方法以及字符串转换成json的3种方法

用jquery解析JSON数据的方法,作为jquery异步请求的传输对象，jquery请求后返回的结果是 json对象,这里考虑的都是服务器返回JSON形式的字符串的形式，对于利用JSONObject等插件封装的JSON对象，与此亦是大同小异，这里不再做说明。 
这里首先给出JSON字符串集，字符串集如下： 
代码如下: 
var data=" 
{ 
root: 
[ 
{name:'1',value:'0'}, 
{name:'6101',value:'北京市'}, 
{name:'6102',value:'天津市'}, 
{name:'6103',value:'上海市'}, 
{name:'6104',value:'重庆市'}, 
{name:'6105',value:'渭南市'}, 
{name:'6106',value:'延安市'}, 
{name:'6107',value:'汉中市'}, 
{name:'6108',value:'榆林市'}, 
{name:'6109',value:'安康市'}, 
{name:'6110',value:'商洛市'} 
] 
}"; 
这里以jquery异步获取的数据类型——json对象和字符串为依据，分别介绍两种方式获取到的结果处理方式。 
1.对于服务器返回的JSON字符串，如果jquery异步请求没做类型说明，或者以字符串方式接受，那么需要做一次对象化处理，方式不是太麻烦，就是将该字符串放于eval()中执行一次。这种方式也适合以普通javascipt方式获取json对象，以下举例说明： 
var dataObj=eval("("+data+")");//转换为json对象 
alert(dataObj.root.length);//输出root的子对象数量 
$.each(dataObj.root,fucntion(idx,item){ 
if(idx==0){ 
return true; 
} 
//输出每个root子对象的名称和值 
alert("name:"+item.name+",value:"+item.value); 
}) 
注：对于一般的js生成json对象，只需要将$.each()方法替换为for语句即可，其他不变。 
2.对于服务器返回的JSON字符串，如果jquery异步请求将type（一般为这个配置属性）设为“json”，或者利用$.getJSON()方法获得服务器返回，那么就不需要eval（）方法了，因为这时候得到的结果已经是json对象了，只需直接调用该对象即可，这里以$.getJSON方法为例说明数据处理方法： 
$.getJSON("http://www.phpzixue.cn/",{param:"gaoyusi"},function(data){ 
//此处返回的data已经是json对象 
//以下其他操作同第一种情况 
$.each(data.root,function(idx,item){ 
if(idx==0){ 
return true;//同countinue，返回false同break 
} 
alert("name:"+item.name+",value:"+item.value); 
}); 
}); 
这里特别需要注意的是方式1中的eval()方法是动态执行其中字符串（可能是js脚本）的，这样很容易会造成系统的安全问题。所以可以采用一些规避了 eval()的第三方客户端脚本库，比如JSON in JavaScript就提供了一个不超过3k的脚本库。 
本文来自: IT知道网(http://www.itwis.com) 详细出处参考：http://www.itwis.com/html/programme/javascript/20090905/6081.html 
=================字符串转换成json的三种方式======================= 
第一种：eval方式解析 

Js代码  json数据解析与JAVA对象转换以及在JQUERY中的使用-编程知识网

  1. function strToJson(str){    
  2.      var json = eval('(' + str + ')');    
  3.      return json;    
  4. }   

第二种：new Function形式 

Js代码  json数据解析与JAVA对象转换以及在JQUERY中的使用-编程知识网

  1. function strToJson(str){  
  2.     var json = (new Function("return " + str))();  
  3.     return json;  
  4. }  

第三种：使用全局的JSON对象 

Js代码  json数据解析与JAVA对象转换以及在JQUERY中的使用-编程知识网

  1. function strToJson(str){  
  2.     return JSON.parse(str);  
  3. }  

另外：使用JSON.parse需严格遵守JSON规范，如属性都需用引号引起来，如下 

Js代码  json数据解析与JAVA对象转换以及在JQUERY中的使用-编程知识网

  1. var str = '{name:"jack"}';  
  2. var obj = JSON.parse(str); // –> parse error  

name没有用引号引起来，使用JSON.parse所有浏览器中均抛异常，解析失败。而前两种方式则没问题。 

JSON数据前后台相互转换

import java.util.ArrayList;
import java.util.List;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.google.gson.Gson;

 

import cn.itcast.beans.Person;

 

public class JsonTest {
 
 
 public static void main(String[] args) {
  /*
   * 这是模拟当我们页面的ajax进行异步的时候，我们从数据库中找到一个对象或一个集合
   * 然后把这个集合传递给页面，那么我们的页面接受到的就是一个json格式的字符粗或json数组格式的字符窜
   * 然后我们在js中eval("("+传递过去的参数+")");这样我们就把一个对象转换成了一个页面的json的对象或json的数组
   */
  List<Person> list = new ArrayList<Person>();
  Person person = new Person(1,"张三");
  Person person1 = new Person(2,"李四");
  list.add(person);
  list.add(person1);
  //构建一个gson对象
  Gson gson = new Gson();
  //这是将一个对象转换成json格式的字符窜
  String jsonPerson1 = gson.toJson(person);
  //这是将一个集合转换成json格式的字符窜
  String jsonPerson = gson.toJson(list);
  System.out.println(jsonPerson1);
  System.out.println(jsonPerson);
  
  
  /*
   * 这是模拟当我们的页面用ajax进行异步的时候，传递过来一个json或json数组格式的字符窜
   * 那么我们在后台首先得把这个json或json数组格式的字符窜转换成一个javaBean对象或一个集合
   * 下面就一个很好的演示
   */
  String json = "{'studentId':2,'studentName':'曹欢'}";
  //这是将一个字符窜的json编程一个java对象
  Gson gson2 = new Gson();
  Person person2 =  gson2.fromJson(json, Person.class);
  System.out.println(person2.getStudentId() + "—>" + person2.getStudentName());
  System.out.println("===========================================================");
  //这是将一个json数组格式的字符窜转换成一个集合–方式1
  String json1 = "[{'studentId':2,'studentName':'曹欢'},{'studentId':3,'studentName':'文斌'}]";
  List<Person> list2 = new ArrayList<Person>();
  try {
   JSONArray array = new JSONArray(json1);
   for (int i = 0; i < array.length(); i++) {
    
    JSONObject object = array.getJSONObject(i);
    Person person3 = new Person(object.getInt("studentId"),object.getString("studentName"));
    list2.add(person3);
   }
  } catch (JSONException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  //这是打印出集合的数据
  for (Person person3 : list2) {
   System.out.println(person3.getStudentId()+"—->"+person3.getStudentName());
  }

 

  //这是将一个json数组格式的字符窜转换成一个集合–方式2

Type type = new TypeToken<List<Person>>(){}.getType();  

Gson gson3 = new Gson();

List<Person> list = gson3.fromJson(json1, type);
 
 }
 
}

 

Json转换利器Gson之实例一-简单对象转化和带泛型的List转化

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

jar和源码下载地址: http://code.google.com/p/google-gson/downloads/list

实体类:

public class Student {
 private int id;
 private String name;
 private Date birthDay;

 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 Date getBirthDay() {
  return birthDay;
 }

 public void setBirthDay(Date birthDay) {
  this.birthDay = birthDay;
 }

 @Override
 public String toString() {
  return "Student [birthDay=" + birthDay + ", id=" + id + ", name="
    + name + "]";
 }

}

测试类:

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class GsonTest1 {

 public static void main(String[] args) {
  Gson gson = new Gson();

  Student student1 = new Student();
  student1.setId(1);
  student1.setName("李坤");
  student1.setBirthDay(new Date());

  // //
  System.out.println("———-简单对象之间的转化————-");
  // 简单的bean转为json
  String s1 = gson.toJson(student1);
  System.out.println("简单Bean转化为Json===" + s1);

  // json转为简单Bean
  Student student = gson.fromJson(s1, Student.class);
  System.out.println("Json转为简单Bean===" + student);
  // 结果:
  // 简单Bean转化为Json==={"id":1,"name":"李坤","birthDay":"Jun 22, 2012 8:27:52 AM"}
  // Json转为简单Bean===Student [birthDay=Fri Jun 22 08:27:52 CST 2012, id=1,
  // name=李坤]
  // //

  Student student2 = new Student();
  student2.setId(2);
  student2.setName("曹贵生");
  student2.setBirthDay(new Date());

  Student student3 = new Student();
  student3.setId(3);
  student3.setName("柳波");
  student3.setBirthDay(new Date());

  List<Student> list = new ArrayList<Student>();
  list.add(student1);
  list.add(student2);
  list.add(student3);

  System.out.println("———-带泛型的List之间的转化————-");
  // 带泛型的list转化为json
  String s2 = gson.toJson(list);
  System.out.println("带泛型的list转化为json==" + s2);

  // json转为带泛型的list
  List<Student> retList = gson.fromJson(s2,
    new TypeToken<List<Student>>() {
    }.getType());
  for (Student stu : retList) {
   System.out.println(stu);
  }

  // 结果:
  // 带泛型的list转化为json==[{"id":1,"name":"李坤","birthDay":"Jun 22, 2012 8:28:52 AM"},{"id":2,"name":"曹贵生","birthDay":"Jun 22, 2012 8:28:52 AM"},{"id":3,"name":"柳波","birthDay":"Jun 22, 2012 8:28:52 AM"}]
  // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=1, name=李坤]
  // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=2, name=曹贵生]
  // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=3, name=柳波]

 }
}

 

 

将一个json数组格式的字符串(包含字段和数组)转换成一个对象(里面包含字段和集合)

public class Address{
 private int id;
 private String name;

List<Student> studentList;

}

Address add1 = new Address();

add1.setId(1);

add1.setName("shenzhen");

Student student1 = new Student();
  student1.setId(1);
  student1.setName("李坤");
  student1.setBirthDay(new Date());

studentList.add(student1);

add1.setStudentList(studentList);

//转字符串

  String a1 = gson.toJson(add1);
  System.out.println("转化为Json===" + a1);

 //转对象
Address address1= gson.fromJson(a1, Address.class);

 

JQUERY AJAX请求在中JS封装JSON数组

 

比如:插入多条数据,并带有其它信息,这样就要求在JS组装成一JSON对象里面包含字段和集合(数组),如下所示:
var employee = {};
employee["id"] = 1;
employee["name"] = "zhansan";

var address =[{name:"shenzhen",telno:"13612345678"},
       {name:"shanhai",telno:"13912345678"}];
employee["address"] = address;
var param = {};
//SON.stringif是把JSON对象转换为字符串
param["employeeInfoStr"] = JSON.stringif(employee);

下面AJAX请求如下:
$.ajax({
            url: "employee.action",
            type: "POST",
            data: param,//{ Action: "getJson", TableName: $("#txt2").val() },
            dataType: "json",
            success: function (result) {
                //成功后调用
            },
            error: function (ex) {
                alert(ex);//失败后调用
            }
        });

ACTION中收到请求,当然在ACTION中有一个属性employeeInfoStr有GET/SET方法能自动收到AJAX请求过来的参数,用REQUEST.GEP方式来取传过来的参数也可以.

然后字符串解析成对象Employee.
public class Employee{
 private int id;
 private String name;
List<Address > address List;
}

public class Address{
 private String name;
 private String telno;
}

if(employeeInfoStr != null && !employeeInfoStr.isEmpty())
{
   Gson gson = new Gson();
   Employee employee= gson.fromJson(a1, Employee.class);
}