Join Alex Theedom for an in-depth discussion in this video Java EE history, present, and future, part of Learning Java Enterprise Edition.
- [Instructor] In this video, we are going to have a quick look at the history of the Java Enterprise Edition ecosystem, where it came from, and how it has changed over the last few decades. We'll explore 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 is proposed for Java EE 8. Java EE consists of a set of over 28 specifications and a runtime environment. This means that all Java SE APIs can be used in combination with any Java EE component.
This set of APIs can be used to build standard component-based multi-tier applications and can be deployed in different containers offering a variety of services. 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 its programming model. Throughout this course, we will see many examples of how to take advantage of this context and dependency injection framework.
The first incarnation of Enterprise Java was released in 1998, but soon after, important technologies were added such as servlets, messaging, and Enterprise JavaBeans. 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. However, 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 been simplified substantially. Annotations replaced 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 all of the conditions of the Managed Beans specification, and depending on the annotation used, it will become an EJB, servlet, singleton, or RESTful Web Service.
The platform continued to grow, but at a much slower rate. With each new release, it became more programmer-friendly, and the number of APIs blossomed to reach 28-plus, from just a handful of five APIs in 1999. So what's planned for 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 compliment this new direction. So as well as advancements to some already-established technologies such as Bean Validation, Context, and Dependency Injection, Java server faces JAX-RS, RESTful Web Services, JSON processing and servlets.
There will be four new APIs, JSON-Binding, a dedicated security API, and two APIs designed for use with Microservice's configuration and health check. Java EE 9 will see even more APIs designed for the development of Microservices and Cloud-based applications. The Java EE platform is developed though the Java Community Process, JCP, which is responsible for all Java technologies. The expert group is composed of interested parties that have created Java specification requests, JSRs, to define the various Java technologies.
This is done in cooperation with 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. Anybody can review and comment on Java 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 on the screen and discover more.
The Java EE Guardians are an independent group of Java Enterprise Edition developers and evangelists that are collaborating in order to move Java EE forward. Their purpose is advocacy, raising awareness, finding solutions, and collaboration and mutual support. Please support their efforts. You can join them by visiting their website, javaee-guardians.io, and you can follow them on their Twitter handle @javaee_guardian. Once the JSR has been approved and its development finalized, it forms part of the next release of the platform.
In the Java EE 7 release, four new APIs are added. They were JSON processing, WebSockets, batch processing, and concurrency. All these APIs started life as a JSR in which the community and JCP members commented, deliberated, discussed, until a final specification request was devised, and the development could begin. In this course, we're going to touch on 13 APIs that form the backbone of a typical Enterprise web application. They are JSF, JSP, and expression language, which are used to produce interactive template and component-driven front-ends; Managed Beans, that back data-rich websites; JAX-RS, that allows for the creation of RESTful APIs and WebSockets that provide functionality for the creation of interactive web pages and a richer user experience; EJBs, Enterprise JavaBeans that form the backbone of an Enterprise, and do much of the heavy lifting.
This is where the majority of your basic logic will reside. JPA, Java persistence API, which provides the all-important ability to persist data and retrieve it with as little ceremony as possible; JMS, Java messaging service, that allows asynchronous message-passing between application components and external systems; batch processing, that provides an Enterprise-level solution for time- and resource-intensive data-related tasks to be performed; and finally, Bean validation, that ensures data integrity across all layers of the application.
So, now that we have touched on the history of Java EE, let's take a look at the application we'll use to explore these APIs in depth.
- Java's past, present, and future
- JavaServer Faces (JSF)
- Context and Dependency Injection (CDI)
- JavaServer Pages (JSP) and Expression Language (EL)
- Enterprise Java Beans (EJB)
- Java Message Service (JMS)
- Java Persistence API (JPA)
- Bean Validation API
- Java API for RESTful Web Services (JAX-RS)
- WebSocket API
- JSON Processing API
- Batch Processing API
- Java 8 with Java EE 7