J-Development

On this page I will try to keep track about resources related to Java EE 7. Initially details were a little scarce, but lately news has been pouring in at almost a weekly basis. The initial release estimate for Java EE 7 was Q3 2012, but as usual (see Java EE 5 and Java EE 6 plans and actual release) this had been delayed to Q2 2013. This date proved to hold as Java EE 7 went final at April 30, 2013.

Java EE 7 overal

Main JSR: http://jcp.org/en/jsr/detail?id=342
Public project home: http://java.net/projects/javaee-spec
Blogs: The Aquarium Java EE 7

Articles:
2010/07 What new features you’d like to see in Java EE 7? (at bottom of page)
2010/09 Java EE.next (at bottom of page)
2010/09 Java EE.next – the cloud? Exalogic? Some thoughts. And fears.
2010/11 The Future Roadmap of Java EE[7]
2010/12 It’s time to start talking about Java EE 7
2011/02 Java EE 7 – I have a (few) dream(s)
2011/04 Red Hat lays out plans for Java EE 7
2011/05 A Look Ahead (middle of page)
2011/06 And what about configuration in Java EE 7?
2011/06 Java EE 7 Looks to the Cloud
2011/07 Java EE 7: Key features, Specifications, Projects, Mailing List Archives, …
2012/03 Java EE 7: the Voyage of the Cloud Treader
2012/05 The Java EE 7 Feature List: Cloud Focused Upgrades
2012/05 Java EE 7: Developing for the Cloud at Geecon 2012
2012/11 Java EE 7 Early Draft Review 2 posted
2013/04 Java EE 7 Maven Archetype
2013/04 JSON and more good to go for Java EE 7
2013/04 JMS 2, Bean Validation 1.1, JBatch, JSON-P Go Final!
2013/04 Java EE 7 (JSR-342) is final
2013/04 Java EE 7 Approved!

JSF 2.2

Main JSR: http://jcp.org/en/jsr/detail?id=344
Public project home: http://java.net/projects/jsf-spec

JSF is the default web layer technology in Java EE. The web framework space in Java is rather fragmented, but JSF is one of most frequently used ones. In a way, JSF can be seen as a foundational technology upon which a very vibrant community is able to build exciting new solutions.

Note that between Java EE 6 and Java EE 7, an intermediate maintenance release JSF 2.1 has been released.

One of the highlights of JSF 2.2 is a continued effort to make building custom components even easier, a trend which was started in JSF 2.0. Java based custom components will be useable in Facelets without declaring a tag in an XML file, and composite components will be simplified a little by making the cc:interface optional. JSF 2.2 will also focus on HTML 5 support and will see some new components being added to the standard component library.

2009/02 Proposed enhancements to JSF 2.1
2010/05 JSF 2.1 Change Log
2010/08 RichFaces JSF 2.2 Proposed Enhancements and Issues
2010/10 Change Log for JSR-000314 JavaServer Faces 2
2010/12 JSF 2.1 & Mojarra new home, Hudson job and more
2011/02 Pre JCP-filed draft of JSF 2.2 JSR Available
2011/04 JSF 2.2 Expert Group’s new member Jakob Korherr
2011/05 HTML5 will be supported in JSF 2.2
2011/06 Ultra quick JSF 2.2 in progress changelog
2011/11 JSF 2.2 recent progress – Early Draft
2012/01 JSF 2.x Update from Ed Burns
2012/10 What’s New in JSF: A Complete Tour of JSF 2.2
2012/11 HTML(5) Friendly Markup in JSF 2.2
2013/02 Resource Library Contracts in JSF2.2
2013/04 What’s new in JSF 2.2?

Expression Language 3.0

Main JSR: http://jcp.org/en/jsr/detail?id=341
Public project home: http://java.net/projects/el-spec

The expression language (EL) in Java EE is a dynamic ‘mini-language’ mainly used to realize bindings to bean properties or methods (as such it’s a kind of function pointer). It can be easily used in JSP, JSF and CDI, but outside those specs it’s notorious difficult to set up.

Expression Language 3.0 will focus on making the technology easier to use everywhere, including Java SE. Other features being investigated are an easier way to define EL functions, and to add concatenation and sizeof operations. Specifically interesting is the research into supporting lambda functions and LINQ-like query operators in EL.

2011/10 Lambda Expression in EL
2011/10 EL Query Operators on Collections
2012/06 Expression Language 3.0 is in public review
2013/04 Expression Language 3.0 / JSR 341 Early Draft Now Available

Servlet 3.1

The main underlying technology of the servlet container (the web part of Java EE) is of course the servlet API itself. This technology is foundational to both JSP and JSF. Previously moving at a relative slow pace (there were only very minor changes between Servlet 2.4 and the current Servlet 2.5), there were some major additions for Servlet 3.0. With Servlet 3.1 the spec is keeping up the pace.

Central for this release are cloud support (an overarching theme of Java EE 7) and a consolidation of the asynchronous support that was introduced with Servlet 3.0.

Main JSR: http://jcp.org/en/jsr/detail?id=340
Public project home: http://java.net/projects/servlet-spec

2011/10 Java Webtier Optimized for the Cloud
2011/12 JavaOne Servlet 3.1 presentation
2012/12 What’s new in Servlet 3.1 ? – Java EE 7 moving forward
2013/01 Servlet 3.1 in Public Review
2013/04 Non-blocking IO in Servlet 3.1 By Example
2013/04 deny-uncovered-http-methods in Servlet 3.1
2013/04 Role “**” in Servlet 3.1 security-constraint

Java API for WebSocket 1.0

Main JSR: http://jcp.org/en/jsr/detail?id=356
Public project home: java.net/projects/websocket-spec

Java EE has always supported request/response requests (predominantly HTTP) via the Servlet spec. With Java EE 7, Java EE now also supports the recently (2011) standardized WebSocket protocol. WebSocket allows for a persistent full-duplex connection between a (web) client and server, which can be initiated via an HTTP upgrade requests and uses port 80 by default (which is rarely blocked by firewalls). Via WebSocket a server can send content to the client without the client having explicitly asked for it (also called Push technology).

2013/05 Java API for WebSocket 1.0: Java EE 7 and GlassFish

JAX-RS 2.0

Main JSR: http://jcp.org/en/jsr/detail?id=339
Public project home: http://java.net/projects/jax-rs-spec

JAX-RS is the specification in Java EE with which RESTful web services can be implemented. Like Servlets, JAX-RS resources can be mapped to a URL pattern and respond to HTTP requests, but where Servlets have a response Writer as their central artifact to which arbitrary content can be written, JAX-RS focuses on method invocations which return Object graphs. These Object graphs are then serialized by the container into any of several supported formats (typically JSON, but also XML and in rare occasions CSV).

Articles:
2010/11 JSR311: Draft of the JAX-RS 2.0 JSR (mailing list discussion)
2011/07 JAX-RS 2.0: A first interim report
2011/10 JAX-RS 2.0 – Client API
2011/10 JAX-RS 2.0 Client API: Generic Interface
2012/02 JAX-RS 2.0 Early Draft Explained
2012/06 JAX-RS 2.0 Early Draft – Third Edition Available
2012/11 What’s New in JAX-RS 2.0
2013/04 Java EE 7 and JAX-RS 2.0

JPA 2.1

JPA, Java Persistence Architecture, is the default ORM implementation in Java. Basically it allows a developer to specify a simple mapping with annotations or in XML from an Object to a relational data base table. JPA is based on existing ORM solutions like Oracle’s Toplink and Hibernate. Although originally part of EJB3, JPA has always been applicable to the entire Java platform, including Java SE.

Main JSR: http://jcp.org/en/jsr/detail?id=338 (review ballot approved)
Public project home: http://java.net/projects/jpa-spec

2010/03 JPA.next – Thinking about the Future
2011/01 New JSR Proposed: JPA 2.1
2012/01 JPA 2.1 Early Draft Explained – Java EE 7 making progress
2012/01 Sneak peak at Java EE 7 – Multitenant Examples with EclipseLink (JPA 2.1)
2012/11 JPA 2.1 Early Draft review 2 posted

CDI 1.1

New kid on the block CDI, Contexts and Dependency Injection, is a modern bean component model that was originally designed to unify the JSF and EJB programming models. With it, EJB beans can be used directly from JSF via EL and stateful EJB beans can be given scopes. It offers more powerful and flexible injection than either JSF Managed Beans or EJB beans do. Although CDI, JSF and EJB already all build on a common but very abstract concept called the managed bean, it seems that JSF Managed Beans might be dropped in favor of CDI and EJB might be retrofitted as a set of CDI services.

CDI could potentially become one of the most important and characteristic elements of Java EE.

Main JSR: http://jcp.org/en/jsr/detail?id=346
Public project home: https://github.com/jboss/cdi/wiki

2011/03 CDI 1.1
2012/01 Weld 2.0.0.Alpha1 released!

EJB 3.2

EJBs are the dedicated type of beans to implement the business logic of an application in Java EE. An important property of these beans are the declarative transactions which default to a convenient “start or join existing”. They once had a bad name for being heavyweight, but ever since EJB3 (2006) they follow a very lightweight programming model. EJB 3.1 continued this trend by removing the requirement to implement a business interface and allowing those beans to be defined everywhere instead of in a dedicated EJB module.

Although it’s officially a full release, the actual changes that have been done for EJB 3.2 are more akin to a maintenance release; some clarifications in the spec, some pruning of deprecated features (mainly Entity Beans) and two smallish features.

Main JSR: http://www.jcp.org/en/jsr/detail?id=345
Public project home: http://java.net/projects/ejb-spec

2011/04 EJB 3.2 can start!
2011/06 EJB 3.2 Expert group mailing list starts
2011/10 JavaOne 2011 Round-Up Reza Rahman mentions lack of progress in EJB 3.2 EG
2012/07 If you didn’t know what is coming in EJB 3.2…
2012/11 What’s new in EJB 3.2? – Java EE 7 chugging along!
2013/03 Java EE 7 and EJB 3.2 support in JBoss AS 8
2013/04 An Overview of EJB 3.2

Bean Validation 1.1
Public project home: http://beanvalidation.org

2011/03 JSR – Bean Validation 1.1: what to put in?
2011/07 Bean Validation 1.1 has started: join us
2012/03 Proposal for method validation added
2012/03 Bean Validation 1.1 early draft 1 is out – time for feedback
2012/08 Big push on Bean Validation 1.1

JMS 2.0

JMS represents the default messaging technology in Java EE. Although still a very powerful API, the previous version was clearly starting to show its age not having been updated for almost a decade. For Java EE 7, the API will finally see the long overdue overhaul.

Among the things being considered are a simplification of the API by taking advantage of injection annotations (CDI) as opposed to the current somewhat arcane {connection/session/producer/consumer}-based API. Furthermore, the JMS spec will finally take steps to specify how to communicate with remote servers from different vendors (something that seems pretty basic for a messaging protocol, but something that isn’t specified in the current version).

Main JSR: http://jcp.org/en/jsr/detail?id=343
Public project home: http://java.net/projects/jms-spec

2011/10 JSR 343: What’s Coming in Java Message Service 2.0
2011/11 What’s (probably) coming in Java Message Service 2.0
2011/12 JMS 2.0: A simplified API Version 1
2012/02 JMS 2.0 Early Draft
2012/03 JSR 343: JMS 2.0 – the next version of the JMS Specification
2012/04 JMS 2.0 Early Draft – Simplified API Sample Code
2013/01 JMS 2.0
2013/04 Ten ways in which JMS 2.0 means writing less code

JCache

Main JSR: http://jcp.org/en/jsr/detail?id=107
Public project home: https://github.com/jsr107

After being inactive for years it seemed JCache, the universal caching API for Java EE, was being reactivated again for Java EE 7. For a short while this was indeed the case, but eventually JCache again didn’t make it into Java EE.

2011/03 News on JSR107 (JCACHE) and JSR342 (Java EE 7)
2011/04 JSR107 (Java Caching API) Update – Lots Happening
2011/04 The backlash against the data grid JSR and JCP reform
2011/08 JSR-107, JCache: Alive and Going to be Part of Java EE 7
2011/10 javax.cache: The new Java Caching Standard
2012/01 Greg Luck and the return of JSR 107

Concurrency utils for Java EE

Main JSR: http://jcp.org/en/jsr/detail?id=236

Another old JSR that was inactive for years is Concurrency utils for Java EE. Like JCache, this one was activated as well and slightly updated for the new world that Java EE had become in the decade that the JSR lay dormant. Unlike JCache this one actually did make it into Java EE.

Unfortunately this JSR still reflects the 2003/2004 era thinking where all resources are mandatory managed by operation teams on the AS side. Specifically this means applications are not allowed to define their own thread pools and executor services, but instead developers have to ask operations to create those for them. This mandatory split of responsibilities is quite out of place for a specification that saw the light of day in 2013 and greatly reduces the usefulness of it.

Nevertheless, it’s a start and hopefully Java EE 8 will correct this thorny issue.

2012/11 Modern concurrency and Java EE
2012/12 Concurrency Utilities for Java EE Early Draft (JSR 236)
2013/02 Create ManagedExecutorService, ManagedScheduledExecutorService, ManagedThreadFactory, ContextService in GlassFish 4
2013/04 Anthony Lai on Java EE Concurrency Utilities

JASPIC 1.1

Main JSR: http://jcp.org/en/jsr/detail?id=196

JASPIC takes care of authentication in Java EE. It provides a so-called SPI with which portable authentication modules can be coded and used with any Java EE implementation. As such JASPIC is an important piece of the security puzzle that was missing in Java EE before version 6. For Java EE 7 JASPIC only got a minor but important update.

2013/04 What’s new in Java EE 7′s authentication support?

Batch Applications for Java Platform 1.0

Main JSR: http://jcp.org/en/jsr/detail?id=352

A rather common concern for a diverse range of applications is that some kind of long running background task possibly involving a large volume of data needs to be periodically performed. E.g. overnight statistics calculations. Up till now Java EE didn’t address this area and users were required to seek out alternatives (e.g. Spring Batch or something home cooked based on Quartz, etc). With Java EE 7, Java EE now finally includes support for this as well with Batch Applications for Java Platform 1.0.

2013/05 Batch Applications for Java Platform 1.0: Java EE 7 and GlassFish

Arjan Tijms