My developer connection home My Developer Connection
knowledgebase for software developers

JSP

  • Use jspInit() method to cache static data
  • Use StringBuffer rather than using + operator when you concatenate multiple strings
  • Use print() method rather than println() method
    Use ServletOutputStream instead of JSPWriter to send binary data
  • Initialize the 'out' object (implicit object) with proper size in the page directive.
  • Flush the data partly
  • Minimize code in the synchronized block
  • Set the content length
  • Release resources in jspDestroy() method.
  • Give 'false' value to the session in the page directive to avoid session object creation.
  • Use include directive instead of include action when you want to include the child page content in the translation phase.
  • Avoid giving unnecessary scope in the 'useBean' action.
  • Do not use custom tags if you do not have reusability.
  • Use application server caching facility
  • Use Mixed session mechanisms such as 'session' with hidden fields
  • Use 'session' and 'application' as cache.
  • Use caching tags provided by different organizations like openSymphony.com
  • Remove 'session' objects explicitly in your program whenever you finish the task
  • Reduce session time out value as much as possible
  • Use 'transient' variables to reduce serialization overhead if your session tracking mechanism uses serialization process.
  • Disable JSP auto reloading feature.
  • Use thread pool for your JSP engine and define the size of thread pool as per application requirement.

Servlets

  • Use init() method to cache static data
  • Use StringBuffer rather than using + operator when you concatenate multiple strings
  • Use print() method rather than println() method
  • Use ServletOutputStream rather than PrintWriter to send binary data
  • Initialize the PrintWriter with proper size
  • Flush the data partly
  • Minimize code in the synchronized block
  • Set the content length
  • Release resources in destroy() method.
  • Implement getLastModified() method to use browser cache and server cache
  • Use application server caching facility
  • Use Mixed session mechanisms such as HttpSession with hidden fields
  • Remove HttpSession objects explicitly in your program whenever you finish the task
  • Reduce session time out value as much as possible
  • Use 'transient' variables to reduce serialization overhead if your HttpSession tracking mechanism uses serialization process.
  • Disable servlet auto reloading feature.
  • Use thread pool for your servlet engine and define the size as per application requirement

Message driven beans

  •  Tune the Message driven beans pool size to promote concurrent processing of messages.
  • Use setMesssageDrivenContext() or ejbCreate() method to cache bean specific resources.
  • Release acquired resources in ejbRemove() method.
  • Use JMS tuning techniques in Message driven beans.
     

Stateless session beans

  • Tune the Stateless session beans pool size to avoid overhead of creation and destruction of beans.
  • Use setSessionContext() or ejbCreate() method to cache bean specific resources.
  • Release acquired resources in ejbRemove() method


Stateful session beans
 

  • Tune Stateful session beans cache size to avoid overhead of activation and passivation process.
  • Set optimal Stateful session bean age(time-out) to avoid resource congestion.
  • Use 'transient' key word for unnecessary variables of Stateful session bean to avoid serialization overhead.
  • Remove Stateful session beans explicitly from client using remove() method.


Entity beans
 

  • Tune the entity beans pool size to avoid overhead of creation and destruction of beans.
  • Tune the entity beans cache size to avoid overhead of activation, passivation and database calls.
  • Use setEntityContext() method to cache bean specific resources.
  • Release acquired resources in unSetEntityContext() method
  • Use Lazy loading to avoid unnecessary pre-loading of child data.
  • Choose optimal transaction isolation level to avoid blocking of other transactional clients.
  • Use proper locking strategy.
  • Make read-only entity beans for read only operations.
  • Use dirty flag to avoid unchanged buffer data updation.
  • Commit the data after the transaction completes to reduce database calls in between transaction.
  • Do bulk updates to reduce database calls.
  • Use CMP rather than BMP to utilize built-in performance optimization facilities of CMP.
  • Use ejbHome() methods for global operations.
  • Tune connection pool size to reduce overhead of creation and destruction of database connections.
  • Use JDBC tuning techniques in BMP.
  • Use direct JDBC rather than using entity beans when dealing with huge data such as searching a large database.
  • Use business logic that is specific to entity bean data.