浅入了解JSON数据格式

1. JSON语法

JSON的全称是”JavaScript Object Notation”，意思是javascript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式。

1.1. JSON的格式

JSON 数据的书写格式是键（名称）/值对。
JSON 键值对是用来保存 JS 对象的一种方式，和 JS 对象的写法也大同小异，键/值对包括字段名称（在双引号中），后面写一个冒号，然后是值。
JSON 值可以是：字符串（在双引号中）、数组（在中括号中）、数字（整数或浮点数）、逻辑值（true 或 false）、对象（在大括号中）、 null。

1.2. JSON结构

JSON结构有两种结构，就是对象和数组。通过这两种结构可以表示各种复杂的结构。
{“province”: “Shanxi”} 可以理解为是一个包含province为Shanxi的对象，
[“Shanxi”,“Shandong”]这是一个包含两个元素的数组
而 [{“province”: “Shanxi”},{“province”: “Shandong”}] 就表示包含两个对象的数组。
当然了,你也可以使用 {“province”:[“Shanxi”,“Shandong”]} 来简化上面的JSON,这是一个拥有一个name数组的对象。
注意：（1）JSON键必须用双引号括起来，否则会报错（2）最后一个属性不能加逗号.我们可以通过JSON校验工具来检查你的JSON数据格式是否正确。比如：http://www.json.cn/、http://www.bejson.com/等等。

1.3. JSON与JS对象的关系

(注意:这里是js的语法)

JSON 是 JS 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。平时说的JSON对象，是JSON格式的JS对象或是符合JSON数据结构要求的JS对象。

1.4. JSON和JS对象互转

要实现从对象转换为 JSON 字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({province:“shanxi”,cify:“jin”});

结果:{“province”:“shanxi”,“city”:“jin”}

要实现从 JSON 转换为对象，使用 JSON.parse() 方法：

var obj = JSON.parse(‘{“province”:“shanxi”,“city”:“jin”}’);

结果:Object {province:“shanxi”,city:“jin”}

举个例子:根据要求自己编写一个json串

data是一个JSON对象，它具有3个属性：code，msg，result，其中code和msg的值都是字符串，result的值是一个对象数组。result包含了一个对象，这个对象具有3个属性userid，uname，email。
{“code”:“0”,

“msg”:“显示信息”,

“result”:[

​ {

​ “userid”:“1”,

​ “uname”:“zhsngsan”,

​ “email”:“[email protected]”

​ }

​ ]

}

2. JSON解析

我们要学习三方的解析架包

2.1. json-lib

需要很多依赖包

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

1.添加的依赖
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
2.具体实现:
public class TestDemo {
	//@Test
	public void test1(){
		//json就是字符串   {}代表对象  []代表数组
		String ss1 = "{\"name\":\"qianfeng\",\"email\":\"22@22\",\"birthday\":\"10-10\"}";
		String ss2 = "[{\"name\":\"qianfeng\",\"email\":\"22@22\",\"birthday\":\"10-10\"},{\"name\":\"qianfeng\",\"email\":\"22@22\",\"birthday\":\"10-10\"}]";
		String ss3 = "{\"name\":\"qianfeng\",\"email\":\"22@22\",\"birthday\":[{\"year\":\"1990\",\"month\":\"10-10\"}]}";
	}
	
	//@Test
	public void test2(){
		Book book = new Book();
		book.setId("92837492834");
		book.setName("好书");
		book.setPrice(100000);
		book.setCategory("艺术");
		book.setDescription("赶紧买吧");
		book.setPnum(2000);
		
		//把对象转成json对象
		JSONObject jsonObject = JSONObject.fromObject(book);
		System.out.println(jsonObject);
	}
	
	@Test
	public void test3()
	{
		List<Book> list =new ArrayList<Book>();
		
		Book book = new Book();
		book.setId("92837492834");
		book.setName("好书");
		book.setPrice(100000);
		book.setCategory("艺术");
		book.setDescription("赶紧买吧");
		book.setPnum(2000);
		
		Book book2 = new Book();
		book2.setId("928374928342");
		book2.setName("2好书");
		book2.setPrice(2100000);
		book2.setCategory("2艺术");
		book2.setDescription("2赶紧买吧");
		book2.setPnum(3000);
		
	   list.add(book);
	   list.add(book2);
	   
	   //把list转成json数组
	   JSONArray jsonArray = JSONArray.fromObject(list);
	   System.out.println(jsonArray.toString());
	}
	public class Book {
	
	private String id;
	private String name;
	private double price;
	private int pnum;
	private String category;
	private String description;
	
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public int getPnum() {
		return pnum;
	}
	public void setPnum(int pnum) {
		this.pnum = pnum;
	}
	public String getCategory() {
		return category;
	}
	public void setCategory(String category) {
		this.category = category;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
}

2.2. fastJSON联合springboot使用

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

主要特点：

• 快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）

• 强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）

• 零依赖（没有依赖其它任何类库除了JDK）

  使用方法:

  1.添加依赖
  <!-- fastjson的依赖 -->
        <dependency>
              <groupId>com.alibaba</groupId>
              <artifactId>fastjson</artifactId>
              <version>1.2.15</version>
        </dependency>
  2.代码实现
  @SpringBootApplication
  public class AnalysisjsonApplication {
      public static   void  testFastJSON(){
      //创建对象
      Group group = new Group();
      group.setId(0L);
      group.setName("admin");
  
      User1 guestUser = new User1();
      guestUser.setId(2L);
      guestUser.setName("guest");
  
      User1 rootUser = new User1();
      rootUser.setId(3L);
      rootUser.setName("root");
  
      group.getUsers().add(guestUser);
      group.getUsers().add(rootUser);
  
      /**
       * java对象转json字符串
       */
      String jsonString = JSON.toJSONString(group);
      System.out.println(jsonString);
  
      /**
       * json字符串转java对象
       */
      String json = "{\"id\":0,\"name\":\"admin\","
              + "\"users\":[{\"id\":2,\"name\":\"guest\"},{\"id\":3,\"name\":\"root\"}]}";
  
      // json字符串转java对象
      Group group1 = JSON.parseObject(json, Group.class);
      System.out.println(group1.getUsers().get(0).getName());
  }
      public static void main(String[] args) throws ParseException, IOException {
          //SpringApplication.run(AnalysisjsonApplication.class, args);
          //testJackJSON();
          testFastJSON();
      }
  }
  class User1 {
  
      private Long id;
  
      private String name;
  
      /**
       * 构造函数
       */
      public User1() {
          super();
      }
  
      public Long getId() {
          return id;
      }
  
      public void setId(Long id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  }
  class Group {
  
      private Long id;
  
      private String name;
  
      private List<User1> users = new ArrayList<User1>();
  
      /**
       * 构造函数
       */
      public Group() {
          super();
      }
  
      public Long getId() {
          return id;
      }
  
      public void setId(Long id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public List<User1> getUsers() {
          return users;
      }
  
      public void setUsers(List<User1> users) {
          this.users = users;
      }
  }
  
  

2.3. JackJSON联合springboot使用

JackJSON是springboot默认的解析架包,它支持的特性丰富,处理json速度很快,学习时中等难度…相比JackJSON,Fastjson支持的特性没有那么多,处理json的速度也很快,易学.

默认在web包里

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

常用方法解释:

• 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对象
        ObjectMapper mapper = new ObjectMapper();
        //创建第一个对象
        User user = new User();
        user.setAge(20);
        user.setEmail("[email protected]");
        user.setName("bingbing");

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        user.setBirthday(simpleDateFormat.parse("1996-11-12"));

        //创建第二个对象
        User user1 = new User();
        user1.setAge(40);
        user1.setEmail("[email protected]");
        user1.setName("chenchen");
        user1.setBirthday(simpleDateFormat.parse("1986-11-12"));

        ObjectMapper mapper = new ObjectMapper();
        //1.User类转JSON
        String json = mapper.writeValueAsString(user);
        System.out.println(json);
        结果:{"name":"bingbing","email":"[email protected]","age":20,"birthday":847728000000}

        //2、List集合转化成json字符串
        List<User> users = new ArrayList<User>();
        users.add(user);
        users.add(user1);
        String jsonlist = mapper.writeValueAsString(users);
        System.out.println(jsonlist);
        结果:[{"name":"bingbing","email":"[email protected]","age":20,"birthday":847728000000},{"name":"chenchen","email":"[email protected]","age":40,"birthday":532108800000}]

        //3、Json字符串转化成指定Class类
        String jsonStr = "{\"name\":\"bingbing\",\"age\":20,\"birthday\":844099200000,\"email\":\"[email protected]\"}";
/**
 * ObjectMapper支持从byte[]、File、InputStream、字符串等数据的JSON反序列化。
 */
        User user2 = mapper.readValue(jsonStr, User.class);
        System.out.println(user2);
        结果:User{name='bingbing', email='xiaomin@sina.com', age=20, birthday=Tue Oct 01 01:00:00 IRKST 1996}

        //4、Json字符串转化成集合List
        String jsonString="[{\"id\":\"1\"},{\"id\":\"2\"}]";
        List<Bean> beanList = mapper.readValue(jsonString, new TypeReference<List<Bean>>() {});
        System.out.println(beanList);
        结果:[Bean{id='1', age='null'}, Bean{id='2', age='null'}]