In this article, you will find out about the history of the Java EE ecosystem: Where it came from and how it has changed over the last few decades. You will discover the major milestones in its development from J2EE 1.2 to its current incarnation Java EE 7 and we will peek into the future at what Java EE 8 has in store.

You will discover how to get involved with the development of the platform itself and how to join the JCP.org to make an even greater contribution. Find out about the Java EE Guardians and how you can support the development and growth of the platform.

What Is Java EE?

Java EE consists of a set of over 28 specifications and a runtime environment. It is a superset of the Java SE platform. This means that Java EE components can take full advantages of all Java SE APIs.

This set of APIs build standard component-based multi-tier applications and that deploy in different containers offering a variety of services. Not only is it be used to develop monolithic application structures but also microservices structured applications too. Learn more about Java EE and microservices by checking out Java EE and Microservices in 2016? Are you interested in cutting edge development in the microservices space in relation to Java EE? Then visit the Eclipse Microprofile project website.

The Java EE programming model relies on annotations to specify configurations rather than XML description files and uses convention over configuration to help you get up and running with as little ceremony as possible.

It has its own contextually aware dependency injection framework at the heart of it programming model.

History of Enterprise Java

1998 saw the release of the first incarnation of Enterprise Java, but soon after, important technologies soon joined the mix, such as Servlets, Messaging, and Enterprise Java Beans.

These technologies still exist in the Enterprise platform today but in a much more advanced and comprehensive form.

Over the following years, it developed a programming model that was difficult to use and very cumbersome. This all changed in the fifth edition, which saw a radical shift away from XML configuration towards annotations and convention over configuration.

The new programming model had simplified substantially. Annotations replace XML description files, convention over configuration replaces the tedious manual configuration and dependency injection hides the creation and lookup of resources. Resources are created and injected at injection points marked by annotations such as @Inject. So all you need is a POJO that meets the conditions of the managed beans specification, JSR 299, and depending on the annotation used it will become an EJB, Servlet, Singleton or a RESTful web service.

The platform continued to grow, but at a much slower rate. With each new release, it becomes more programmer friendly and the number of APIs blossomed to reach 28+, up from just a handful of five APIs in 1999.

So what’s planned in Java EE 8?

What’s Coming in Java EE 8?

Oracle is moving Java EE’s focus to microservices and the cloud, and the next version of Java EE is going to include APIs that complement this new direction.

So as well as advancements in some already established technologies such as Bean Validation, Context and Dependency Injection, JavaServer Faces, JAX-RS (RESTful web services), JSON-Processing and Servlets, there will be two new APIs.

JSON-binding, a dedicated security API and Security API for Java EE, designed to standardize security.

Image source: www.slideshare.net/delabassee/java-ee-8-february-2017-update

Java EE 9 will see even more APIs designed for the development of microservices and cloud-based applications.

Java EE Guardians

The Java EE Guardians are an independent group of Java Enterprise Edition developers and evangelists that are collaborating to move Java EE forward.

Their purpose is advocacy, raising awareness, finding solutions, collaboration, and mutual support. Please support their efforts. You can join them by visiting their website javaee-guardians.io and you follow them on the twitter handle @javaee_gaurdian.

Java Community Process (JCP)

The Java EE platform development happens through the Java Community Process (JCP), which is responsible for all Java technologies.

The expert group consists of interested parties that have created Java Specification Requests (JSRs) to define the various Java EE technologies. All done in cooperation with the international Java developer community.

The work of the Java Community under the JCP program helps to ensure Java technology’s standards of stability and cross-platform compatibility.

Anyone can review and comment on draft specifications and JSR proposals, as well as read the JCP blog. Anyone can register as a user of the site and can self-nominate as a Contributor or Expert Group member. You can become a JCP Member yourself and make an even greater contribution. Go to the link to discover more.

Java EE 7

Once a JSR is approved and its development finalized, it forms part for the next release of the platform.

The Java EE 7 release added four new APIs.

They were JSON-Processing, WebSocket API, Batch Processing and Concurrency. All these APIs started life as a JSR on which the community and JCP members commented, deliberated and discussed until a final specification request was devised and the development could begin.

What Next?

Lynda.com offers online video training for a wide range of Java EE technologies. The ideal course for someone just starting out in enterprise Java is the Learning Java Enterprise Edition presented by myself. The course is just over 2hrs and covers all the most important Java EE APIs including JAX-RS for RESTful APIs, JavaServerFaces, Enterprise Java Beans and much more.

Once you have completed this course you can dive deeper into the Java the Java EE APIs and take a course on how to build a RESTful API with JAX-RS, build a chat application with WebSocket API and handle JSON with Java EE's own JSON-Processing API. There are more courses coming so why not take a take a look and get ready to give your Java EE career a boost.

Further Reading

I write about Java EE on my blog readlearncode.com and have recently published a series of articles focusing on JAX-RS and discussing What is javax.ws.rs.core.context?. It is a 5 part series diving deep into the many usages of the @Context annotation.

If you want to learn more about this technology, my articles on how to handle bean validation, MediaTypes and JAX-RS, and Resource Entities, take you deeper into this essential API.