4 Implementing Business Logic

4.2.1 Conditions that Favor Using EJBs

Choose EJBs when:

• You need to model complex business logic.

• You need to model complex relationships between business objects.

• You need to access your component from different client types such as JSPs and servlets.

• You need J2EE services.

4.2.2 Conditions that Favor Using Servlets

Choose servlets when:

• You need to maintain state but do not require J2EE services (HttpSession object).

• You do not need to dedicate servlet instances to individual clients. In large deployments with thousands of concurrent users, maintaining one stateful session bean instance for each client may be a bottleneck. Servlets provide a lighter weight alternative.

• You need to temporarily store state of business process within a single HTTP request and the request involves multiple beans.

4.2.3 Conditions that Favor Using Normal Java Objects

Choose normal Java objects when:

• You do not need built-in Web and EJB services such as transactions, security, persistence, resource pooling.

• You need the following features that are not allowed in EJBs:

  • accessing a local disk using the java.io package

  • creating threads

  • using the synchronized keyword

  • using the java.awt or javax.swing packages

  • listening to a socket or creating a socket server

  • modifying the socket factory

  • using native libraries (JNI)

  • reading or writing static variables

4.5.1 Home Interface

The Employee entity bean has the following home interface:

package empbft.component.employee.ejb;
import java.rmi.RemoteException;
import javax.ejb.*;

public interface EmployeeHome extends EJBHome 
{
  public Employee findByPrimaryKey(int employeeID)
    throws RemoteException, FinderException;
}

The findByPrimaryKey method, which is required for all entity beans, enables clients to find an Employee object. It takes an employee ID as its primary key.

It is implemented in the EmployeeBean class as ejbFindByPrimaryKey. To find an Employee object, it uses a data access object (DAO) to connect to the database and perform a query operation based on the employee ID.

See Section 4.5.6.3, "EmployeeDAO Classes" for details on DAOs.

4.5.2 Remote Interface

The Employee bean’s remote interface declares the methods for executing business logic operations:

package empbft.component.employee.ejb;
import java.rmi.RemoteException;
import javax.ejb.EJBObject;
import empbft.component.employee.helper.*;

public interface Employee extends EJBObject 
{
    public void addBenefits(int benefits[]) throws RemoteException;
    public void removeBenefits(int benefits[]) throws RemoteException;
    public EmployeeModel getDetails() throws RemoteException;
}

The addBenefits and removeBenefits methods access the database using a DAO and perform the necessary operations. See Section 4.5.6, "Data Access Object for Employee Bean" for details.

The getDetails method returns an instance of EmployeeModel, which contains employee information. The query operation calls this method to get and display employee data. JSP pages call the getEmployeeDetails method in EmployeeManager, which in turn calls the getEmployee method (see Figure 4-4). The getEmployee method returns an Employee object, and the EmployeeManager invokes the getDetails method on this Employee object. The getDetails method returns an EmployeeModel object to the EmployeeManager, which returns it to the JSP. See Section 6.2, "Query Employee Operation" for details on the query operation.

Figure 4-4 Getting Employee Details

Description of the illustration getEmpDetails.gif

4.5.3 Persistence

The Employee entity bean uses bean-managed persistence (BMP), rather than container-managed persistence. The bean controls when it updates data in the database.

See Chapter 10, " Updating EJBs to Use EJB 2.0 Features" for examples of EJBs that use container-managed persistence.

4.5.4 Load Method

The Employee entity bean implements the ejbLoad method, although the bean uses bean-managed persistence. The ejbLoad method queries the database (using the DAO) and updates the data in the bean with the new data from the database. This ensures that the bean’s data is synchronized with the data in the database.

ejbLoad is called after the user adds or removes benefits.

// from EmployeeBean.java
public void ejbLoad() {
   try {
      if (m_dao == null)
          m_dao = new EmployeeDAOImpl();
      Integer id = (Integer)m_ctx.getPrimaryKey();
      this.m_emp = m_dao.load(id.intValue());
   } catch (Exception e) {
      throw new EJBException("\nException in loading employee.\n"
             + e.getMessage());
   }
}

See also Section 4.5.6.3, "Load Method", which describes the load method in the DAO.

4.5.5 EmployeeModel Class

The implementation of the Employee bean uses a variable of type EmployeeModel, which contains all the employee details such as first name, last name, job ID, and so on. The following code snippet from EmployeeBean shows m_emp as a class variable:

public class EmployeeBean implements EntityBean
{
  private EmployeeModel m_emp;
  ...
}

Code snippet from EmployeeModel:

public class EmployeeModel implements java.io.Serializable 
{
  protected int m_id;
  protected Collection m_benefits;
  private String m_firstName;
  private String m_lastName;
  private String m_email;
  private String m_phoneNumber;
  private Date m_hireDate;
  private String m_jobId;
...
}

Figure 4-5 Employee and EmployeeModel

Description of the illustration emp_empmodel.gif

4.5.6 Data Access Object for Employee Bean

Data access objects (DAOs) are the only classes in the application that communicate with the database, or in general, with a data source. The entity and session beans in the application do not communicate with the data source. See Figure 2-2.

By de-coupling business logic from data access logic, you can change the data source easily and independently. For example, if the database schema or the database vendor changes, you only have to update the DAO.

DAOs have interfaces and implementations. EJBs access DAOs by invoking methods declared in the interface. The implementation contains code specific for a data source.

For details on DAOs, see:

http://java.sun.com/blueprints/patterns/DAO.html

package empbft.component.employee.dao;
import empbft.component.employee.helper.EmployeeModel;

public interface EmployeeDAO {
  public EmployeeModel load(int id) throws Exception;
  public Integer findByPrimaryKey(int id) throws Exception;
  public void addBenefits(int empId, int benefits[]) throws Exception;
  public void removeBenefits(int empId, int benefits[]) throws Exception;
}

// from EmployeeBean.java
public void addBenefits(int benefits[])
{
    try {
      if (m_dao == null) m_dao = new EmployeeDAOImpl();
      m_dao.addBenefits(m_emp.getId(), benefits);
      ejbLoad();
    } catch (Exception e) {
      throw new EJBException ("\nData access exception in adding benefits.\n"
        + e.getMessage());
    }
}

public void addBenefits(int empId, int benefits[]) throws Exception
{
   String queryStr = null;
   PreparedStatement stmt = null;
   try {
      getDBConnection();
      for (int i = 0; i < benefits.length; i ++) {
         queryStr = "INSERT INTO EMPLOYEE_BENEFIT_ITEMS "
                 + " (EMPLOYEE_ID, BENEFIT_ID, ELECTION_DATE) "
                 + " VALUES (" + empId + ", " + benefits[i] + ", SYSDATE)";
         stmt = dbConnection.prepareStatement(queryStr);
         int resultCount = stmt.executeUpdate();
         if (resultCount != 1) {
            throw new Exception("Insert result count error:" + resultCount);
         }
      }
   } catch (SQLException se) {
      throw new Exception(
          "\nSQL Exception while inserting employee benefits.\n"
          + se.getMessage());
   } finally {
       closeStatement(stmt);
       closeConnection();
   }
}

4.5.6.3 Load Method

After the Employee bean adds or removes benefits for an employee, it calls the load method in EmployeeDAOImpl:

// from EmployeeBean.java
public void addBenefits(int benefits[])
{
   try {
      if (m_dao == null)
         m_dao = new EmployeeDAOImpl();
      m_dao.addBenefits(m_emp.getId(), benefits);
      ejbLoad();
   } catch (Exception e) {
      throw new EJBException ("\nData access exception in adding benefits.\n"
          + e.getMessage());
   }
}



// also from EmployeeBean.java
public void ejbLoad()
{
   try {
      if (m_dao == null)
         m_dao = new EmployeeDAOImpl();
      Integer id = (Integer) m_ctx.getPrimaryKey();
      this.m_emp = m_dao.load(id.intValue());
   } catch (Exception e) {
      throw new EJBException("\nException in loading employee.\n"
          + e.getMessage());
   }
}

The ejbLoad method in the Employee bean invokes load in the DAO object. By calling the load method after adding or removing benefits, the application ensures that the bean instance contains the same data as the database for the specified employee.

// from EmployeeDAOImpl.java
public EmployeeModel load(int id) throws Exception
{
   EmployeeModel details = selectEmployee(id);
   details.setBenefits(selectBenefitItem(id));
   return details;
}

Note that the EJB container calls ejbLoad in the Employee bean automatically after it runs the findByPrimaryKey method. See Section 6.2, "Query Employee Operation" for details.

Figure 4-6 EmployeeDAO Classes

Description of the illustration cl_empdao.jpg

4.6.1 Home Interface

The BenefitCatalog session bean has the following home interface:

package empbft.component.benefit.ejb;
import java.rmi.RemoteException;
import javax.ejb.EJBHome;
import javax.ejb.CreateException;

public interface BenefitCatalogHome extends EJBHome 
{
  public BenefitCatalog create() throws RemoteException, CreateException;
}

The create method, which is implemented in BenefitCatalogBean as ejbCreate, queries the BENEFITS table in the database to get a master list of benefits. The returned data (benefit ID, benefit name, benefit description) is saved to a BenefitModel object. Each record (that is, each benefit) is saved to one BenefitModel object.

The application gets a performance gain by retrieving the benefit data when the EJB container creates the bean, instead of when it needs the data. The application can then query the bean when it needs the data.

4.6.2 Remote Interface

The BenefitCatalog session bean has the following remote interface:

package empbft.component.benefit.ejb;
import java.rmi.RemoteException;
import javax.ejb.EJBObject;
import java.util.Collection;

public interface BenefitCatalog extends EJBObject 
{
  public Collection getBenefits() throws RemoteException;
  public void refresh() throws RemoteException;
}

The getBenefits method returns a Collection of BenefitModels. This is the master list of all benefits. This method is called by the EmployeeManager bean (by the getUnelectedBenefitItems method) when the application needs to display a user’s unelected benefits. It compares a user’s elected benefits against the master list, and displays the benefits that are not elected. The user then selects benefits to add from this list.

4.6.3 Benefit Details

The BenefitCatalog bean contains a Collection of BenefitModel’s. The BenefitModel class contains the details (benefit ID, benefit name, and benefit description) for each benefit.

The BenefitCatalog bean contains a class variable called m_benefits of type Collection. Data in the Collection are of type BenefitModel. Each BenefitModel contains information about a benefit (such as benefit ID, name, and description). BenefitItem is a subclass of BenefitModel.

Figure 4-8 BenefitItem and BenefitModel Classes

Description of the illustration benefitmodel.jpg

JSPs call methods in BenefitModel to display benefit information. For example, queryEmployee.jsp calls the getName method to display benefit name.

<%
    Collection benefits = emp.getBenefits();
    if (benefits == null || benefits.size() == 0) {
  %>
      <tr><td>None</td></tr>
  <%
    } else {
      Iterator it = benefits.iterator();
      while (it.hasNext()) {
        BenefitItem item = (BenefitItem)it.next();
  %>
        <tr><td><%=item.getName()%></td></tr>
  <%
      } // end of while
    } // end of if
  %>

4.7.1 Home Interface

The EmployeeManager has the following home interface:

package empbft.component.employee.ejb;

import java.rmi.RemoteException;
import javax.ejb.*;

public interface EmployeeManagerHome extends EJBHome 
{
  public EmployeeManager create() throws RemoteException, CreateException;
}

The create method does nothing.

4.7.2 Remote Interface

The EmployeeManager has the following remote interface:

package empbft.component.employee.ejb;
import java.rmi.RemoteException;
import javax.ejb.EJBObject;
import java.util.Collection;
import empbft.component.employee.helper.*;

public interface EmployeeManager extends EJBObject 
{
  public Employee getEmployee(int id) throws RemoteException;
  public EmployeeModel getEmployeeDetails(int id) throws RemoteException;
  public Collection getUnelectedBenefitItems(int id) throws RemoteException;
}

getUnelectedBenefitItems in EmployeeManager invokes methods on the BenefitCatalog bean and returns a Collection to the JSP, which iterates through and displays the contents of the Collection.

Methods in EmployeeManager also return non-bean objects to the application. For example, queryEmployee.jsp invokes the getEmployeeDetails method, which returns an EmployeeModel. The JSP can then invoke methods in EmployeeModel to extract the employee data.

// from queryEmployee.jsp
<%
   int id = Integer.parseInt(empId);
   EmployeeManager mgr = SessionHelper.getEmployeeManager(request);
   EmployeeModel emp = mgr.getEmployeeDetails(id);
   ...
%>
...
<table>
<tr><td>Employee ID: </td><td colspan=3><b><%=id%></b></td></tr>
<tr><td>First Name: </td><td><b><%=emp.getFirstName()%></b></td>
<td>Last Name: </td><td><b><%=emp.getLastName()%></b></td></tr>

Similarly, in removeBenefitFromEmployee.jsp, the page calls getEmployeeDetails to get an EmployeeModel, then it calls the getBenefits method on the EmployeeModel to list the benefits for the employee. The user can then select which benefits should be removed.

// from removeBenefitFromEmployee.jsp
<%
  int empId = Integer.parseInt(request.getParameter(
                          SessionHelper.EMP_ID_PARAMETER));
  EmployeeManager mgr = SessionHelper.getEmployeeManager(request);
  Collection elected = mgr.getEmployeeDetails(empId).getBenefits();
  ...
%>
...
<h4>Select Elected Benefits</h4>
<%
   Iterator i = elected.iterator();
   while (i.hasNext()) {
      BenefitItem b = (BenefitItem) i.next();
%>
<input type=checkbox name=benefits value=<%=b.getId()%>><%=b.getName()%><br>
<%
   }   // end while
%>