Novelties in Java EE 7: JAX-RS 2.0 + IPT REST HATEOAS Polling Demo @ BGOUG Conference, Pravets 2014

IPT – Intellectual Products & Technologies Trayan Iliev, http://www.iproduct.org/

BGOUG Meeting – Pravets

November 14, 2014

Slide 1Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License

Novelties in Java™ EE 7: JAX – RS 2.0

Trayan Iliev

IPT – Intellectual Products & Technologiese-mail: [email protected]

web: http://www.iproduct.org

Oracle®, Java™ and JavaScript™ are trademarks or registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.

mailto:[email protected]



November 14, 2014


Agenda I

Service Oriented Architecture (SOA), REST & HATEOAS

Richardson Maturity Model of Web Applications

IPT Proposal: Separation of Query & Command Representations & dynamically generated meta-data for RESTful resources

Novelties in Java™ EE 7: Java API for RESTful Web Services – JAX-RS 2.0 (JSR 339)

Standardized REST Client API;

Client-side and server-side asynchronous HTTP request processing

Integration of declarative validation of resources, response entities, method parameters, and fields using JSR 349: Bean Validation 1.1



November 14, 2014


Agenda II

Improved server-suggested content negotiation in addition to that suggested by clientAspect-oriented extensibility of request/response processing using Filters (non wrapping) and Interceptors (wrapping) client and server extensions

Dynamic extension registration using DynamicFeature interface;

Hypermedia As The Engine Of Application State (HATEOAS) REST architectural constraint support using state transition links (support for new HTTP Link header as well as JAXB serialization of resource links).

Let's try it (IPT Polling Demo + hands-on)



November 14, 2014


Question 1

How many people know what REST means?



November 14, 2014


Question 2

How many know what HATEOAS stays for?



November 14, 2014


Question 3

How many people have developed at least one RESTful service with JAX-RS?



November 14, 2014


Software Architecture – Definitions [1]

Almost everybody feels at peace with nature: listening to the ocean

waves against the shore, by a still lake, in a field of grass, on a

windblown heath. One day, when we have learned the timeless way

again, we shall feel the same about our towns, and we shall feel as

much at peace in them, as we do today walking by the ocean, or

stretched out in the long grass of a meadow.

— Christopher Alexander, The Timeless Way of Building (1979)



November 14, 2014



According to Dr. Roy Thomas Fielding [Architectural Styles and the Design of Network-based Software Architectures, 2000]:

A software architecture is an abstraction of the run-time elements of a software system during some phase of its operation. A system may be composed of many levels of abstraction and many phases of operation,each with its own software architecture.

A software architecture is defined by a configuration of architectural elements - components, connectors, and data - constrained in their relaionships in order to achieve a desired set of architectural properties.



November 14, 2014




An architectural style is a coordinated set of architectural constraints that restricts the roles/features of architectural elements and the allowed relationships among those elements within any architecture that conforms to that style.

The primary distinction between Network-based architectures and software architectures in general is that communication between components is restricted to message passing, or the equivalent of message passing if a more efficient mechanism can be selected at runtime based on the location of components.



November 14, 2014


Architectural Properties


PerformanceScalabilityReliabilitySimplicityExtensibility

All of them should be present in a desired Web Architecture and REST architectural style tries to preserve them by consistently applying several architectural constraints

Dynamic evolvabilityCusomizabilityConfigurabilityVisibility



November 14, 2014


Service Oriented Architecture (SOA) – Definitions

Thomas Erl: SOA represents an open, agile, extensible, federated, composable architecture comprised of autonomous, QoS-capable, vendor diverse, interoperable, discoverable, and potentially reusable services, implemented as Web services. SOA can establish an abstraction of business logic and technology, resulting in a loose coupling between these domains. SOA is an evolution of past platforms, preserving successful characteristics of traditional architectures, and bringing with it distinct principles that foster service-orientation in support of a service-oriented enterprise. SOA is ideally standardized throughout an enterprise, but achieving this state requires a planned transition and the support of a still evolving technology setReferences: Erl, Thomas. Serviceorientation.org – About the Principles, 2005–06



November 14, 2014


SOA == SOAP + WSDL?

Web Services are:

components for building distributed applications in SOA architectural style

communicate using open protocols

are self-descriptive and self-content

can be searched and found using UDDI or ebXML registries (and more recent specifications – WSIL & Semantic Web Services)

Source: http://en.wikipedia.org/wiki/File:Webservices.png, Author: H. VoormannLicense: Creative Commons Attribution 3.0 Unported

SemanticModels

Mapping WSDL

MessagesWSDL



November 14, 2014


Java EE 6 Architecture

Source: http://en.wikipedia.org/wiki/File:SOA_Detailed_Diagram.png, Author: JamesLWilliams2010, License: Creative Commons Attribution 3.0 Unported

Service Oriented Architecture (SOA)



November 14, 2014


SOA Implemetation - Java SE/EE 7 APIs

According to Java™ EE Specification:Web Services (SOAP)

Java API for XML Web Services (JAX-WS)

Java Architecture for XML Binding (JAXB)

SOAP with Attachments API for Java (SAAJ)

Java API for XML Registries (JAXR)

RESTful Web ServicesJava API for RESTful Web Services - JAX-RS



November 14, 2014


Representational State Transfer (REST) [1]

REpresentational State Transfer (REST) is an architecture for accessing distributed hypermedia web-services

The resources are identified by URIs and are accessed and manipulated using an HHTP interface base methods (GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH)

Information is exchanged using representations of these resources

Lightweight alternative to SOAP+WSDL -> HTTP + Any representation format (e.g. JavaScript™ Object Notation – JSON)



November 14, 2014


Representational State Transfer (REST) [2]

Identification of resources – URIs

Representation of resources – e.g. HTML, XML, JSON, etc.

Manipulation of resources through these representations

Self-descriptive messages - Internet media type (MIME type) provides enough information to describe how to process the message. Responses also explicitly indicate their cacheability.

Hypermedia as the engine of application state (aka HATEOAS)

Application contracts are expressed as media types and [semantic] link realtions (rel attribute - RFC5988, "Web Linking")

[Source: http://en.wikipedia.org/wiki/Representational_state_transfer]



November 14, 2014


Advantages of REST

Scalability of component interactions – through layering the client server-communication and enabling load-balancing, shared caching, security policy enforcement;

Generality of interfaces – allowing simplicity, reliability, security and improved visibility by intermediaries, easy configuration, robustness, and greater efficiency by fully utilizing the capabilities of HTTP protocol;

Independent development and evolution of components, dynamic evolvability of services, without breaking existing clients.

Fault tolerat, Recoverable, Secure, Loosely coupled



November 14, 2014


Richardson's Maturity Model of Web Services

According to Leonard Richardson [Talk at QCon, 2008 - http://www.crummy.com/writing/speaking/2008-QCon/act3.html]:

Level 0 – POX: Single URI (XML-RPC, SOAP)

Level 1 – Resources: Many URIs, Single Verb (URI Tunneling)

Level 2 – HTTP Verbs: Many URIs, Many Verbs (CRUD – e.g Amazon S3)

Level 3 – Hypermedia Links Control the Application State = HATEOAS (Hypertext As The Engine Of Application State) === truely RESTful Services



November 14, 2014


Is There A Level 4 for WebApp Maturity?

Considerations:

Command Query Responsibility Segregation (CQRS):http://martinfowler.com/bliki/CQRS.html (gentle introduction by Martin Fowler) & ReportingDatabases: http://martinfowler.com/bliki/ReportingDatabase.html

A single representation type can not be optimal for both reading (Query) and updating the application state (Command)

We may prefer to model Query and Command as separate resources / representation types

http://martinfowler.com/bliki/CQRS.html

http://martinfowler.com/bliki/ReportingDatabase.html



November 14, 2014


What About Meta-Data?

Very important for a RESTful applications where resources and resource states are dynamically discoverable / changeable

But what we have?

For SOAP services there is a WSDL (XML Schema based data type descriptions)

REST should have the same -> Welcome WADL !

But is it really a good thing to have a static description of dynamically changeable resources and valid resource state change transitions?

Static model can be evil in a Live World!



November 14, 2014


Web Application Description Language (WADL)

XML-based file format providing machine-readable description of HTTP-based web application resources – typically RESTful web services

WADL is a W3C Member SubmissionMultiple resourcesInter-connections between resourcesHTTP methods that can be applied accessing each resource Expected inputs, outputs and their data-type formatsXML Schema data-type formats for representing the RESTful resources

But WADL resource description is static ... let's make it dynamic!

Източник: http://en.wikipedia.org/wiki/File:Webservices.png, автор: H. VoormannЛиценз: Creative Commons Attribution 3.0 Unported



November 14, 2014


The New Kids on the Block: JSON, JSON Schema & Hyper Schema, Microformats

There are good use cases for WADL (REST resource metadata descriptions): automatic generation of client code & functional REST service tests, client data validation, building of generic REST clients.

WADL is XML (and relies on XML Schema Definitions) – this is a limitation for JavaScript Clients

Welcome JSON Schema & JSON Hyper-Schema !

But there are also Microformats (XHTML Meta Data Profiles –XMDP): e.g. hCard, hReview, hProduct, hCalendar ...

Talking about meta-data: W3C Resource Description Framework (RDF) and Web Ontology Language (OWL)



November 14, 2014


Metadata-Representations Proposal (& Questions)

Meta-data can be very useful for generic REST clients and agents crawling the Web!

Meta-data should be dynamically generated

... but can be more stable than the data it describes

Separation of data and meta-data representations (different life-cycles – allows optional retrieval, caching)

Meta-data should be dynamically discoverable using hyper links in resource representations (rel= type/ describedby/ lrdd?)

Separation of Command and Query representations -> optimal representations for each task (possibly with separate MIME types – application/vnd.*+json/xml?)



November 14, 2014


Java API for RESTful Web Service (JAX-RS 2.0)

Allows modelling (and more importantly decoupling) of RESTful resource controllers, models and representations – enables HATEOAS: Level 3 in Richardson WebApp Maturity ModelResource Controllers are modelled as Plain Old Java Objects (POJO) + declarative annotations mapping HTTP request & response URIs / Headers / Body / Parameters / Cookies/ to Java Classes / Methods / Method Arguments / Sub-resourcesModels are again POJO + (eventually) some XML / JSON mapping annotations – e.g. JAX-B / Jackson / Jettison / MOXyRepresentations – custom HATEOAS resource representations can be easily build using provided Link class and @XmlJavaTypeAdapter(JaxbAdapter.class) annotation




November 14, 2014


Java API for RESTful Web Service (JAX-RS)

Packages: javax.ws.rs, javax.ws.rs.core, javax.ws.rs.ext Basic annotations:

@Path@PathParam@QueryParam@FormParam@HeaderParam@CookieParam@MatrixParam@DefaultValue@Encoded


@Produces@Consumes, @HttpMethod@GET@POST@PUT@DELETE@Provider@Context



November 14, 2014


Implementing REST Resources using JAX-RS [1]

@Stateless@Path("courses")@TransactionManagement(TransactionManagementType.BEAN)public class CoursesResource extends AbstractFacade<Course> { @PersistenceContext(unitName = "IPTCourseManagerPU") private EntityManager em; @Context private UriInfo context; @Resource UserTransaction utx;



November 14, 2014



@POST@Consumes({"application/json", "application/xml"})public Response createCourse(Course entity){ try { utx.begin(); super.create(entity); utx.commit(); return Response.created(UriBuilder.fromUri(context.getAbsolutePath()).path(entity.getId().toString()).build()).build(); } catch (Exception ex) { throw new WebApplicationException(ex); }}



November 14, 2014



@GET@Produces({"application/xml", "application/json"})public CoursesRepresentation getAllCourses() { return new CoursesRepresentation(super.findAll());}

@Path("{id}")public CourseResource getCourseResource( @PathParam("id") Integer id) { return new CourseResource(id, em, utx);}

Sub-resource



November 14, 2014


Novelties in JAX-RS 2.0 by Example:IPT Polling Demo

You can clone (or download) IPT RESTful Polling Demo at GitHub: https://github.com/iproduct/IPT-Polling-Demo-JAXRS20-HATEOAS

The demo shows how to integrate multiple Java EE 7 technologies: EJB 3.1, CDI 1.1, JPA 2 + EclipseLink, JTA, Bean Validation.

It is a Maven project and can be deployed as Web application (.WAR) or started from command line, as simple as:

mvn embedded-glassfish:run (in project's root folder)

I demonstrates also how to develelop functional/integration tests using embedded GlassFish 4 and maven-surefire / maven-failsafe plugins; to start the integration tests from command line: mvn verify

There is also a project Wiki page discussing the details of the demo:https://github.com/iproduct/IPT-Polling-Demo-JAXRS20-HATEOAS/wiki

https://github.com/iproduct/IPT-Polling-Demo-JAXRS20-HATEOAS

https://github.com/iproduct/IPT-Polling-Demo-JAXRS20-HATEOAS/wiki



November 14, 2014


IPT Polling Demo Resources



November 14, 2014


IPT Polling Demo – Poll Resource States



November 14, 2014


IPT Polling Demo + Hands-on Exercises



November 14, 2014


Proposed Architecture:jQuery Client + RESTful Backend



November 14, 2014


Some Open Source WS Implementation Stacks

Glassfish Metro – http://metro.java.net/ – JAX-WS (SOAP + WSDL) Reference Implementation

Glassfish Jersey – http://jersey.java.net/ – JAX-RS (JSR 311) Reference Implementation for building RESTful Web services

RESTEasy – http://resteasy.jboss.org/ – JBoss JAX-RS implementation

Apache CXF – http://cxf.apache.org/ – JAX-WS & JAX-RS

Apache Axis 2 – http://axis.apache.org/axis2/java/core/ – SOAP & REST web services

http://metro.java.net/

http://jersey.java.net/



November 14, 2014


JAX-RS 2.0: Standardized REST Client API

Java Client API is important for:

RESTful services integration – building composite RESTful services and server-side mashupsFunctional & integration testing of web applications – using JUnit/ TestNG for testing integration scenariosLoad / Perfomance / Stress testing of REST servicesBuilding GUI clients – could utilize rich interface capabilities of Swing & Java FX

Before Java EE 7 each of JAX-RS implementations had its own client API

Now the client code can be standardized and portable between implementations



November 14, 2014


Standardized REST Client API Example (1)

public class PollsResourceTest { public static final String BASE_URI = "http://localhost:8080/polling/resources/polls"; private static WebTarget target; ... @BeforeClass public static void setUpClass() { // Initialize base REST client and target URI uri = UriBuilder.fromUri(BASE_URI).build(); ClientConfig config = new ClientConfig(); Client client = ClientBuilder.newClient(config); target = client.target(uri); setupResources(); }

http://localhost:8080/polling/resources/polls



November 14, 2014



private static List<Poll> setupResources() { List<Poll> updatedPolls = Arrays.asList(SAMPLE_POLLS) .stream().map(poll -> { try{ Poll updatedPoll =target.request(APPLICATION_JSON) .post(Entity.entity(poll, APPLICATION_JSON), Poll.class); if(updatedPoll != null) forCleanup(updatedPoll); return updatedPoll; } catch (Exception e) { … } return null; }).collect(Collectors.toList()); return updatedPolls;}



November 14, 2014



@Testpublic void testGetAllPollsJSONReturnsNotNull() { List<Poll> allPolls = target.request(APPLICATION_JSON) .get(new GenericType<List<Poll>>(){}); assertNotNull(allPolls);}@Testpublic void testGetPollByIdReturns404ForNonexisitingResource() { Response resp =target.path(Long.toString(NONEXISTING_POLL_ID)) .request(APPLICATION_JSON).get(); assertEquals("Status code not 404", 404, resp.getStatus()); assertThat("Response does not contain espected string: '" , resp.readEntity(String.class), containsString( NONEXISTING_POLL_ID + " does not exist"));}



November 14, 2014


Asynchronous HTTP Request Processing

Allows for efficient non-blocking concurrency

Useful for long running business operations – e.g. DB queries

AsyncResponse generation can be suspended till results are ready and then resumed

Both client and server side APIs available

Different types of callback listeners can be registered to suspended response on server side:

ResumeCallback – onResume() methodCompletionCallback – onComplete(), onError() methodsConnectionCallback – onDisconnect() method



November 14, 2014


AsyncResponse Main Methods

boolean cancel(Date retryAfter) – cancels processing

boolean isCancelled() - checks if processing canceled

boolean isDone() - checks if processing finished

Collection<Class<?>> register(Class<?> callback)

Collection<Class<?>> register(Object callback) - register asynchronous processing callback

boolean resume(Object response) – resume suspended resp.

boolean resume(Throwable response) – resume + exception

boolean setTimeout(long time, TimeUnit unit) – set timeout

void setTimeoutHandler(TimeoutHandler handler)



November 14, 2014


Asynch Server-Side Processing Example (1)

@GET @Produces(value = {APPLICATION_XML, APPLICATION_JSON})@Asynchronouspublic void getAllPolls(@Suspended final AsyncResponse asyncResponse) { asyncResponse.setTimeoutHandler( (AsyncResponse aResp) -> { if(isBusy()) aResp.resume( new WebApplicationException( "Server is too busy. Try again later.", SERVICE_UNAVAILABLE)); //aResp.cancel(300); else aResp.setTimeout(10, SECONDS); }); asyncResponse.setTimeout(10, TimeUnit.SECONDS); asyncResponse.resume(doGetAllPolls(selfLink));}



November 14, 2014


Asynch Server-Side Processing Example (2)

private static boolean isBusy() { return serverBusy;}

private PollsRepresentation doGetAllPolls(Link selfLink){ return new PollsRepresentation( pollController.findPollEntities(), Arrays.asList(selfLink));}



November 14, 2014


Asynch Client-Side Processing Example (1)

protected List<Poll> setupResourcesAsync() throws InterruptedException, ExecutionException{ List<Future<Poll>> updateFutures = Arrays.asList(SAMPLE_POLLS).stream() .map(poll -> { Future<Poll> updateFuture = target.request(APPLICATION_JSON) .async() .post(Entity.entity(poll, APPLICATION_XML), new InvocationCallback<Poll>(){ @Override public void completed(Poll updatedPoll) { forCleanup(updatedPoll); } @Override public void failed(Throwable throwable) {} }); return updateFuture; }).collect(Collectors.toList());



November 14, 2014


Asynch Client-Side Processing Example (2)

do{ Thread.sleep(100); } while(!updateFutures.stream() .allMatch((Future<Poll> fp) -> fp.isDone())); //return collected results List<Poll> results = new ArrayList<>(); for(Future<Poll> fp: updateFutures){ Poll resPoll = fp.get(); if(resPoll != null) results.add(resPoll); } return results; }



November 14, 2014


Declarative Validation Using Bean Validation 1.1

Method parameters: @GET @Path("/{id}") @Produces({APPLICATION_XML, APPLICATION_JSON}) public Response getPollById( @PathParam("id") @NotNull @Min(1) Long id) { ... }

Beans fields & properties:

@NotNull @Size(min = 1, max = 255) @Email @Basic(optional = false) private String email;



November 14, 2014


Declarative Validation Using Bean Validation 1.1

Declarative validation annotations can be attached to:

Request entity body @POST @Consumes({APPLICATION_XML, APPLICATION_JSON}) public Response addPoll(@Valid Poll poll) { ... }

Response entity: @GET @Path("/count") @Produces(TEXT_PLAIN) @Pattern(regexp = "\\d+") public String getPollsCount() { return Integer.toString(pollController.getPollCount()); }



November 14, 2014


Improved Server-Suggested Content Negotiation

Client driven content negotiation has been traditional capability of HTTP protocol – for example:

GET /polling/resources/polls HTTP/1.1Host: localhost:8080Accept: application/xml; q=0.5, application/json; q=0.4Cache-Control: no-cache

But when client does not specify Accept header preference?

- Server can:@GET@Produces(value = {APPLICATION_XML + "; qs=0.75", APPLICATION_JSON + "; qs=0.9"}) public Collection<Poll> getAllPolls() { ...}



November 14, 2014


Filters & Interceptors – Client & ServerAspect-oriented extensibility of request/response processing

Resource Filters – very similar to “classical” HttpServlet filters, non wrapping, do not invoke next processors in the chain directly, can filter HttpRequest (ContainerRequestFilter, ClientRequestFilter) or HttpResponse (ContainerResponseFilter, ClientResponseFilter). can bypass the next filters and resources by calling: ContainerRequestContext.abortWith(javax.ws.rs.core.Response)

Resource Interceptors – they “wrap” the call to the entity readers/writers by explicitly calling [Reader/Writer]InterceptorContext.proceed() to pass the input stream or entity body read / written by next interceptor / resource/ sub-resource method in the chain.

Filters & interceptors can manipulate headers and entity body. The main difference is that filters can change the requested resource URI (if @PreMatching), while interceptors can not (they are executed after resource processing method has been matched).



November 14, 2014


Filters & Interceptors – Client & ServerAspect-oriented extensibility of request/response processing



November 14, 2014


LoggingFilter Example (1)

@Provider//@PreMatching@Priority(1000)@Loggedpublic class LoggingFilter implements ContainerRequestFilter, ContainerResponseFilter { @Override public void filter(ContainerRequestContext requestContext) { Logger.getLogger("Logging Resource Request >>>>> ", LoggingFilter.class).log(Level.INFO, "Method: " + requestContext.getMethod() + ", URI: " + requestContext.getUriInfo().getAbsolutePath() + ", Headers: " + requestContext.getHeaders() ); }



November 14, 2014


LoggingFilter Example (2)

@Overridepublic void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) { Logger.getLogger("Logging Service Response >>>>> ", LoggingFilter.class).log(Level.INFO, "Method: " + requestContext.getMethod()+ ", URI: " + requestContext.getUriInfo().getAbsolutePath() + ", Status Code: " + responseContext.getStatus() + ", MIME Type: " + responseContext.getHeaders() + ", Entity Body: " + responseContext.getEntity() ); }}



November 14, 2014


@Logged + @NameBinding Example (1)

@NameBinding@Retention(value = RetentionPolicy.RUNTIME)@Target({ElementType.TYPE, ElementType.METHOD})public @interface Logged {}

@GET @Logged@Profiled@Path("/{id}")@Produces({APPLICATION_XML, APPLICATION_JSON})public Response getPollById( @PathParam("id") @NotNull @Min(1) Long id) { ... }



November 14, 2014


AddSelfLinkInterceptor Example (1)

@Provider@SelfLinkedpublic class AddSelfLinkInterceptor implementsWriterInterceptor{ @Context UriInfo uriInfo;

@Override public void aroundWriteTo(WriterInterceptorContext responseContext)throws WebApplicationException, IOException{ List<Object> links = responseContext.getHeaders().get("Link"); if(links == null) links = new ArrayList<>(); links.add("<" + uriInfo.getAbsolutePath() + ">; rel=self"); responseContext.getHeaders().put("Link", links); responseContext.proceed(); }}



November 14, 2014


Dynamic extension registration using DynamicFeature interface

Allows dynamic programmatic registration of post-matching providers during JAX-RS setup at deployment time

public void configure(ResourceInfo resourceInfo, FeatureContext context) method called for each resource allows to dynamically decide during application configuration phase which ContainerRequestFilter, ContainerResponseFilter, ReaderInterceptor, WriterInterceptor, and Feature classes to register for that resource / subresource class / method (based on annotations provided for the method for example)

May be annotated with @Provider annotation to be dynamically discovered



November 14, 2014


DynamicFeature Example (1)

@Providerpublic class SelfLinkingDynamicFeature implements DynamicFeature{ @Override public void configure(ResourceInfo resourceInfo, FeatureContext context) { if(resourceInfo.getResourceMethod() .isAnnotationPresent(GET.class) ||resourceInfo.getResourceMethod() .isAnnotationPresent(POST.class) ){ context.register(AddSelfLinkInterceptor.class); } }}



November 14, 2014


Hypermedia As The Engine Of Application State (HATEOAS) – Document Links Example (1)

@XmlAccessorType(XmlAccessType.FIELD)@XmlRootElement(name="poll")public class PollRepresentationDocumentLinks { private Long id; private PollStatus status = PollStatus.CREATED; private String title; private String question; private Date start; private Date end; @XmlElementWrapper(name = "_embedded") @XmlElement(name = "alternative") private List<Alternative> alternatives; @XmlElementWrapper(name = "_links") @XmlElement(name = "link") @XmlJavaTypeAdapter(JaxbAdapter.class) private Collection<Link> links; ...



November 14, 2014


Hypermedia As The Engine Of Application State (HATEOAS) – New Link Header (RFC 5988) (2)

Response resp = Response.ok( new PollRepresentationHeaderLinks(poll)) .links(links.toArray(new Link[]{}));Content-Length →1656Content-Type →application/xmlLink →<http://localhost:8080/polling/resources/polls/629>; rel="prev"; type="application/json"; title="Previous poll", <http://localhost:8080/polling/resources/polls/632>; rel="next"; type="application/json"; title="Next poll", <http://localhost:8080/polling/resources/polls>; rel="collection"; type="application/json"; title="Polls collection", <http://localhost:8080/polling/resources/polls>; rel="collection up"; type="application/json"; title="Root resource", <http://localhost:8080/polling/resources/polls/630>; rel="self"; type="application/json"; title="Self link", <http://localhost:8080/polling/resources/polls/630>; rel=selfServer →GlassFish Server Open Source Edition 4.1



November 14, 2014


Want to Learn More?

Welcome to IPT Java™ trainings [http://iproduct.org/]:Programming in Java Language - 3 modules

Web Programming with Java Technology: Servlet 3.1, JSP, JSTL, EL, JSF 2.2, Facelets & Templating, AJAX, JSON, WebSocket, SSE, WebRTC

Java Enterprise Technologies (Java EE 7) – EJB 3.2, JSF 2.2, JAX-RS 2.0, Web Services, WebSocket, JMS, CDI, Bean Validation, JPA, JTA, Batch and Concurrency

Service Oriented Architecture (SOA) & Contemporary Standards for Business Process Modeling (BPM) – Apache AXIS 2 & CXF, Glassfish Metro & Jersey, JBoss RESTEasy, SoapUI & Service Testing, SOAP, WSDL 2.0, WS-*, SOA, SCA, SDO, BPMN, WS-BPEL

Java™ Portlet Development with JSR 286: Portlet 2.0 API, Liferay® 6 & GateIn 3 – JSP™, JSF 2.2, Spring & AJAX Portlets

Oracle®, Java™ and JavaScript™ are trademarks or registered trademarks of Oracle and/or its affiliates. Liferay® is a registered trademark of Liferay, Inc. Other names may be trademarks of their respective owners.

http://iproduct.org/



November 14, 2014


References

R. Fielding, Architectural Styles and the Design of Networkbased Software Architectures, PhD Thesis, University of California, Irvine, 2000

Fielding's blog discussing REST – http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven

Representational state transfer (REST) in Wikipedia – http://en.wikipedia.org/wiki/Representational_state_transfer

Hypermedia as the Engine of Application State (HATEOAS) in Wikipedia – http://en.wikipedia.org/wiki/HATEOAS

JavaScript Object Notation (JSON) – http://www.json.org/

JAX-RS 2.0 (JSR 339) Reference Implementation for building RESTful Web services – http://jersey.java.net/

http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven

http://en.wikipedia.org/wiki/Representational_state_transfer

http://en.wikipedia.org/wiki/HATEOAS

http://www.json.org/

http://jersey.java.net/



November 14, 2014


Thanks for Your Attention!

Questions?

Novelties in Java EE 7: JAX-RS 2.0 + IPT REST HATEOAS Polling Demo @ BGOUG Conference, Pravets 2014

Technology

Transcript of Novelties in Java EE 7: JAX-RS 2.0 + IPT REST HATEOAS Polling Demo @ BGOUG Conference, Pravets 2014