By Yolande Poirier-Oracle on Mar 30, 2016
The Java Track includes three code-heavy sessions:
The Java Track includes three code-heavy sessions:
José is an assistant professor at the Institut Galilée (Université Paris 13), PhD in applied mathematics from the ENS de Cachan. He has also worked as one of the lead members of the Paris JUG for 6 years, and is a co-founder of Devoxx France.
As a member of the CDI 2.0 Expert Group, he has contributed new ways of handling events, especially in the asynchronous part of the spec. He provided new patterns that have been adopted by the EG.
José has been working as an independent programmer for 20 years and is a well-known Java / Java EE / software craftsmanship expert and trainer. His expertise includes Tomcat, JBoss, Weblogic, Websphere, Glassfish, and the most popular Java EE parts: JPA (Hibernate & Eclipselink), EJB (including version 2), JMS, JTA, the Web tier, and more.
José speaks at conferences, including JavaOne and Devoxx; and writes technical articles for various publications including Java Magazine and Oracle Technology Network. Passionate about education, he publishes MOOC for several companies: Oracle Virtual Technology Summit, Pluralsight, Microsoft Virtual Academy and Voxxed.
His blog: blog.paumard.org/en/ Follow him @josepaumard
Java champions are an exclusive group of passionate Java technologists and community leaders who are community-nominated. Learn more about Java Champions.
Antoine Sabot-Durand, Co-Spec Lead for CDI, discusses CDI 2.0. It is slated to be a part of Java EE 8. Find out how you can learn the details about CDI 2.0 and how you can get involved. Learn more on the Contexts and Dependency Injection for Java page on Java.net.
We're always adding more videos to the YouTube/Java channel.
By Guest Blogger John Clingan
GlassFish Server 4.1 Open Source Edition is available for download! This release of the world's first Java EE 7 application server includes multiple new and valuable features and updates. Here is a quick look at what's new:
In summary, GlassFish 4.1 offers updated platform support, improved developer experience, new features and is bundled in the refreshed Java EE 7 SDK. GlassFish 4.1 can be downloaded from glassfish.org, and the Java EE 7 SDK can be downloaded from the Oracle Technology Network (OTN).
by Timothy Beneke
On Tuesday afternoon, noted Java EE authors Arun Gupta and Antonio
Goncalves offered a whirlwind tour of new features in “Java EE 7: Fifty
New Features of Java EE 7 in 50 Minutes”. Gupta is legendary at Oracle
for his hard work and astute grasp of the Java EE platform. His blog offers a wealth of insight into Java EE and other Java matters. He is the author, most recently, of Java EE 7 Essentials published by O’Reilly. Goncalves is one of the most highly regarded writers on EE anywhere and the author of Beginning Java EE 7, published by Apress.
Java EE 7’s new features enhance HTML5 support, increase developer productivity, and further improve how enterprise demands can be met. Developers will write significantly less boilerplate code, have better support for the latest Web applications, and gain access to enhanced scalability and richer, simpler functionality. The session did a stellar job of spelling out the details to a packed house.
With four new components (WebSocket, JSON-P, batch, and concurrency), and three old ones significantly updated (JAX-RS, JMS, and EL), along with other significant changes to the platform, a lot of new functionality has been added.
They divided the new Java EE 7 features into 19 categories and explained an average of two to three features in each category. Here were the categories:
CDI 1.1 (JSR 346)
Bean Validation 1.1 (JSR 349)
Interceptors 1.2 (JSR 318)
Concurrency utilities 1.0 (JSR 236)
JPA 2.1 (JSR 338)
JTA 1.2 (JSR 907)
EJB 3.2 (JSR 345)
JMS 2.0 (JSR 343)
Servlet 3.1 (JSR 340)
Web Socket 1.0 (JSR 356)
Expression Language 3.0 (JSR 341)
JSF 2.2 (JSR 344)
JAX-RS 2.0 (JSR 339)
JSON-P 1.0 (JSR 353)
Batch 1.0 (JSR 352)
JavaMail 1.5 (JSR 919)
JCA 1.7 (JSR 322)
Java Connector Architecture
Here are just a few of the high points:
CDI 1.1 (JSR 346) enables finer scanning control and the ability to veto the processing of a class or package. Bean Validation 1.1 (JSR 349) allows for method validation and the ability to pre/post conditions on method and constructors. Interceptors 1.2 (JSR 318) focused on the ability to associate an Interceptor associated with a constructor and the ability to prioritize interceptor bindings.
For Concurrency utilities 1.0 (JSR 236), the emphasis was on ManagedExecutor with a focus on:
* User threads in Java EE applications
* The ability to support simple and advance concurrency design patterns
* And to extend Concurrency Utilities API from Java SE (JSR 166y)
Further emphasis in concurrency was on ManagedThreadFactory and DynamicProxy.
* Creates dynamic proxy objects, and adds contextual information available for applications running in Java EE environment
* It supports Classloading, JNDI, Security, …
Also covered as part of concurrency: ManagedExecutor
* User threads in Java EE applications
* Support simple and advance concurrency design patterns
* Extend Concurrency Utilities API from Java SE (JSR 166y)
– java.util.concurrent package
In addition: ManagedScheduledExecutor
* Managed version of ScheduledExecutorService
* Submit delayed or periodic tasks
For JPA 2.1 (JSR 338), standardized database schema generation and the ability to define additional indexes in schema generation were emphasized. JTA 1.2 (JSR 907) was praised for its capacity for transaction management on Managed Beans as a CDI interceptor binding; in addition, it offers CDI scope whose lifecycle is scoped to the currently active JTA transaction.
They discussed WebSocket and annotated server endpoint which enables full-duplex bi-directional communication over a single TCP connection.
JSON Builder creates an object model (or an array) in memory by adding elements. JsonParser is an event-based parser that can read JSON data from a stream.
All in all, it was an impressive display of Java SE 7 expertise.
Java EE 7 Essentials by Arun Gupta
Beginning Java EE 7 by Antonio Goncalves
Be sure to check out Parleys.com in early October to listen to the entire session. It's well worth it.
Adam Bien, who is not only a Java Champion and JavaOne Rock Star, but
was named in 2010 as Oracle Magazine’s Java Developer of the Year, spoke
to an enthusiastic crowd where he addressed some core issues about Java
EE. He encouraged questions – “The more heretical or offensive the
better.” It was obvious that Bien loves to think about and code in Java.
He remarked, “The more I code the happier I am”. Spoken like a
hard-core Java developer!
First, he asked, “What is Java EE? Innovation vs. Standardization”? For Bien, Java EE is nothing but a release of co-existing APIs. Before Java EE, there was a mess with lots of application servers, with absolutely no chance of finding two application servers with similar APIs. Java EE resulted in a huge simplification. Now with Java EE 7 a wealth of are applications available. Java EE, insisted Bien, was never about innovation because building a standard precludes innovation. “Java EE will always lag behind,” he observed. “For instance, Hibernate will always have more features than JPA. Spring will always have more features than CDI. Java EE is the 80% that makes products work. It was never about innovation.”
He boiled down the whole point of Java EE: “What matters are small WARs – the smaller the WAR, the faster the build and deployment. The faster the build and deployment, the more productive you become,” he insisted. He explained that Java EE enables you to not put everything into the WAR and place as much as possible on the application server and less on the WAR. He explained that most of his WARs in Java EE 6 or Java EE 7 projects are very small
Bien asked, “Are EJBs bloated?” He explained that the question implies some voodoo stuff behind the scenes making EJBs bloated. He offered a means to answer this question.
He went on to answer a wealth of questions in a way that was thoughtful, incisive, witty and, at times, a bit provocative.
Here's some of the topics/issues (pulled directly from his slides) that Adam touched on in this fast-paced session:
*Do we need transactions?
*Is Dependency Injection Black Magic, VooDoo, or both?
*Is EJB pooling needed? Are EJBs bloated? What happens, if you violate the EJB programming restrictions?
*Why AOP didn't take off in Java EE?
*Stateless vs. Stateful programming model?
*HA without a Cluster?
*Are there any POJOs out there? What happens during deployment?
*Is Java EE faster than J2EE? Does JMS 2.0 scale and perform well? Is Java EE only suitable for the "big" enterprise?
*Is JSF the silver bullet? What is the deal with CORBA and RMI?
*How to unit test Java EE applications? Why we don't build a best of breed server from scratch?
This was a lively, entertaining and information-packed session. Just what you would expect from a pro developer as Adam Bien. I highly recommend viewing this session.
Adam Bien’s Blog
Check out Parleys.com where you can listen to the session in early October.
Ed Burns, Consulting Member of Technical Staff, and Kinman Chung,
Principle Member of Technical Staff, both at Oracle, presented a session
on Monday in which they described new features in JSR 341, Expression
Language (EL) 3.0. They discussed the APIs for the use of EL in
standalone environments and EL syntax for new operators, plus lambda
expressions, and support for collection objects, all the while offering
copious code illustrations.
Burns remarked that he was pleased that Java Champion and JavaOne Rock Star Adam Bien had referred to EL 3.0 as “the hidden gem of Java EE”. “I don’t know how hidden it is,” said Burns, “but I think it’s a gem.”
He discussed the origins of EL, which has a long and active history in the Java platform. EL began in 2004 as part of the Java Standard Tag Library (JSTL 1.0), moved to JSP 2.0 in 2006, and became an independent specification with JSR 341 in 2011. It is used in JSF, CDI, and Avatar. Now, 9 years after its inception, it is an independent specification that is heavily used in JSF.
Burns observed that the presence of EL is the key differentiator between Java server and non-java server stacks. “Java server-based web frameworks are likely to use EL,” said Burns. “When you show someone who is not familiar with EL how easy it is to move things together from disparate parts of your application, it’s very compelling.”
The most important feature that EL 3 brings is lambda expressions – developers do not have to wait until Java SE 8 is released. It all runs on Java EE 7, which requires Java SE 7 -- which means that it is currently available. Burns gave a brief discussion of lambda expressions, which basically behave like an anonymous function -- lambdas in EL are EL expressions. They offer full access to the EL environment within the body of the EL lambda expression, something not available from Java SE lambdas. “You won’t be able to refer to other EL things from a plain old SE lambda expression,” said Burns.
The goal of EL 3 is to provide greater expressive power for applications and to use it outside of Java EE. Burns and Chung provided an overview of collection operations and explained EL’s support for stand-alone environments. EL 3 is easy to use outside of Java EE and provides standard data structures: ELContext; ELResolvers; and local variable and function repositories.
They explained that it enables direct EL operations and has: EL expression evaluation; Bean definition; and Function definition. They emphasized that other key parts of Java EE can also be used standalone, such as: Bean Validation; Persistence (JPA); and Contexts and Dependency Injection (CDI). They encouraged developers to consider the possibilities for cloud deployment in: Defining functions and variables and defining beans.
They spent the rest of the session illustrating their key points with a healthy dose of code.
Links and Downloads:
* JSR 341: http://www.jcp.org/en/jsr/detail?id=341
Download spec and API javadocs
* Project home: https://java.net/projects/el-spec/
Report spec bugs or RFE for el.next
* RI: https://java.net/projects/uel/
Maven artifacts available from Maven Central
Download source and report RI bugs
* Integrated in Glassfish 4.0: https://glassfish.java.net/
You can listen to this session in early October on Parleys.com.
Up on otn/java is a new article by Oracle senior software engineer Mahesh Kannan, titled “An Overview of Batch Processing in Java EE 7.0,” which explains the new batch processing capabilities provided by JSR 352 in Java EE 7. Kannan explains that “Batch processing is used in many industries for tasks ranging from payroll processing; statement generation; end-of-day jobs such as interest calculation and ETL (extract, load, and transform) in a data warehouse; and many more. Typically, batch processing is bulk-oriented, non-interactive, and long running—and might be data- or computation-intensive. Batch jobs can be run on schedule or initiated on demand. Also, since batch jobs are typically long-running jobs, check-pointing and restarting are common features found in batch jobs.”
JSR 352 defines the programming model for batch applications plus a runtime to run and manage batch jobs. The article covers feature highlights, selected APIs, the structure of Job Scheduling Language, and explains some of the key functions of JSR 352 using a simple payroll processing application. The article also describes how developers can run batch applications using GlassFish Server Open Source Edition 4.0.
Kannan summarizes the article as follows:
“In this article, we saw how to write, package, and run simple batch applications that use chunk-style steps. We also saw how the checkpoint feature of the batch runtime allows for the easy restart of failed batch jobs. Yet, we have barely scratched the surface of JSR 352. With the full set of Java EE components and features at your disposal, including servlets, EJB beans, CDI beans, EJB automatic timers, and so on, feature-rich batch applications can be written fairly easily.”
Check out the article here.
Insider News from the Java Team at Oracle!