Java EE 7 Series

Arun Gupta on Higher Productivity from Embracing HTML5 with Java EE 7


Oracle Java EE Expert Arun Gupta provides glimpses into Java EE 7.

Oracle Java EE Expert Arun Gupta provides glimpses into Java
EE 7. Reprinted with permission from the Oracle
Technology Network, Oracle Corporation.

At the annual IOUC (International Oracle User Community) Summit,
held January 14–16, 2013, at Oracle headquarters in Redwood Shores,
California, more than 100 top user group leaders from around the
world gathered to share best practices, provide feedback, and
receive updates from leading Oracle developers.

Of particular note was a session by Oracle Java evangelist and
Java EE expert Arun Gupta entitled “The Java EE 7 Platform: Higher
Productivity and Embracing HTML5,” which offered a window into the
rich possibilities that will be available in Java EE 7 upon its
release in the spring of 2013. Gupta took the attendees through
some major developments in Java EE 7:

  • Java API for RESTful Web Services 2.0
  • Java Message Service 2.0
  • Java API for JSON Processing 1.0
  • Java API for WebSocket 1.0
  • Bean Validation 1.1
  • Batch Applications for the Java Platform 1.0
  • Java Persistence API 2.1
  • Servlet 3.1
  • Concurrency Utilities for Java EE 1.0
  • JavaServer Faces 2.2

In addition, he discussed the implementation status of Java EE
7, looked ahead to Java EE 8, and addressed the challenges and
potential pitfalls involved in establishing a standards-based cloud
programming model.

Gupta began the session with a brief discussion of Java EE 6,
released on December 10, 2009. The intervening years have seen more
than 50 million Java EE 6 component downloads, establishing it as
the world’s premier application development platform. The success
of Java EE 6 constitutes the fastest implementation of a Java EE
release thus far.

“In addition to Oracle, companies such as IBM, SAP, Hitachi, Red
Hat, Fujitsu, and Caucho have adopted it,” said Gupta. “There are
18 implementations of compliant Java EE 6 application servers
today. Every month or so, we see a new vendor coming in.”

He pointed out that Java EE 7 offers higher productivity; less
boilerplate; richer functionality; more default options; and HTML5
support in the form of WebSocket and JSON. Although Java EE 7
offers a standards-based platform with a lot of innovation, Gupta
observed, “There are not enough standards in the cloud with W3C and
other standards bodies. More standards are needed so that we can
define a Java API for the cloud. Premature standardization can also
be a problem if not enough innovation has taken place. So what is
the right thing for the platform? We have reached out to the
community, the core group members, and the executive committee of
the Java Community Process and have focused on providing higher
productivity and on embracing the HTML5 platform more closely. We
are going to use dependency injection a lot more, which will give
developers the ability to write less boilerplate code and offer
richer functionality such as batch applications and caching.
Similarly, for HTML5, we are embracing WebSocket functionality and
the ability to parse and generate a JSON structure. We are
providing support for HTML5-friendly markup as part of JSF.”

He then discussed the most important features of Java EE 7.

JSR 339: Java API for RESTful Web Services 2.0

“We are building several new features in JAX-RS 1.0,” explained
Gupta. “We are introducing a new client API in 2.0 that will enable
you to invoke a REST endpoint in a standard way. We are providing
extension points, methods filters, and entity interceptors that
improve how to do request and response and how to do pre- and
postprocessing very easily, which will be useful in addressing
cross-cutting concerns such as logging or security, which you can
easily do as part of your REST endpoint.”

Other new developments include asynchronous processing for both
the server and the client, enabling more-scalable applications,
hypermedia support, common configuration to simplify the REST
endpoint, and more.

For more on JAX-RS 2.0, check out Gupta’s blog
 on this topic.

JSR 343: Java Message Service 2.0

Gupta pointed out that the last version of Java Message Service
was released in December 2003—before JDK 1.4. Although JMS is
stable and extensively used, he explained that it needed to catch
up with subsequent changes in the Java platform such as generics,
injection, and annotation. Java EE 7 leverages the new
functionality to improve the way developers write JMS code. With
JMS 2.0, developers will use less boilerplate code and will be able
to take advantage of resource injection, meaning greater
functionality and more-effective, simpler code.

Gupta demonstrated how it took 20 lines to send a simple message
with JMS 1.1 whereas with JMS 2.0, it could be done in 6 lines with
cleaner and more semantically readable code. “This is a huge
improvement,” he remarked.

JSR 353: Java API for JSON Processing 1.0

Gupta turned to Java API for JSON Processing 1.0. whose original
purpose was to parse and generate JSON when it was first introduced
into the platform. Gupta remarked, “If you are familiar with JAXP,
you know that it has an event-driven StAX streaming API and a
DOM-based API. The same analogy applies to Java API for JSON
Processing: it has a streaming API and an object API.”

Streaming API

  • Provides a low-level, efficient way to parse/generate JSON
  • Provides pluggability for parsers/generators

Object model

  • Simple, easy-to-use, high-level API
  • Implemented on top of streaming API

“What has been missing,” said Gupta, “is the ability to take a
POJO and place an annotation so that it will automatically do the
binding for you as in JAXB. This improvement is forthcoming.”

JSR 356: Java API for WebSocket 1.0

JSR 356 defines how to write a standards-based WebSocket
application. It defines not just the service endpoint but also ways
it can be written with either an annotation-driven or an
interface-driven model. A separate client-side API will be
introduced as well.

“The WebSocket protocol works by having everything on the wire
functioning as a data or control frame,” explained Gupta. “So an
API or an SPI for data frames can be defined, enabling developers
to manipulate the data frames. For example, you can use the SPIs to
perform some WebSocket extensions for things such as compression or
multiplexing. We are often asked how this can work in a Java SE
environment. Whether it gets defined and approved in JSR 356 is to
be determined. But Tyrus, the reference implementation for JSR 356,
will provide a client profile.”

JSR 349: Bean Validation 1.1

Gupta explained that Bean Validation was a new specification
introduced in Java EE 6. Instead of defining validation
constraints—such as the number of characters allowed in a name or
the number of elements in a list—as part of the application logic,
they could be more easily defined with annotation. “An annotation,”
said Gupta, “is put as a constraint on a method, and the Bean
Validator, which is part of Java EE, automatically kicks in and
honors those constraints.”

He explained that constraints can be defined at one point and
are automatically honored by the Bean Validator; they can be
enabled, disabled, configured, or defined as custom constraints.
“In Java EE 6, this was used primarily by Java Persistence API and
JavaServer Faces,” Gupta remarked. “In Java EE 7, they can be put
on EJBs or simple POJOs.”

JSR 352: Writing Simple Batch Applications in Java EE 7

JSR 352 offers new functionality in Java EE 7 for
non-interactive, bulk-oriented, long-running tasks such as
generating monthly bank statements, which involves processing
thousands of accounts in the short processing time of the bank’s
network. “You just define a process, and it runs by itself on
schedule,” said Gupta. “Most of the concepts of JSR 352 are
borrowed from Spring. Tasks can be run in parallel or sequentially.
There is a full Java XML that will define what your task will look
like, with defined steps and a complete task flow.”

JSR 236: Concurrency Utilities for Java EE 1.0

Gupta commented that JSR 236 was filed a long time ago and has
recently gained momentum. It defines how you can create, for
example, new managed threads. Java EE itself restricts the creation
of new threads. Java EE is a managed application, so if the user
creates new threads and the container and the runtime have no
knowledge of those threads, how does it manage it? JSR 236 will
enable developers to create managed threads that are known and
managed by the container.

JSR 344: JavaServer Faces 2.2

Reusable flows, HTML5-friendly markup, and resource library
contracts are the big-ticket items for JSF 2.2. Faces Flow borrows
core concepts from Oracle ADF Task Flow, Spring Web Flow, and
Apache MyFaces CODI. It
introduces @FlowScoped CDI annotation, for
flow local storage, and @FlowDefinition, for
defining the flow with CDI producer methods. There are clearly
defined entry and exit points with well-defined parameters, so the
flow can be reused.

Minor Changes in Servlets and Java Persistence API 2.1

Gupta closed the session with a brief discussion of the minor
changes offered by Servlet 3.1 and Java Persistence API 2.1. He
pointed out that although the changes in Java EE 7 for these are
minor, they each received major overhauls in Java EE 6.

Adopt-a-JSR for Java EE 7

Gupta encouraged developers to participate in Adopt-a-JSR, where
they can pursue their interest in particular Java EE 7 JSRs and
download code, play with it, report bugs, and offer feedback to
Java EE 7 specification leads.

See Also

Author Bio: Janice J. Heiss is the Java acquisitions editor
at Oracle and a technology editor at 
Java Magazine.

comments powered by Disqus