Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book

Core J2EE Packages

J2EE is effectively a superset of J2SE, meaning that it encompasses or contains all of J2SE. In addition to the various standard packages of J2SE, several optional packages are added to the J2EE distribution. The APIs or packages that are commonly used are identified in Table 1–2 and explained in the sections below.

A J2EE application may use additional APIs or tools to create a distributed application. It is not uncommon and is in fact useful to use the frameworks and tools of the open source community, notably the Apache Software Foundation, to augment J2EE and shorten the time-to-market cycle for application development. (Chapter 33 34 and 35 demonstrate a J2EE application which uses the Struts framework, an Apache open-source project.)

Table 1-2 Core J2EE Packages




Provides connectivity to relational databases.


Provides Java access to naming services (LDAP, Windows Registry).

XML Processing (JAXP)

Provides for manipulation of XML documents.

Web Services (JAXM)

Provides the ability to send and recieive XML messages using protocols such as SOAP.


Allows secure SSL communications both as a server and a client.


Allows common encryption techniques to be used with Java applications.


Allows Java objects to be invoked remotely using the Remote Method InvocationRMI protocol.


Provides a Web tier component using the HTTP protocol.


The Java Messaging Service. Provides access to message queues and topics both as a client and a server.


Provides a scripting language for insertion into HTML documents.


Allows Java applications to interact with CORBA servers.


Allows the use of business tier components operating within an abstract container that provides a number of services.


Allows access to email servers using common protocols such as POP3 and IMAP.


The Java Database Connectivity (JDBC) API is an important part of J2EE applications. Every application needs data, and today that data is usually kept in a relational database. JDBC provides an open, vendor-independent API for accessing relational databases. The common goal of most applications is to make them database-neutral; JDBC contains a number of features that can aid in this effort. Later additions to the API provide for accessing JDBC resources for a specific database through naming services (using DataSource implementations) and batch updates. The JDBC package is covered in chapters 5, 6 and 7.


The Java Naming and Directory Interface (JNDI) package provides consistent access to a variety of naming services. These naming services provide for storage and access of various objects. They are effectively lightweight databases with very specific uses. For instance, Domain Naming Service (DNS) servers provide naming resolution services to resolve network domain names to IP addresses. Lightweight Directory Access Protocol (LDAP) servers allow a variety of objects to be stored in hierarchical fashion. LDAP servers are used to store information such as the location of various system resources, or to authenticate information such as the user names and passwords for system users. With the introduction of JNDI, these LDAP servers are now more commonly being pressed into use to store arbitrary Java objects. JNDI also supports Windows platform naming services such as the Windows Registry.

The advantage of using JNDI is that system-wide configuration information, such as the name and location of a database server, can be stored in a central location and broadcast to interested applications. Should the location of the resource change, it would need to be changed in only a single location. The various applications using the resource would then receive the new location information the next time they connected to the naming service. Unlike the alternative method of either hardcoding the configuration information into the source code files or using Java properties files, this method is simple and automatic. The JNDI package is covered in detail in Chapter 12.


The Extensible Markup Language (XML) has become the de facto standard for information interchange. XML allows data to be stored in a simple text file using tags that are easy to read and understand. Parsers and transformers allow XML documents to be easily read and transformed into other formats. This allows the development of service components that create XML documents for a number of different clients. The client application can access the XML document and transform it to the format required.

The JAXP package contains a number of classes that provide parsers and transformation services for Java applications. Chapters 14, 15 and 16 discuss XML and the JAXP package.


Web services combine the data interchange capabilities of XML and the openness of the HTTP protocol to create a service delivered over the Web. While it has been suggested that this facility could be used to create complete applications, it is more likely to be used to facilitate information interchange between applications, an important and often time-consuming task for developers.

The Java for XML Messaging (JAXM) package contains classes and interfaces that provide access to Web Services. This package allows SOAP clients and servers to be developed. Using this package, an enterprise, for example, could expose a service to provide information on stock availability or allow products to be ordered. The JAXM package is covered in Chapter 22 and 23.


The RMI package allows an object to be created which exposes specific methods to remote clients. This package also provides for client access to these remote methods. RMI is relatively simple and easy to use and is the lower level protocol used by a number of J2EE application servers to provide access to their EJB components. RMI also allows a client to provide access to its methods as a call back service to the server. Chapter 17 discusses the Java networking API and Chapter 18 and 19 discuss the RMI package.

Java servlets and JSPs

The servlet was the original Java Web component. The servlet is a Java class implementation that is invoked and run within a container. The container (operating in a Web server) provides various services for the servlet, such as lifecycle management and security.

JSPs provide for Web page scripting, allowing Java code fragments to be embedded in an HTML page. The JSP is converted into a servlet and runs within the servlet container. Both servlets and JSPs are covered in Chapter 27.


Email is used by Java applications for a variety of purposes: for example, to send a warning message to an administrator or user or to transmit data to another application. The JavaMail package provides access to these services using a flexible API. Common protocols, such as POP3 and IMAP, are supported. The JavaMail API is covered in Chapter 21.


The JMS package provides access to asynchronous messaging services. Many applications do not require an instant synchronous response to a request. These applications can pass a request to another application, leaving it to yet some other application to determine the success or failure of the operation and to manage it accordingly.

This messaging service can be used to exchange data within a transactional context (using the Java Transaction API, JTA), supporting distributed transactions across multiple data sources. Message queues are not new, but before JMS, there was no consistent standardized API for message queues in the Java language. JMS queues can support concurrent consumption of messages.

With the release of EJB 2.0, JMS has now been integrated into EJBs with the addition of message-driven beans (MDBs). With MDBs, an EJB can be exposed as a message queue, thus simplifying the creation of message queues and allowing them to be controlled within the same context as EJBs. The JMS package provides access through a service provider interface to common messaging servers. This package is covered in Chapter 21.


The EJB is the middleware component of J2EE. Like the servlet, this component runs in a container, which provides a variety of services. The services for the EJB are provided by the application server and are often significant. Application servers are usually, but not always, used for applications that expect a high usage load and/or must be highly available with very little downtime. But even if an application does not have these requirements, EJBs provide a development paradigm that isolates business logic into easily accessible components, which can be accessed by Web tier components, such as JSPs or servlets, or even directly by client tier components such as a Swing GUI. EJBs are covered in Chapter 24, 25 and 26.


Java-IDL provides the ability for Java applications to interact with Common Object Request Broker Architecture (CORBA) components written in any language. Applications using Java-IDL can invoke operations on remote services using the OMG IDL (Object Management Group's Interface Definition Language).

  • + Share This
  • 🔖 Save To Your Account