Step 3: Use the init() Method of HttpServlet for Data Caching
The init() method of a servlet is invoked by the server immediately after the instance of the servlet is created and before processing any of the client requests. It is invoked only once in the lifetime of the servlet. Performing all the expensive operations and initialization in the init() method can yield better performance.
Connection pooling is one of the best examples of an activity better performed in this method. You can create the required/configured number of connections, to be re-used later, as required.
Here's some example code:
public class TaskServlet extends HttpServlet{
private javax.sql.DataSource dataSource = null;
public void init(ServletConfig config) throws ServletException{
super.init(config);
Context context = null;
try
{
context = new InitialContext();
dataSource = (javax.sql.DataSource)context.lookup
("jdbc/dataSource");
}
catch(NamingException namingException)
{
namingException.printStackTrace();
}
catch(Exception exception)
{
exception.printStackTrace();
}
}
public java.sql.Connection getConnection(){
//return connection from dataSource
}
//Other methods will go here
}
Step 4: Disable Auto-reloading of Servlets and JSPs
Auto-reloading of JSP/Servlets eliminates the hassle of restarting the server after every change in your servlet/JSP.
However, when an application is deployed, auto-reloading is very expensive. Auto-reloading affects performance because it includes the additional activity of unnecessary loading, which is a burden on the Classloader. It's also risky due to the possibility of unexpected conflicts when classes, loaded by a previous Classloader, cannot cooperate with classes loaded by the current Classloader. The best option is to keep this facility OFF in a live/production environment.
Step 5: Session Management
Most applications require a session to maintain a sequence of requests from the same client. Java servlet technology has exposed this feature with an API for session management. You can use the HttpSession object for maintaining sessions, but only at the cost of your application's performance.
By default, all JSP pages create an instance of HttpSession. This allows you to take a call and decide if it is required. However, if you're not going to use it, you should choose not to create it. The below code segment will instruct the server not to create a session:
<%@ page session="false"%>
Another reason to avoid using HttpSession is that every time there is a request, the HttpSession object is processed. If you've got large objects stored there, this can create yet another performance bottleneck. If you must use HttpSession, at least try to avoid using it for storage of large objects.
Actually, it's not advisable to maintain sessions for any extended period of time. Setting a low session time-out value not only improves application performance, it prevents also long-term degradradation of your server's performance.
Always remember to close sessions when they are no longer required. You can use the invalidate() method on HttpSession to close/release the session for memory.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
