基本概念,校验实例

JSON Schema 那一个事情:基本概念

2016/01/27 · HTML5 ·
JSON

原文出处: 天猫商城前端团队(FED)-
邦彦   

亚洲必赢官网 1

1. JSON Schema关键字简介

上篇作品中,大家因此一个不难的JSON Schema的例证,简要地介绍了JSON
Schema中时常应用的首要字,并介绍了有的在线支持工具。一般的话,领会了这个知识点就足以应对比较常见的必要情形了,不过,若是你必要更加多的定制化需求以及进一步深刻的底细校验的话,那么,我们就必要越来越询问越来越多主要字的用法和选拔处境。

本文相关代码,请看这里

转载:
http://www.jianshu.com/p/8b428e1d1564\#

引子

在早期的天猫商城 TMS
页面搭建系统中,为了缓解页面模板和数目标离别难题,机智的圣人们增加了一层层灵活的
PHP
标签函数,得以将数据的定义从沙盘视图中解耦出来。以其中一个极其常用的函数为例:

JavaScript

_tms_custom(‘{“name”:”TextLinks”,”title”:”文字链接”,”group”:”文字链接”,”row”:”10″,”defaultRow”:”5″,”fields”:”text:文字:string,href:链接地址(URL):href”}’);

1
_tms_custom(‘{"name":"TextLinks","title":"文字链接","group":"文字链接","row":"10","defaultRow":"5","fields":"text:文字:string,href:链接地址(URL):href"}’);

当调用 _tms_custom(...) 函数并传到指定格式的 JSON
参数,交由翻译引擎处理后,会创设出那样的编排表单:

亚洲必赢官网 2

而由此编制表单录入的数目,最后会在页面中以 PHP 数组的花样填充和占位:

JavaScript

array(5) { [0]=> array(2) { [“text”]=> string(6) “淘宝网”
[“href”]=> string(22) “” }, … }

1
2
3
4
5
6
7
8
9
10
array(5) {
[0]=>
array(2) {
["text"]=>
string(6) "淘宝网"
["href"]=>
string(22) "http://www.taobao.com/"
},
}

从标签函数到数量对象的运转流程,可以用一张图不难予以概括:

亚洲必赢官网 3

那种模板和数量分离的法子,在早些年那是一对一先进的。它用简单的语法,描述了模版所需的多寡格式,还足以根据标签定义,直接社团出模拟数据,方便在开发阶段使用
“标签 + 模拟数据” 的措施调试页面。

叙述数据格式布局模拟数据 的角度,那和大家要谈的 JSON
Schema 不谋而合。我们用 JSON 格式来重写多少对象,应该是酱紫的:

JavaScript

[ { “text”: “淘宝网”, “href”: “” }, … ]

1
2
3
4
5
6
7
[
{
    "text": "淘宝网",
    "href": "http://www.taobao.com/"
},
]

一经用 JSON Schema
语法描述那份数据,可以完全代表标签函数的方案。那也多亏天猫商城 TMS
页面搭建系统在数量那块的衍生和变化进度:即从使用标签函数定义数据的方法,转变为使用
JSON Schema 描述数据。

2. JSON Schema关键字详解

例一:涉及的机要字($schema、title、description、type、properties、required)

{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "title": "TestInfo",
    "description": "some information about test",
    "type": "object",
    "properties": {
        "name": {
            "description": "Name of the test",
            "type": "string"
        }
    },
    "required": [
        "name"
    ]
}

JSON Schema 简介

JSON Schema is a vocabulary that allows you to annotate and validate
JSON documents.

JSON
Schema官网

JSON Schema
是一个方可对json格式数据举办校验和进展内容叙述的文档,它自身也是根据json格式的。
驷不及舌有以下职能:

  1. 对现有的json数据格式举行描述(字段类型、内容长度、是不是必须存在、取值示例等);
  2. 是一个叙述清晰、人机可读的文档;
  3. 自动测试、验证客户端提交的多少;

JSON概览

JSON(JavaScript Object
Notation)是一种基于文本的数据交流格式。无论你的施用是用哪一种开发语言编写的(Java/EE,Ruby,PHP,C#/.Net等等),你都可以运用JSON来通过互连网进行数量交互和处理。大概所有的编程语言都有很好的库或第三方工具来提供按照JSON的API协理,因而你可以极度有利于地使用其余自己喜爱的编程语言来处理JSON数据。而另一方面随着REST、像MongoDB那样的NoSQL技术或正式的常见应用,JSON也正变成一种被引进的数码交互格式。

JSON是在2001年,由道格拉斯 Crockford创造的,并且被IETF(Internet
Engineering Task Force)定义为RFC
4627标准,详请参考:http://tools.ietf.org/html/rfc4627。JSON的媒体类型被定义为
application/json,而文件的后缀为.json。

什么是 Schema?

当大家在讲述 文字链接
的时候,必要预约数据的团队方式,比如,须要通晓有哪些字段,这一个字段的取值如何表示等,那就是
JSON Schema 的源于。

我们以 文字链接 为例,它对应的 JSON Schema 大约如此:

JavaScript

{ “type”: “object”, “properties”: { “text”: { “type”: “string”, “title”:
“文字” }, “href”: { “type”: “string”, “title”: “链接地址(URL)” } } }

1
2
3
4
5
6
7
8
9
10
11
12
13
{
"type": "object",
"properties": {
"text": {
"type": "string",
"title": "文字"
},
"href": {
"type": "string",
"title": "链接地址(URL)"
}
}
}

JSON Schema 概念了怎么样依据 JSON 格式描述 JSON
数据结构的正规化,进而提供数据校验、文档生成和接口数据交互控制等一名目繁多能力。它的特性和用途,可以大概归咎为以下几点:

2.1 $schema

该重大字用于指定JSON
Schema版本新闻,例一中指定的本子为:draft-04。该重大字是能够简单的,当前风靡版本为draft-06。注意:该重大字的值必须选择官方提供的值,不可以和谐无论写。

JSON Schema 不难示例

咱俩把需要被评释的json文档称为instance,用来校验它的文档就是schema;
一个最基础的schema就是一个空的json对象 {}
,对instance不做任何限制,没有其余描述。上边是一个概括的instance和schema示例:

内需被校验的instance:

{
  "foo": 32,
  "bar": "Must equal this value"
}

schema:

{
  "type": "object",
  "properties": {
    "foo": {
      "type": "number"
    },
    "bar": {
      "const": "Must equal this value"
    }
  }
}

里头重大字“type”能够用来对instance的种类进行限定,它可以取如下多少个值
object, array, string, number, boolean, null。
关键字“const”要求被证实的数码与其所定义的内容保持一致。

JSON是什么

JSON是一种简单多少格式,它有二种数据结构:

  • 键值对 —— Name/Value (Key/Value)
  • 对象 —— Object
  • 数组 —— Arrays

一个立竿见影的JSON文档需要被含有在一对花括号内
{ JSON-Data }

请小心,有些开发社区或线上文档直接将上边的JSON文档称为JSON字符串,那四头的意思是一致的

1. 用于描述数据结构

在叙述 JSON
数据时,如若数额本身的复杂度很高,高到三维四维,普通的竹签函数已经无力回天代表那种层级结构了,而
JSON Schema 利用 objectarray
字段类型的高频嵌套,可以避开除这一个毛病。

本来,除了键值等为主音信,规范范围还提供了充分的显要词接济,假诺想透过自定义扩大字段,解决特定情景的业务需要,也是老大方便的。

2.2 title和description

那五个第一字都是用来讲述对应的JSON元素的,唯一的不同在于,title相对来说,越发简洁,而description越发倾向于详细描述相关新闻。当然了,那四个根本字都是足以省略的。我们看出例一中最外层的title和description是对待校验JSON对象的叙说,而里面,name元素之下的description其实是比照校验JSON对象的顶级key(name)的描述,当然,你也可以对name扩充title信息。

JSON Schema 在线工具

根据JSON数据和对应的JSON Schema校验数据:
http://json-schema-validator.herokuapp.com/
https://jsonschemalint.com/

据悉JSON数据在线生成JSON Schema:
https://jsonschema.net/

为什么使用JSON

JSON被认为是XML的很好替代者。因为JSON的可读性万分好,而且它从不像XML那样带有众多冗余的元素标签,那使得应用在采纳JSON举行互联网传输以及开展分析处理的快慢更快,效用更高。

2. 用来营造人机可读的文档

微机领域有个概念叫做自描述。所谓自描述,可以了然为:文档本身富含了自己与任何文档交相互关的叙述音讯,不须求其它的布局文件或者额外新闻来描述。

而 JSON Schema
就是自描述的,它自己就是一份很全面的验证文档,字段的意思表明、该怎么着取值、格式的渴求等都清晰明了。

2.3 type

该重大字用于限定待校验JSON元素所属的数据类型,例一中最外层的type关键字值为object,即意味着待校验JSON数据为一个JSON对象,而name下的type关键字值为string,即表示待校验JSON对象中的一级key(name)的数据类型为string。那么,根据这些需求,上面那些JSON数据是符合供给的。

{
    "name": "hello first blog"
}

而,下边那几个JSON数据是不符合需要的,因为name的品种为integer或者number,而不是string。

{
    "name": 520
}

JSON Schema第三方工具

JSON
Schema已经有各个语言完成的第三方工具得以应用,详见官网证实:http://json-schema.org/implementations。上边3个是java的相关兑现:

json-schema-validator
supports draft 4 includes draft-04 hype-schema syntax support (LGPLv3)
json-schema
(implementation based on the org.json API) supports draft 4, draft 6
(Apache License 2.0)
json-schema-validator
supports draft 4 (Apache License 2.0)

键值对 —— Name/Value

键值对是JSON中最基本的数据结构:
{ “firstName”: “John”}

在地点的事例中属性”firstName”是用一对双引号括起来的一个字符串。而它的值”John”在这几个例子中也是一个字符串,当然它还是可以够是任何门类,具体可参考前面数据类型的章节。在市面上很多的出品或技术声称他们使用的是JSON数据格式,但她俩在概念属性时,并没有用双引号将属性名称括起来,其实那是违反JSON定义标准的。

3. 用来转移模拟数据

透过标签函数生成模拟数据,只可以解决主干的格式需要。比如 string
类型的字段,模拟出来的数目,无非是一个随便字符串。

但在 JSON Schema
中,由于字段的讲述不仅仅是种类,更加多的羁绊规范,可以确保模拟数据更类似于真实数据。

2.3.1 type常见取值

那么,type又有何样取值呢?当type取值为string类型的时候,是或不是还足以添加任何一些外加限制标准吧?大家接下去会根据type的不比取值一点点剖析涉及到的重中之重字含义及用法。首先,大家来看一下,type常见的取值。具体如下:

type取值 对应的Java数据类型
object java.lang.Object
array java.util.List
integer int(java.lang.Integer)
number float(java.lang.Float)或int
null null
boolean java.lang.Boolean
string java.lang.String

在上表中,大家利用了和Java数据类型相比分析的样式提交了type的常见取值,接下去,我们会分析当type为差距取值时,可能涉嫌的重大字含义和用法。

利用第三方工具json-schema-validator

上面采纳上述3个工具中的第二个,完成用schema验证json数据的法力:
1.首先在pom里,添加如下配置:

                <!-- fge -->
        <dependency>
            <groupId>com.github.fge</groupId>
            <artifactId>json-schema-validator</artifactId>
            <version>2.2.6</version>
        </dependency>
        <!-- fasterxml -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.8</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.8</version>
        </dependency>

2.编纂工具类JsonSchemaValidator.java

public class JsonSchemaValidator {
    public static Map<String, Object> validateJsonByFgeByJsonNode(JsonNode jsonNode, JsonNode schemaNode) {
        Map<String, Object> result = new HashMap<String, Object>();
        ProcessingReport report = null;
        report = JsonSchemaFactory.byDefault().getValidator().validateUnchecked(schemaNode, jsonNode);
        if (report.isSuccess()) {
            // 校验成功
            result.put("message", "校验成功!");
            result.put("success", true);
            return result;
        } else {
            System.out.println("校验失败!");
            Iterator<ProcessingMessage> it = report.iterator();
            String ms = "";
            while (it.hasNext()) {
                ProcessingMessage pm = it.next();
                if (!LogLevel.WARNING.equals(pm.getLogLevel())) {
                    ms += pm;
                }

            }
            result.put("message", "校验失败!" + ms);
            result.put("success", false);
            return result;
        }
    }

    public static JsonNode getJsonNodeFromString(String jsonStr) {
        JsonNode jsonNode = null;
        try {
            jsonNode = JsonLoader.fromString(jsonStr);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return jsonNode;
    }

    public static JsonNode getJsonNodeFromFile(String filePath) {
        JsonNode jsonNode = null;
        try {
            jsonNode = new JsonNodeReader().fromReader(new FileReader(filePath));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return jsonNode;
    }

}

3.接受页面数据、读取文件数量的JsonSchemaController

@RestController
public class JsonSchemaController {

    @Value("${upload.rootPath}")
    private String rootPath;


    @RequestMapping(value = "/json-schema/validate", method = RequestMethod.GET)
    public Map<String, Object> jsonSchemaValidate(String jsonStr) {
        Map<String, Object> result = new HashMap<String, Object>();

        JsonNode jsonNode = JsonSchemaValidator.getJsonNodeFromString(jsonStr);
        if (jsonNode == null) {
            result.put("success", false);
            result.put("message", "json报文格式错误");
            return result;
        }

        String filePath =  rootPath + "/json-file/json_schema_test.json";
        JsonNode schemaNode = JsonSchemaValidator.getJsonNodeFromFile(filePath);
        if (schemaNode == null) {
            result.put("success", false);
            result.put("message", "json Schema文件不存在,无法校验!");
            return result;
        }
        return JsonSchemaValidator.validateJsonByFgeByJsonNode(jsonNode, schemaNode);
    }

}

3.前端页面json_schema.html

<body class=" ">
    <div>
        <textarea class=" " name="parameterContentLeft" id="parameterContentLeft" placeholder="请输入请求报文内容"></textarea>
    </div>
    <br>
    <button onclick="setAjaxRequest();" id="doJson" class=" ">发送</button>
    <div class=" ">
        <pre id="responsePre">

        </pre>
    </div>
    <script src="frame/jquery.min.js"></script>
    <script>
        function setAjaxRequest() {
            $.ajax({
                url : "/json-schema/validate",
                type : "GET",
                data : {
                    jsonStr : $("#parameterContentLeft").val()
                },
                async : false
            }).done(function(data) {
                $("#responsePre").html(data.message);
            });
        }
    </script>
</body>

对象 —— Object

一个JSON对象是涵盖了一组未排序键值对的汇集。下边例子中的address就是一个JSON对象:

{
    “address” : {
        “line1” : “555 Main Street”,
        “city” : “Denver”,
        “stateOrProvince” : “CO”,
        “zipOrPostalCode” : “80202”,
        “country” : “USA”
    }
}

地点的例子中address对象涵盖了5个属性,它们中间用,举行划分

4. 用来校验数据,完毕自动化测试

接口数据的校验工作,往往借助于测试代码逻辑和用例。假如用 JSON Schema
描述一个数量接口,就不须要再编辑测试代码了,所有的逻辑都足以移植到 JSON
Schema 中爱戴。同盟 jsvtv4
等二方校验工具,接口测试可以真正自动化。

2.3.2 从type的两样取值说起

(1)当type取值为object时,涉及的基本点字:properties、required、minProperties、maxProperties、propertyNames、dependencies、patternProperties、additionalProperties

  • properties

该重大字的值是一个对象。

用于指定JSON对象中的各个不同key应该满意的校验逻辑,如若待校验JSON对象中所有值都可以因而该重大字值中定义的呼应key的校验逻辑,每个key对应的值,都是一个JSON
Schema,则待校验JSON对象通过校验。从那里,大家可以见见,只要待校验JSON对象的有着key分别都经过相应的JSON
Schema的校验检测,那个目的才好不不难通过校验。

此外,须求专注的是,省略该重大字和该重大字的值为空对象,具有同等效果。例如:

"properties": {
        "id": {
            "description": "The unique identifier for a book",
            "type": "integer",
            "minimum": 1
        },
        "price": {
            "type": "number",
            "minimum": 0,
            "exclusiveMinimum": true
        }
    }
  • required

该重大字的值是一个数组,而数组中的元素必须是字符串,而且必须是绝无仅有的。

该重大字限制了JSON对象中务必带有哪些超级key。若是一个JSON对象中含有required关键字所指定的具有一流key,则该JSON对象可以透过校验。

别的,须求专注的是,省略该重大字和该重大字的值为空数组,具有相同效果。例如:

"required": [
        "id",
        "name",
        "price"
    ]
  • minProperties、maxProperties

那三个第一字的值都是非负整数。

点名了待校验JSON对象中一级key的个数限制,minProperties指定了待校验JSON对象足以承受的至少顶尖key的个数,而maxProperties指定了待校验JSON对象足以承受的最多一级key的个数。

其它,需求留意的是,省略minProperties关键字和该重大字的值为0,具有同等功用。而,若是简单maxProperties关键字则象征对超级key的最大个数没有限制。例如,假诺界定一个JSON对象的一流key的最大个数为5,最小个数为1,则JSON
Schema如下:

"minProperties": 1,
"maxProperties": 5
  • propertyNames

在意:该重大字,官方认证中援救,可是,有可能你使用的阳台依然第三方工具不协助啊。所以,使用需谨慎。

该重大字的值是一个管用的JSON Schema。

借使待校验JSON对象中的每个顶尖key都能通过该重大字指定的JSON
Schema的校验,那么才认为待校验的JSON对象通过校验。注意,待校验JSON对象的一流key都是string类型。

除此以外,必要专注的是,省略该重大字和该重大字的值为空JSON
Schema,具有同样作用。

  • patternProperties

该重大字的值是一个JSON对象,该JSON对象的每一个一流key都是一个正则表明式,value都是一个JSON
Schema。

基本概念,校验实例。唯有待校验JSON对象中的一级key,通过与之匹配的patternProperties中的一流正则说明式,对应的JSON
Schema的校验,才算通过校验。例如,借使patternProperties对应的值如下:

"patternProperties": {
        "^a": {
            "type": "number"
        },
        "^b": {
            "type": "string"
        }
}

上面的JSON
Schema表示,待校验JSON对象中,所有以a开端的超级key的value都必须是number,所有以b初步的顶尖key的value都不可能不是string。

  • additionalProperties

该重大字的值是一个JSON Schema。

倘使待校验JSON对象中存在,既没有在properties中被定义,又尚未在patternProperties中被定义,那么那一个一级key必须透过additionalProperties的校验。

  • dependencies

待定。。。

  • 总体示例:

{
    "type": "object",
    "properties": {
        "id": {
            "description": "The unique identifier for a book",
            "type": "integer",
            "minimum": 1
        },
        "price": {
            "type": "number",
            "minimum": 0,
            "exclusiveMinimum": true
        }
    },
    "patternProperties": {
        "^a": {
            "type": "number"
        },
        "^b": {
            "type": "string"
        }
    },
    "additionalProperties": {
        "type": "number"
    },
    "minProperties": 1,
    "maxProperties": 5,
    "required": [
        "id",
        "name",
        "price"
    ]
}

(2)当type取值为array时,涉及的最主要字:items、additionalItems、minItems、maxItems、uniqueItems、contains

  • items

该重大字的值是一个有效的JSON Schema或者一组有效的JSON Schema。

当该重大字的值是一个卓有效能的JSON
Schema时,只有待校验JSON数组中的所有因素均经过校验,整个数组才算通过校验。例如,假诺items关键字的现实定义如下:

{
   "type": "array",
   "items": {
     "type": "string",
     "minLength": 5 
   }
}

地点的JSON
Schema的意思是,待校验JSON数组的因素都是string类型,且最小可接受长度是5。那么下边这些JSON数组显著是符合须要的,具体内容如下:

["myhome", "green"]

那么上边那几个JSON数据则是不符合需求,因为第三个因素的长度小于5,具体内容如下:

["home", "green"]

当该重大字的值是一组有效的JSON
Schema时,唯有待校验JSON数组的具备因素通过items的值中对应地方上的JSON
Schema的校验,那么,整个待校验JSON数组才算通过校验。

此间须求专注的是,假设items定义的实用的JSON
Schema的数据和待校验JSON数组中元素的数量分化等,那么就要拔取“取小规则”。即,假如items定义了3个JSON
Schema,可是待校验JSON数组唯有2个要素,那时,只要待校验JSON数组的前四个元素可以分别通过items中的前七个JSON
Schema的校验,那么,大家以为待校验JSON数组通过了校验。而,若是待校验JSON数组有4个元素,这时,只要待校验JSON数组的前八个因素可以通过items中对应的JSON
Schema的校验,大家就以为待校验JSON数组通过了校验。

譬如说,借使items的值如下:

{
    "type": "array",
    "items": [
        {
            "type": "string",
            "minLength": 5
        },
        {
            "type": "number",
            "minimum": 10
        },
        {
            "type": "string"
        }
    ]
}

地点的JSON
Schema提议了待校验JSON数组应该满意的尺度,数组的率先个要素是string类型,且最小可承受长度为5,数组的第四个因素是number类型,最小可接受的值为10,数组的首个要素是string类型。那么上边那五个JSON数组显明是符合要求的,具体内容如下:

["green", 10, "good"]

["helloworld", 11]

上边那三个JSON数组却是不符合需求的,具体内容如下:

["green", 9, "good"]

["good", 12]
  • additionalItems

该重大字的值是一个实用的JSON Schema。

急需小心的是,该重大字只有在items关键字的值为一组有效的JSON
Schema的时候,才方可选取,用于规定超出items中JSON
Schema总数量之外的待校验JSON数组中的剩余的元素应该满足的校验逻辑。当然了,只有那些剩余的具备因素都满意additionalItems的渴求时,待校验JSON数组才算通过校验。

实在,你可以如此清楚,当items的值为一组有效的JOSN
Schema的时候,一般能够和additionalItems关键字组合使用,items用于规定对应地点上相应满足的校验逻辑,而additionalItems用于规定超出items校验范围的持有剩余元素应该满足的基准。如果两岸同时存在,那么唯有待校验JSON数组同时通过双方的校验,才算真的地通过校验。

除此以外,要求专注的是,若是items只是一个得力的JSON
Schema,那么就不可能拔取additionalItems,原因也很粗略,因为items为一个实用的JSON
Schema的时候,其规定了待校验JSON数组所有因素应该满足的校验逻辑。additionalItems已经没有用武之地了。

最后,同样强调一下,省略该重大字和该重大字的值为空JSON
Schema,具有同样效果。

设若一个additionalItems的值如下:

{
    "type": "array",
    "items": [
        {
            "type": "string",
            "minLength": 5
        },
        {
            "type": "number",
            "minimum": 10
        }
    ],
    "additionalItems": {
        "type": "string",
        "minLength": 2
    }
}

上面的JSON
Schema的趣味是,待校验JSON数组第三个因素是string类型,且可承受的最短长度为5个字符,第三个要素是number类型,且可承受的最小值为10,剩余的任何因素是string类型,且可接受的最短长度为2。那么,下边四个JSON数组是力所能及透过校验的,具体内容如下:

["green", 10, "good"]

["green", 11]

["green", 10, "good", "ok"]

下边JSON数组是无力回天透过校验的,具体内容如下:

["green", 10, "a"]

["green", 10, "ok", 2]
  • minItems、maxItems

那多个主要字的值都是非负整数。

点名了待校验JSON数组中元素的个数限制,minItems指定了待校验JSON数组可以承受的最少元素个数,而maxItems指定了待校验JSON数组能够接受的最多因素个数。

除此以外,须求留意的是,省略minItems关键字和该重大字的值为0,具有同样效果。而,如若简单maxItems关键字则意味着对元素的最大个数没有限制。例如,假若界定一个JSON数组的因素的最大个数为5,最小个数为1,则JSON
Schema如下:

"minItems": 1,
"maxItems": 5
  • uniqueItems

该重大字的值是一个布尔值,即boolean(true、false)。

当该重大字的值为true时,只有待校验JSON数组中的所有因素都有所唯一性时,才能由此校验。当该重大字的值为false时,任何待校验JSON数组都能经过校验。

其它,须求注意的是,省略该重大字和该重大字的值为false时,具有同样的功效。例如:

"uniqueItems": true
  • contains

瞩目:该重大字,官方认证中接济,不过,有可能你利用的平台依然第三方工具不支持啊。所以,使用需谨慎。

该重大字的值是一个使得的JSON Schema。

唯有待校验JSON数组中最少有一个元素可以因而该重大字指定的JSON
Schema的校验,整个数组才算通过校验。

此外,要求小心的是,省略该重大字和该重大字的值为空JSON
Schema具有同等功效。

  • 全体示例:

{
    "type": "array",
    "items": [
        {
            "type": "string",
            "minLength": 5
        },
        {
            "type": "number",
            "minimum": 10
        }
    ],
    "additionalItems": {
        "type": "string",
        "minLength": 2
    },
    "minItems": 1,
    "maxItems": 5,
    "uniqueItems": true
}

(3)当type取值为integer或number时,涉及的第一字:multipleOf、maximum、exclusive马克斯imum、minimum、exclusiveMinimum

大家率先来回顾一下integer和number的分别,integer相当于Java中的int类型,而number相当于Java中的int或float类型。

  • multipleOf

该重大字的值是一个大于0的number,即可以是大于0的int,也得以是大于0的float。

唯有待校验的值可以被该重大字的值整除,才算通过校验。

设若带有该重大字的JSON Schema如下:

{
    "type": "integer",
    "multipleOf": 2
}

那就是说,2、4、6都是足以经过校验的,可是,3、5、7都是力不从心通过校验的,当然了,2.0、4.0也是无能为力通过校验的,不过,并不是因为multipleOf关键字,而是因为type关键字。

若果带有multipleOf关键字的JSON Schema如下:

{
    "type": "number",
    "multipleOf": 2.0
}

那就是说,2、2.0、4、4.0都是可以通过校验的,然而,3、3.0、3、3.0都是无能为力透过校验的。

别的,必要注意的是,省略该重大字则不对待校验数值举办该项校验。

  • maximum

该重大字的值是一个number,即可以是int,也足以是float。

该重大字规定了待校验元素可以通过校验的最大值。

省略该重大字,即意味着对待校验元素的最大值没有须要。

  • exclusiveMaximum

该重大字的值是一个boolean。

该重大字平时和maximum一起使用,当该重大字的值为true时,表示待校验元素必须低于maximum指定的值;当该重大字的值为false时,表示待校验元素得以低于或者等于maximum指定的值。

亟需小心的是,省略该重大字和该重大字的值为false,具有相同效果。例如:

{
    "type": "number",
    "maximum": 12.3,
    "exclusiveMaximum": true
}
  • minimum、exclusiveMinimum

minimum、exclusiveMinimum关键字的用法和意义与maximum、exclusiveMaximum相似。唯一的区分在于,一个束缚了待校验元素的纤维值,一个羁绊了待校验元素的最大值。那里就不开展解释了。

  • 全体示例:

{
    "type": "number",
    "multipleOf": 0.5,
    "maximum": 12.5,
    "exclusiveMaximum": true,
    "minimum": 2.5,
    "exclusiveMinimum": true
}

(4)当type取值为string时,涉及的主要性字:maxLength、minLength、pattern、format

  • maxLength

该重大字的值是一个非负整数。

该重大字规定了待校验JSON元素可以因而校验的最大尺寸,即待校验JSON元素的最大尺寸必须低于或者等于该重大字的值。

其它,需求注意的是,若是省略该重大字则代表对待校验元素的最大尺寸没有限定。

  • minLength

该重大字的值是一个非负整数。

该重大字规定了待校验JSON元素能够因而校验的微小长度,即待校验JSON元素的微小长度必须超出或者等于该重大字的值。

其余,必要留意的是,倘使省略该重大字和该重大字的值为0,具有相同作用。

  • pattern

该重大字的值是一个正则表明式。

唯有待校验JSON元素符合该重大字指定的正则表达式,才算通过校验。

  • format

该重大字的值只能是以下取值:

date-time(时间格式)、email(邮件格式)、hostname(网站地址格式)、ipv4、ipv6、uri、uri-reference、uri-template、json-pointer。

设若待校验的JSON元素正好是一个邮箱地址,那么,大家就可以使用format关键字展开校验,而毋庸经过pattern关键字指定复杂的正则说明式进行校验。例如:

{
    "type": "string",
    "format": "email"
}
  • 总体示例:

{
    "type": "string",
    "pattern": "^#([0-9a-fA-F]{6}$",
    "maxLength": 6,
    "minLength": 6
}

(5)全类型可用,即不囿于于某个type,涉及的紧要性字:enum、const、allOf、anyOf、oneOf、not、default

  • enum

该重大字的值是一个数组,该数组至少要有一个因素,且数组内的每一个要素都是绝无仅有的。

设若待校验的JSON元素和数组中的某一个要素相同,则透过校验。否则,无法透过校验。

留神,该数组中的元素值能够是其余值,包蕴null。省略该重大字则表示绝不对待校验元素举行该项校验。例如:

{
    "type": "number",
    "enum": [2, 3, null, "hello"]
}
  • const

该重大字的值可以是其余值,包蕴null。

假若待校验的JSON元素的值和该重大字指定的值相同,则通过校验。否则,不可以透过校验。

省略该重大字则代表绝不对待校验元素举办该项校验。

瞩目,该重大字部分第三方工具,并不协理。

  • allOf

该重大字的值是一个非空数组,数组里面的各类元素都不可以不是一个使得的JSON
Schema。

唯有待校验JSON元素通过数组中享有的JSON
Schema校验,才算真的通过校验。

  • anyOf

该重大字的值是一个非空数组,数组里面的各类元素都不能不是一个卓有功用的JSON
Schema。

假定待校验JSON元素可以通过数组中的任何一个JSON
Schema校验,即便通过校验。

  • oneOf

该重大字的值是一个非空数组,数组里面的各类元素都不可能不是一个立竿见影的JSON
Schema。

即使待校验JSON元素能且不得不通过数组中的某一个JSON
Schema校验,才算真正通过校验。不可能经过其它一个校验和能经过四个及以上的校验,都不算真正通过校验。

  • not

该重大字的值是一个JSON Schema。

除非待校验JSON元素不可能通过该重大字指定的JSON
Schema校验的时候,待校验元素才算通过校验。

  • default

该重大字的值是尚未其余必要的。

该重大字常常用来指定待校验JSON元素的默许值,当然,那些默许值最好是符合须求的,即可以透过相应的JSON
Schema的校验。

除此以外,必要专注的是,该重大字除了提示功能外,并不会发出其余实质性的震慑。

(6)再说type关键字

亟需尤其注意的是,type关键字的值能够是一个string,也能够是一个数组。

只要type的值是一个string,则其值只可以是以下三种:null、boolean、object、array、number、string、integer。

要是type的值是一个数组,则数组中的元素都必须是string,且其取值仍然被限定为上述三种。只要带校验JSON元素是其中的一种,则通过校验。

测试成效

上边选取方面提到的在线生成scheme的工具里提供的样例,测试下大家刚刚编写的代码:
instance:

{
  "checked": false,
  "dimensions": {
    "width": 5,
    "height": 10
  },
  "id": 1,
  "name": "A green door",
  "price": 12.5,
  "tags": [
    "home",
    "green"
  ]

schema过长,就不贴了,详见这里

在页面举办测试,效果如下:

亚洲必赢官网 4

image

把 “width”: 5 改为 “width”: 5.5,测试效果:

亚洲必赢官网 5

qq 20171226130003

在2个在线测试工具上测试效果:

亚洲必赢官网 6

qq 20171226121604

亚洲必赢官网 7

qq 20171226121733

可以看看2个在线测试工具,一个出口了错误新闻和警示新闻,另一个只输出了错误音讯。而我辈地方开发的工具只输出了错误新闻,是因为我把警告过滤掉了,这一个可以依照实际必要进行修改。

数组 —— Array

JSON中[]来含有数组元素,参考下边的事例:

{
    “people” : [
        { “firstName”: “John”, “lastName”: “Smith”, “age”: 35 },
        { “firstName”: “Jane”, “lastName”: “Smith”, “age”: 32 }
    ]
}

主旨约束

在 JSON Schema 的世界里,一个空对象,可以描述和校验任意格局的 JSON
数据:

JavaScript

{}

1
{}

上面的三份数据,假如用空对象来校验的话,都是符合须要的:

JavaScript

250 “我是一个字符串” {“code”: 200, “data”: “”, “message”: “呵呵”}

1
2
3
250
"我是一个字符串"
{"code": 200, "data": "", "message": "呵呵"}

本来,若是那样玩的话,JSON Schema 就全盘没有意思了。

3. JSON Schema比较复杂的以身作则:

{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "title": "book info",
    "description": "some information about book",
    "type": "object",
    "properties": {
        "id": {
            "description": "The unique identifier for a book",
            "type": "integer",
            "minimum": 1
        },
        "name": {
            "type": "string",
            "pattern": "^#([0-9a-fA-F]{6}$",
            "maxLength": 6,
            "minLength": 6
        },
        "price": {
            "type": "number",
            "multipleOf": 0.5,
            "maximum": 12.5,
            "exclusiveMaximum": true,
            "minimum": 2.5,
            "exclusiveMinimum": true
        },
        "tags": {
            "type": "array",
            "items": [
                {
                    "type": "string",
                    "minLength": 5
                },
                {
                    "type": "number",
                    "minimum": 10
                }
            ],
            "additionalItems": {
                "type": "string",
                "minLength": 2
            },
            "minItems": 1,
            "maxItems": 5,
            "uniqueItems": true
        }
    },
    "minProperties": 1,
    "maxProperties": 5,
    "required": [
        "id",
        "name",
        "price"
    ]
}

小心,以上JSON
Schema只是为着突显部分重大字的用法,可能和实际应用略有不一样。

合法的参照文档如下:http://json-schema.org/latest/json-schema-validation.html

数据类型

JSON中的数值(键值对中的值)可以是以下任意一种:
Object
Array
String
Number
Boolean
null

type 关键字

从而,大家需求使用 type 关键字,将 JSON Schema
限制为一定的数据类型。比如上面那么些 JSON Schema
描述,唯有字符串类型的数据,才能顺风经过校验:

JavaScript

{ “type”: “string” }

1
{ "type": "string" }

可以校验通过:

JavaScript

“我是一个字符串”

1
"我是一个字符串"

无法校验通过:

JavaScript

250

1
250

type 关键字也取值为任何数据类型,比如 objectarray 等,当 type
object 类型时,properties 关键字是必备的,当 typearray
类型时,items 关键字是须求的。

于此同时,objectarray
类型的引入使得数据结构可以协理无限级嵌套,也就突破了俺们在引子中提到的,标签函数描述过于扁平的题材。

Number

数值类型数据足以是整型也可以是双精度的浮点型数据。上面是一对示范:
“age”: 29“cost”: 299.99“temperature”: -10.5“speed_of_light”:
1.23e11“speed_of_light”: 1.23e+11“speed_of_light”:
1.23E11“speed_of_light”: 1.23E+11

上面的品质(如age等)都是用双引号括起来的字符串,而数值是不须要用双引号括起来的。你可以在数值前增进-号来代表负数,也足以运用科学计数法。但不可以在数值前加0或使用16进制来表示一个数值。

title 和 description

titledescription
关键字是描述性的,并不对数据颇具约束听从,只是用来对文档作补充表明:

JavaScript

{ “title”: “标题”, “description”: “描述” }

1
2
3
4
{
"title": "标题",
"description": "描述"
}

Boolean

JSON中的Boolean值可以用true或false来代表。不用加{}
{ “emailValidated” : true}
Boolean值也不需求选取双引号来修饰。

声明 JSON Schema

设想到 JSON Schema 文档本身也是 JSON 格式的,初识 JSON Schema
的人,不必然能将一般性 JSON 和 JSON Schema 区分别来,于是草案提供了一个
$schema 关键字,专门用来声称当前文档是业内的 JSON Schema
文档,当然,这几个重中之重词并不是必不可少的。

JavaScript

{ “$schema”: “” }

1
{ "$schema": "http://json-schema.org/schema#" }

实际上意况中,陈旧的 JSON Schema 文档可以一如既往比依然的草案,所以,利用
$schema 也可以指明具体看重的草案版本,规避草案演进可能带来的差距难点。

为了表示文档的唯一性,还可选指定一个 id 关键字,经常是一个实际的 URL
地址,比如:

JavaScript

{ “id”: “” }

1
{ "id": "http://example.com/schemas/my_schema.json" }

在整个 JSON Schema 文档中,id 的取值一定是绝无仅有的,就像是 css 中的 id
一样在时下文档中是不足重复的。

null

严谨来说null并不是一个数据类型,但它丰富紧要,它象征一个特性或因素没有值。因而请小心**
‘ ‘ 表示的是空字符串,而null表示的才是空值。**
{ “age” : null}

简单的讲的例证

或者以引子中涉及的情景为例,尝试用 JSON Schema
语法描述标签函数,可以从一个基本概略开首:

JavaScript

{ “$schema”: “”, “title”:
“TextLinks”, “description”: “文字链接”, “type”: “array” }

1
2
3
4
5
6
{
"$schema": "http://json-schema.org/draft-04/schema#",
    "title": "TextLinks",
    "description": "文字链接",
    "type": "array"
}

个中,首个维度为数组,而各种数组成员,又都是由 texthref
三个字段构成的目的,分别代表链接的标题和地点。由此,描述可以增加为:

JavaScript

{ “$schema”: “”, “title”:
“TextLinks”, “description”: “文字链接”, “type”: “array”, “items”: {
“type”: “object”, “properties”: { “text”: { “type”: “string”, “title”:
“文字” }, “href”: { “type”: “string”, “title”: “链接地址(URL)” } } } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"$schema": "http://json-schema.org/draft-04/schema#",
    "title": "TextLinks",
    "description": "文字链接",
    "type": "array",
    "items": {
     "type": "object",
     "properties": {
     "text": {
     "type": "string",
     "title": "文字"
     },
     "href": {
     "type": "string",
     "title": "链接地址(URL)"
     }
     }
    }
}

基于标签函数的概念,对数据行数的决定,还有 rowdefaultRow
多个附加约束,可以分级对应到 JSON Schema 规范中的最大条文限制 maxItems
和纤维条目限制 minItems 七个基本点字。那么,最后的数码描述就成为了:

JavaScript

{ “$schema”: “”, “title”:
“TextLinks”, “description”: “文字链接”, “type”: “array”, “items”: {
“type”: “object”, “properties”: { “text”: { “type”: “string”, “title”:
“文字” }, “href”: { “type”: “string”, “title”: “链接地址(URL)” } } },
“maxItems”: 10, “minItems”: 5 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
"$schema": "http://json-schema.org/draft-04/schema#",
    "title": "TextLinks",
    "description": "文字链接",
    "type": "array",
    "items": {
     "type": "object",
     "properties": {
     "text": {
     "type": "string",
     "title": "文字"
     },
     "href": {
     "type": "string",
     "title": "链接地址(URL)"
     }
     }
    },
    "maxItems": 10,
    "minItems": 5
}

好了,例子潦潦草草地讲完了,没有深入地展开,你可能对 JSON Schema
已经有了主导认知,也说不定一头雾水。没有提到,越来越多细节,我们将在接下去的再三再四串作品中持续道来。

代码注释

JSON不容许在JSON文档或字符串中添加注释。注释功用最早在JSON中是存在的,但开发者们错误地接纳了它来援助JSON数据的分析,当道格拉斯Crockford意识到这种不好的施用进行后,便注销了诠释成效,以保险JSON在分裂总括平台间作为交互数据格式的性状。

有关材料

  • JSON Schema and Hyper-Schema
  • Schema and
    metadata
  • draft-zyp-json-schema-04

样式

你也许曾经注意到了在头里的例证中,所有的习性名称都使用了驼峰式的命名规则。那并不是JSON的一个正规必要,但那可以协理进步JSON文档的可读性,由此作为一个事实标准在享有JSON应用中被选拔。

  • [1]: TMS 为天猫内部运营移动系统。

    1 赞 2 收藏
    评论

亚洲必赢官网 8

语法

Douglas Crockford
在他的JSON网站http://www.json.org/中,给出了拥有JSON语克罗地亚共和国语义的认证。其它还有一个iOS
App JSON Pro FREE可以用来经过演示学习或参考JSON。

JSON校验

一个文本文档或字符串必须信守JSON的语法定义,才能被用作一个可行的JSON文档。JSON文档是还是不是行得通相当关键,因为它平昔决定了,你的JSON数据能不能在分化的应用中被科学地剖析和利用。JSONLint提供了一个可相互的Web版JSON校验工具,你只需求将您的JSON文档粘贴进去,并点击校验按钮,它便会自动举办校验,并将难题显得在凡间。

Paste_亚洲必赢官网,Image.png

在上头这一个例子中,这么些JSON对象的city属性没有拉长双引号,导致校验败北。在回去的提醒中,突显了“Expecting
‘STRING’, got ‘undefined’”错误。
JSONLint也提供了一个足以在Chrome中间接使用的插件。

JSON数据模型

在接纳中手工编制JSON文档,会很枯燥并简单失误。为了避免那样的恶错误
,你可以应用JSONPad或JSON Editor
Online那样的工具,它们能够帮忙你创设JSON逻辑模型(类似于UML),然后经过模型生成JSON文档。

JSON Editor Online

[ JSON Editor Online]
(http://jsoneditoronline.org/)
是一个在线JSON数据建模工具,他也提供了一个Chrome插件可以使用。

Paste_Image.png

浏览器中的JSON

Firefox和Chrome都提供了一些很好的插件方便开发人士查看或拍卖JSON数据。

REST Client

Rest
Client是Firefox中的一个恢弘应用。他可以帮忙开发人士在浏览器中调试REST风格的Web
Service。它最大的优点是能将回来的JSON数据结果,以很好的格式显示出来。

Paste_Image.png

JSONView

JSONView是一个FireFox和Chrome上的插件,能够很好地将JSON数据打印出来,从而大大进步了JSON数据的可读性。

Paste_Image.png

JSON与AJAX

AJAX可能是行使JSON数据中最常见的风貌了。上边的那段代码示例,通过jQuery来调用一个REST风格的Web
Service,并处理回来的JSON对象。

$.getJSON(‘http://example/service/addresses/home/1’,
    function(data) {
        var address = JSON.parse(data);
        console.log(“Address Line 1 = “ + address.line1);
    }
);

在上头的那段代码中,$getJSON(那是一种jQuery中$.ajax()标准调用的一种缩写方式)会倡导一个HTTP
GET 请求,调用Web
Service,之后在它的隐式回调函数中,获取再次来到的data数据,并透过JSON.parse()方法将回到的数额转换为JSON对象。之后便得以像获取普通属性那样(address.line1)获取对象的质量数值了。

JSON与JAVA

Jackson是JAVA中用来处理JSON的一个第三方库。它很有名,并且提供了一组尤其好用的JSON
API。上面就是它的一个例证:

import java.io.Writer;
import java.io.StringWriter;
import org.codehaus.jackson.map.ObjectMapper;

public class Address {
    private String line1;
    private String city;
    private String stateOrProvince;
    private String zipOrPostalCode;
    private String country;

    public Address() {}

    public String getLine1() {
        return line1;
    }

    public void setLine1(line1) {
        this.line1 = line1;
    }

    // Remaining getters and setters ...
}

Address addrOut = new Address();

// Call setters to populate addrOut …
ObjectMapper mapper = new ObjectMapper(); // Reuse this.
// Marshal Address object to JSON String.
Writer writer = new StringWriter();
mapper.writeValue(writer, addrOut);
System.out.println(writer.toString());

// Unmarshal Address object from JSON String.
String addrJsonStr =
“{“ +
    “\”address\” : {“ +
    “\”line1\” : \”555 Main Street\”,” +
    “\”city\” : \”Denver\”,”
    “\”stateOrProvince\” : \”CO\”,”
    “\”zipOrPostalCode\” : \”80202\”,” +
    “\”country\” : \”USA\”” +
    “}” +
“}”;

Address addrIn = mapper.readValue(addrJsonStr, Address.class);

除却杰克逊之外,还有一对别样基于JAVA的第三方JSON API库。
API
Source

Google GSON
http://code.google.com/p/google-json/

SOJO
http://sojo.sourceforge.net/

org.json (by DouglasCrockford)
http://www.json.org/java

json-lib
http://sourceforge.net/projects/json-lib/

json-io
http://code.google.com/p/json-io

jsontools
http://jsontools.berlios.de/

jsonbeans
http://code.google.com/p/jsonbeans/

JSON与RUBY

Ruby中也有不少与JSON相关的第三方库,而JSON
gem是Ruby自带的,上面就是它的用法:

require ‘json’
class Address
    attr_accessor :line1, :city, :state_or_province,
                  :zip_or_postal_code, :country

    def initialize(line1=’’, city=’’, state_or_province=’’,
        zip_or_postal_code=’’, country=’’)
        @line1 = line1
        @city = city
        @state_or_province = state_or_province
        @zip_or_postal_code = zip_or_postal_code
        @country = country
    end

    def to_json
        to_hash.to_json
    end

    def from_json!(str)
        JSON.parse(str).each { |var, val| send(“#{var}=”, val) }
    end

    private

    def to_hash
        Hash[instance_variables.map { |var| [var[1..-1].to_sym,
            send(var[1..-1])] }]
    end
end

JSON
gem的to_json方法将字符串或哈希转换为JSON。Address对象的to_json方法通过将它的积极分子转换成哈希再对哈希值调用to_json,最终将一个Address对象转换为JSON格式。

addr1 = Address.new(‘555 Main Street’, ‘Denver’, ‘CO’, ‘80231’,
‘US’)
puts addr1.to_json
# Outputs the following …
{“line1”:”555 Main Street”,”city”:”Denver”,”state_or_
province”:”CO”,”zip_or_postal_code”:”80231”,”country”:”US”}

JSON
gem的JSON.pase方法则将JSON字符串转换为哈希。Address对象的from_jason!方法接收一个JSON字符串,然后调用JSON.parse来转换哈希,然后再在对象上分别安装这一个哈希的值。
json_addr = <<END{ “line1” : “999 Broadway”, “city” : “Anytown”,
“state_or_province” : “CA”, “zip_or_postal_code” : “90210”,
“country” : “USA”}ENDaddr2 = Address.newaddr2.from_json!(json_addr)

除了JSON gem之外,还有以下部分Ruby的JSON第三方库
API
Source

ActiveSupport JSON
http://api.rubyonrails.org/classes/ActiveSupport/JSON.html

Yajl
https://github.com/brianmario/yajl-ruby

Oj
https://github.com/ohler55/oj

JSON与RUBY ON RAILS
Ruby on
Rails也提供了将Ruby对象转换为JSON的效应。上边的事例中的Controller使用了render方法将一个Ruby对象以JSON数据的格式举办输出。
Rails中的ApplicationController会负责对象与JSON数据里面的交互转换
。由此,不须求格外调用to_json方法。

JSON SCHEMA

JSON
Schema用来定义JSON文档的结构,它可以被用来证实和校验发送或接受的JSON文档是不是可行和规范。JSON
Schema本身也是用JSON格式编写的,它的求实定义可以参见http://json-schema.org。
下边是JSON Schema的有的结构定义:
结构
描述

type
对象的数据类型,如Object,array,string,number 等

$schema
提供Schema版本的URI

required
true/false

id
多少元素id

properties
数据元素的校验属性,包罗最大值,最小值,枚举等

上面是JSON Schema的一个示范
“type”: “object”,“$schema”:
“http://json-schema.org/draft-03/schema”,“id”:
“#”,“required”: true,“properties”: { “registrants”: { “type”: “array”,
“id”: “registrants”, “required”: true, “items”: { “type”: “object”,
“required”: false, “properties”: { “address”: { “type”: “object”, “id”:
“address”, “required”: true, “properties”: { “city”: { “type”: “string”,
“id”: “city”, “required”: true }, “country”: { “type”: “string”, “id”:
“country”, “required”: false }, “line1”: { “type”: “string”, “id”:
“line1”, “required”: true }, “line2”: { “type”: “string”, “id”: “line2”,
“required”: false }, “postalCode”: { “type”: “string”, “id”:
“postalCode”, “required”: true }, “premise”: { “type”: “string”, “id”:
“premise”, “required”: true, “enum”: [ “work”, “home”, “other” ] },
“stateOrProvince”: { “type”: “string”, “id”: “stateOrProvince”,
“required”: true } } }, “firstName”: { “type”: “string”, “id”:
“firstName”, “required”: true }, “lastName”: { “type”: “string”, “id”:
“lastName”, “required”: true }, “phoneNumber”: { “type”: “object”, “id”:
“phoneNumber”, “required”: true, “properties”: { “channel”: { “type”:
“string”, “id”: “channel”, “required”: true, “enum”: [ “cell”, “work”,
“home” ] }, “number”: { “type”: “string”, “id”: “number”, “required”:
true } } } } } } } }

在上头的Schema中对JSON对象做了以下约束:
registrants必须是一个数组对象
phoneNumber的channel必须是cell, work, fax, home中的一个
address的premise必须是home, work, other中的一个。

一个选择上述JSON Schema的Web Service可以分析和拍卖下边这几个JSON文档:
{ “registrants”: [ { “firstName”: “Fred”, “lastName”: “Smith”,
“phoneNumber”: { “channel”: “cell”, “number”: “303-555-1212” },
“address”: { “premise”: “home”, “line1”: “555 Broadway NW”, “line2”: “#
000”, “city”: “Denver”, “stateOrProvince”: “CO”, “postalCode”: “88888”,
“country”: “USA” } } ]}

JSON Schema 生成器
大家得以应用JSON
Schema生成器来为一个有效的JSON文档生成对应的Schema。你需求拜访(www.jsonschema.net),然后依照以下步骤操作:
将你的JSON文档粘贴到右手文本框
挑选JSON输入选项
点击Generate Schema按钮

JSON Schema 校验器
俺们可以用JSON Schema
Validator来担保咱们的JSON文档时有效的。上边是本着分裂开发语言的片段宽广的JSON
Schema 校验器。
校验器
编程语言
品类地址

JSV
JavaScript
https://github.com/garycourt/JSV

Ruby JSON Schema Validator
Ruby
https://github.com/hoxworth/jsonschema

json-schemavalidator
Java
https://github.com/fge/json-schema-validator

php-json-schema(by MIT)
PHP
https://github.com/hasbridge/php-json-schema

JSON.Net
.NET
http://james.newtonking.com/projects/json-net.aspx

除开上边那么些与编程语言相关的校验器之外,你还足以一向动用在线的JSON
Schema校验器(
http://json-schema-validator.herokuapp.com
),将Schema和JSON文档粘贴到左手的文本框中,然后点击Validate按钮,校验的结果就会显示在显示屏左边。
总结
上述,我们已经起头询问了JSON的主旨概念和用法,但对此JSON本身来说我们还只是摸底了里面很小的一有些,还有为数不少与它相关的工具或技术可以使用。JSON作为一个数目的准,它曾经逐步取代XML成为Internet上最受欢迎的竞相数据格式。
简书签约小编:技匠,以上内容欢迎大家分享到朋友圈/今日头条等。如需转发,请通过简信联系授权。谢谢我们!

网站地图xml地图