Principles of Enterprise Web Development

Packaging Data for the Web

EN 605.481

Overview

• Both XML and JSON can be used to pass data between remote applications, clients and servers, etc.

• XML – Usually heavier than JSON

– More difficult to parse

• JSON – Readily parsed by Javascript

– Faster to process

XML Overview

• Like HTML based on Standard Generalized Markup Language (SGML)

• XML allows arbitrary definition and use of tags and attributes • Well-formed for to faciliate parsing, search and manipulation

– XML documents have a single root tag that contains the remaining content

– Every open tag has a corresponding close tag that must match in name (including case)

– Tags are nested hierarchically – Attribute values must be quoted

• XML comprises many technologies – XML Schema – XSL/XSLT – Extensible Stylesheet Language/Transforms – Xpath – XML Path Language – Others

JSON Overview

• Self-describing format based on syntax used for Javascript objects

– ECMA-262 standard

• Completely language independent

– Easily integrated into Javascript

– Other languages provide supporting APIs (C/C++, Java, ASP, Python, Ruby…)

• Lightweight for rapid processing

XML – JSON Example

<?xml version=“1.0”

encoding=“UTF-8”?>

<authors>

<name>

<firstname>Larry</firstname>

<lastname>Brown</lastname>

</name>

<name>

<firstname>Bob</firstname>

<lastname>Evans</lastname>

</name>

</authors>

235 bytes

{ authors: {

name: [

{

firstname:”Larry”,

lastname:”Brown”

},

{

firstname:”Bob”,

lastname:”Evans”

}

]

}}

146 bytes (38% smaller)

JSON versus XML

• While XML and JSON are both used for the exchange of data over the web, JSON is becoming the defacto format for exchanging data because: – More often JSON offers a more lightweight

representation that improves performance and processing

– Javascript’s built in mapping into objects make it easy to “export” and “import” data from/to the client

• XML as technology still has much to offer that is not available with JSON. For more information see: – Class “Additional Resources”

JSON Syntax

• Data is in name : value pairs (colon delimited) – Names are enclosed in double quotes – Values can be

• Integer or floating point numbers • Strings (enclosed in double quotes) • Boolean (true or false) • Arrays (enclosed in square brackets [] ) • Objects (enclosed in curly brackets {}) • null (all lowercase, represents empty type) • Whitespace (ignored)

• Data pairs are separated by commas • Curly brackets contain objects • Square brackets contain arrays

JSON Examples

• Name : Value Pair – “firstname” : “Richard” – “age” : 30

• Objects – {“firstname”:”Richard”, “lastname”:”Spiegel”, “age”:30 } – {“id”:88421, “Experience”:17, “Reviews:[8,5,7,4] } – {“InnerObject”: { “name”:”Spiegel”, “years”:”10”}, “level”:4}

• Arrays [ {“firstname”:”Richard”, “lastname”:”Spiegel”, “age”:30 } {“firstname”:”Brian”, “lastname”:”Spiegel”, “age”:20} {“firstname”:”Robert”, “lastname”:”Evand”, “age”:40 } ]

JSON Console

• Interactive Browser Consoles

– Chrome :

• ctrl+shift+j (cmd+shift+j for mac)

• Select Console tab

– Firefox

• About:blank in address bar for blank tab

• Tools->Web Developer->Web Console (ctrl+shift+k)

– IE

• F12

• Select console tab

• Other

– Firefox tool Scratchpad

– Jsbin.com

– Chrome extension JavaScript Editor

JSON and JavaScript

• Creating objects in Javascript – Empty object:

• var sampleObj = {};

– New object • var sampleObj = new Object();

– Initialized object: • var sampleObj = {“firstname”:”rich”,”age”:50};

– Array object: var sampleArray = { “directory” : [ {“firstname”:”rich”,”age”:35}, {“firstname”:”bob”,”age”:50}, {“firstname”:”emma”,”age”:12} ] };

JSON and JavaScript

• Accessing JSON object fields var x = sampleObj.firstname ; // x = “rich”

var y = sampleObj.age; // y = 50

• Accessing JSON array object fields var x = sampleArray.directory[2].firstname; // x = “emma”

var y = sampleArray.directory[0].age; // y = 35

var z = sampleArray.directory[1];

// z = {firstname:”bob”, age:50}

JSON and Java

• Official standard API, JSR 353 – Java API for JSON Processing

– https://jcp.org/en/jsr/detail?id=353

• Several open source APIs existed prior to JSR 353 and are quite popular today – FasterXML/Jackson: https://github.com/FasterXML

– GSON: https://github.com/google/gson (Google)

– JSON-P: https://javaee.github.io/jsonp/

– JSON.org: http://www.json.org

– MOXy: https://wiki.eclipse.org/EclipseLink/FAQ/MOXy

FasterXML/Jackson Overview

• Streaming API that parses and generates JSON in a series of events – Low overhead – Fast read/writes

• Tree model for loading and manipulating JSON document as Java objects (JsonNodes) – Most flexible for manipulation

• Data binding converts JSON to plain old Java objects (POJOs) using configurations or annotations and generates JSON from configured POJOs – Useful for serializing/deserializing Java Objects – Especially for web based application!

• Full documentation with tutorials and more at: https://github.com/FasterXML/jackson-docs

FasterXML/Jackson Databinding • Getting and Installing

– Download from https://github.com/FasterXML • URLs provided to included in Maven builds • Links to jar files with library files, source code and api docs

– Three library jar files required for minimal access • jackson-core • jackson-databind • jackson-annotations

• API Usage – com.fasterxml.jackson.databind.ObjectMapper

• Primary class to facilitate the marshalling and unmarshalling of java objects to and from JSON

• Constructor and supporting methods

– com.fasterxml.jackson.core package • core classes used by databind package (aka ObjectMapper) • Exception classes thrown by class methods throughout Jackson

– com.fasterxml.jackson.annotations package • All supported annotations used for java class mapping to JSON formats • Helper classes that are used by ObjectMapper

ObjectMapper

• Provides function of converting Java objects to JSON and vice versa

– Wraps other Jackson objects (from core library) for reading/writing JSON

• import com.fasterxml.jackson.databind.ObjectMapper • Constructor: new ObjectMapper() • Methods:

– readValue: several methods for moving data sources (streams, files, Strings) into Java objects • readValue(String content, Class<T> valueType) : deserializes JSON content into object of type

valueType

– writeValue: several methods for serializing Java objects into JSON output into Strings, files, streams • writeValueAsString : serializes Java object to String

– enable: methods for configuring the mapper for parsing JSON or generating JSON

• Exceptions – IOException – JsonGenerationException – JsonMappingException – JsonProcessingException – JsonParseException

Annotations

• Meta data to control how Java classes map to JSON documents and vice versa

• Added to either property or one of the accessor/mutator methods on that property

• Some have additional properties that can be set • @JsonProperty

– value: provides a name of the property in the JSON or just use name of java filed

– defaultValue: value for the property if one is not provided

• @JsonRootName – value: root name to use around object if root-level wrapping is

enabled

• @JsonIgnore • @JsonInclude • @JsonPropertyOrder

Using JSON with ReST

• The JAX-RS API (aka Jersey) interfaces with the JAX-B (JSON/XML binding) API inherently when necessary – JSON passed in conjunction with appropriate @Consumes

annotation will use JAX-B to deserialize JSON into objects. – Java objects passed in conjunction with appropriate

@Produces annotation will use JAX-B to serialize objects into JSON.

• Jersey projects must have a JAX-B implementation to support those API calls or they will fail – Will use default JAX-B API implementation packaged with

Jersey (MOXy) – Can replace MOXy with alternative JAX-B implementations

through library manipulation

FasterXML/Jackson with ReST • FasterXML/Jackson libraries are required for processing

the underlying POJOs and JSON mappings – jackson-core – jackson-databind – jackson-annotations

• Need additional libraries that account for Jackson under the Java API for RESTful Web Services (JAX-RS) – jackson-jaxrs-base – jackson-jaxrs-json-provider

• Out of the box, Jersey provides another JAXB API (Moxy) that must be removed in order to use Jackson. – Remove jersey-media-moxy.jar file from classpath

Netbeans Project View

Default libraries provided by Jersey Library with jersey-media-moxy jar

file removed

Basic FasterXML/Jackson JAX-B libraries

FasterXML/Jackson libraries for use under JAX-RS

Using JSON Binding in ReST

• Create POJOs that will be mapped to desired JSON (and vice-versa) – Objects create from JSON passed from client

– JSON serialized from objects used on server

• Optionally, employ Jackson annotations on object to dictate mapping features (field names, order, etc)

• Employ the objects in ReST service methods as parameters or return variables in conjunction with @Produces/@Consumes annotations

Example JSON Output

• A ReST call to http://host/path..../record will return content of type application/json that will look as follows: {“first”:”rich”,”last”:”spiegel”,”age”:35}

@GET

@Path(“/record”)

@Produces(MediaType.APPLICATION_JSON)

public Record getRecord() {

Record r = new Record();

r.setFirstname(“Rich”);

r.setLastname(“Spiegel”);

r.setAge(35);

return r;

}

public class Record {

@JsonProperty(“first”)

private String firstname;

@JsonProperty(“last”)

private String lastname;

@JsonProperty(“age”)

private int age;

:

}

Example JSON Input

• A POST to http://host/path..../new with attached JSON content will automatically create record and initialize it with fields from the JSON passed.

@POST

@Path(“/new”)

@Consumes(MediaType.APPLICATION_JSON)

public Response newRecord(Record record)

{

// record is initialized from the

// json content provided in the POST

// request

}

public class Record {

@JsonProperty(“first”)

private String firstname;

@JsonProperty(“last”)

private String lastname;

@JsonProperty(“age”)

private int age;

:

}