org.apache.juneau.dto.jsonschema.package.html Maven / Gradle / Ivy
JSON-Schema Data Transfer Objects
Table of Contents
{@doc package-summary.html#Overview Overview}
{@doc package-summary.html#SchemaDefinition JSON-Schema schema definition}
{@doc package-summary.html#Serialize Creating JSON-Schema documents}
{@doc package-summary.html#SerializeToOther Serializing to other data types}
{@doc package-summary.html#Parse Parsing JSON-Schema documents}
1 - Overview
Juneau supports serializing and parsing of JSON-Schema documents through the use of beans defined in the
org.apache.juneau.dto.jsonschema package.
These beans are used with the existing {@link org.apache.juneau.json.JsonSerializer} and
{@link org.apache.juneau.json.JsonParser} classes to produce and consume JSON-Schema documents.
NOTE: JSON-Schema is currently in draft form.
This API may change as the JSON-Schema specification changes.
1.1 - JSON-Schema schema definition
The draft JSON-Schema specification that the JSON-Schema beans are modeled after is as follows:
{
"id" : "http://json-schema.org/draft-04/schema#" ,
"$schema" : "http://json-schema.org/draft-04/schema#" ,
"description" : "Core schema meta-schema" ,
"definitions" : {
"schemaArray" : {
"type" : "array" ,
"minItems" : 1,
"items" : { "$ref" : "#" }
},
"positiveInteger" : {
"type" : "integer" ,
"minimum" : 0
},
"positiveIntegerDefault0" : {
"allOf" : [ { "$ref" : "#/definitions/positiveInteger" },
{ "default" : 0 } ]
},
"simpleTypes" : {
"enum" : [ "array" , "boolean" , "integer" , "null" ,
"number" , "object" , "string" ]
},
"stringArray" : {
"type" : "array" ,
"items" : { "type" : "string" },
"minItems" : 1,
"uniqueItems" : true
}
},
"type" : "object" ,
"properties" : {
"id" : {
"type" : "string" ,
"format" : "uri"
},
"$schema" : {
"type" : "string" ,
"format" : "uri"
},
"title" : {
"type" : "string"
},
"description" : {
"type" : "string"
},
"default" : {},
"multipleOf" : {
"type" : "number" ,
"minimum" : 0,
"exclusiveMinimum" : true
},
"maximum" : {
"type" : "number"
},
"exclusiveMaximum" : {
"type" : "boolean" ,
"default" : false
},
"minimum" : {
"type" : "number"
},
"exclusiveMinimum" : {
"type" : "boolean" ,
"default" : false
},
"maxLength" : { "$ref" : "#/definitions/positiveInteger" },
"minLength" : { "$ref" : "#/definitions/positiveIntegerDefault0" },
"pattern" : {
"type" : "string" ,
"format" : "regex"
},
"additionalItems" : {
"anyOf" : [
{ "type" : "boolean" },
{ "$ref" : "#" }
],
"default" : {}
},
"items" : {
"anyOf" : [
{ "$ref" : "#" },
{ "$ref" : "#/definitions/schemaArray" }
],
"default" : {}
},
"maxItems" : { "$ref" : "#/definitions/positiveInteger" },
"minItems" : { "$ref" : "#/definitions/positiveIntegerDefault0" },
"uniqueItems" : {
"type" : "boolean" ,
"default" : false
},
"maxProperties" : { "$ref" : "#/definitions/positiveInteger" },
"minProperties" : { "$ref" : "#/definitions/positiveIntegerDefault0" },
"required" : { "$ref" : "#/definitions/stringArray" },
"additionalProperties" : {
"anyOf" : [
{ "type" : "boolean" },
{ "$ref" : "#" }
],
"default" : {}
},
"definitions" : {
"type" : "object" ,
"additionalProperties" : { "$ref" : "#" },
"default" : {}
},
"properties" : {
"type" : "object" ,
"additionalProperties" : { "$ref" : "#" },
"default" : {}
},
"patternProperties" : {
"type" : "object" ,
"additionalProperties" : { "$ref" : "#" },
"default" : {}
},
"dependencies" : {
"type" : "object" ,
"additionalProperties" : {
"anyOf" : [
{ "$ref" : "#" },
{ "$ref" : "#/definitions/stringArray" }
]
}
},
"enum" : {
"type" : "array" ,
"minItems" : 1,
"uniqueItems" : true
},
"type" : {
"anyOf" : [
{ "$ref" : "#/definitions/simpleTypes" },
{
"type" : "array" ,
"items" : { "$ref" : "#/definitions/simpleTypes" },
"minItems" : 1,
"uniqueItems" : true
}
]
},
"allOf" : { "$ref" : "#/definitions/schemaArray" },
"anyOf" : { "$ref" : "#/definitions/schemaArray" },
"oneOf" : { "$ref" : "#/definitions/schemaArray" },
"not" : { "$ref" : "#" }
},
"dependencies" : {
"exclusiveMaximum" : [ "maximum" ],
"exclusiveMinimum" : [ "minimum" ]
},
"default" : {}
}
The bean classes that make up the model are as follows:
-
{@link org.apache.juneau.dto.jsonschema.JsonSchema} - Top level schema object.
-
{@link org.apache.juneau.dto.jsonschema.JsonSchemaProperty} - A subclass of
Schema for
representing properties.
-
{@link org.apache.juneau.dto.jsonschema.JsonSchemaPropertySimpleArray} - A convenience subclass of
SchemaProperty for representing properties of simple array types.
-
{@link org.apache.juneau.dto.jsonschema.JsonSchemaRef} - Represents a URI reference to another schema.
-
{@link org.apache.juneau.dto.jsonschema.JsonSchemaArray} - An array of
Schema objects.
-
{@link org.apache.juneau.dto.jsonschema.JsonType} - An enum of possible JSON data types.
-
{@link org.apache.juneau.dto.jsonschema.JsonTypeArray} - An array of
JsonType objects.
1.2 - Creating JSON-Schema documents
JSON-Schema documents can be constructed using the Juneau JSON-Schema beans as a document model object.
These beans are defined with fluent-style setters to make constructing documents as easy as possible.
The following is an example JSON-Schema document:
{
"title" : "Example Schema" ,
"type" : "object" ,
"properties" : {
"firstName" : {
"type" : "string"
},
"lastName" : {
"type" : "string"
},
"age" : {
"description" : "Age in years" ,
"type" : "integer" ,
"minimum" : 0
}
},
"required" : ["firstName" , "lastName" ]
}
This document can be constructing using the following code:
// Create the document object model
JsonSchema s = new JsonSchema()
.setTitle("Example Schema" )
.setType(JsonType.OBJECT )
.addProperties(
new JsonSchemaProperty("firstName" , JsonType.STRING ),
new JsonSchemaProperty("lastName" , JsonType.STRING ),
new JsonSchemaProperty("age" , JsonType.INTEGER )
.setDescription("Age in years" )
.setMinimum(0)
)
.addRequired("firstName" , "lastName" );
// Serialize to JSON
String json = JsonSerializer.DEFAULT_READABLE .serialize(s);
The following is a more-complex example showing various kinds of constraints.
{
"id" : "http://some.site.somewhere/entry-schema#" ,
"$schema" : "http://json-schema.org/draft-04/schema#" ,
"description" : "schema for an fstab entry" ,
"type" : "object" ,
"required" : [ "storage" ],
"properties" : {
"storage" : {
"type" : "object" ,
"oneOf" : [
{ "$ref" : "#/definitions/diskDevice" },
{ "$ref" : "#/definitions/diskUUID" },
{ "$ref" : "#/definitions/nfs" },
{ "$ref" : "#/definitions/tmpfs" }
]
},
"fstype" : {
"enum" : [ "ext3" , "ext4" , "btrfs" ]
},
"options" : {
"type" : "array" ,
"minItems" : 1,
"items" : { "type" : "string" },
"uniqueItems" : true
},
"readonly" : { "type" : "boolean" }
},
"definitions" : {
"diskDevice" : {},
"diskUUID" : {},
"nfs" : {},
"tmpfs" : {}
}
}
This document can be constructing using the following code:
JsonSchema s = new JsonSchema()
.setId("http://some.site.somewhere/entry-schema#" )
.setSchemaVersionId("http://json-schema.org/draft-04/schema#" )
.setDescription("schema for an fstab entry" )
.setType(JsonType.OBJECT )
.addRequired("storage" )
.addProperties(
new JsonSchemaProperty("storage" )
.setType(JsonType.OBJECT )
.addOneOf(
new JsonSchemaRef("#/definitions/diskDevice" ),
new JsonSchemaRef("#/definitions/diskUUID" ),
new JsonSchemaRef("#/definitions/nsf" ),
new JsonSchemaRef("#/definitions/tmpfs" )
),
new JsonSchemaProperty("fstype" )
.addEnum("ext3" , "ext4" , "btrfs" ),
new JsonSchemaPropertySimpleArray("options" , JsonType.STRING )
.setMinItems(1)
.setUniqueItems(true ),
new JsonSchemaProperty("readonly" )
.setType(JsonType.BOOLEAN )
)
.addDefinition("diskDevice" ,
new JsonSchema()
)
.addDefinition("diskUUID" ,
new JsonSchema()
)
.addDefinition("nfs" ,
new JsonSchema()
)
.addDefinition("tmpfs" ,
new JsonSchema()
);
// Serialize to JSON
String json = JsonSerializer.DEFAULT_READABLE .serialize(s);
1.2.1 - Serializing to other data types
Since the JSON-Schema DTOs are simple beans, they can be used to serialize to a variety of other
language types as well as JSON.
This also allows JSON-Schema documents to be easily served up using the Juneau REST API.
The sample web application includes a REST resource that generates a JSON-Schema document.
We'll use this resource to show what the JSON-Schema document looks like in other languages.
/**
* Sample resource that shows how to serialize JSON-Schema documents.
*/
@RestResource (
path="/jsonSchema" ,
messages="nls/JsonSchemaResource" ,
title="Sample JSON-Schema document" ,
htmldoc=@HtmlDoc (
navlinks={
"options: ?method=OPTIONS"
}
)
)
public class JsonSchemaResource extends BasicRestServletJena {
private JsonSchema schema ; // The schema document
/** Servlet initialization */
@Override
public void init() {
try {
schema = new JsonSchema()
.setId("http://example.com/sample-schema#" )
.setSchemaVersionUri("http://json-schema.org/draft-04/schema#" )
.setTitle("Example Schema" )
.setType(JsonType.OBJECT )
.addProperties(
new JsonSchemaProperty("firstName" , JsonType.STRING ),
new JsonSchemaProperty("lastName" , JsonType.STRING ),
new JsonSchemaProperty("age" , JsonType.INTEGER )
.setDescription("Age in years" )
.setMinimum(0)
)
.addRequired("firstName" , "lastName" );
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/** GET request handler */
@RestMethod (name=GET , path="/" )
public JsonSchema getSchema() throws Exception {
return schema ;
}
/**
* PUT request handler.
* Replaces the schema document with the specified content, and then mirrors it as the response.
*/
@RestMethod (name=PUT , path="/" )
public JsonSchema setSchema(@Body JsonSchema schema) throws Exception {
this .schema = schema;
return this .schema ;
}
/** OPTIONS request handler */
@RestMethod (name=OPTIONS , path="/*" )
public ResourceOptions doOptions(RestRequest req) {
return new ResourceOptions(this , req);
}
}
When you point your browser to this resource, the default content type is HTML (since that's what the
browser asks for by default).
HTML
The REST API allows you to specify the Accept header as a GET parameter, and the
plainText=true parameter forces the returned Content-Type to be
text/plain.
We'll use this to view the JSON-Schema document in other languages.
Normal JSON
XML
URL-Encoded
Abbreviated RDF/XML
Turtle
The full list of options for this resource can be accessed by the options link on the HTML
page.
Resource Options
1.3 - Parsing JSON-Schema documents
Use the {@link org.apache.juneau.json.JsonParser} to parse JSON-Schema documents into DTOs:
// Use parser to load JSON-Schema document into JSON-Schema DTOs
Schema schema = JsonParser.DEFAULT .parse(json, JsonSchema.class );
Schema objects can also be constructed from the other media types using the appropriate parsers.
*** fín ***