About
The J2EE platform offers:
- the ability to reuse components,
- integrated Extensible Markup Language (XML)-based data interchange,
- a unified security model,
- and flexible transaction control.
The term was changed from J2EE and JEE to Java EE in May 2006.
Articles Related
Architecture
The J2EE platform uses a multitiered, distributed application model.
Application logic is divided into components according to function, and the various application components that make up a J2EE application are installed on different machines depending on the tier in the multitiered J2EE environment to which the application component belongs.
| Type Tier | Component | Run on the |
|---|---|---|
| Client-tier | Rich Java Client, Applet, Web Client | client machine |
| Web-tier | Web components (jsp page or servlet) | J2EE server |
| Business-tier | Enterprise javabean (EJB) | J2EE server |
| Enterprise information system (EIS)-tier | ERP, mainframe transaction processing, database systems, and other legacy information systems. | EIS server |
Although a J2EE application can consist of the three or four tiers. J2EE multitiered applications are generally considered to be three-tiered applications because they are distributed over three different locations:
- client machines,
- the J2EE server machine,
- and the database or legacy machines at the back end.
Typical 3-tier Web application:
Component
J2EE applications are made up of components.
J2EE
A J2EE component is a self-contained functional software unit that is assembled into a J2EE application with its related classes and files and that communicates with other components.
The J2EE specification defines the following J2EE components that run:
- On the Client:
Application clients directly access enterprise beans running in the business tier. However, if application requirements warrant it, a J2EE application client can open an HTTP connection to establish communication with a servlet running in the Web tier.
- On the server:
- Enterprise JavaBeans (EJB) components (enterprise beans) are business components
J2EE components are written in the Java programming language and are compiled in the same way as any program in the language.
Difference with Standard Java Class: The difference between J2EE components and “standard” Java classes is that J2EE components are assembled into a J2EE application, verified to be well formed and in compliance with the J2EE specification, and deployed to production, where they are run and managed by the J2EE server.
JavaBeans
The server and client tiers might also include components based on the JavaBeans component architecture (JavaBeans component) to manage the data flow between an application client or applet and components running on the J2EE server or between server components and a database. JavaBeans components are not considered J2EE components by the J2EE specification.
J2EE Server Communications
Business code, which is logic that solves or meets the needs of a particular business domain such as banking, retail, or finance, is handled by enterprise beans running in the business tier.
An enterprise bean:
- receives data from client programs, processes it (if necessary), and sends it to the enterprise information system tier for storage.
- retrieves data from storage, processes it (if necessary), and sends it back to the client program.
A JavaBeans component is generally included in the client to manage the user input and send that input to enterprise beans running in the business tier for processing.
General Improvement
There are tons of improvements in the Java EE platform to make it easy-to-use and powerful.
Some examples:
- EJBs can be packaged in a WAR with no special packaging or deployment descriptors
- web.xml and faces-config.xml are optional in most of the common cases
- Typesafe dependency injection is now part of the Java EE platform
- Add @Path on a POJO allows you to publish it as a RESTful resource
- EJBs can be used as backing beans for Facelets-driven JSF pages providing full MVC
- Java EE 6 WARs are known to be kilobytes in size and deployed in milliseconds