list json格式_json之自定义JsonSchema

最新推荐文章于 2024-03-09 15:39:05 发布
最新推荐文章于 2024-03-09 15:39:05 发布
阅读量450 收藏
点赞数
文章标签： list json格式

8f5b7d9d7eda0f44155a189ae1f67220.png

json之自定义JsonSchema

使用fastjsonschema来校验数据

# 导入验证器
import json
import fastjsonschema

# 读取schema
with open('../schema/oneof-schema.json', encoding='utf8') as f:
    my_schema = json.load(f)

# json数据：
with open('../data/test.json', encoding='utf8') as f:
    json_data = json.load(f)

# 验证：
fastjsonschema.validate(my_schema, json_data)

使用jsonschema来校验数据

import json
# 导入验证器
from jsonschema import validate, draft7_format_checker, SchemaError, ValidationError

if __name__ == '__main__':
    with open('../schema/MySchema.json', encoding='utf8') as f:
        my_schema = json.load(f)

    # json数据：
    with open('../data/cece.json', encoding='utf8') as f:
        json_data = json.load(f)

    # error_list = check_type(my_schema, json_data)
    # print(error_list)

    # 验证：
    try:
        validate(instance=json_data, schema=my_schema, format_checker=draft7_format_checker)
        # Draft7Validator.format_checker
    except SchemaError as serr:
        print("schema 错误 【%s】 nschema错误" % str(serr))
    except ValidationError as verr:
        print("数据 错误 【%s】 n数据错误" % str(verr))

JSONSchema缺点

  1. 错误提示英文
  2. 校验数据为一步步校验，遇到错误停止

自定义JSONSchema

schema遵循 http://json-schema.org/，

"$schema": "http://json-schema.org/draft-07/schema#",

使用方法 >>>> 点击这里

代码

个人编写的校验的代码，自定义成分较多 目前仅仅扩展了 string类型的数据 format 的选型判断

CheckDataUti.py

import re
import time

# email 正则表达式
EMAIL_REGEX = "^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$"
# URL 正则表达式
URL_REGEX = "^[a-zA-z]+://[^s]*$"
# PHONE 正则表达式
PHONE_REGEX = "^([1][3,4,5,6,7,8,9])d{9}$"
# 身份证 正则表达式
ID_CARD_REGEX = "^((d{18})|([0-9x]{18})|([0-9X]{18}))$"
# 邮政编码 正则表达式
ZIP_CODE_REGEX = "^[1-9]d{5}(?!d)$"
# IP 地址 正则表达式
IP_REGEX = "^d+.d+.d+.d+$"
# 正整数
INTEGER_REGEX = "^[1-9]d*$"

ERR_LIST = []
COMMON_ERR_LIST = []


def log_error(msg, data, schema, is_common=False):
    """
    打印错误日志
    """
    err_log = "%s,数据:【%s】,校验规则: %s" % (str(msg), str(data) + " type of " + str(type(data).__name__), str(schema))

    if not is_common:
        ERR_LIST.append(err_log)
        print("=================================================")
        print(err_log)
        print("=================================================")
    else:
        COMMON_ERR_LIST.append(err_log)


def check_object(data, schema, is_common):
    """
    校验对象格式
    【 properties、required、minProperties、maxProperties、patternProperties、additionalProperties 】
    """
    if type(data) != dict:
        log_error("当前校验的json不是一个对象格式", data, schema, is_common)
    else:
        # 获取当前校验数据的所有key
        keys = dict.keys(data)

        # 处理必需值
        if "required" in schema:
            required_schema = schema['required']
            for schema_key in required_schema:
                if schema_key not in keys:
                    log_error("字段【%s】必填" % schema_key, data, schema, is_common)

        # 处理最小key和最大key
        if "minProperties" in schema:
            min_properties = schema['minProperties']
            if len(keys) < min_properties:
                log_error("校验数据的key个数小于【%s】" % str(min_properties), data, schema, is_common)

        if "maxProperties" in schema:
            max_properties = schema['maxProperties']
            if len(keys) > max_properties:
                log_error("校验数据的key个数大于【%s】" % str(max_properties), data, schema, is_common)

        # 处理具体的key
        if "properties" in schema:
            # 处理 properties
            properties_schema = schema['properties']
            schema_keys = dict.keys(properties_schema)
            for data_key in schema_keys:
                if data_key in data:
                    check_data(properties_schema[data_key], data[data_key])

        # 处理满足正则表达式的key
        if "patternProperties" in schema:
            # 处理 properties
            pattern_properties = schema['patternProperties']
            schema_keys = dict.keys(pattern_properties)

            # 循环所有正则表达式的key
            for schema_key in schema_keys:
                # 循环当前待校验的数据key
                for data_key in keys:
                    # 仅仅处理满足正则表达式的key数据
                    if re.match(schema_key, data_key):
                        check_data(pattern_properties[schema_key], data[data_key])


def check_array(data, schema, is_common):
    """
    校验数组格式
    【 items、additionalItems、minItems、maxItems、uniqueItems 】
    """
    if type(data) != list:
        log_error("当前校验的json不是数组格式", data, schema, is_common)
    else:
        # minItems、maxItems
        # 判断最小值
        if "minItems" in schema:
            min_items = schema['minItems']
            if len(data) < min_items:
                log_error("当前校验的数据数组长度小于【%s】" % str(min_items), data, schema, is_common)

        # 判断最大值
        if "maxItems" in schema:
            max_properties = schema['maxItems']
            if len(data) > max_properties:
                log_error("当前校验的数据数组长度大于【%s】" % str(max_properties), data, schema, is_common)

        # uniqueItems true 数组元素不能重复
        if "uniqueItems" in schema:
            unique_items_schema = schema['uniqueItems']

            if unique_items_schema:
                # 数组元素不能重复
                try:
                    if len(set(data)) != len(data):
                        log_error("当前校验的数据数组元素不能重复", data, schema, is_common)
                except TypeError:
                    # 存在数组内部元素是dict格式
                    pass
        # 判断每一个items
        if "items" in schema:
            items_schema = schema["items"]
            # 判断items_schema 是数组还是对象
            if type(items_schema) is list:
                # 如果是数组 每一个item都是一个jsonSchema 索引对应的数组内索引的格式
                index = 0
                for item_sc in items_schema:
                    check_data(item_sc, data[index])
                    index += 1

                # additionalItems该关键字只有在items是数组的时候才会有效
                # additionalItems 除了上述规定之外的数据必需符合指定的规则
                if "additionalItems" in schema:
                    additional_items_schema = schema['additionalItems']

                    for i in range(index, len(data)):
                        check_data(additional_items_schema, data[i])

            # items如果是对象  当前schema规范了数组内所有元素的格式
            elif type(items_schema) is dict:
                for item_data in data:
                    check_data(items_schema, item_data)


def check_number(data, schema, is_common):
    """
    校验数字类型
    """
    if type(data) not in (int, float):
        log_error("当前校验的json不是一个数字格式", data, schema, is_common)
    else:
        # 判断最大值 maximum 如果exclusiveMaximum该关键字是True 包含本身
        if "maximum" in schema:
            maximum_schema = schema['maximum']
            if 'exclusiveMaximum' in schema and schema['exclusiveMaximum']:
                if data >= maximum_schema:
                    log_error("当前校验的数据大于等于【%s】" % maximum_schema, data, schema, is_common)
            else:
                if data > maximum_schema:
                    log_error("当前校验的数据大于【%s】" % maximum_schema, data, schema, is_common)

        # minimum、exclusiveMinimum
        if "minimum" in schema:
            minimum_schema = schema['minimum']
            if 'exclusiveMinimum' in schema and schema['exclusiveMinimum']:
                if data <= minimum_schema:
                    log_error("当前校验的数据小于等于【%s】" % minimum_schema, data, schema, is_common)
            else:
                if data < minimum_schema:
                    log_error("当前校验的数据小于【%s】" % minimum_schema, data, schema, is_common)

        # multipleOf    整除
        if "multipleOf" in schema:
            multiple_of_schema = schema['multipleOf']
            if not data % multiple_of_schema == 0:
                log_error("当前校验的数据不能被%s整除" % multiple_of_schema, data, schema, is_common)


def check_str(data, schema, is_common):
    """
    校验字符串类型
    涉及的关键字 【maxLength、minLength、pattern、format】
    """
    if type(data) != str:
        log_error("当前校验的数据不是一个字符串格式", data, schema, is_common)
    else:
        # maxLength
        if "maxLength" in schema:
            max_length_schema = schema['maxLength']
            if len(data) > max_length_schema:
                log_error("当前校验的数据长度大于%d" % max_length_schema, data, schema, is_common)

        # minLength
        if "minLength" in schema:
            min_length_schema = schema['minLength']
            if len(data) < min_length_schema:
                log_error("当前校验的数据长度小于%d" % min_length_schema, data, schema, is_common)

        # pattern
        if "pattern" in schema:
            pattern_schema = schema['pattern']
            if not re.match(pattern_schema, data):
                log_error("当前校验的数据不符合正则表达式规则【%s】" % pattern_schema, data, schema, is_common)
        # format
        if 'format' in schema:
            format_schema = schema['format']

            if format_schema == 'email' and not re.match(EMAIL_REGEX, data):
                log_error("当前校验的数据不是正确的邮箱格式", data, schema, is_common)

            elif format_schema == 'phone' and not re.match(PHONE_REGEX, data):
                log_error("当前校验的数据不是正确的手机号码格式", data, schema, is_common)

            elif format_schema == 'hostname' and not re.match(IP_REGEX, data):
                log_error("当前校验的数据不是正确的IP地址格式", data, schema, is_common)

            elif format_schema == 'idCard' and not re.match(ID_CARD_REGEX, data):
                log_error("当前校验的数据不是正确的身份证格式", data, schema, is_common)

            elif format_schema == 'date':
                format_patten = '%Y-%m-%d'
                if 'format_patten' in schema:
                    format_patten = schema['format_patten']
                try:
                    time.strptime(data, format_patten)
                except ValueError:
                    log_error("当前校验的数据不是正确的日期格式格式【%s】" % format_patten, data, schema, is_common)


def check_common(schema, data):
    """
    校验通用的
    涉及到关键字：
    【 enum、const、allOf、anyOf、oneOf、not、 if……then…… 】
    """
    if "enum" in schema:
        enum_schema = schema['enum']
        if data not in enum_schema:
            log_error("当前校验的数据值不存在【%s】中" % str(enum_schema), data, schema)

    if "const" in schema:
        const_schema = schema['const']
        if data != const_schema:
            log_error("当前校验数据值不等于【%s】" % str(const_schema), data, schema)

    if "allOf" in schema:
        all_of_schema = schema['allOf']
        for item_schema in all_of_schema:
            check_data(item_schema, data)
    if "anyOf" in schema:
        any_of_schema = schema['anyOf']

        begin_len = len(COMMON_ERR_LIST)

        for item_schema in any_of_schema:
            check_data(item_schema, data, True)

        end_len = len(COMMON_ERR_LIST)

        if end_len - begin_len == len(any_of_schema):
            log_error("当前校验的数据不符合当前anyof中的任一规则", data, schema)

    if "oneOf" in schema:
        one_of_schema = schema['oneOf']

        begin_len = len(COMMON_ERR_LIST)

        for item_schema in one_of_schema:
            check_data(item_schema, data, True)

        end_len = len(COMMON_ERR_LIST)

        if end_len - begin_len != len(one_of_schema) - 1:
            log_error("待校验JSON元素不能通过oneOf的校验", data, schema)

    if "not" in schema:
        not_schema = schema['not']
        begin_len = len(COMMON_ERR_LIST)
        check_data(not_schema, data, True)
        end_len = len(COMMON_ERR_LIST)

        if end_len == begin_len:
            log_error("待校验JSON元素不能通过not规则的校验", data, schema)

    # if……then……
    if 'if' in schema:
        if_schmea = schema['if']
        begin_len = len(COMMON_ERR_LIST)
        check_data(if_schmea, data, True)
        end_len = len(COMMON_ERR_LIST)

        if end_len == begin_len:
            if "then" in schema:
                then_schema = schema['then']
                check_data(then_schema, data, False)
        else:
            if "else" in schema:
                else_schema = schema['else']
                check_data(else_schema, data, False)

def get_data_type(data):
    """
    获取type
    """
    if type(data) == dict:
        return 'object'
    if type(data) == list:
        return 'array'
    if type(data) in (int, float):
        return 'number'
    if type(data) == str:
        return 'string'
    if type(data) == bool:
        return 'boolean'


def check_data(schema, data, is_common=False):
    # 优先处理 通用的
    check_common(schema, data)

    # 没有type的情况
    # type 默认为string
    type_name = schema['type'] if "type" in schema else get_data_type(data)

    if type_name == 'object':
        check_object(data, schema, is_common)
    elif type_name == 'array':
        check_array(data, schema, is_common)
    elif type_name in ['integer', 'number']:
        check_number(data, schema, is_common)
    elif type_name == 'string':
        check_str(data, schema, is_common)
    # type是布尔类型
    elif type_name == 'boolean':
        if type(data) != bool:
            log_error("当前校验的数据不是一个boolean格式", data, schema, is_common)

JsonSchmea 的数据示例

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "minProperties": 1,
  "maxProperties": 200,
  "properties": {
    "name": {
      "type": "string",
      "enum": [
        "shaofei",
        "shaofeer",
        "pyfysf"
      ]
    },
    "email": {
      "type": "string",
      "format": "email",
      "const": "pyfysf@163.com"
    },
    "idCard": {
      "type": "string",
      "format": "idCard",
      "pattern": "d+"
    },
    "phone": {
      "type": "string",
      "format": "phone"
    },
    "hostname": {
      "type": "string",
      "format": "hostname"
    },
    "createTime": {
      "format": "date",
      "format_patten": "%Y%m%d"
    },
    "is": {
      "type": "boolean"
    },
    "age": {
      "type": "integer",
      "maximum": 20,
      "minimum": 1,
      "multipleOf": 2
    },
    "like": {
      "type": "array"
    }
  },
  "allOf": [
    {
      "type": "string"
    }
  ],
  "patternProperties": {
    "^S+123$": {
      "type": "integer"
    }
  },
  "required": [
    "email"
  ]
}

使用方式

import json

from CheckDataUti import check_data

if __name__ == '__main__':
    with open('../schema/MySchema.json', encoding='utf8') as f:
        my_schema = json.load(f)

    # json数据：
    with open('../data/cece.json', encoding='utf8') as f:
        json_data = json.load(f)

    check_data(my_schema, json_data)
    # print(ERR_LIST)
参考：

schema遵循 http://json-schema.org/，

"$schema": "http://json-schema.org/draft-07/schema#",

使用方法 >>>> 点击这里

结尾

好记性不如烂笔头，本文为个人学习总结。
  • 笔者：shaofeer
  • 个人网站（首发）：
shaofeer's Blog​quxuecx.com
a1c063397c72512df97e7296d91930dd.png
  • 邮箱: shaofeer@163.com
  • QQ：337081267
  • 公众号：“趣学程序”

我这里整理了很多的学习资料、编程源码、学习笔记、面试心得，如果有需要，可以通过关注“趣学程序”公众号来获取哟~

http://weixin.qq.com/r/SSpxaX-E2iKlrTsK939b (二维码自动识别)

weixin_39540315
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
js json-schema 转换 json
jaychou1979的博客
07-27 2688
json 和json-schema的互相转换
json转换jsonschema
08-12
json转换json schema
JsonSchema转JSON
qq_42975676的博客
08-08 1796
代码JsonSchema转JSON。
JSONLint - 简洁、强大的JSON校验工具
最新发布
gitblog_00009的博客
03-09 875
JSONLint - 简洁、强大的JSON校验工具 如果你在日常工作中经常处理JSON数据，那么一定遇到过各种各样的问题，如格式错误、语法不规范等。这时你需要一个强大而简洁的JSON校验工具来帮助你解决这些问题。今天我们要推荐的就是这样一款工具——JSONLint。 什么是JSONLint？ JSONLint是一个在线的JSON校验器，由Zaach开发。它可以帮助开发者检测JSON数据的有效性，并...
基于Jackson2的JsonSchema实现java实体类生成json（二）
daodfs1的博客
11-16 1048
  同时支持Json和Xml 核心工具类 Json2Utils.java 怎么使用 测试用的实体类 Base.java BaseDt.java Score.java TestMap.java Student.java 用法 JsonUtils类转Springboot2以代码的方式统一配置Jackson->Jackson工具类
【Java】基于JSON-Schema生成随机JSON的解决方案
hgSuper的博客
03-10 2629
java解析json-schema随机生成json串
ASP-list.rar_json 数据库_显示更多
09-21
ASP程序通过查询数据库将最新的几条记录显示在列表页，在列表页的底部有个“更多”链接，通过触发该链接，向服务端发送Ajax请求，后台ASP程序接收请求参数，并作出相应，获取数据库相应的记录并以JSON的形式返回给...
json转为list 涉及 java springboot
03-03
json转为list 涉及 java springboot
list转json字符串 FastJSON 调用
05-19
list转json字符串 FastJSON 的详细说明:https://mp.weixin.qq.com/s/uiNw5QKEnfvdJ4IU8SfbWw
list集合转换为json对象.doc
02-05
list集合转换为json对象
将List对象列表转换成JSON格式的类实现方法
10-22
下面小编就为大家带来一篇将List对象列表转换成JSON格式的类实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
批量转换json到java类工具
06-27
将json转换为javebean的工具，封装jsonschema2pojo，用户可以修改配置文件json2Beans.json，然后运行Json2JavaBean2.bat直接生成对应类。 能够批量转换json为bean，直接拷贝到项目中使用。 提醒： 需要提前安装java sdk。 如果应对restful的请求和回应，输入和输出类可以放在同一个包里。否则json文件路径，class名，package名需要一一对应，避免出现同一个包里有相同的类。 具体使用方法参考 https://mp.csdn.net/mp_blog/creation/editor/125489040
JSON格式的互相转换
lm759231639的博客
05-19 1497
String smodelJson="";//json字符串 JSONObject modelJsons = JSON.parseObject(modelJson);//json字符串转为json对象 JSONArray array= modelJsons.getJSONArray("metadata");//json对象转为json数组 String obj = array.getJSONOb...
Json的数据格式的定义
qq_42317817的博客
12-23 1635
json的使用方法
自定义Json格式
baixiao9898的博客
05-19 561
老铁们都知道，一般的json格式就是键值对格式，在一些特定的框架或者系统中，会用到自定义格式的json文件，假设我们要得到的特定格式json格式如下： {"A":"2","B":20,"C":"38","D":[{"E":"232","cell":["a","b","c","d"]},{"E":"235","cell":["a1","b1","c1","d1"]}]} 那么代码就可以...
如何快速写出Json Schema，校验Json Schema
软测小生
06-26 7465
本文首发于微信公众号： 【软测小生】 得到一个Json文件，如何快速的去测试呢？ 难道是一个个节点的去验证吗？那显然效率太低了。 一般推荐使用Json Schema（一种Json的数据结构定义）去校验。 对于JsonSchema，有很多种方式：可以自己一个个节点的写，可以使用生成工具，或者在线生成工具生成。 那么如何快速的根据Json内容 写出一个JsonSchema呢？ 我最近在做Json相...
.net core json 为null输出_使用Java将JSON转换为POJO
weixin_39923262的博客
11-29 83
如果您有要映射到POJO而不需要编写完整的POJO类的JSON，则可以使用jsonschema2pojo库。这是一个出色的库，可以使用输入的JSON创建Java类。先决条件程式语言：JavaPom依赖关系：<dependency> <groupId>org.jsonschema2pojo</groupId> <artifactId&gt...
JsonSchema用法
趣学程序
12-13 1684
JsonSchmea用法 简介 JSON Schema是基于JSON格式，用于定义JSON数据结构以及校验JSON数据内容。 JSON Schema官网地址：http://json-schema.org/ 个人观点：JsonSchema类似于xml的schema和DTD的作用，主要是用来规范json的格式。 关键字及其描述 关键字 描述 $schema 表示该JSON Sche...
使用java json-schema-inferrer,将json转换为json schema
baidu_41761770的博客
03-29 1396
github地址：https://github.com/saasquatch/json-schema-inferrer 在线演示：https://json-schema-inferrer.herokuapp.com/ 第一步 引入相关json-schema-inferrer包，需要jdk8以上的版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instanc
list json格式
09-20
JSON中的list格式是通过数组（array）来表示的。数组是一个有序的元素集合，每个元素可以是任意类型的值，包括字符串、数字、布尔值、对象或者另一个数组。在JSON中，数组使用方括号（[ ]）来表示，其中的每个元素...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值