Java Enterprise Edition (J2EE) Middleware

This page summarizes how Java Enterprise Edition (J2EE) programs work for enterprise development

Topics this page:

Site Map  
About this site  

Newsgroup: comp.lang.java

Roedy Green's Java Glossary

Versions of J2EE

The J2EE v1.3 Specification [174 pages dated July 1, 2001] is the original version. Official website

The J2EE v1.4 Specification [246 pages dated Nov 24, 2003] Official website

Since then, AOP (Aspected Oriented Programming) implemented in packages such as AspectJ have made J2EE more agile with open-source Spring and the Hibernate persistence provider.

Java Platform, Enterprise Edition (Java EE 5) makes optional XML deployment descriptors (side files for defining components and specifying deployment instructions) with annotations in the code. It also features Enterprise JavaBeans (EJB) Technology 3.0, JavaServer Faces (JSF) Technology for interface design, and the Java Persistence API.

• MyEclipse IDE ($199 Pro version) is a plug-in built on top of base Eclipse to add facilities specific to web application development, such as JSP and JavaScript debugging, browsing and Hibernate map generation from databases, formatted editing of XML, JSP, XSD, Struts, JSF, Hibernate, etc. files (rather than via the Text Editor in Eclipse). Apps are deploy manually using an Ant script.

java.sun.com/products/j2ee/ is Sun Microsystem's Java 2, Enterprise Edition official home.

The J2EE Architect's Handbook: How to be a Successful Technical Architect for J2EE Applications (DVT Press, 2004, 284 pages) by Derek Ashmore

J2EE Architecture

J2EE is called "middleware" because it sits in the middle between web servers responding to clients at the presentation layer and databases in Enterprise Information Systems (EIS).

1. Interaction with user GUI requests are managed by web servers, which in large sites usually sit behind a load balancer
2. process-oriented or service-based requests are managed by application servers.
3. Database servers provide data to application servers.
4. In more complex environments, there is an additional business objects server. These servers manage Behaviors, Properties, Relationships with other entities, and Rules or policies.

Behind the scenes, unnoticed by users of a typical web application, run web services :

• Single-signon login servers providing authentication, usually via an infrastructure LDAP server.
• Java Naming and Directory Interface (JNDI) allows named resources to be located.
• Java Message Service (JMS) and Java API for XML Messaging (JAXM) allows programs to exchange messages.
• Java Transaction Service (JTS) allows requests to be segmented into transactions that succeed or fail as a whole, so that partial transactions are not persisted if only a part of the transaction is successful.
• JTA
• JCA for connection to legacy systems
• JDBC servers provide access to underlying databases.
• JMX provide access to monitoring mbeans.

Java Server Pages (JSP) has Java (usually presentation logic) code embedded in HTML-like text documents. v1.2 JSPs may contain HTML-like tags from the JSTL (JSP Standard Tag Library) in \WEB-INF\lib. See JSP Standard Tag Library Kick Start (published by Sams) or Making Use of JSP by Madhushree Ganguli (published by Wiley Publishing, Inc.).

Java Servlets are Java programs which issue HTML. See Java Servlet Programming Bible by Suresh Rajagopalan (Editor), Ramesh Rajamani, Ramesh Krishnaswamy, and Sridhar Vijendran (published by Wiley Publishing, Inc.).

J2EE app servers integrate with other web-based apps using resource adaptor components developed with an Common Client Interface (CCI) Sun introduced with the Java 2 Enterprise Edition (J2EE) 1.3 specification J2EE Connector Architecture (JCA) common interface of scalable, secure, and transactional integrity mechanisms just like JDBC provides for databases. iWay

J2EE Software Vendors

The major J2EE vendors are:

Company	Product	Architecture	Notes
SourceForge	JBoss	Application Server (AS)	an open source architecture
BEA	WebLogic Server	WebLogic Platform
IBM	WebSphere	Visual Age
Oracle	10g, 9iAS	for 11i Applications	integrated with applications

To avoid the complexity of deploying Web services in a Java environment, some projects have stuck with individual API's like JAX-RPC or frameworks such as Apache Axis for plain old Java objects (POJO's) with no inheritance dependencies.

MiddleAware.com

IBM WebSphere

Download 60 Day Demo versions of Websphere

• IBM WebSphere V5.1 Performance, Scalability,and High Availability, SG24-6198
• WebSphere Application Server V5 for iSeries: Installation, Configuration, and Administration, SG24-6588
• IBM WebSphere Developer Technical Journal: Planning for Availability in the Enterprise
• WebSphere Application Server for iSeries Information Center
• iSeries Performance Capabilities Reference Version 5, Release 2, SC41-0607
• AS/400 HTTP Server Performance and Capacity Planning, SG24-5645

JBoss

J2EE Deployment Descriptors

In an attempt to make modules portable between EJB servers that support the EJB specification, J2EE was specified to cleanly separate development of Java class code and deployment in XML files.

The META-INF/application.xml file is the standard J2EE deployment descriptor that defines an Enterprise application.

It contains an element for each Web application, EJB, and connector module, as well as additional elements to describe security roles and application resources such as databases.

An Enterprise application consists of one or more of the following:

• .WAR archive files holding Web application modules described by weblogic-application.xml for each WebLogic Server-specific extension
• .JAR archive files holding EJB modules
• .RAR archive files holding resource adapter/connector modules described by ra.xml
• .EAR archive files holding client-application.xml

These are all within an .EAR archive file also holding compiled Java .class files, .JSP files, .HTML files, and descriptor XML files.

The J2EE-specified deployment descriptor, ejb-jar.xml describes the enterprise beans packaged in an EJB application. It defines the beans’ types, names, and the names of their home and remote interfaces and implementation classes. It also defines security roles for the beans, and transactional behaviors for the beans’ methods.

Additionally, the weblogic-cmp-rdbms-jar.xml deployment descriptor unique to container-managed entity beans maps a bean to tables in a database. The weblogic-ejb-jar.xml deployment descriptor supplies additional information specific to the WebLogic Server environment, such as JNDI bind names, clustering, and cache configuration.

J2EE FrontEnd Technologies: A Programmer's Guide to Servlets, JavaServer Pages, and Enterprise JavaBeans (Apress, 2002, 1112 pages) by Lennart Jörelid

J2EE Deployment Packages

Module Type	Archive	J2EE Descriptor	Weblogic Descriptor

The .ear package file contains the classes that implement the Home and Remote interfaces using IIOP (IIO Protocol). The stub class file for the serve communicates with the skeleton class on the server.

They are both in the .ear file generated by the delopyment tool (deploytool.exe form the Sun J2EE Reference Platform) and copied to (deployed on) the EJB server and all EJB client machines.

Java Beans

The JavaBeans standard is a low-level component model tailored to the Java language.

Java beans are reusable platform-neutral software components that can be visually manipulated with a software development tool. Bean interface components include: methods, properties, and events.

"Coarse-grained" methods which communicate several items of information at a time are more efficient than
"fine-grained" methods which require more round trips to the server.

Beans communicate state changes to their properties. So other interested Beans can listen to the changes fired and behave appropriately. Listening Beans with an identical property can match the change, such as a change to the color of one component causing a whole group of components to change as well.

Bounding changes among beans make it possible for one bean to act as a controller for any component that wants to subscribe to its service.

Beans can veto changes sent to them, rejecting values that exceed a defined range for the target Bean (or whatever rule that Bean institutes). Of course, this process only has value to the sending Bean if it can learn whether its target accepts or rejects a change, and then it can respond. The sending Bean may wish to roll back to the previous state if the target Bean cannot comply or, in the case of multiple targets, the sender may attempt to set all target Beans to the last agreed-upon state.

Expert One-on-One J2EE Development without EJB (Wrox June 21, 2004) by Rod Johnson & Juergen Hoeller

The J2EE Architect's Handbook by Derek Ashmore at The Server Side.com

J2EE (Enterprise Endition) Java Beans

Java beans run within (are managed by) an EJB Container maintained by an application server (j2ee.exe in the Sun J2EE Reference Platform). It uses interfaces in the J2EE extension javax.ejb.EnterpriseBean, which is extended by several bean libraries:
• SessionBean
• EntityBean
• MessageDrivenBean (Mail service)

Session beans execute a particular business task on behalf of a single client. Session beans are non-persistent. When a client finishes with a session bean, the bean goes away. There are 2 kinds of session beans:

• Stateless Session beans are used to cache and manage infrequently changed data. They must be updated explicitly.
• Stateful Session beans, which "most architects avoid if at all possible."[1]

Entity beans represent business objects in a data store, usually in a relational database system. Entity bean methods model the behaviors of the business objects they represent. There are 2 kinds of beans which load and save data:
• Container-managed persistence (CMP) entity bean for declarative transaction management.
• Bean-managed persistence (BMP) entity bean

Entity beans can be accessed concurrently by multiple clients and they are persistent by definition. So they are pooled.

Entity beans are the only dedicated data access components in J2EE and also the most questionable part of J2EE, Their non-J2EE alternatives include Hibernate and JDO.

Message beans are not associated with any client since they simply handle messages as they arrive.

EJBs may not spawn threads, access files directly, use graphics or sockets.

Local interfaces in EJB 2.0 is one attempt to improve overall performance: local interfaces provide for beans in the same container to interact locally without involving RMI.

Run client

Instead of java.exe, EJB clients are run with a client program which enforces user password authentication.

The Sun J2EE Reference Platform provides the runclient.exe program:

runclient -client xx.ear -name xx.class

WebLogic Server 8.1 supports a true J2EE application thin client in a small footprint (400 KB) standard wlclient.jar and wljmsclient.jar for JMS. These are provided in the /server/lib subdirectory of the weblogic81 installation directory. In previous versions of WebLogic Server, a Java client required the full WebLogic Server JAR on the client machine.

This client JAR file also contains a Main-Class entry in its META-INF/MANIFEST.MF file to specify the entry point for the program.

Application clients directly access Enterprise JavaBeans running in the business tier, and may, as appropriate communicate through HTTP with servlets running in the Web tier.

The client doesn't invoke EJB methods directly, but through a remote interface proxy exposed by EJB remote objects which contain business methods such as “getPubNames()”.

RMI/IIOP remoting is an outstanding remoting technology with EJB. There are better alternatives for thread pooling web services remoting because a web container provides thread pooling and there’s no need to duplicate it in the business object tier.

Buy Java beans:
• IBM alphaBeans
• JClass Enterprise Suite from KL Group
• StudioJ from Rogue Wave Software

  $21 EJB Design Patterns: Advanced Patterns, Processes, and Idioms (Wiley, February 2002. 288 pages) by Floyd Marinescu, Ed Roman.

  $27 Mastering Enterprise JavaBeans (2nd Edition) (John Wiley, December 14, 2001. 672 pages) by Ed Roman, Scott W. Ambler, Tyler Jewell, Floyd Marinescu

  $42 Professional EJB (Wrox Press: July 2001. 1200 pages) by P G Sarang, Kyle Gabhart, Andre Tost, Tim McAllister, Rahim Adatia, Matjaz Juric, Ted Osborne, Faiz Arni, Jeremiah Lott, Vaidyanathan Nagarajan, Craig A. Berry, Dan O'Connor, John Griffin, Aaron Mulder, Dave Young

  $35 Developing EJB 2.0 Components (Prentice Hall: March 2002. 654 pages) by Pravin V. Tulachan

EJB Coding

try ( // 1. Use JNDI to lookup home object: Context initial = new InitialContext(); Object o = initial.lookup( "PubInfoBeanJNDIName" ); // 2. PubInfoHome home = (PubInfoHome)PortableRemoteObject.narrow( o, PubInfoHome.class); // 3. Use home factory object to create remote object: PubInfo pubInfo = home.create(); // 4. Invoke business method: String[] pubs = pubInfo.getPubNames() ... } catch { system.err.println("Caught unexpected exception"); ex.printStackTrace(); }

1. The client performs a lookup() of a JNDI Name string (such as “PubInfoBeanJNDIName”) from a JNDI (Java Naming Directory Interface) Name Service. method from the javax.naming.Context and javax.naming.NamingContext libraries' Stateless InitialContext() or the Stateful Class.newInstance() method.

   Use a dedicated session bean to perform and cache JNDI lookups, since ServletRequest.getRemoteHost() is inefficient, and can take seconds to complete the reverse DNS lookup it performs.

   The Home interface extends javax.ejb.EJBHome, which extends java.rmi.Remote.

2. The JNDI service returns to the client a reference to a context — the Home Factory object on some EJB server. Example: “PubInfoHome” Some JNDI servers assign references so that load balancing is achieved among several EJB servers.

   The stateful setSessionContext(SessionContext ctx) is invoked on the session bean instance. For an entity bean, connnection initailizes the class JdbcOdbcDriver.

3. The client obtains an instance of the bean's remote object by invoking the Stateless create() or Stateful ejbCreate() method programmed in the custom beanHome class.

4. The container instantiates stateless beans from a pool of method-ready beans in memory. This makes them much faster than stateful beans.
   The container instantiates stateful beans dedicated to a client. Stateful beans can timeout into a “Does not exist” state.
   The container can temporarily swap (idle) a bean out of memory into a “Passivated” state by calling the ejbPassivate() method.
   To avoid extra overhead in case the container needs to be passivated, remove stateful session beans (and any other unneeded objects) as soon as you're finished with them.

   Try to avoid excessive cycling (creation/deletion or activation/passivation) of beans.

5. The EJB references the Deployment Descriptor file defined for each bean. This XML file describes relationships among beans. It may also specify run-time Environment Entries.

6. When the client is finished with a bean, it invokes the remove() method, to which the container calls the bean's Stateful ejbRemove() method.

Resource Adaptor Connectors

Sample "cciblackbox" resource adapter for the "CCIEIS" EIS.

import javax.resource.cci.*;
import javax.resource.*; // contains the root ResourceException class.
import com.sun.connector.cciblackbox.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import javax.naming.*;
import java.math.BigDecimal;
import java.util.*;

To access the underlying app, JCA Version 1.0 defined CCI portable contracts for

• security.
• connection management for authentication, and authorization
• transaction management,

JcA Version 1.5 added system-level contracts:

• lifecycle management for adapter start-up and shut-down
• work management of threads,
• transaction inflow to propagate a transaction context and handle crash recovery.
• message inflow for asynchronous message delivery.

J2EE Tools & Resources

Open source efforts include:

• J2EE Blueprints

• The Jakarta Struts project

• The Jakarta Commons project

• The Castor project

  the Cloudscape database included with the J2EE SDK supports stored procedures written in Java.

  3 modes: IN (only pass data into the DBMS), OUT (only receive data from the DBMS), INOUT

  /*
   *
   * Stored procedures for accounts table
   *
   */
  
  import java.sql.*;
  import java.io.*;
  import java.lang.Integer;
  
  // Cloudscape stored procedures are written using Java
  public class AccountProcs implements Serializable {
  
      public static void insertAccount(String name, int bal) {
          try {
              Connection con =
                  DriverManager.getConnection("jdbc:cloudscape:;current=true");
              PreparedStatement ptstmt =
                  con.prepareStatement("INSERT INTO ACCOUNTS VALUES (?,?)");
              ptstmt.setString(1, name);
              ptstmt.setInt(2, bal);
              ptstmt.executeUpdate();
              ptstmt.close();
          } catch(Exception ex){
              ex.printStackTrace();
          }
      }
  
      public static int countAccounts() {
          int count = 0;
          try {
              Connection con =
                  DriverManager.getConnection("jdbc:cloudscape:;current=true");
              PreparedStatement ptstmt =
                  con.prepareStatement("SELECT COUNT(*) FROM ACCOUNTS");
              ResultSet rs = ptstmt.executeQuery();
              while (rs.next()) {
                  count = rs.getInt(1);
              }
              ptstmt.close();
          } catch (Exception ex) {
              ex.printStackTrace();
          }
          return count;
      }
  
  	public static int getAccountBal(String name) {
  		int bal = 0;
  		try {
  			Connection con =
  				DriverManager.getConnection("jdbc:cloudscape:;current=true");
  			PreparedStatement ptstmt =
  				con.prepareStatement("SELECT BALANCE FROM ACCOUNTS WHERE NAME = ?");
              ptstmt.setString(1, name);
  			ResultSet rs = ptstmt.executeQuery();
  			while (rs.next()) {
  				bal = rs.getInt(1);
  			}
  			ptstmt.close();
  		} catch (Exception ex) {
  			ex.printStackTrace();
  		}
  		return bal;
      }
  }
  

Commercial vendors

• IBM Websphere MQ Series (at version 5.3) supports Java Messaging Service JMS v1.1. Their Extended Security version combines Tivoli Access Manager.

• BEA Weblogic
• etc.

  J2EE Performance Testing with BEA WebLogic Server (Peer Information; April, 2002) by Peter Zadrozny, Philip Aston, Ted Osborne

  PreciseJava.com offers "over 100 best practices to improve performance in J2EE".

  The J2EE v1.3 Tutorial for the Sun ONE Platform [486 pages Feb 13, 2003]

  Course: Developing J2EET Compliant Applications by Scientific Computers on Java web user interface dev frameworks that J2EE standard (lots of demand and jobs): fast and easy to develop with, rich navigation framework. Tag soup for JSPs, a bit immature (doesn't come with everything), no single source for implementation.