一 .json简介
 

 1）概念:json全称是javaScript object Notation，是一种病轻量级的数据交换格式。
 

 2）特点：
 

 1.本质就是具有特定格式的字符串
 

 2，.json完全独立于编程语言
 

 3.json比xml数据传输的有效性要高出很多
 

 
 
 

 二。json数据格式
 

 1）整体结构：
 

 String json1="{“id”：“12”，“name”：“TOM”}";
 

 String json2=''[{“id”：“12”，“name”：“TOM”},{“id”：“12”，“name”：“TOM”},{“id”：“12”，“name”：“TOM”}]"
 

 2)json对象
 

 1）json对象的结构：
 

 {key:value1,key:value2,}
 

 2)key的数据结构类型：字符串
 

 3）value的数据类型：数值，字符串，null,json数组[] ，json对象{}
 

 4：例子：{“id”：“12”，“name”：“TOM”}
 

 3）json数组
 

 1）json数组的结构 [value1,value2,value3]
 

 2)value的数据类型：数值， 字符串 null json数组[] json对象{}
 

 3）例子：[1, “ab”,[], {“n”:123, “b”:”abc”}]
 

 
 
 

 三。json解析方向
 

 1）将java对象（包含集合）转换为json字符串格式（在服务器端应用）
 

 2）将json格式字符串转换java对象（在客户端应用）
 

 
 

 3）json和java之间的转换关系
 

 json对应java对象转换
 

 json数组和java对象构成的list对应
 

 
 
 

 json解析技术
 

 android原生解析
 

 1）特点： 编程相对麻烦
 

 2）数据之间转换
 

 （1）将json格式的字符串{}转换为Java对象
 

 API：
 

 JSONObject(String json) : 将json字符串解析为json对象
 

 Xxx getXxx(String name) : 根据name, 在json对象中得到对应的Value
 

 Xxx optXxx(String name) : 根据name, 在json对象中得到对应的Value
 

 注意：
 

 optXxx方法会在对应的key中的值不存在的时候返回一个空字符串或者返回你指定的默认值，但是getString方法会出现空指针异常的错误。
 

 测试数据：
 

 （2）将json格式的字符串[]转换为Java对象的List
 

 API:
 

 JSONArray(String json) : 将json字符串解析为json数组
 

 int length() : 得到json数组中元素的个数
 

 Xxx getXxx(int index) : 根据下标得到json数组中对应的元素数据
 

 Xxx optXxx(int index) : 根据下标得到json数组中对应的元素数据
 

 注意：
 

 optXxx方法会在对应的key中的值不存在的时候返回一个空字符串或者返回你指定的默认值，但是getString方法会出现空指针异常的错误。
 

 测试数据：
 

 （3）复杂json数据解析
 

 a) 测试数据:
 

 http://api.ds.lingshi.cccwei.com/?cid=625561&uid=0&tms=20160427085818&sig=36b291895c63dfc4&wssig=26637611c0c64fb7&os_type=3&version=24&channel_name=feibo&srv=2402&classify_id=32
 

 b) GsonFormat工具生成对象类
 

 见工具使用
 

 c) 手动解析json数据
 

 （4）特殊json数据解析
 

 a) 测试数据
 

 http://api.bilibili.com/online_list?_device=android&platform=android&typeid=13&sign=a520d8d8f7a7240013006e466c8044f7
 

 b) 手动写解析json数据的对象类
 

 c) 手动解析json数据
 

 
 
 

 2.Gson框架技术
 

 1)特点：编码简洁，谷歌官方推荐
 

 2）下载地址：
 https://mvnrepository.com/artifact/com.google.code.gson/gson
 

 3）数据之间转换
 

 （1）将json格式的字符串{}转换为Java对象
 

 API：
 

 fromJson(String json, Class<T> classOfT);
 

 注意：
 

 要求json对象中的key的名称与java对象对应的类中的属性名要相同
 

 步骤
 

 1）将Gson的jar包导入到项目中
 

 2）创建Gson对象 ：
 

 Gson gson = new Gson();
 

 3）通过创建的Gson对象调用fromJson()方法，返回该JSON数据对应的Java对象：
 

 ShopInfo shopInfo = gson.fromJson(json, ShopInfo.class);
 

 测试数据：
 

 （2）将json格式的字符串[]转换为Java对象的List
 

 API:
 

 fromJson(String json, Type typeOfT);
 

 type
 

 测试数据：
 

 步骤
 

 1）将Gson的jar包导入到项目中
 

 2）创建Gson对象 ：
 

 Gson gson = new Gson();
 

 3）通过创建的Gson对象调用fromJson()方法，返回该JSON数据对应的Java集合：
 

 List<ShopInfo> shops = gson.fromJson(json, new TypeToken<List<ShopInfo>>() {}.getType());
 

 （3）将Java对象转换为json字符串{}
 

 API:
 

 String toJson(Object src);
 

 步骤
 

 1）将Gson的jar包导入到项目中
 

 2）创建Gson对象 ：
 

 Gson gson = new Gson();
 

 3）通过创建的Gson对象调用toJson()方法，返回json数据：
 

 ShopInfo shop = new ShopInfo(1, "鲍鱼", 250.0, "");
 

 String json = gson.toJson(shop);
 

 （4）将Java对象的List转换为json字符串[]
 

 API:
 

 String toJson(Object src);
 

 步骤
 

 1）将Gson的jar包导入到项目中
 

 2）创建Gson对象 ：
 

 Gson gson = new Gson();
 

 3）通过创建的Gson对象调用toJson()方法，返回json数据：
 

 List<ShopInfo> shops = new ArrayList<>();
 

 String json = gson.toJson(shops);
 

 
 
 

 3。FastJson框架技术
 

 1）特点：FasrJson是java语言编程写的高性能完善json库，他采用一种假定有序快速匹配算法，把jsonParse的性能提升到极致，目前是java语言中最快的json库
 

 2）下载地址：
 https://github.com/alibaba/fastjson/wiki
 

 3)数据之间的转换
 

 （1）将json格式的字符串{}转换为Java对象
 

 API: parseObject(String json, Class<T> classOfT);
 

 步骤：
 

 1）导入fastjson的jar包
 

 2）JSON调用parseObject()方法，获取转换后的Java对象
 

 例如：ShopInfo shopInfo = JSON.parseObject(json, ShopInfo.class);
 

 测试数据：
 

 （2）将json格式的字符串[]转换为Java对象的List
 

 API: List<T> parseArray(String json,Class<T> classOfT);
 

 步骤：
 

 1）导入fastjson的jar包
 

 2）JSON调用parseArray()方法，获取转换后的Java集合
 

 例如：List<ShopInfo> shopInfos = JSON.parseArray(json, ShopInfo.class);
 

 测试数据：
 

 （3）将Java对象转换为json字符串{}
 

 API: String toJSONString(Object object);
 

 步骤：
 

 1）导入fastjson的jar包
 

 2）JSON调用toJSONString()方法，获取转换后的json数据
 

 例如：
 

 ShopInfo shopInfo = new ShopInfo(1, "鲍鱼", 250.0, "baoyu");
 

 String json = JSON.toJSONString(shopInfo);
 

 （4）将Java对象的List转换为json字符串[]
 

 API: String toJSONString(Object object);
 

 步骤：
 

 1）导入fastjson的jar包
 

 2）JSON调用toJSONString()方法，获取转换后的json数据
 

 例如：
 

 List<ShopInfo> shops = new ArrayList<>();
 

 ShopInfo baoyu = new ShopInfo(1, "鲍鱼", 250.0, "baoyu");
 

 ShopInfo longxia = new ShopInfo(2, "龙虾", 251.0, "longxia");
 

 shops.add(baoyu);
 

 shops.add(longxia);
 

 String json = JSON.toJSONString(shops);
 

 
 
 

 5.GsonFormat工具使用教程
 

 1
 _
  GsonFormat
 工具使用
 

 1
 .1_
 GsonFormat
 

 1
 ）打开
 Android studio
 页面，点击设置按钮。
 

 
 

   
 

  
 
 
 

  
 
 
 

  
 

 2
 ）点击
 Plugins
 按钮
 

 
 

  
 

  
 

 3
 ）在右侧输入框中输入
 gsonformat,
 然后点击中间部位的
 Browse(
 必须在联网情况下点击
 )
 

 
 

  
 

  
 

 4
 ）选择
 GsonFormat
 ，点击右侧的安装插件
 

 
 
 

 
 

  5
 ）重启一下
 Android studio
 

 6
 ）在
 Android studio
 中创建一个类
 

 
 

  
 

  
 

 7
 ）在该类中同时按下
 alt
 +shift+s
 ，并点击
 GsonFormat
 

 
 

  
 

  
 

 8
 ）将要解析的
 JSON
 字符串粘贴到
 GsonFormat
 中
 

 
 
 

 
 

  9
 ）点击
 OK
 

 
 

  
 

  
 

 10
 ）这样就将输入的
 JSON
 数据转换为了
 bean
 对象
 
 
 
 
     

      public class 
      TestGsonFormat {
     
 
     

          
      /**
     
 
     

           * id : 2
     
 
     

           * name : 
      大虾
     
 
     

           
      * price : 12.3
     
 
     

           * imagePath : http://192.168.10.165:8080/L05_Server/images/f1.jpg
     
 
     

           */
     
 
     

          
      private int 
      id
      ;
     
 
     

          
      private 
      String 
      name
      ;
     
 
     

          
      private double 
      price
      ;
     
 
     

          
      private 
      String 
      imagePath
      ;
     
 
     

      
 
     
 
     

          
      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 double 
      getPrice() {
     
 
     

              
      return 
      price
      ;
     
 
     

          }
     
 
     

      
 
     
 
     

          
      public void 
      setPrice(
      double 
      price) {
     
 
     

              
      this
      .
      price 
      = price;
     
 
     

          }
     
 
     

      
 
     
 
     

          
      public 
      String getImagePath() {
     
 
     

              
      return 
      imagePath
      ;
     
 
     

          }
     
 
     

      
 
     
 
     

          
      public void 
      setImagePath(String imagePath) {
     
 
     

              
      this
      .
      imagePath 
      = imagePath;
     
 
     

          }
     
 
     

      }
     
 
 
 

 
 
 

 
 

       整理记录一个Json解析的函数方法，方法如下：
 
 
Create FUNCTION [dbo].[parseJSON]( @JSON NVARCHAR(MAX))
	RETURNS @hierarchy TABLE
	  (
	   element_id INT IDENTITY(1, 1) NOT NULL, /* internal surrogate primary key gives the order of parsing and the list order */
	   sequenceNo [int] NULL, /* the place in the sequence for the element */
	   parent_ID INT,/* if the element has a parent then it is in this column. The document is the ultimate parent, so you can get the structure from recursing from the document */
	   Object_ID INT,/* each list or object has an object id. This ties all elements to a parent. Lists are treated as objects here */
	   NAME NVARCHAR(2000),/* the name of the object */
	   StringValue NVARCHAR(MAX) NOT NULL,/*the string representation of the value of the element. */
	   ValueType VARCHAR(10) NOT null /* the declared type of the value represented as a string in StringValue*/
	  )
	AS
	BEGIN
	  DECLARE
	    @FirstObject INT, --the index of the first open bracket found in the JSON string
	    @OpenDelimiter INT,--the index of the next open bracket found in the JSON string
	    @NextOpenDelimiter INT,--the index of subsequent open bracket found in the JSON string
	    @NextCloseDelimiter INT,--the index of subsequent close bracket found in the JSON string
	    @Type NVARCHAR(10),--whether it denotes an object or an array
	    @NextCloseDelimiterChar CHAR(1),--either a '}' or a ']'
	    @Contents NVARCHAR(MAX), --the unparsed contents of the bracketed expression
	    @Start INT, --index of the start of the token that you are parsing
	    @end INT,--index of the end of the token that you are parsing
	    @param INT,--the parameter at the end of the next Object/Array token
	    @EndOfName INT,--the index of the start of the parameter at end of Object/Array token
	    @token NVARCHAR(200),--either a string or object
	    @value NVARCHAR(MAX), -- the value as a string
	    @SequenceNo int, -- the sequence number within a list
	    @name NVARCHAR(200), --the name as a string
	    @parent_ID INT,--the next parent ID to allocate
	    @lenJSON INT,--the current length of the JSON String
	    @characters NCHAR(36),--used to convert hex to decimal
	    @result BIGINT,--the value of the hex symbol being parsed
	    @index SMALLINT,--used for parsing the hex value
	    @Escape INT --the index of the next escape character
	    
	  DECLARE @Strings TABLE /* in this temporary table we keep all strings, even the names of the elements, since they are 'escaped' in a different way, and may contain, unescaped, brackets denoting objects or lists. These are replaced in the JSON string by tokens representing the string */
	    (
	     String_ID INT IDENTITY(1, 1),
	     StringValue NVARCHAR(MAX)
	    )
	  SELECT--initialise the characters to convert hex to ascii
	    @characters='0123456789abcdefghijklmnopqrstuvwxyz',
	    @SequenceNo=0, --set the sequence no. to something sensible.
	  /* firstly we process all strings. This is done because [{} and ] aren't escaped in strings, which complicates an iterative parse. */
	    @parent_ID=0;
	  WHILE 1=1 --forever until there is nothing more to do
	    BEGIN
	      SELECT
	        @start=PATINDEX('%[^a-zA-Z]["]%', @json collate SQL_Latin1_General_CP850_Bin);--next delimited string
	      IF @start=0 BREAK --no more so drop through the WHILE loop
	      IF SUBSTRING(@json, @start+1, 1)='"' 
	        BEGIN --Delimited Name
	          SET @start=@Start+1;
	          SET @end=PATINDEX('%[^\]["]%', RIGHT(@json, LEN(@json+'|')-@start) collate SQL_Latin1_General_CP850_Bin);
	        END
	      IF @end=0 --no end delimiter to last string
	        BREAK --no more
	      SELECT @token=SUBSTRING(@json, @start+1, @end-1)
	      --now put in the escaped control characters
	      SELECT @token=REPLACE(@token, FROMString, TOString)
	      FROM
	        (SELECT
	          '\"' AS FromString, '"' AS ToString
	         UNION ALL SELECT '\\', '\'
	         UNION ALL SELECT '\/', '/'
	         UNION ALL SELECT '\b', CHAR(08)
	         UNION ALL SELECT '\f', CHAR(12)
	         UNION ALL SELECT '\n', CHAR(10)
	         UNION ALL SELECT '\r', CHAR(13)
	         UNION ALL SELECT '\t', CHAR(09)
	        ) substitutions
	      SELECT @result=0, @escape=1
	  --Begin to take out any hex escape codes
	      WHILE @escape>0
	        BEGIN
	          SELECT @index=0,
	          --find the next hex escape sequence
	          @escape=PATINDEX('%\x[0-9a-f][0-9a-f][0-9a-f][0-9a-f]%', @token collate SQL_Latin1_General_CP850_Bin)
	          IF @escape>0 --if there is one
	            BEGIN
	              WHILE @index<4 --there are always four digits to a \x sequence   
	                BEGIN
	                  SELECT --determine its value
	                    @result=@result+POWER(16, @index)
	                    *(CHARINDEX(SUBSTRING(@token, @escape+2+3-@index, 1),
	                                @characters)-1), @index=@index+1 ;
	         
	                END
	                -- and replace the hex sequence by its unicode value
	              SELECT @token=STUFF(@token, @escape, 6, NCHAR(@result))
	            END
	        END
	      --now store the string away 
	      INSERT INTO @Strings (StringValue) SELECT @token
	      -- and replace the string with a token
	      SELECT @JSON=STUFF(@json, @start, @end+1,
	                    '@string'+CONVERT(NVARCHAR(5), @@identity))
	    END
	  -- all strings are now removed. Now we find the first leaf.  
	  WHILE 1=1  --forever until there is nothing more to do
	  BEGIN
	 
	  SELECT @parent_ID=@parent_ID+1
	  --find the first object or list by looking for the open bracket
	  SELECT @FirstObject=PATINDEX('%[{[[]%', @json collate SQL_Latin1_General_CP850_Bin)--object or array
	  IF @FirstObject = 0 BREAK
	  IF (SUBSTRING(@json, @FirstObject, 1)='{') 
	    SELECT @NextCloseDelimiterChar='}', @type='object'
	  ELSE 
	    SELECT @NextCloseDelimiterChar=']', @type='array'
	  SELECT @OpenDelimiter=@firstObject
	  WHILE 1=1 --find the innermost object or list...
	    BEGIN
	      SELECT
	        @lenJSON=LEN(@JSON+'|')-1
	  --find the matching close-delimiter proceeding after the open-delimiter
	      SELECT
	        @NextCloseDelimiter=CHARINDEX(@NextCloseDelimiterChar, @json,
	                                      @OpenDelimiter+1)
	  --is there an intervening open-delimiter of either type
	      SELECT @NextOpenDelimiter=PATINDEX('%[{[[]%',
	             RIGHT(@json, @lenJSON-@OpenDelimiter)collate SQL_Latin1_General_CP850_Bin)--object
	      IF @NextOpenDelimiter=0 
	        BREAK
	      SELECT @NextOpenDelimiter=@NextOpenDelimiter+@OpenDelimiter
	      IF @NextCloseDelimiter<@NextOpenDelimiter 
	        BREAK
	      IF SUBSTRING(@json, @NextOpenDelimiter, 1)='{' 
	        SELECT @NextCloseDelimiterChar='}', @type='object'
	      ELSE 
	        SELECT @NextCloseDelimiterChar=']', @type='array'
	      SELECT @OpenDelimiter=@NextOpenDelimiter
	    END
	  ---and parse out the list or name/value pairs
	  SELECT
	    @contents=SUBSTRING(@json, @OpenDelimiter+1,
	                        @NextCloseDelimiter-@OpenDelimiter-1)
	  SELECT
	    @JSON=STUFF(@json, @OpenDelimiter,
	                @NextCloseDelimiter-@OpenDelimiter+1,
	                '@'+@type+CONVERT(NVARCHAR(5), @parent_ID))
	  WHILE (PATINDEX('%[A-Za-z0-9@+.e]%', @contents collate SQL_Latin1_General_CP850_Bin))<>0 
	    BEGIN
	      IF @Type='Object' --it will be a 0-n list containing a string followed by a string, number,boolean, or null
	        BEGIN
	          SELECT
	            @SequenceNo=0,@end=CHARINDEX(':', ' '+@contents)--if there is anything, it will be a string-based name.
	          SELECT  @start=PATINDEX('%[^A-Za-z@][@]%', ' '+@contents collate SQL_Latin1_General_CP850_Bin)--AAAAAAAA
	          SELECT @token=SUBSTRING(' '+@contents, @start+1, @End-@Start-1),
	            @endofname=PATINDEX('%[0-9]%', @token collate SQL_Latin1_General_CP850_Bin),
	            @param=RIGHT(@token, LEN(@token)-@endofname+1)
	          SELECT
	            @token=LEFT(@token, @endofname-1),
	            @Contents=RIGHT(' '+@contents, LEN(' '+@contents+'|')-@end-1)
	          SELECT  @name=stringvalue FROM @strings
	            WHERE string_id=@param --fetch the name
	        END
	      ELSE
SELECT @Name=null,@SequenceNo=@SequenceNo+1 
	      SELECT
	        @end=CHARINDEX(',', @contents)-- a string-token, object-token, list-token, number,boolean, or null
                IF @end=0
	        --HR Engineering notation bugfix start
	          IF ISNUMERIC(@contents) = 1
		    SELECT @end = LEN(@contents)
	          Else
	        --HR Engineering notation bugfix end 
		  SELECT  @end=PATINDEX('%[A-Za-z0-9@+.e][^A-Za-z0-9@+.e]%', @contents+' ' collate SQL_Latin1_General_CP850_Bin) + 1
	       SELECT
	        @start=PATINDEX('%[^A-Za-z0-9@+.e][A-Za-z0-9@+.e]%', ' '+@contents collate SQL_Latin1_General_CP850_Bin)
	      --select @start,@end, LEN(@contents+'|'), @contents  
	      SELECT
	        @Value=RTRIM(SUBSTRING(@contents, @start, @End-@Start)),
	        @Contents=RIGHT(@contents+' ', LEN(@contents+'|')-@end)
	      IF SUBSTRING(@value, 1, 7)='@object' 
	        INSERT INTO @hierarchy
	          (NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)
	          SELECT @name, @SequenceNo, @parent_ID, SUBSTRING(@value, 8, 5),
	            SUBSTRING(@value, 8, 5), 'object' 
	      ELSE 
	        IF SUBSTRING(@value, 1, 6)='@array' 
	          INSERT INTO @hierarchy
	            (NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)
	            SELECT @name, @SequenceNo, @parent_ID, SUBSTRING(@value, 7, 5),
	              SUBSTRING(@value, 7, 5), 'array' 
	        ELSE 
	          IF SUBSTRING(@value, 1, 7)='@string' 
	            INSERT INTO @hierarchy
	              (NAME, SequenceNo, parent_ID, StringValue, ValueType)
	              SELECT @name, @SequenceNo, @parent_ID, stringvalue, 'string'
	              FROM @strings
	              WHERE string_id=SUBSTRING(@value, 8, 5)
	          ELSE 
	            IF @value IN ('true', 'false') 
	              INSERT INTO @hierarchy
	                (NAME, SequenceNo, parent_ID, StringValue, ValueType)
	                SELECT @name, @SequenceNo, @parent_ID, @value, 'boolean'
	            ELSE
	              IF @value='null' 
	                INSERT INTO @hierarchy
	                  (NAME, SequenceNo, parent_ID, StringValue, ValueType)
	                  SELECT @name, @SequenceNo, @parent_ID, @value, 'null'
	              ELSE
	                IF PATINDEX('%[^0-9]%', @value collate SQL_Latin1_General_CP850_Bin)>0 
	                  INSERT INTO @hierarchy
	                    (NAME, SequenceNo, parent_ID, StringValue, ValueType)
	                    SELECT @name, @SequenceNo, @parent_ID, @value, 'real'
	                ELSE
	                  INSERT INTO @hierarchy
	                    (NAME, SequenceNo, parent_ID, StringValue, ValueType)
	                    SELECT @name, @SequenceNo, @parent_ID, @value, 'int'
	      if @Contents=' ' Select @SequenceNo=0
	    END
	  END
	INSERT INTO @hierarchy (NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)
	  SELECT '-',1, NULL, '', @parent_id-1, @type
	--
	   RETURN
	END
 
       有如下的Json数据：
 
{
	"status": 0,
	"msg": "SUCCESS",
	"data": [{
		"id": 1,
		"name": "xiaohong"
	}, {
		"id": 2,
		"name": "xiaoming"
	}]
}
 
       测试数据如下：
 
--测试数据
if not object_id(N'Tempdb..#T') is null
	drop table #T
Go
Create table #T([JsonStr] nvarchar(200))
Insert #T
select N'{"status":0,"msg":"SUCCESS","data":[{"id":1,"name":"xiaohong"},{"id":2,"name":"xiaoming"}]}'
Go
--测试数据结束
 
       读取数据：
 
Select b.* from #T CROSS APPLY dbo.parseJSON(JsonStr) AS b
 
 
       我们看到数据已经解析出来了，可以根据需要读取自己想要的数据了。
 
        方法来源：论坛问题

JSON简介
 
JAVAScript Object Notation是一种轻量级的数据交换格式
具有良好的可读和便于快速编写的特性。
业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持）
JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org
JSON作为数据是目前网络中主流的数据传输格式之一，应用十分广泛，说是使用率达到99%一点也不勉强
 
JSON支持的数据类型
 
我们要学习使用JSON解析，必须对JSON解析的规则原理有深刻的认识和了解，然后才知道它的一个实现原理 
 JSON里面的数据是以一种键值对的方式存在 
 （”key”:”value”）中值的类型可以是下面数据类型中的任意一种： 
 1. 数字（整数或浮点数） 
 2. 逻辑值（true 或 false） 
 3. 字符串（在双引号中） 
 4. 数组（在方括号中） 
 5. 函数 
 6. 对象（在大括号中） 
 7. null
 
JSON语法规则
 
JSON的语法规则非常的简单，就是使用 
 大括号’{}’， 
 中括号’[]’， 
 逗号’，’， 
 冒号’：’， 
 双引号’“”’。
 
数据类型： 
 嵌套对象、数组、字符串、数字、布尔值或空值。
 
我们在JSON解析中只有三中情况出现 
 1.｛｝ 解析’大括号’类型 
 2. [ ] 解析是’中括号’类型 
 3. 其实只有两种，那第三种则是1与2的组合方法即”｛’name’:’李书豪’ ，’hobby’:[‘编程’,’电竞’,’睡觉’]｝”那么下面分别来看一些这三种类型以及解析
 
JSON基本语法与图例
 
Object(对象类型) 
 
  
用{ }包含一系列无序的key–Value键值对表示，其中Key和Value之间用冒号分割，每个key-value之间用逗号分割。
比如：
 
Array(数组类型) 
 
  
使用[ ]包含所有元素，每个元素用逗号分隔，元素可以是任意的值
比如：
 
组合形 
 
  
 
  
 
 
JSON数据解析
 
 
JSON解析一定要掌握的两条规则：
 
  
1.如果看到是{ }–>使用JSONObject
2.如果看到的[ ]–>使用JSONArray解析
 
 
掌握了JSON的数据类型和基本语法后，下面我们将对JSON的各种语法类型进行详细解析(注意掌握两条规则的使用,掌握了JSON解析就那么回事) 
 
 
纯对象(Object)的解析{ }:
 

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

/**
 * JSON-->纯对象(Object)的解析
 * 
 * 注：我们在eclipse里面操作JSON解析的时候需要第三方jar包的支持
 * @author sKy°
 * @date 2016-5-8
 * @version 1.0
 */
public class Json01 {
    public static void main(String[] args) {
//      编辑一个我们要解析的数据对象
//     根据JSON的官方定义，键，加"",值，如果是字符串，就加""，其他不加。
        String json="{'name':'李书豪','age':24}";

        try {
//          创建JSON解析对象(两条规则的体现:大括号用JSONObject,注意传入数据对象)
            JSONObject obj = new JSONObject(json);
//          obj.后面有各种数据类型,根据对象来选择使用的数据类型
            String name = obj.getString("name");
//          同理如上，这里的age为Int类型，我们就用对应的类型进行解析
            int age = obj.getInt("age");
//          最后输出到控制台
            System.out.println(name+"<--->"+age);

        } catch (JSONException e) {
            e.printStackTrace();
        }

    }
}

 
 
 
纯数组(Array)的解析{ }:
 
import org.json.JSONArray;
import org.json.JSONException;

/**
 * 对纯数组Aarry的解析
 * @author sKy°
 * @date 2016-5-8
 * @version 1.0
 */
public class Json02 {
    public static void main(String[] args) {
//      编辑一个我们要解析的数据对象
        String json="['天津冷','北京暖','东京热','南京凉']";

        try {
//          创建JSON解析对象(两条规则的体现:中括号用JSONArray,注意传入数据对象)
            JSONArray jArray = new JSONArray(json);
//          取得数组长度
            int length = jArray.length();
//          回想数组的取值的方式？ --->for循环遍历数组--->得到值
            for (int i = 0; i < length; i++) {
//              根据解析的数据类型使用该类型的get方法得到该值，打印输出
                String string = jArray.getString(i);
                System.out.print(string+",");
            }

        } catch (JSONException e) {
            // TODO: handle exception
        }


    }
}

 
 
组合类型的解析(一):
 
例子: String json=”{‘name’:’李书豪’,’girlFriend’:{‘name’:’高圆圆’,’age’:18}}”;
分析: 我们首先是解析外面的大括号的对象，然后，通过girlfFriend，获取到对应的被包含的里面大括号对象。所以这里我们需要建立一个类,封装对应的数据字段，根据setName ,setAge的方式在去得到对应的值
 
/**
 * 创建一个Person用于接收解析数据，封装对应字段
 * @author sKy°
 * @date 2016-5-8
 * @version 1.0
 */
public class Person {
//    分析我们要解析的对象，根据解析对象的属性值去创建对应的属性值
//    根据分析我们所要解析的对象，两条属性 1.name(String类型) 2.是girlFrien(类类型,意味着还需要在类中去嵌套一个类(创建类部类也可))

//   封装字段
    private String name;
    private GirlFriend girlFriend;  //类类型
//   setter getter方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public GirlFriend getGirlFriend() {
        return girlFriend;
    }
    public void setGirlFriend(GirlFriend girlFriend) {
        this.girlFriend = girlFriend;
    }

//   toString方法用于控制台输出
    @Override
    public String toString() {
        return "Person [name=" + name + ", girlFriend=" + girlFriend + "]";
    }

}

// 为了方便咱们看，这里就直接在下面创建了一个GirlFriend这个类
class GirlFriend{
//   根据对象属性值，创建对应的值
    private String name;
    private int age;
//   setter getter方法
    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;
    }
//   toString方法用于控制台输出
    @Override
    public String toString() {
        return "GirlFriend [name=" + name + ", age=" + age + "]";
    }



}

 开始解析:
import org.json.JSONException;
import org.json.JSONObject;





/**
 * 组合数据类型的解析--->对象嵌套对象类型
 * @author sKy°
 * @date 2016-5-8
 * @version 1.0
 */
public class Json03 {
    public static void main(String[] args) {
//      编辑一个我们要解析的数据对象
//      分析: 应该先解析外面的大的对象，然后，通过girlfFriend，获取到对应的被包含的对象。
//      所以这里我们需要建立一个类,封装对应的数据字段，根据setName ,setAge的方式在去得到对应的值

        String json="{'name':'李书豪','girlFriend':{'name':'高圆圆','age':18}}";
        try {
//          1.创建JSON解析对象(两条规则的提现:大括号用JSONObject,注意传入数据对象)
            JSONObject jObj = new JSONObject(json);
//          2.实例化Person对象获取对应的值--->这里是获得外面大括号{}的name值 思考?里面{}如何获得?
            Person per=new Person();
            String name = jObj.getString("name");
            per.setName(name);
//          3.分析:里面{}是嵌套在外面大括号类的所以我们解析的对象是通过外面大括号去取得里面大括号值，注意看
            //取得对应里面大括号的girlFriend,取得name值，赋值给girlFriend对象
            GirlFriend girlFriend=new GirlFriend();
            JSONObject jObj1 = jObj.getJSONObject("girlFriend");
            String gfName = jObj1.getString("name");
            girlFriend.setName(gfName);
//          获得age值并赋值
            int gfAge = jObj1.getInt("age");
            girlFriend.setAge(gfAge);
//          通过set把girlFriend的值赋Person 用于toString的输出，不然为空
            per.setGirlFriend(girlFriend);
//          输出
            System.out.println(per);
    }catch (JSONException e) {
        e.printStackTrace();
    }
    }
}

 
 
 小结: ｛[ {},{} ]｝–>思路：第一步看到大括号：JSONObject去解,创建好对应里面的属性的值；第二步看到中括号：JSONArray去解析 对应创建好对应里面的属性值；第三步中括号里面的{}，又是一个JSONObject。思路大致如此，强调注意的是，设置的属性值setXxx getXxx必须要和去获得值名称一致，不然会出错！！
 
组合类型的解析(二):
 下面我们来解析一个略为复杂的JSON数据 

 要解析的数据如下:

 

{
    'desc': 'OK',
    'status': 1000,
    'data': {
        'wendu': '20',
        'ganmao': '相对于今天将会出现大幅度降温，易发生感冒，请注意适当增加衣服，加强自我防护避免感冒。',
        'forecast': [
            {
                'fengxiang': '北风',
                'fengli': '3-4级',
                'high': '高温 27℃',
                'type': '中雨',
                'low': '低温 19℃',
                'date': '6日星期五'
            },
            {
                'fengxiang': '北风',
                'fengli': '微风级',
                'high': '高温 23℃',
                'type': '大雨',
                'low': '低温 17℃',
                'date': '7日星期六'
            },
            {
                'fengxiang': '北风',
                'fengli': '微风级',
                'high': '高温 26℃',
                'type': '小雨',
                'low': '低温 17℃',
                'date': '8日星期天'
            },
            {
                'fengxiang': '南风',
                'fengli': '微风级',
                'high': '高温 27℃',
                'type': '多云',
                'low': '低温 15℃',
                'date': '9日星期一'
            },
            {
                'fengxiang': '南风',
                'fengli': '微风级',
                'high': '高温 29℃',
                'type': '多云',
                'low': '低温 16℃',
                'date': '10日星期二'
            }
        ],
        'yesterday': {
            'fl': '微风',
            'fx': '北风',
            'high': '高温 33℃',
            'type': '阴',
            'low': '低温 22℃',
            'date': '5日星期四'
        },
        'aqi': '58',
        'city': '成都'
    }
}

 
 
因为数据略大，不方便咱们看，这里给大家提供一个JSON在线解析工具http://json.phpddt.com/ 这是JSON在线高亮解析 ，可以很好的帮助咱们进行解析分析。下面是我用网页解析好的图片，可以思考下步骤(记住两条规则) 
 
 
分析： 
  
 一:第一个大括号(JSONObject)｛”desc”: “status”: “data”｝ 
 二：大括号里面有一个大括号(JSONObject)｛”wendu”: “20”, “ganmao”: “forecast”: “yesterday”: “aqi”: “city”: ｝ 
 三：第二个大括号里面有两个对象 1.数组形（JSONArray） 2.对象形( JSONObject ) 
 而数组形里面又套有数组的对象{} 。这就需要咱们在解析的时候需要很细致的去创建对应的属性值，JSON解析并不难，而难受的地方就提现在对类的创建中，只要够细心也超简单！
 
开始封装字段：
 

import java.util.List;

/**
 * 对应的字段的封装
 * @author sKy°
 * @date 2016-5-6
 * @version 1.0
 */
public class Weather {
//  外面大括号的字段封装 setter getter toString
    public String desc;
    public int status;
    public Data data;
    @Override
    public String toString() {
        return "Weather [desc=" + desc + ", status=" + status + ", data="
                + data + "]";
    }


}

class Data{
//  里面大括号的字段封装 setter getter toString 
//  该类中包含有数组形和对象形，需要一并的封装在里面
    public String wendu;
    public String ganmao;
    public List<Forecast> forecast;
    public Yesterday yesterday;
    public String aqi;
    public String city;
    @Override
    public String toString() {
        return "Data [wendu=" + wendu + ", ganmao=" + ganmao + ", forecast="
                + forecast + ", yesterday=" + yesterday + ", aqi=" + aqi
                + ", city=" + city + "]";
    }


}

class Forecast{
//  数组里面的大括号类型字段的封装
    public String fengxiang;
    public String fengli;
    public String high;
    public String type; 
    public String low;
    public String date;
    @Override
    public String toString() {
        return "Forecast [fengxiang=" + fengxiang + ", fengli=" + fengli
                + ", high=" + high + ", type=" + type + ", low=" + low
                + ", date=" + date + "]";
    }


}
class Yesterday{
//   最后{}的字段封装
    public String fl;
    public String fx;
    public String high;
    public String type;
    public String low;
    public String date;
    @Override
    public String toString() {
        return "Yesterday [fl=" + fl + ", fx=" + fx + ", high=" + high
                + ", type=" + type + ", low=" + low + ", date=" + date + "]";
    }

}

 
 
开始解析：
 
import java.util.ArrayList;
import java.util.List;

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




/**
 * 组合类型二的解析
 * @author sKy°
 * @date 2016-5-6
 * @version 1.0
 */
public class Test01 {
    public static void main(String[] args) throws Exception {

         //要解析的对象
        String json="{ 'desc': 'OK', 'status': 1000, 'data': { 'wendu': '20', 'ganmao': '相对于今天将会出现大幅度降温，易发生感冒，请注意适当增加衣服，加强自我防护避免感冒。', 'forecast': [ { 'fengxiang': '北风', 'fengli': '3-4级', 'high': '高温 27℃', 'type': '中雨', 'low': '低温 19℃', 'date': '6日星期五' }, { 'fengxiang': '北风', 'fengli': '微风级', 'high': '高温 23℃', 'type': '大雨', 'low': '低温 17℃', 'date': '7日星期六' }, { 'fengxiang': '北风', 'fengli': '微风级', 'high': '高温 26℃', 'type': '小雨', 'low': '低温 17℃', 'date': '8日星期天' }, { 'fengxiang': '南风', 'fengli': '微风级', 'high': '高温 27℃', 'type': '多云', 'low': '低温 15℃', 'date': '9日星期一' }, { 'fengxiang': '南风', 'fengli': '微风级', 'high': '高温 29℃', 'type': '多云', 'low': '低温 16℃', 'date': '10日星期二' } ], 'yesterday': { 'fl': '微风', 'fx': '北风', 'high': '高温 33℃', 'type': '阴', 'low': '低温 22℃', 'date': '5日星期四' }, 'aqi': '58', 'city': '成都' } }";

        Weather wea=new Weather();
//      首先看到的是一个{}所以用JSON Object来进行解析
//      获得外部的Weather
        JSONObject obj = new JSONObject(json);
        String desc = obj.getString("desc");
        int status = obj.getInt("status");
        wea.status=status;
        wea.desc=desc;

//      获得内部Data的数据
        JSONObject obj1 = obj.getJSONObject("data");
        Data data=new Data();
        data.wendu=obj1.getString("wendu");
        data.ganmao=obj1.getString("ganmao");
        data.aqi=obj1.getString("aqi");
        data.city=obj1.getString("city");
        wea.data=data;
        List<Forecast> forecasts=new ArrayList<>();

//      获取forecast数组
        JSONArray jArr = obj1.getJSONArray("forecast");
        for (int i = 0; i < jArr.length(); i++) {
            JSONObject obj2 = jArr.getJSONObject(i);
            Forecast forecast=new Forecast();
            forecast.date=obj2.getString("date");
            forecast.fengxiang=obj2.getString("fengxiang");
            forecast.high=obj2.getString("high");
            forecast.low=obj2.getString("low");
            forecast.fengli=obj2.getString("fengli");
            forecast.type=obj2.getString("type");
            forecasts.add(forecast);
        }
        data.forecast=forecasts;
        JSONObject obj3 = obj1.getJSONObject("yesterday");
        Yesterday yesterday=new Yesterday();
        yesterday.fl=obj3.getString("fl");
        yesterday.fx=obj3.getString("fx");
        yesterday.high=obj3.getString("high");
        yesterday.type=obj3.getString("type");
        yesterday.low=obj3.getString("low");
        yesterday.date=obj3.getString("date");
        data.yesterday=yesterday;

//      输出字段
        System.out.println(wea);
    }


 
解析结果:
 
 
 
结语: 对于JSON解析个人的粗浅看法， 
 1.首先是对JSON数据的一个分析 
 2.其次是掌握JSON一些技巧(两条规则–对象形JSONObject ,数组形JSONArray) 
 3.而后是对对应的属性值进行对应的字段封装建立对应的类(分析要细心,思路要清晰,程序这行需要有耐心不能浮躁) 
 4.而后是解析中要有明确的思路
 
(以上只是一个JSON初步的解析，但JSON解析的大致思路如此，后面有http套用的，无非也就把下载的文件转为JSON对象,后面解析思路也是如此，写的不好的地方大家包涵！有啥问题，欢迎留言!)
 

本文主要介绍使用 jsoncpp 库，编写C++语言的 JSON 解析程序。
 
1 概述
 
jsoncpp 是一个可以与 JSON 进行交互的C++库。官网定义如下：
 
jsoncpp is an implementation of a JSON reader and writer in C++.
 
通过使用 jsoncpp ，我们可以对 JSON 进行读写。
 
2 示例代码
 
2.1 从字符串中解析json
 
从字符串中解析 json 的代码（jsonstrparse.cpp）如下：
 
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>

using namespace std;

int main()
{
    string strJsonContent = "{\"role_id\": 1,\"occupation\": \"paladin\",\"camp\": \"alliance\"}";

    int nRoleDd = 0;
    string strOccupation = "";
    string strCamp = "";
    
    Json::Reader reader;
    Json::Value root;

    if (reader.parse(strJsonContent, root))
    {
        nRoleDd = root["role_id"].asInt();
        strOccupation = root["occupation"].asString();
        strCamp = root["camp"].asString();
    }

    cout << "role_id is: " << nRoleDd << endl;
    cout << "occupation is: " << strOccupation << endl;
    cout << "camp is: " << strCamp << endl;

    return 0;
}

 
使用如下命令编译上述代码，命令如下：
 
g++ -o jsonstrparse jsonstrparse.cpp -ljsoncpp
 
运行编译生成的程序，结果如下：
 
 
从上述结果能够看到，我们成功地解析了字符串中的 json 数据。
 
2.2 从字符串中解析带有数组的json
 
示例代码（json_parse_array.cpp）如下：
 
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>

using namespace std;

int main()
{
    string strJsonContent = "{\"list\" : [{ \"camp\" : \"alliance\",\"occupation\" : \"paladin\",\"role_id\" : 1}, \
        {\"camp\" : \"alliance\",\"occupation\" : \"Mage\",\"role_id\" : 2}],\"type\" : \"roles_msg\",\"valid\" : true}";

    string strType;
    int nRoleDd = 0;
    string strOccupation;
    string strCamp;
    
    Json::Reader reader;
    Json::Value root;

    if (reader.parse(strJsonContent, root))
    {
        // 获取非数组内容
        strType = root["type"].asString();
        cout << "type is: " << strType << endl;

        // 获取数组内容
        if (root["list"].isArray())
        {
            int nArraySize = root["list"].size();
            for (int i = 0; i < nArraySize; i++)
            {
                nRoleDd = root["list"][i]["role_id"].asInt();
                strOccupation = root["list"][i]["occupation"].asString();
                strCamp = root["list"][i]["camp"].asString();

                cout << "role_id is: " << nRoleDd << endl;
                cout << "occupation is: " << strOccupation << endl;
                cout << "camp is: " << strCamp << endl;
            }
        }
    }
    
    return 0;
}


 
编译并运行上述代码，结果如下：
 
 
从上述结果能够看到，我们成功地解析了字符串中的 包含数组的 json 数据。
 
3 使用说明
 
3.1 编译错误
 
在上面的源码中，引用 json.h 时使用了如下语句：
 
#include <jsoncpp/json/json.h>
 
这里如果使用如下语句替换上面的 include 语句（当然需要同步修改头文件目录），如下：
 
#include "json.h"
 
在编译时则会报错，很多错，看起来与 GLIBC 相关的，部分错误信息如下：
 
/usr/include/bits/sched.h:132:20: error: missing binary operator before token "("
 # if __GNUC_PREREQ (2, 91)
                    ^
 
出现上述编译错误的原因是 jsoncpp 提供的头文件 /usr/local/include/json/features.h 与 GLIBC 提供的头文件 /usr/include/features.h 有冲突，如果我们使用 #include "json.h" 形式包含 json.h，则需要把头文件包含路径设置为 /usr/local/include/json/，此时，如果代码中有地方包含了 features.h（实际上，这是个很常用的头文件，很多地方都会包含此文件），则就会使用 json 提供的 features.h 了（而不是 GLIBC 提供的那个 features.h），从而导致 GLIBC 提供的 features.h 中的一些宏定义缺失（如上面的编译错误），进而导致编译失败。
 
此问题的解决方案也很简单，就是按照我们提供的示例代码，不直接包含 json.h，而使用间接包含，如：
 
#include "jsoncpp/json/json.h"
 
或
 
#include "json/json.h"
 
均可（注意适配修改头文件路径）。