毕业设计 基于区块链的智能投顾系统源码+详细文档+全部资料（高分项目）.zip

[](https://godoc.org/github.com/xeipuuv/gojsonschema) [](https://travis-ci.org/xeipuuv/gojsonschema) [](https://goreportcard.com/report/github.com/xeipuuv/gojsonschema) # gojsonschema ## Description An implementation of JSON Schema for the Go programming language. Supports draft-04, draft-06 and draft-07. References : * http://json-schema.org * http://json-schema.org/latest/json-schema-core.html * http://json-schema.org/latest/json-schema-validation.html ## Installation ``` go get github.com/xeipuuv/gojsonschema ``` Dependencies : * [github.com/xeipuuv/gojsonpointer](https://github.com/xeipuuv/gojsonpointer) * [github.com/xeipuuv/gojsonreference](https://github.com/xeipuuv/gojsonreference) * [github.com/stretchr/testify/assert](https://github.com/stretchr/testify#assert-package) ## Usage ### Example ```go package main import ( "fmt" "github.com/xeipuuv/gojsonschema" ) func main() { schemaLoader := gojsonschema.NewReferenceLoader("file:///home/me/schema.json") documentLoader := gojsonschema.NewReferenceLoader("file:///home/me/document.json") result, err := gojsonschema.Validate(schemaLoader, documentLoader) if err != nil { panic(err.Error()) } if result.Valid() { fmt.Printf("The document is valid\n") } else { fmt.Printf("The document is not valid. see errors :\n") for _, desc := range result.Errors() { fmt.Printf("- %s\n", desc) } } } ``` #### Loaders There are various ways to load your JSON data. In order to load your schemas and documents, first declare an appropriate loader : * Web / HTTP, using a reference : ```go loader := gojsonschema.NewReferenceLoader("http://www.some_host.com/schema.json") ``` * Local file, using a reference : ```go loader := gojsonschema.NewReferenceLoader("file:///home/me/schema.json") ``` References use the URI scheme, the prefix (file://) and a full path to the file are required. * JSON strings : ```go loader := gojsonschema.NewStringLoader(`{"type": "string"}`) ``` * Custom Go types : ```go m := map[string]interface{}{"type": "string"} loader := gojsonschema.NewGoLoader(m) ``` And ```go type Root struct { Users []User `json:"users"` } type User struct { Name string `json:"name"` } ... data := Root{} data.Users = append(data.Users, User{"John"}) data.Users = append(data.Users, User{"Sophia"}) data.Users = append(data.Users, User{"Bill"}) loader := gojsonschema.NewGoLoader(data) ``` #### Validation Once the loaders are set, validation is easy : ```go result, err := gojsonschema.Validate(schemaLoader, documentLoader) ``` Alternatively, you might want to load a schema only once and process to multiple validations : ```go schema, err := gojsonschema.NewSchema(schemaLoader) ... result1, err := schema.Validate(documentLoader1) ... result2, err := schema.Validate(documentLoader2) ... // etc ... ``` To check the result : ```go if result.Valid() { fmt.Printf("The document is valid\n") } else { fmt.Printf("The document is not valid. see errors :\n") for _, err := range result.Errors() { // Err implements the ResultError interface fmt.Printf("- %s\n", err) } } ``` ## Loading local schemas By default `file` and `http(s)` references to external schemas are loaded automatically via the file system or via http(s). An external schema can also be loaded using a `SchemaLoader`. ```go sl := gojsonschema.NewSchemaLoader() loader1 := gojsonschema.NewStringLoader(`{ "type" : "string" }`) err := sl.AddSchema("http://some_host.com/string.json", loader1) ``` Alternatively if your schema already has an `$id` you can use the `AddSchemas` function ```go loader2 := gojsonschema.NewStringLoader(`{ "$id" : "http://some_host.com/maxlength.json", "maxLength" : 5 }`) err = sl.AddSchemas(loader2) ``` The main schema should be passed to the `Compile` function. This main schema can then directly reference the added schemas without needing to download them. ```go loader3 := gojsonschema.NewStringLoader(`{ "$id" : "http://some_host.com/main.json", "allOf" : [ { "$ref" : "http://some_host.com/string.json" }, { "$ref" : "http://some_host.com/maxlength.json" } ] }`) schema, err := sl.Compile(loader3) documentLoader := gojsonschema.NewStringLoader(`"hello world"`) result, err := schema.Validate(documentLoader) ``` It's also possible to pass a `ReferenceLoader` to the `Compile` function that references a loaded schema. ```go err = sl.AddSchemas(loader3) schema, err := sl.Compile(gojsonschema.NewReferenceLoader("http://some_host.com/main.json")) ``` Schemas added by `AddSchema` and `AddSchemas` are only validated when the entire schema is compiled, unless meta-schema validation is used. ## Using a specific draft By default `gojsonschema` will try to detect the draft of a schema by using the `$schema` keyword and parse it in a strict draft-04, draft-06 or draft-07 mode. If `$schema` is missing, or the draft version is not explicitely set, a hybrid mode is used which merges together functionality of all drafts into one mode. Autodectection can be turned off with the `AutoDetect` property. Specific draft versions can be specified with the `Draft` property. ```go sl := gojsonschema.NewSchemaLoader() sl.Draft = gojsonschema.Draft7 sl.AutoDetect = false ``` If autodetection is on (default), a draft-07 schema can savely reference draft-04 schemas and vice-versa, as long as `$schema` is specified in all schemas. ## Meta-schema validation Schemas that are added using the `AddSchema`, `AddSchemas` and `Compile` can be validated against their meta-schema by setting the `Validate` property. The following example will produce an error as `multipleOf` must be a number. If `Validate` is off (default), this error is only returned at the `Compile` step. ```go sl := gojsonschema.NewSchemaLoader() sl.Validate = true err := sl.AddSchemas(gojsonschema.NewStringLoader(`{ $id" : "http://some_host.com/invalid.json", "$schema": "http://json-schema.org/draft-07/schema#", "multipleOf" : true }`)) ``` ``` ``` Errors returned by meta-schema validation are more readable and contain more information, which helps significantly if you are developing a schema. Meta-schema validation also works with a custom `$schema`. In case `$schema` is missing, or `AutoDetect` is set to `false`, the meta-schema of the used draft is used. ## Working with Errors The library handles string error codes which you can customize by creating your own gojsonschema.locale and setting it ```go gojsonschema.Locale = YourCustomLocale{} ``` However, each error contains additional contextual information. Newer versions of `gojsonschema` may have new additional errors, so code that uses a custom locale will need to be updated when this happens. **err.Type()**: *string* Returns the "type" of error that occurred. Note you can also type check. See below Note: An error of RequiredType has an err.Type() return value of "required" "required": RequiredError "invalid_type": InvalidTypeError "number_any_of": NumberAnyOfError "number_one_of": NumberOneOfError "number_all_of": NumberAllOfError "number_not": NumberNotError "missing_dependency": MissingDependencyError "internal": InternalError "const": ConstEror "enum": EnumError "array_no_additional_items": ArrayNoAdditionalItemsError "array_min_items": ArrayMinItemsError "array_max_items": ArrayMaxItemsError "unique": ItemsMustBeUniqueError "contains" : ArrayContainsError "array_min_properties": ArrayMinPropertiesError "array_max_properties": ArrayMaxPropertiesError "additional_property_not_allowed": AdditionalPropertyNotAllowedError