Why J2EE?

You are probably asking: So, why use the J2EE? Isn't it too new and unproven? What does it really offer? Is it just another fad?

Let's start with the newness aspect. Although the J2EE packaging is new, specific pieces that make up the J2EE have been around for a while. For instance, the JDBC API is well established. Servlet technology has also been used for some time as a lightweight and maintainable alternative to the Common Gateway Interface (CGI)^[1] scripts.

^[1] An older approach used for processing user input provided via the Web and for providing dynamic content based on the input.

J2EE also offers some promising benefits. As described in the following paragraphs, these include features that enable developers to focus on developing business logic, on implementing the system without prior detailed knowledge of the execution environment, and on creating systems that can be ported more easily between hardware platforms and operating systems (OSs).

Enterprise software development is a complex task and can require extensive knowledge of many different areas. For instance, a typical enterprise application development effort might require that you be familiar with interprocess communication issues, security issues, database specific access queries, and so on. J2EE includes built-in and largely transparent support for these and similar services. As a result, developers are able to focus on implementing business logic code rather than code that supports basic application infrastructure.

The J2EE enterprise development model also encourages a cleaner partition between system development, deployment, and execution. Because of this, developers can defer deployment details, such as the actual database name and location, host specific configuration properties, and so on, to the deployer.

J2EE supports hardware and OS independence by enabling system ser vices to be accessed via Java and J2EE rather than underlying system APIs. For this reason, enterprise systems that conform to the J2EE architectural specification can be ported fairly easily between different hardware systems and different OSs.

Perhaps one of the greatest J2EE benefits is its support for componentization. Component-based software has numerous advantages over traditional, custom software development:

• Higher productivity: Fewer developers can achieve more by putting together an application from prebuilt, pretested components rather than implementing a custom solution from scratch.

• Rapid development: Existing components can be put together rapidly to create new applications.

• Higher quality: Rather than testing entire applications, component-based application developers can concentrate on testing the integration and the overall application functionality achieved via the prebuilt components.

• Easier maintenance: Because components are stand-alone to begin with, maintenance such as upgrades to individual components is much easier and more cost-effective.

Although some level of software componentization does exist, it is a far cry from the type of componentization prevalent in other industries, such as electronics or automobiles. Imagine the diminished electronics industry if each and every chip required needed to be handcrafted in order to put together a new electronic gadget.

J2EE facilitates componentization in many ways. A few examples follow:

• The “Write Once, Run Anywhere” nature of Java makes it appealing for developing components for a diverse set of hardware systems and operating systems.

• J2EE offers a well thought-out approach for separating the development aspects of a component from its assembly specifics and its assembly aspects from its deployment details. Thus, components developed independently can be readily integrated into new environments and applications.

• J2EE offers a wide range of APIs that can be used for accessing and integrating products provided by third-party vendors in a uniform way, for example, databases, mail systems, messaging platforms, and so on.

• J2EE offers specialized components that are optimized for specific types of roles in an enterprise application. For example, enterprise components can be developed in different “flavors,” depending on what they are expected to accomplish.

Component marketplaces have already started to emerge. A recent Gartner Group study forecasted that by 2003, 70 percent of all new applications would be built from components. J2EE, with its support for component-based development (CBD), rapid adoption, and broad industry support, should play a prominent role in this switch to CBD.