USING AOP WITHIN THE SAMPLE APPLICATION S BUSINESS TIER in Font

Generator Data Matrix 2d barcode in Font USING AOP WITHIN THE SAMPLE APPLICATION S BUSINESS TIER

Listing 11-9. The EJBGetter Class package aop.j2ee.business.util; import javax.rmi.PortableRemoteObject; import javax.naming.InitialContext; import javax.naming.NamingException; import aop.j2ee.commons.util.CodedNames; import aop.j2ee.business.entity.account.*; [...] // other imports public final class EJBGetter { public static AccountHome getAccountHome() throws NamingException { InitialContext initial = new InitialContext(); Object objref = initial.lookup(CodedNames.ACCOUNT_EJBHOME); return (AccountHome) PortableRemoteObject.narrow(objref, AccountHome.class); } [...] // other resolving methods } In the original Duke s Bank design, the account resolving and the transaction parameters testing are factorized within a single method. These two independent concerns are mixed because of the need to hide the use of the Home interface. This choice makes the transactional method code less explicit. Listing 11-10 is an example of a business service implementation that corresponds to an account withdrawal. Listing 11-10. A Withdrawal Business Service Implementation 01 public void withdraw(BigDecimal amount,String description, 02 String accountId) 03 throws InvalidParameterException, AccountNotFoundException, 04 IllegalAccountTypeException, InsufficientFundsException { 05 06 Account account = 07 checkAccountArgsAndResolve(amount, description, accountId); 08 try { 09 String type = account.getType(); 10 if (DomainUtil.isCreditAccount(type)) 11 throw new IllegalAccountTypeException(type); 12 BigDecimal newBalance = account.getBalance().subtract(amount); 13 if (newBalance.compareTo(bigZero) == -1) 14 throw new InsufficientFundsException(); 15 executeTx( 16 amount.negate(), 17 description,

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

accountId, newBalance, account); } catch (RemoteException ex) { throw new EJBException("withdraw: " + ex.getMessage()); } } // withdraw private void executeTx(BigDecimal amount, String description, String accountId, BigDecimal newBalance, Account account) { try { makeConnection(); String txId = DBHelper.getNextTxId(con); account.setBalance(newBalance); Tx tx = txHome.create(txId,accountId,new java.util.Date(), amount,newBalance,description); } catch (Exception ex) { throw new EJBException("executeTx: " + ex.getMessage()); } finally { releaseConnection(); } } // executeTx

The executedTx method of line 15 gathers two independent functions that would benefit from being explicitly coded within the functional implementation: the Tx EJB creation (line 33), and the invocation of setBalance (line 32) on an account. As shown in the code, the Tx EJB creation uses a database-related method: DBHelper. getNextTxId (line 31), which returns the next available transaction identifier. This operation is a low-level operation that should probably not be used within a business method. Conceptually speaking, we can classify all the presented operations Home interface resolving, account lookup from a primary key, and instantiation of the Tx EJB within a reference-managing concern. This concern depends highly on the J2EE infrastructure and on the EJB model. This is clearly a crosscutting concern for all EJB accessing or for the creation of EJBs, particularly the session EJBs. The use of design patterns such as the locator can make the code less dependent on the infrastructure and minimize the design efforts through reuse. However, it is then the use of the pattern that becomes a crosscutting concern. Furthermore, the use of a locator pattern still requires an indirect use of the EJB model.

AOP, and more precisely the previously discussed implicit protocol technique, significantly simplifies the design and efficiently modularizes the reference-resolving crosscutting concern. First, we defined the reference accessing protocol in the EJB itself, as shown in Listing 11-11. In our program, it is a POJO since it automatically implements the javax.ejb.SessionBean interface through the POJOSession aspect. This POJO, named TxControllerPOJO, will be detailed in the rest of the chapter, once all the applied aspects have been presented.

Listing 11-11. The Implicit Protocol for EJB Resolving [...] // excerpt of the TxControllerPOJO implicit resolving protocol implementation private Collection findTxByAccountId(Date startDate, Date endDate,String accountId) throws Exception {return null;} private Tx findTxByPrimaryKey(String txId) throws Exception {return null;} private Account findAccountByPrimaryKey(String accountID) throws Exception {return null;} private Tx createTx(String accountId, Date date, BigDecimal amount, BigDecimal newBalance, String description) throws Exception {return null;} We now define the aspect implementing this protocol. In our study, this aspect is called the EJBResolver aspect, which is an abstract aspect extended by the POJOSession and POJOEntity concrete aspects. The purpose of the EJBResolver aspect is to implement common behaviors for reference-resolving implementation, as shown in Listing 11-12. Listing 11-12. The Aspect Implementation of the EJB Resolving Implicit Protocol 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 package aop.j2ee.business.aspect; import import import import import import import import java.util.Collection; java.util.Date; java.math.BigDecimal; aop.j2ee.business.entity.account.AccountHome; aop.j2ee.business.entity.account.Account; aop.j2ee.business.entity.tx.TxHome; aop.j2ee.business.entity.tx.Tx; aop.j2ee.business.aspect.sql.DBUtil;

public abstract aspect EJBResolver { static protected TxHome txHome; static protected AccountHome accountHome; [...] // Other homes... Account around(String accountID) throws Exception: execution( private Account *.findAccountByPrimaryKey(String) && args(accountID) { return accountHome.findByPrimaryKey(accountID); } Tx around(String txID) throws Exception: execution(private Tx *.findTxByPrimaryKey(String)) && args(txID) { return txHome.findByPrimaryKey(txID); }