精华内容
下载资源
问答
  • Unity Json解析

    2018-09-25 14:05:51
    Unity与服务器交互取得数据后的json解析工具,使用灵活 方便。listJson和Newtonsoft.Json
  • 超大流式解析JSON文件,适用于格式为json数组的文件。理论上对文件大小无要求。
  • json3.js 【JS / JavaScript 中解析JSON的js包,JSON官方的JSON解析包】。JavaScript中解析JSON的js包,页面中引入json3.js,即可使用。 使用方法:JSON.parse(str), JSON.stringify(obj) 更多详情请参考博文: ...
  • C/C++解析JSON Exjson**是一款高性能的基于Flex & Bison的 **JSON** 解析器,**Xserver**引擎自带 **Exjson** 解析器,其他需要使用的只需要引入几个头文件和源文件即可
  • windows下得json解析工具 windows下得json解析工具 windows下得json解析工具windows下得json解析工具
  • c#解析带数组的json,采用Newtonsoft.Json。资源是VS2013创建的工程。适合新手使用,老鸟就自己钻研解析哦~
  • C#对多级json解析

    2016-03-26 10:52:16
    C#对多级json解析,非常实用,此代码写在load事件里面,然后可以了解解析json的原理。尤其是多级解析。
  • Vc++/MFC下 Json解析

    热门讨论 2014-04-02 22:42:59
    Vc++/MFC 、 Json解析,内涵jsonDLL.lib文件和json文件夹,还有Json实例。将json文件夹放到工程所在路径下,然后在工程里包含里面所有的头文件和引用lib文件。添加头文件:#pragma comment(lib, "JsonDLL.lib") #...
  • 实现Delphi下Json解析,支持DelphiXe10,官网下载的最高支持到Xe7。
  • json解析万能工具类

    热门讨论 2013-11-12 13:15:46
    用于json解析万能工具类,只需传入jsonString以及数据模板类,可以返回对应的对象或list对象
  • C#Json解析类,Json协议解析。

    热门讨论 2011-04-28 17:06:08
    C#Json解析类,使用本文中的JSONConvert类可将任意JSON字符串转化为JSONObject或JSONArray对象,并获取需要的值,克服了.NET自带JSON类反序列化时需知道并引用序列化时使用的类的缺点。当然,也可以使用JSONConvert...
  • 新手小白分享 从Json原生解析到jar包解析
  • mac系统JSON解析工具

    2013-10-17 15:38:35
    一款非常好用的JSON数据解析软件
  • 纯C语言实现的json解析,很好用!封装得很好,请需要的同学放心下载
  • PB调用http api接口,PB解析json到数据源,get和post都有案列,PB解析json,可解析树立菜单,也完美可解析后将结果存到数据源
  • HttpPost请求和JSON解析

    2014-02-17 18:17:43
    简单的HttpPost请求和JSON解析 【包含完整的注释,适合初学者学习】
  • Json解析获取网络图片

    热门讨论 2013-01-14 14:54:14
    本程序实现解析网络图片,并显示在android手机上。
  • Java Json解析,Java Web Json解析,Java Web服务端获取Json数据,客户端通过HTTP获取Json数据
  • json离线解析工具

    2018-06-20 17:00:14
    这是一款windows版绿色的离线json解析工具,还在担心json格式化吗?简单易用。完全绿色,不需要安装。离线即可将json数据进行格式化。且自动去除数据中字段为null的字段
  • android json解析详解(json手动解析)

    万次阅读 多人点赞 2017-11-13 08:43:17
    一 .json简介 1)概念:json全称是javaScript object Notation,是一种病轻量级的数据交换格式。 2)特点: 1.本质就是具有特定格式的字符串 2,.json完全独立于编程语言 3.json比xml数据传输的有效性要高出很多...
    一 .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)特点:编码简洁,谷歌官方推荐
    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库
    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;
        }
    }


    展开全文
  • SQL SERVER Json 解析方法

    万次阅读 2018-09-25 10:45:02
    整理记录一个Json解析的函数方法,方法如下: Create FUNCTION [dbo].[parseJSON]( @JSON NVARCHAR(MAX)) RETURNS @hierarchy TABLE ( element_id INT IDENTITY(1, 1) NOT NULL, /* internal surrogate ...

           整理记录一个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解析步骤

    万次阅读 多人点赞 2016-09-19 14:58:56
    JSON简介 JAVAScript Object Notation是一种轻量级的数据交换格式具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持)JSON采用...

    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对象,后面解析思路也是如此,写的不好的地方大家包涵!有啥问题,欢迎留言!)


    展开全文
  • 安卓天气预报DEMO(API+JSON解析

    热门讨论 2015-05-16 09:53:42
    安卓天气预报小DEMO 欢迎下载
  • JSON解析(C++)

    万次阅读 2019-08-21 17:20:33
    本文主要介绍使用 jsoncpp 库,编写C++语言的 JSON 解析程序。 1概述 jsoncpp 是一个可以与 JSON 进行交互的C++库。官网定义如下: jsoncpp is an implementation of a JSON reader and writer in C++. 通过使用...

    本文主要介绍使用 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"

    均可(注意适配修改头文件路径)。

     

    展开全文
  • 一、简介利用递归的方式反射解析到bean里面二、详细代码1、 Json格式例如服务器指定规定json格式为:{ "code": "……" , // 返回代号,预留字段,默认返回null "type":"ERROR", // 返回类型,表示操作是成功或失败 ...
  • Delphi 7下的JSON解析

    热门讨论 2010-12-02 02:12:48
    delphi下的json解析器,挺好用的 将里面的superobject.dcu添加进工程就可以了
  • 几种常用的JSON解析工具的使用

    万次阅读 2018-09-09 22:44:56
    目录 简介: (1)org.json的使用 (2)net.sf.json的使用 ...现在越来越多的网站采用JSON来交换数据,在Json.org网站上,Java可以使用的解析Json的组件就有超过20种。 Json官网:http://json.org/ 页面...
  • json解析用到的所有jar包 .
  • Json解析(Json集合,Json嵌套)

    万次阅读 2018-12-02 16:15:15
    导入maven依赖: &lt;dependency&gt; &lt;groupId&gt;net.sf.json-lib&...json-lib&lt;/artifactId&gt; &lt;version&gt;2.4&lt;/version&gt; &lt;cl

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457,725
精华内容 183,090
关键字:

json解析