java ee 8 recipes
TRANSCRIPT
Java EE 8 RecipesPresented By: Josh JuneauAuthor and Application Developer
About MeJosh Juneau
Day Job: Developer and DBA @ Fermilab
Night/Weekend Job: Technical Writer
- Java Magazine and OTN
- Java EE 7 Recipes
- Introducing Java EE 7
- Java 8 Recipes
JSR 372 EG and JSR 378 EG
Twitter: @javajuneau
Agenda
- Take a look at big picture of Java EE 8
- Resolve a series of real life scenarios using the features of Java EE 7 and Java EE 8
Before we start. . .
Old: J2EE
Modern: Java EE
Java EE of the Past (J2EE)
Difficult to Use ConfigurationVerbose
Few Standards
Progressive Improvements
More Productive
Less Configuration
More Standards
Java EE 7 Increases Productivity Even More
and Introduces Standards for Building Modern Applications
Java EE 7 Increased Productivity
• CDI Everywhere
• JAX-RS Client API, Async Processing
• Bean Validation in EJBs and POJOs
• JSF Flows
• JMS 2.0 - Much Less Code
Java EE 7 Introduced New Standards
• WebSockets
• JSON-P
• Batch API
• Concurrency Utilities for Java EE
Who uses Java EE?
Java EE 8 Continues this Momentum
• Continued enhancements for productivity and web standards alignment
• Cloud enhancements
• Better alignment with Java SE 8
• Work towards a better platform for development of microservices
Recipes!Lots to cover…
Recipes!Statement for Completeness:
Recipes are not meant to provide comprehensive coverage of the features. Rather, they are meant to get you up and running with the new functionality quickly, providing the
details you need to know. To learn more details on any of the features covered, please refer to the online
documentation.
Let’s Cook!
How to Run
Setting up your environment for Java EE 8
• Payara 5 Branch• Clone git repository and build:
mvn clean install -DskipTests
• Clone and Build/Download latest EA of Spec• Most have git repositories
JSF 2.3JSR 372
• New features added in JSF 2.3, adding more flexibility
• Improved CDI Alignment
• PostRenderViewEvent
• WebSocket Integration and Ajax Enhancements
• Java 8 Date-Time Support
• Enhanced Components
• Much More
Problem #1
You would like to work with the Java 8 Date-Time API via your JSF application. Does not work with Java EE 7 out of the box.
Solution
Make use of the <f:convertDateTime /> tag.
How it Works
JSF 2.3 requires a minimum of Java 8, so we can make use of Java 8 goodness.
New type attribute values on <f:convertDateTime>:• localDate, localTime, localDateTime• offsetTime,offsetDateTime, zonedDateTime
Problem #2
Oftentimes, you need to work with FacesContext or another JSF artifact. It can be cumbersome to obtain the current instance, ServletContext, etc. time after time.
Problem
FacesContext context = FacesContext.getCurrentInstance();
ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();
Problem
Map<String, Object> cookieMap = FacesContext.getCurrentInstance().getExternalContext().getRequestCookieMap();
Map<String, Object> viewMap = FacesContext.getCurrentInstance().getViewRoot().getViewMap();
Solution
Inject JSF artifacts in JSF 2.3, and inject into JSF artifacts.
Solution@Inject
private ExternalContext externalContext;
@Inject
private ServletContext servletContext;
@Inject
@ViewMap
private Map<String, Object> viewMap;
How it Works
JSF 2.3 provides default producers for many of the most commonly used JSF artifacts, therefore, we can now inject rather than hard-code.
Converters, validators and behaviors are now also injection targets.
How it Works
Bean ValidationJSR-380
New Features in Bean Validation 2.0:
• Focus on Java SE 8 Features
• Type annotations, Date-Time Validation, etc.
• Simpler Constraint Ordering on Single Properties
• Custom Payload for Constraint Violations
Problem #3
You would like to validate dates and times utilizing the Java 8 Date-Time API to ensure that they are in the past or in the future.
Solution@Future and @Past will work with Java 8 Date-Time
How it Works• Place validation constraint annotations on a field,
method, or class such as a JSF managed bean or entity class.
• When the JSF Process Validations phase occurs, the value that was entered by the user will be validated based upon the specified validation criteria. At this point, if the validation fails, the Render Response phase is executed, and an appropriate error message is added to the FacesContext. However, if the validation is successful, then the life cycle continues normally.
• Specify a validation error message using the message attribute within the constraint annotation
How it Works
Other New Features:
Type-use annotation:List<@NotNull @Email String> emails;
Mark standardized constraints with @Repeatable, eliminating the need for the usage of the @Size.List pattern.
JSON-P 1.1JSR-374
The Java API for JSON Processing is a standard for generation and processing of JavaScript Object Notation data.
JSON-P provides an API to parse, transform, and query JSON data using the object model or the streaming model.
JSON is often used as a common format to serialize and deserialize data for applications that communicate with each other over the Internet.
JSON-P 1.1
• Adds new JSON standards for JSON-Pointer and JSON-Patch
• Provides editing operations for JSON objects and arrays
• Helper classes and Java SE 8 Support
Problem #4
You would like to build a JSON object model using Java code.
We wish to create a list of current reservations.
Solution
Utilize JSON Processing for the Java EE Platform to build a JSON object model containing all of the current reservations.
Solution
How it Works
JSON defines only two data structures: objects and arrays. An object is a set of name-value pairs, and an array is a list of values. JSON defines seven value types: string, number, object, array, true, false, and null.
How it WorksJava EE includes support for JSR 353, which provides an API to parse, transform, and query JSON data using the object model or the streaming model
Make use of JsonObjectBuilder to build a JSON object using the builder pattern.
Call upon the Json.createObjectBuilder() method to create a JsonObjectBuilder.
How it Works
Utilize the builder pattern to build the object model by nesting calls to the JsonObjectBuilder add() method, passing name/value pairs.
How it WorksIt is possible to nest objects and arrays.
The JsonArrayBuilder class contains similar add methods that do not have a name (key) parameter. You can nest arrays and objects by passing a new JsonArrayBuilder object or a new JsonObjectBuilder object to the corresponding add method.
Invoke the build() method to create the object.
Problem #5
You are interested in finding a specific value within a JSON document.
Solution
Utilize JSON Pointer to find the desired value.
How it Works
• Create a new JsonPointer object and pass a string that will be used for identifying a specific value.
How it Works
• Obtain the value by calling the JsonPointer.getValue() method and passing the JsonObject you wish to parse. The JsonValue will contain the value to which you had pointed.
Problem #6
You would like to perform an operation on a a specified value within a JSON document.
Solution
Utilize JSON Patch to replace a specified value within a JSON document with another value.
The original document{"baz": "qux", "foo": "bar"}The patch[ { "op": "replace", "path": "/baz", "value": "boo" }, { "op": "add", "path": "/hello", "value": ["world"] }, { "op": "remove", "path": "/foo"}]The result{"baz": "boo","hello": ["world"]}
Solution
How it Works
• JSON Document or JsonPatchBuilder
• JSON Pointer is used to find the value or section that will be patched
• A series of operations can be applied
Problem #7
You wish to parse some JSON using Java.
Solution
Use the JsonParser, which is a pull parser that allows us to process each document record via iteration.
How it Works
Parser can be created on a byte or character stream by calling upon the Json.createParser() method.
Iterate over the JSON object model and/or array, and parse each event accordingly.
JSON-BJSR-367
Java API for JSON Binding• Standardize means of converting JSON to
Java objects and vice versa• Default mapping algorithm for converting
Java classes• Draw from best of breed ideas in existing
JSON binding solutions• Provide JAX-RS a standard way to support
“application/json” for POJOs• JAX-RS currently supports JSON-P
Problem #8
You would like read in a JSON document and map it to a Java class or POJO.
Solution
Utilize default JSON binding mapping to quickly map to a POJO.
Solution
SolutionCreate JSON from Java object
SolutionCreate JSON from Java List
How it Works
• JSON-B API provides serialization and deserialization operations for manipulating JSON documents to Java
• Default mapping, with custom annotation mapping available for compile-time
• JsonConfig class for runtime mapping customizations
CDI 2.0JSR 365
• JSR is in active progress…can download WELD betas and test
• Java SE Bootstrap
• XML Configuration
• Asynchronous Events
• @Startup for CDI Beans
• Portable Extension SPI Simplification
• Small features/enhancements
Problem #9
You’d like to mark a CDI event as asynchronous.
SolutionFire the event calling upon the fireAsync() method, passing the event class.
SolutionUse @ObservesAsync to observe an asynchronous event.
How it Works
• Utilizes the Java 8 Asynchronous API to provide a streamlined approach.
• @ObservesAsync annotation added to annotate an observer method parameter so that existing observers annotated with @Observes would remain synchronous.
• fireAsync() added to the Event interface.
ConfigurationNew Spec Pending
• Standard for externalizing configuration
• Aimed at cloud-based environments
• Provide the ability to change one or more configurations that are independent/decoupled of apps...multiple configuration files
• Unified API for accessing configuration in many different environments
• Layering and overrides
Problem #10
The application that you are developing requires some external configuration values for specifying server-side paths and/or resources.
SolutionUse the standardized configuration API to retrieve the configuration values.
Suppose you have a property file with the following values:
city=Chicago
language=Java
Solution
Config config = ConfigProvider.getConfig();
String city = config.getProperty(“city”);
String language = config.getProperty(“language”);
Long val = config.getProperty(“someLong”, Long.class);
How it Works
• Define the configuration sources for an application using a config-sources.xml file, or using an api to set up at deployment time.
WebSockets
The Java API for WebSocket provides support for building WebSocket applications.
WebSocket is an application protocol that provides full-duplex communications between peers over the TCP protocol.
What about Java EE 8??
Problem #11
You wish to create a communication channel that can be used to receive messages asynchronously.
Solution
Create a WebSocket endpoint by annotating a POJO class using @ServerEndpoint, and providing the desired endpoint path.
Create a message receiver method, and annotate it with @OnMessage
Solution
How it Works
Create a WebSocket endpoint by annotating a class with @ServerEndpoint, and passing the value attribute with a desired path for the endpoint URI.
@ServerEndpoint(value=“/chatEndpoint”)
URI: ws://server:port/application-name/path
How it Works
Method annotated @OnOpen is invoked when the WebSocket connection is made.
Method annotated @OnMessage is invoked when a message is sent to the endpoint. It then returns a response.
How it Works
Specify optional Encoder and Decoder implementations to convert messages to and from a particular format.
How it WorksExample of a Decoder:
JAX-RS 2.1JSR 370
• Hypermedia API
• Reactive API
• Security API
• Support for SSE (Server Sent Events)
• Improved CDI Integration
• Support for Non-Blocking IO in Providers
Problem #12
You would like to initiate an open-ended communication channel from a server to clients. You wish to have a connection remain open to the client so that subsequent single-sided communications from the server can be sent.
SolutionCreate an SSE Resource using JAX-RS 2.1, and broadcast server messages to connected clients at will.
Solution
How it Works• Try now by downloading Jersey 2.24
• Similar to long-polling, but may send multiple messages
• Annotate resource method with @Produces(SseFeature.SERVER_SENT_EVENTS)
• Also possible to broadcast using SseBroadcaster
MVC 1.0Features of MVC 1.0:
• Action-based
• Follows suit of Spring MVC or Apache Struts
• Does not replace JSF
• No UI Components
• Model: CDI, Bean Validation, JPA
• View: Facelets, JSP, other
• Controller: Layered on top of JAX-RS
We’ve Covered A Lot
…but there is a lot more to cover!!!!
Microservices?
What is a microservice?
How to do micro services with Java EE?
We’ll get there in Java EE 9…
Learn More
Code Examples: https://github.com/juneau001/AcmeWorld
Contact on Twitter: @javajuneau