Simplified Architecture and Development

The J2EE platform supports a simplified, component-based development model. Because it’s based on the Java programming language and the Java 2 Platform, Standard Edition (J2SE platform), this model offers Write Once, Run Anywhere portability, supported by any server product that conforms to the J2EE standard.

The component-based J2EE development model can enhance application development productivity in a number of ways.

Maps easily to application functionality: Component-based application models map easily and flexibly to the functionality desired from an application. The J2EE platform provides a variety of ways to configure the architecture of an application, depending on such things as client types required, level of access required to data sources, and other considerations. Component-based design also simplifies application maintenance, since components can be updated and replaced independently new functionality can be shimmed into existing applications simply by updating selected components.

Enables assembly- and deploy-time behaviors: Components can expect the availability of standard services in the runtime environment, and can be dynamically connected to other components providing well-defined interfaces. As a result, many application behaviors can be configured at the time of application assembly or deployment, without any recoding required. Component developers can communicate their requirements to application deployers through specific settings. Tools can automate this process to further expedite development.

Supports division of labor: Components help divide the labor of application development among specific skill sets, enabling each member of a development team to focus on his or her ability. Thus, JSP templates can be created by graphic designers, their behavior by Java programming language coders, business logic by domain experts, and application assembly and deployment by the appropriate team members. This division of labor also helps expedite application maintenance. For example, the user interface is the most dynamic part of many applications, particularly on the Web. With the J2EE platform, graphic designers can tweak the look and feel of JSP-based user interface components without the need for programmer intervention.

A number of generic roles are discussed in the J2EE specifications, including Application Component Provider, Application Assembler, and Application Deployer. On some development teams, one or two people may perform all these. roles, while on others, these tasks may be further subdivided into more specific skill sets (such as user interface designers, programmers, and so on).

Scales Easily

J2EE containers provide a mechanism that supports simplified scaling of distributed applications, without requiring any effort on the part of the application development team.

Because J2EE containers provide components with transaction support, database connections, life cycle management, and other features that influence performance, they can be designed to provide scalability in these areas. For example, by providing database connection pooling, containers can ensure that clients will have access to data quickly.

Because the J2EE specifications allow server providers freedom to configure containers to run on multiple systems, Web containers can be implemented to perform automatic load balancing as the demand for a particular application fluctuates.

Integrating Existing Enterprise Information Systems

The J2EE platform, together with the J2SE platform, includes a number of industry standard APIs for access to existing enterprise information systems. Basic access to these systems is provided by the following APIs:

• JDBC is the API for accessing relational data from Java.
• The Java Transaction API (JTA) is the API for managing and coordinating transactions across heterogeneous enterprise information systems.
• The Java Naming and Directory Interface (JNDI) is the API for accessing in-formation in enterprise name and directory services.
• The Java Message Service (JMS) is the API for sending and receiving messages via enterprise messaging systems like IBM MQ Series and TIBCO Rendez-vous.
• JavaMail is the API for sending and receiving email.
• Java IDL is the API for calling CORBA services.

In addition, specialized access to enterprise resource planning and mainframe systems such as IBM’s CICS and IMS will be provided in future versions of J2EE through the Connector architecture. Since each of these systems is highly complex and specialized, they each require unique tools and support to ensure utmost simplicity to application developers. As J2EE evolves, enterprise beans will be able to combine the use of connector access objects and service APIs with middle-tier business logic to accomplish their business functions.

Choice of Servers, Tools, and Components

The J2EE standard and J2EE brand are central to creating a marketplace for servers, tools, and components. The J2EE brand on a server product ensures the kind of ubiquity that’s fundamental to the goals of the J2EE platform. In addition, J2EE standards ensure a lively marketplace for tools and components.

A range of server choices: Application development organizations can expect J2EE branded platforms from a variety of vendors, providing a range of choices in hardware platforms, operating systems, and server configurations. This ensures that businesses get a choice of servers appropriate to the strategic purpose of the applications they need.

Designed for tool support: Both EJB and JSP components are designed to be manipulated by graphical development tools, and to allow automating many of the application development tasks traditionally requiring the ability to write and debug code. Both J2EE server providers and third-party tool developers can develop tools that conform to J2EE standards and support various application development tasks and styles. Application developers get a choice of tools to manipulate and assemble components, and individual team members may choose tools that suit their specific requirements best.

A marketplace for components: Component-based design ensures that many types of behavior can be standardized, packaged, and reused by any J2EE application. Component vendors will provide a variety of off-the-shelf component solutions, including accounting beans, user interface templates, and even vertical market functionality of interest in specific industries. Application architects get a choice of standardized components to handle common or specialized tasks.

The J2EE standard and associated branding programming ensure that solutions are compatible. By setting the stage for freedom of choice, J2EE makes it possible to develop with confidence that the value of your investment will be protected.

Simplified, Unified Security Model

The J2EE security model is designed to support single signon access to application services. Component developers can specify the security requirements of a component at the method level, to ensure that only users with appropriate permissions can access specific data operations.

While the EJB and Java Servlet APIs both provide mechanisms for building security checks into code, the basic mechanism for matching users with roles (groups of users having specific permissions) is performed entirely at application deployment time. This provides both greater flexibility and better security control.