Look no further — Java EE 8 and all the related technologies that are a part of it is your key to the kingdom. First, we are going to learn about what servlet containers are and how they work with an app server. After we get input from the user with a HTTP request, we crunch the numbers and do the business logic and ferret out the contents to user via a presentation layer with technology like Java Server Pages (JSP). After some time, we will take a gander at the Spring Framework, and how in some parts supplants Java EE. Also, we need to record data and have a keepsake for it indefinitely. Ultimately, we need to store data on a database and map them from the tables using a persistence layer and entities. Our knowledge map can be divided into 4 sections.

I. Creating Enterprise Apps

The core components of Java EE are servlets, filters, listeners and JSP. This is where we respond to HTTP requests and map them to URLs. Filters are able to assist with JSPs, tags and an expression-based language. Considering that HTTP is stateless, we need to store state in some instances when you have perhaps a shopping cart app like Amazon and you need to not fully persist that data to a database. Websockets are an exciting new technology that allow for bidirectional communication in real-time, like a chat app on the web. Finally, we keep a live streaming record of what is happening in the app that we can keep for informational and debugging purposes. These are the logs. A logging framework like slf4j is crucial as the code base expands.

II. Spring Framework to the mix

Although there are things possible in Java EE that can be done instead of Spring, Spring is a well-documented simple to use out of the box for common problems when developing web apps. Enter the Dependency Injection and an IoC Container. These are necessary for creating modular and extensible code that scales well and is easy to debug: we will get code that is highly cohesive and is loosely coupled. We need to configure portions of the app and this can be done with lots of XML boilerplate or annotations. Next, we need to look at validating beans and adding some i18n (internationalization), because Murica is not the only country out there. We need to have services that can talk over the web, these are SOAP and REST services using the Spring MVC controllers. Lastly, we can take a look at RabbitMQ and Quartz for delivering tasks asynchronously and synchronously.

III. Persisting Data with JPA and Hibernate ORM

We need to store objects in databases somehow. JPA is the standard and Hibernate is an implementation of JPA. Hibernate provides an abstracted way of doing things SQL like using the Java language. It takes away that ugly look of mixing SQL inside of Java code. ORM is an object relational mapper. JPA is the Java Persistence API. Spring Data can help us create persistence applications without having to write any persistence code.

IV. Security

Authentication (who are who you say you are) and Authorization (what role and powers you have within the organization) are mandatory for apps these days when PII is involved. We will also take a look at OAuth, which is an Open Authorization standard for sharing information to log in as users across other platforms.