Java 2 Enterprise Edition

The Java 2 Platform, Enterprise Edition (J2EE) defines the standard for developing multitier enterprise applications. The J2EE platform simplifies enterprise applications by basing them on standardized, modular components, by providing a complete set of services to those components, and by handling many details of application behavior automatically, without complex programming.

The J2EE platform takes advantage of many features of the Java 2 Platform, Standard Edition (J2SE), such as "Write Once, Run Anywhere" portability, JDBC API for database access, CORBA technology for interaction with existing enterprise resources, and a security model that protects data even in internet applications. Building on this base, the Java 2 Platform, Enterprise Edition adds full support for Enterprise JavaBeans components, Java Servlets API, JavaServer Pages and XML technology. The J2EE standard includes complete specifications and compliance tests to ensure portability of applications across the wide range of existing enterprise systems capable of supporting the J2EE platform. In addition, the J2EE specification now ensures Web services interoperability through support for the WS-I Basic Profile.

Today's enterprises gain competitive advantage by quickly developing and deploying custom applications that provide unique business services. Whether they're internal applications for employee productivity, or Internet applications for specialized customer or vendor services, quick development and deployment are key to success.

Portability and scalability are also important for long term viability. Enterprise applications must scale from small working prototypes and test cases to complete 24 x 7, enterprise-wide services, accessible by tens, hundreds, or even thousands of clients simultaneously.

However, multitier applications are hard to architect. They require bringing together a variety of skill sets and resources, legacy data and legacy code. In today's heterogeneous environment, enterprise applications have to integrate services from a variety of vendors with a diverse set of application models and other standards. Industry experience shows that integrating these resources can take up to 50% of application development time.

As a single standard that can sit on top of a wide range of existing enterprise systems -- database management systems, transaction monitors, naming and directory services, and more -- the J2EE platform breaks the barriers inherent between current enterprise systems. The unified J2EE standard wraps and embraces existing resources required by multitier applications with a unified, component-based application model. This enables the next generation of components, tools, systems, and applications for solving the strategic requirements of the enterprise.

The J2EE specification also supports emerging Web Services technologies through inclusion of the WS-I Basic Profile. WS-I Basic Profile compliance means that the developers can build applications on the J2EE platform as Web services that interoperate with Web services from non-J2EE compliant environments.

With simplicity, portability, scalability, and legacy integration, the J2EE platform is the platform for enterprise solutions.

While Sun Microsystems invented the Java programming language and pioneered its use for enterprise services, the J2EE standard represents a collaboration between leaders from throughout the enterprise software arena. Our partners include OS and database management system providers, middleware and tool vendors, and vertical market applications and component developers. Working with these partners, Sun has defined a robust, flexible platform that can be implemented on the wide variety of existing enterprise systems currently available, and that supports the range of applications IT organizations need to keep their enterprises competitive.

The success of the J2EE platform in the enterprise continues to rise as more than two-thirds of enterprise software development managers use the J2EE platform to develop and deploy their applications. With addition of interoperable Web services and other new features in version 1.4, the J2EE platform will continue to be the industry standard for enterprise solutions for many years to come.

 
 
The Enterprise Java BluePrints for the J2EE platform describe the J2EE application model and best practices for using the J2EE platform. Building on the J2SE platform, the J2EE application model provides a simplified approach to developing highly scalable and highly available internet or intranet based applications.

Thanks to the J2EE application model, maybe the most interesting thing about J2EE applications is what they don't do. That is, various complexities inherent in enterprise applications -- transaction management, life-cycle management, resource pooling -- are built into the platform and provided automatically to the components it supports. Component and application developers are free to focus on specifics such as business logic and user interfaces.

Another advantage of the J2EE platform is that the application model encapsulates the layers of functionality in specific types of components. Business logic is encapsulated in Enterprise JavaBeans (EJB) components. Client interaction can be presented through plain HTML web pages, through web pages powered by applets, Java Servlets, or JavaServer Pages technology, or through stand-alone Java applications. Components communicate transparently using various standards: HTML, XML, HTTP, SSL, RMI, IIOP, and others.

Reusable J2EE components mean competitive choices for enterprise developers and IT organizations. The J2EE platform enables them to assemble applications from a combination of standard, commercially available components and their own custom components. From general business application components to vertical market solutions, a range of standardized J2EE functionality is available off the shelf.

This means that an e-commerce site could be built using a combination of off-the-shelf EJB components for shopping cart behaviors, modified EJB components for specialized customer services, and completely customized layouts using JavaServer Pages technology that bring a unique look and feel to the site.

This approach means faster development time, better quality, maintainability and portability, and Web services interoperability across a range of enterprise platforms. The bottom line benefits are increased programmer productivity, better strategic use of computing resources, and greater return on an organization's technology investments.

The J2EE application model divides enterprise applications into three fundamental parts: components, containers, and connectors. Components are the key focus of application developers, while system vendors implement containers and connectors to conceal complexity and promote portability.

Containers intercede between clients and components, providing services transparently to both, including transaction support and resource pooling. Container mediation allows many component behaviors to be specified at deployment time, rather than in program code.

Connectors sit beneath the J2EE platform, defining a portable service API that communicates with existing enterprise vendor offerings. Connectors promote flexibility by enabling a variety of implementations of specific services. In particular, connectors implementing pluggable messaging contracts enable bidirectional communication between J2EE components and enterprise systems.

The J2EE platform provides choices for graphical user interfaces across a company's intranet or on the World Wide Web. Clients can run on desktops, laptops, PDAs, cell phones, and other devices. Pure client-side user interfaces can use standard HTML and Java applets. Support for simple HTML means quicker prototypes, and support for a broader range of clients. Additionally, the J2EE platform supports automatic download of the Java Plug-in to add applet support where it's lacking. The J2EE platform also supports stand-alone Java application clients.

For server-side generation of dynamic content, the J2EE platform supports two types of web component technologies: Java Servlets and JavaServer Pages (JSP). Java Servlets enable developers to easily implement server-side behaviors that take full advantage of the power of the rich Java API. JavaServer Pages technology combines the ubiquity of HTML with the power of server-side dynamic content generation. The JSP 2.0 specification supports static templates, simplified access to Java objects, and easy extensibility.

Enterprise JavaBeans (EJB) technology enables a simplified approach to multitier application development, concealing application complexity and enabling the component developer to focus on business logic.

EJB technology gives developers the ability to model the full range of objects useful in the enterprise by defining several types of EJB components: session beans, entity beans, message-driven beans. Session beans represent behaviors associated with client sessions -- for example, a user purchase transaction on an e-commerce site. Session beans can serve as Web service endpoints. Entity beans represent collections of data -- such as rows in a relational database -- and encapsulate operations on the data they represent. Entity beans are intended to be persistent, surviving as long as the data they're associated with remains viable. Message-driven beans allow J2EE applications to process messages asynchronously. A message-driven bean normally acts as a JMS message listener, which is similar to an event listener except that it receives JMS messages instead of events. The messages may be sent by any J2EE component--an application client, another enterprise bean, or a Web component--or by a JMS application or system that does not use J2EE technology.

The Java 2 Platform, Enterprise Edition version 1.4 is the most complete Web services platform ever. The platform features Web services support through the new JAX-RPC 1.1 API, which provides service endpoints based on servlets and enterprise beans. JAX-RPC 1.1 provides interoperability with Web services based on the WSDL and SOAP protocols. The J2EE 1.4 platform also supports the Web Services for J2EE specification, which defines deployment requirements for Web services and utilizes the JAX-RPC programming model. In addition to numerous Web services APIs, the J2EE 1.4 platform also features support for the WS-I Basic Profile 1.0. This means that in addition to platform independence and complete Web services support, the J2EE 1.4 platform offers platform Web services interoperability.

Based on these flexible component configurations, the J2EE application model means quicker development, easier customization and greater ability to deploy powerful enterprise applications. And, because it's based on the Java programming language, this model enables all J2EE applications to achieve all the benefits of Java technology: scalability, portability, and programming ease.

Sun Microsystems set a new standard for client-side computing with the Java 2 Platform, Standard Edition (J2SE). Experience with the J2SE platform, plus input from enterprise software vendors and developers, led to development of the Java 2 Platform, Enterprise Edition (J2EE). The J2EE platform includes four deliverables: the J2EE specification, a J2EE reference implementation, a Compatibility Test Suite, and the Enterprise Java BluePrints.

Subjected to close scrutiny and feedback from a variety of enterprise technology leaders and the industry at large, the J2EE specification defines a consistent yet flexible approach to implementing the platform. The J2EE specification enumerates the APIs to be provided with all J2EE platforms and includes full descriptions of the support levels expected for containers, clients, and components. It defines a flexible standard that can be built on either a single system or deployed across several servers, each providing a specific set of J2EE support services. This means a wide range of existing enterprise systems already in use throughout industry will be able to support the J2EE platform.

Key to validating the Java 2 Platform, Enterprise Edition, the J2EE reference implementation is a complete implementation of the J2EE specification and is used by system vendors to compare with their own implementations.

The J2EE SDK is built on the J2EE reference implementation and provides application developers with a way to familiarize themselves with J2EE technology as they explore full-scale deployment of J2EE applications. The J2EE 1.4 SDK includes the J2EE 1.4 reference implementation, the J2SE SDK, and various tools to help developers prototype J2EE applications and learn about the J2EE platform and technologies.

By providing a means to fully test implementations of the platform standard, the Compatibility Test Suite ensures consistent implementation across various vendor offerings. For application developers, this means full portability for enterprise applications. The suite includes tests for all classes and methods required by the J2EE specification. It also includes end-to-end tests to check that all layers of a J2EE application will interact correctly and consistently. There are over 20,000 tests in the CTS, including tests for WS-I interoperability.

Provided as both documentation and complete examples, the Enterprise Java BluePrints describes and illustrates "best practices" for developing and deploying component-based enterprise applications in the J2EE platform. Topics explored include component design and optimization, Web services, division of development labor, and allocation of technology resources.

In addition to providing support for Enterprise JavaBeans and Java Servlets and JavaServer Pages components and Web services APIs, the J2EE platform specification defines a number of services for use by J2EE components.

Designed to standardize access to a variety of naming and directory services, the Java Naming and Directory Interface (JNDI) API provides a simple mechanism for J2EE components to look up other objects they require.

JDBC API enables applications to manipulate existing data from relational databases and other data repositories. The J2EE platform includes the latest implementation of the JDBC API -- version 3.0. This new technology includes handling of SQL User-Defined Types (UDTs), rowset manipulation, connection pooling, and distributed transactions support.

The J2EE Deployment API defines standard APIs to enable deployment of components and applications based on the J2EE platform, as well as the development of platform-independent deployment tools.

The Java Authorization Contract for Containers (Java ACC) specification defines new java.security.Permission classes to satisfy the J2EE authorization model. The Java ACC specification defines the binding of container access decisions to operations on instances of these permission classes. It defines the semantics of policy providers that employ the new permission classes to address the authorization requirements of the J2EE platform.

The J2EE Management API includes standard mappings of the model to the Common Information Model (CIM), to an SNMP Management Information Base (MIB), and to the Java object model through a server resident Enterprise JavaBeans (EJB) component, known as the J2EE Management EJB Component (MEJB). The MEJB provides interoperable remote access to the model from any standard J2EE application.

The J2EE platform includes JavaMail to support applications such as e-commerce websites. The JavaMail API provides the ability to send order confirmations and other user feedback.

J2EE supports two CORBA-compliant technologies: JavaIDL and RMI-IIOP. JavaIDL enables Java applications to interact with any CORBA-compliant enterprise system. RMI-IIOP technology combines the programming ease of the Java Remote Method Invocation API (RMI) with CORBA's Internet Inter-ORB Protocol (IIOP) for easier integration of J2EE applications with legacy applications.

While J2EE provides transaction support automatically, the Java Transaction API (JTA) provides a way for J2EE components and clients to manage their own transactions and for multiple components to participate in a single transaction.

The Java Message Service (JMS) API defines a standard mechanism for components to send and receive messages asynchronously, for fault-tolerant interaction.