JavaOne 2015 Diary – Day 1
JavaOne is happening as we speak and we’ve got Lars Röwekamp reporting on what you want to know from the biggest Java event of the year. Day 1 of his daily digest gives us a load of Java EE 8 as well as questions about the cloud.
As in recent years, the various events of the JavaOne are spread out over several neighbouring hotels. Although these are considered quite close together, after a fast 10km walk you could arrive at an unfavourable choice of sessions for the day. Therefore I had the choice of either sporting my running shoes and making the Health App on my Apple Watch happy, or committing myself entirely to a topic and thus also to a hotel. I opted for the latter and for this diary entry – with a few exceptions – the topic of “Enterprise Java” is on the agenda.
Java EE 8 – Status Quo
It was fortunate that Linda DeMichiel, the Specification Lead on Java EE 8, gave an overview today of the current state of Java EE. For those who do not yet know: The new APIs in Java EE haven’t been formulated by chance in the specification, but are the direct result of a two-stage survey of the Java Enterprise Community.
Leading the survey was JSON Binding which came as no surprise, followed closely by Security Simplification and JCache. And the desire for an action-based MVC framework made it after all in the Top 5! In order for the Specification Groups involved not to lose focus in their discussions, the forthcoming innovations and changes in Java EE are based on three main issues. We’re already aware of the first two from Java EE 7:
- HTML 5 Web Tier Enhancement
- Ease of Development and CDI Alignment
- Infrastructure for running in the Cloud
But what exactly is the current status of these different specs? To get to point: Linda DeMichiel stressed several times that the (PowerPoint) shown code examples are to be understood as ideas and a basis for discussion, with a high probability that the final release will come in 2017 – yes you read right, unfortunately – due to many changes still arising.
Web Tier Enhancements
In the specification of JSON-B, work wants to be strongly geared towards existing solutions. For example Moxy, Jackson, Gson, Genson and Xstream were all mentioned. It should be possible in any case for the underlying JSON Binding Provider to be exchanged for a faster mechanism. As might be expected, with the XML equivalent of JAX-B, default mappings can be overridden by annotations. According to the motto “All the way to the Database”, a standardised mechanism is provided for JAX-RS to support “application / json” on-the-fly.
This increasingly focuses on JSON and the enhancements want to slowly but surely step away from XML by showing the proposed changes in JSON-P 1.1 (JSON Processing). Essentially, there are updates to the existing API to keep pace with the evolution of the JSON specification environment. By introducing JSON Pointer elements, a JSON document can be targeted and read out in the future. Using JSON Patch – the implementation of RFC 6902 – there are possible operations such as replace, add or delete, that can be used on JSON objects. As a little treat for Java 8-lovers, there’s also a plan for Lambda expressions to be allowed in JSON queries.
SEE ALSO: JavaOne 2015 Diary – Day 0
Another important innovation in the Web environment of Java EE 8 is the planned support for the HTML5 standard server-side events, which was represented by server-to-client streaming via mime type text / event-stream. This mechanism always makes sense if the server regularly sends data to the client (as is the case with a Stock Ticker or a dashboard) or after the single establishment of a connection by the client. According to DeMichiel there was some debate within the specification group over the method of implementation.
In the end, you could only agree that an implementation as an attachment on JAX-RS is useful because it can be realised with very little effort. On the server side, only a resource method must be annotated so that it produces the appropriate mime-type. On the client side, however, a special event listener ensures that incoming messages can be processed.
Can we expect something new in the Web environment? Ah yes, the Action-based MVC Framework MVC 1.0! The 2nd Early Draft is now available and can be inspected by all, as reported by JAXenter previously. Hopefully this draft isn’t stiffened in lieu of support for Facelets or JSPs.
Ease of Development
In addition to the many new features in the Web environment, naturally there should also be a number of simplifications for developers. Thanks to Java EE Security API 1.0, an authorisation by CDI Interceptor will be possible in the future. JMS 2.1 should bring improved JMS MDB support (Message Driven Beans) to more easily deal with asynchronous messages. With a bit of luck there might also be a CDI-based variant for processing asynchronous messages incorporated into the specification. However, this is at the present time still purely speculative, according to DeMichiel.
With simplicity also comes a bit of pruning, thus the elimination of some optional “historical” APIs will be taking place. The candidates for this are CORBA and EJB 2.x, plus RemoteView Client View. A live poll during the session resulted in 100% of those present in favour of this step, which even surprised DeMichiel. I’m guessing that the few remaining EJB 2.x supporters have so much to do in their programming time that they couldn’t participate in JavaOne.
Ready for the (Cloud) Future?
Despite the euphoria around the many new features and changes in Java EE, the legitimate question of whether Java EE can continue to play such an important role in enterprise computing, as it did previously, must be raised. The heavily modified Management API and some new features in Java EE Security 1.0 (for example, Password Aliasing, User Management, Role Mapping, REST Authentication) tries at least to keep a purely technological perspective. But in the end, is this enough? This exact question was tackled by Ian Robinson, WebSphere Foundation Chief Architect, in his session aptly titled “Is Enterprise Java still relevant?”
According to Robinson, the usual platform boundaries are slowly being absorbed (or rather quickly?) by the move to cloud in virtualisation containers. Theoretically, there would be no objection to running a Java EE application in such a container. But if you once questioned the motivation for container use, it quickly becomes clear that choosing a container means it’ll do exactly what you want it to – no more and no less. Sounds great, right? The aim must therefore be the ability to bundle the required Java EE components so that established technologies can be used without creating unnecessary overhead. This has been done successfully for some time via the Spring Boot Project, and Java EE has lined up its first candidates in Wildfly Swarm and Drop Wizard, who are headed in the right direction.
Java EE is definitely at a crossroads, according to Robinson. “Java EE is quite strong and relevant at the cloud party, but younger guests are making more noise. So let’s make more noise ourselves!” His closing argument sounded much like a war cry and I can only add my voice to it!
Stay tuned for more JavaOne happenings in tomorrow’s recap.