Value List Handler

Avijeet Dash and Satyabrata Dash

While using the J2EE Framework one should be aware of the consequences of

using it under various scenarios. The most critical concern in a distributed

paradigm is the latency time, that is the time taken to serve a client request.

And this time is significantly higher compared to a local computing environment,

as the object communication is potentially remote. One such consideration is the

use of Entity beans. We learnt to use Entity beans as a coarse grained object in

the Composite Entity pattern. Composite entity reduces the number of

fine-grained entity beans and thus inter-entity bean communications, which have

a significant overhead. One more consideration while using Entity beans is the

use of its finder methods. Ejb-finder methods are used in a search and query

context, where the client wants a list of items and the size is unknown, which

could be very large.

The way ejb-finder methods work is they return a collection of EJBObject

references. Every container implementation has a certain amount of finder method

overhead for creating a collection of EJBObject references. Finder method

behavior performance varies depending on a vendor's container implementation.

According to the EJB specification, a container may invoke ejbActivate() methods

on entities found by a finder method. At a minimum, a finder method returns the

primary keys of the matching entities, which the container returns to the client

as a collection of EJBObject references. This behavior applies for all container

implementations. Some container implementations may introduce additional finder

method overhead by associating the entity bean instances to these EJBObject

instances to give the client access to those entity beans. This overhead can

significantly impede application performance if the application includes queries

that produce many matching results.

Value List Handler Pattern suggests an alternate approach of using ejb-finder

methods, that is to use DAO objects to query using JDBC and store results in a

list object holding fine-grained value objects. There are many advantages of

this approach.

1. Avoiding overheads associated with ejb-finder methods
. When the client

is the presentation tier, and a large list of items is required for view

operations, its efficient to pass collection of fine-grained local value

objects rather than remote entity beans collection. When the client is the

business tier and the list of items resulted could be less, using finder

method could be preferred.
2. Caching of searched results, typically when client needs huge list of
   
   items for browsing, it may be less concerned about its correctness, what the
   
   client needs is a fast access of the list in a page-by-page iterator manner
   
   where each page displays a sub-list of the result set. When the value list
   
   handler is implemented in the state-full session bean fashion the list can be
   
   saved for further client requests. A read-only data pattern can be used load
   
   data at start up time to avoid database lookups for static kind of data.
3. Querying flexibility, using ejb-finders in CMP the query has to be
   
   specified in the EJB Query language in the configuration xml. This language
   
   has lesser flexibility that using sql in DAO objects, though EJB2.0 EJBQL has
   
   more flexibility.
4. Allows differing entity bean transaction. While client views large
   
   list of data transaction requirements are not required. And the transaction
   
   requirements can be differed until one item has been selected for updation.
   
   While updating or inserting single row data entity bean offers better option.
5. Improves network performance. Network performance may improve because
   
   only requested data, rather than all data is shipped (serialized) to the
   
   client on an as-needed basis.

Structure

of Value List Handler

Sequence

diagram of Value List Handler

Sample Code

/*

This sample code of value list handler is found at

http://www.phptr.com/corej2eepatterns/codeChap8_2.html#ex8.29

http://www.phptr.com/corej2eepatterns/codeChap8_2.html#ex8.30

http://www.phptr.com/corej2eepatterns/codeChap8_2.html#ex8.31

*/

Reference

http://developer.java.sun.com/developer/restricted/patterns/ValueListHandler.html

http://www.precisejava.com/javaperf/j2ee/Patterns.htm

http://www.orionserver.com/docs/jdbc/javax/sql/CachedRowSet.html

http://java.sun.com/blueprints/patterns/j2ee_patterns/fast_lane_reader/index.html

The authors are senior developers at MindTree Consulting. They can be reached

at avijeetd@mindtree.com and satyabrata_dash@mindtree.com.