tomcat configuration

tomcat mod_jk tutorial

2010-11-18T04:19:00.001-08:00

mod_jk is a replacement to the elderly mod_jserv. It is a plug-in that handles the communication between Tomcat and Apache.

In this tutorial, we assume that a stable Apache Web Server 2.X has been installed on your host. The next step in the checklist is downloading the latest stable release of Tomcat mod_jk, available at

http://www.apache.org/dist/tomcat/tomcat-connectors/jk/binaries/

Once downloaded, the module mod_jk.so should be copied in your Apache module directory (usually located in the APACHE_ROOT/modules directory). Check your Apache documentation if you cannot locate it.

Windows users are encouraged to rename the binary file to mod_jk.dll if the downloaded Windows module bears the .so extension. This way you will not confuse this library with a compiled library for Unix.
The configuration of mod_jk can be included into the Apache httpd.conf file or held in an external file, which is a good practice:

# Load mod_jk module

LoadModule jk_module modulesc/mod_jk.so # UNIX

# LoadModule jk_module modules/mod_jk.dll # WINDOWS

# Where to find workers.properties

JkWorkersFile /etc/httpd/conf/workers.properties

# Where to put jk shared memory

JkShmFile /var/log/httpd/mod_jk.shm

# Where to put jk logs

JkLogFile /var/log/httpd/mod_jk.log

# Set the jk log level [debug/error/info]

JkLogLevel info

# Select the timestamp log format

JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

# Send everything for context /yourApplication to mod_jk loadbalancer

JkMount /yourApplication/* loadbalancer

The module is loaded in memory by the LoadModule directive; the configuration of the single nodes is contained in a separate file named workers.properties, which will be examined in a moment.

The JkMount directive tells Apache which URLs it should forward to the mod_jk module. Supposing we have deployed a web application reachable at the web context yourApplication, with the above JKMount directive all requests with URL path /yourApplication/* are sent to the mod_jk load balancer. This way, you actually split the requests either on Apache directly (static contents) or on the load balancer for Java applications.

So, if you want your web application served directly by Tomcat Web Server you would need to point the browser to this location: http://localhost:8080/yourApplication

The same web context, proxied by Apache Web server can be reached at:
http://localhost/yourApplication

Additionally, you can use the JkMountFile directive that allows dynamic updates of mount points at runtime. When the mount file is changed, mod_jk will reload its content.

# Load mount points

JkMountFile conf/uriworkermap.properties

The format of the file is /url=worker_name. To get things started, paste the following example into the file you created:

# Mount the Servlet context to the ajp13 worker

/yourApplication=loadbalancer

/yourApplication/*=loadbalancer

This will configure mod_jk to forward requests to /yourApplication Apache web container.
Next, you need to configure the workers file conf/workers.properties. A worker is a process that defines a communication link between Apache and the Tomcat container.

This file specifies where the different nodes are located and how to balance the calls between the hosts. The configuration file is made up of global directives (that are generic for all nodes) and the individual worker's configuration. This is a sample two-node configuration:

# Define list of workers that will be used

worker.list=loadbalancer,status

# Define Node1

worker.node1.port=8009

worker.node1.host=192.168.10.1

worker.node1.type=ajp13

worker.node1.lbfactor=1

worker.node1.cachesize=10

# Define Node2

worker.node2.port=8009

worker.node2.host=192.168.10.2

worker.node2.type=ajp13

worker.node2.lbfactor=1

worker.node2.cachesize=10

# Load-balancing behaviour

worker.loadbalancer.type=lb

worker.loadbalancer.balance_workers=node1,node2

worker.loadbalancer.sticky_session=1

# Status worker for managing load balancer

worker.status.type=status

In this file, each node is defined using the worker.XXX naming convention where XXX represents an arbitrary name you choose for each of the target servlet containers. For each worker, you must specify the host name (or IP address) and the port number of the AJP13 connector running in the servlet container.

balance_workers is a comma-separated list of workers that the load balancer need to manage.
sticky_session specifies whether requests with SESSION IDs should be routed back to the same Tomcat worker. If sticky_session is set to true or 1, sessions are sticky, otherwise sticky_session is set to false. (The default is true.)

Finally, we must configure the Web instances on all clustered nodes so that they can expect requests forwarded from the mod_jk load balancer. Edit the server.xml file; locate the element and add an attribute jvmRoute:


    ... ...

The same attribute is required on node2:

    ... ...


You also need to be sure the AJP Connector definition is uncommented. By default, it is enabled.

emptySessionPath="true" enableLookups="false" redirectPort="8443" />

Tomcat pooling

2009-03-17T08:38:00.000-07:00

With Database Connection Pooling (DBCP), we can scale our applications to handle increased load and deliver high performance benefits. Using recycled database connection objects cuts the time taken to re-instantiate and load frequently used objects, thus reducing unnecessary overheads.

Our approach to DBCP uses the Jakarta-Commons database connection pool. But first, we need to configure the JNDI DataSource in Tomcat by adding a declaration for the resource to server.xml file, which resides inside the /conf directory of your Tomcat installation (indicated by the environment variable CATALINA_HOME). The JNDI DataSource is used as a factory for connections. One of the major advantages of using a configuration like this is that the characteristics of the pool can be changed without affecting the application code.

server.xml ========================================
.........


<Host >

 <Context path="/edi-web" docBase="edi-web" debug="5"
             reloadable="true" crossContext="true">

      <Resource name="EDI-DS" auth="Container"
           type="javax.sql.DataSource" removeAbandoned="true"
           removeAbandonedTimeout="30" maxActive="100"
           maxIdle="30" maxWait="10000" username="user"
           password="passws"
           driverClassName="oracle.jdbc.driver.OracleDriver"
           url="jdbc:oracle:thin:@192.168.0.1:1521:SME1" />

 </Context>
      
             
</Host>

=================================================

In this example we have configured the DataSource EDI-DS which references an Oracle connection.

Use of the JDBC Data Sources requires that you make an appropriate JDBC driver available to both Tomcat internal classes and to your web application. This is most easily accomplished by installing the driver's JAR file(s) into the $CATALINA_HOME/common/lib directory, which makes the driver available both to the resource factory and to your application
(Notice: Tomcat 6 library repository is $CATALINA_HOME/lib )

We can configure a maximum number of DB connections in the pool. Make sure you choose a maximum connection count large enough to handle all of your database connections--alternatively, you can set 0 for no limit.

We can also specify the maximum time (in milliseconds) to wait for a database connection to become available, which in this example is 30 seconds.

Further, we can set the maximum number of idle database connections to be retained in the pool. Set this value to -1 for no limit. The most optimal performance is attained when the pool in its steady state contains just enough connections to service all concurrent connection requests, without having to create new physical database connections at runtime

Retrieving the Connection

Getting a connection form the DataSource is just a matter of looking up the Datasource from the InitialContext and then retrieve the associated connection:


Context   ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("java:/comp/env/EDI-DS");
Connection conn = ds.getConnection();

Tomcat axis tutorial

2009-01-20T03:23:00.000-08:00

Axis is essentially a SOAP engine, that is a framework for constructing SOAP processors such as clients, servers, gateways, etc.

Installing Axis on Tomcat

At first download Axis from the Apache project:

http://ws.apache.org/axis/java/index.html

Explode the zip folder. Now you need to deploy the Axis engine to Tomcat: Here's how to do it:

Rename the folder axis under AXIS_HOME/webapps to axis.war and copy the folder under "webapps" of your tomcat

Verify that Axis has been deployed correctly:

http://localhost:8080/axis/

Publishing Web Services with Axis

Let's say we have a simple class like the following:



package test;

public class HelloWorld {

  public String hello(String message) {

    return "Invoked with" +message;

  }

}

How do we go about making this class available via SOAP? There are a couple of answers to that

question, but we'll start with an easy solution.

At first compile the class :

javac -d . HelloWorld.java

Now copy the class under WEB-INF/classes of your axis.war

Ok, now the last step is registering your Web Service so that Axis is aware of it. A Web Service can be registered with a Deployment Descriptor (WSDD) file. A deployment descriptor contains a bunch of things you want to "deploy" into Axis - i.e. make available to the Axis engine.

Here's a simple wsdd file for our WebService:

<deployment
xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

<service name="HelloWorld" provider="java:RPC">
<parameter name="className" value="test.HelloWorld"/>
<parameter name="allowedMethods" value="*"/>
</service>
</deployment>

Pretty simple, really - the outermost element tells the engine that this is a WSDD deployment,and defines the "java" namespace. Then the service element actually defines the service for us. A service is a targeted chain which means it may have any of: a request flow, a provider, and a response flow.

In this case, our provider is "java:RPC", which is built into Axis, and indicates a Java RPC service. We need to tell the RPCProvider that it should instantiate and call the correct class (e.g. test.HelloWorld), and another to tell the engine that any public method on that class may be called via SOAP (that's what the "*" means)

Now save your wsdd file as deploy.wsdd and run the AdminClient which is an Utility to deploy the WebService

java -classpath %AXIS_HOME%/lib/axis.jar;%AXIS_HOME%/lib/commons-discovery-0.2.jar;%AXIS_HOME%/lib/commons-logging-1.0.4.jar;%AXIS_HOME%/lib/saaj.jar;%AXIS_HOME%/lib/jaxrpc.jar org.apache.axis.client.AdminClient deploy.wsdd

If everything was Ok now you should see the WebService deployed on Axis: check the "List" option from the URL http://localhost:8080/axis/

The client

Let's take a look at an example Web Service client that will call the hello method of the HelloWorld Web Service


package test;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import javax.xml.namespace.QName;
import java.net.URL;

public class Client {

  public static void main (String args[]) {

    try {

      String url;

      url="http://localhost:8080/axis/services/HelloWorld";

      Service service = new Service();

      Call call = (Call)service.createCall();

      call.setTargetEndpointAddress(new URL(url));

      call.setOperationName(new QName("HelloWorld", "hello"));

      Object[] params = new Object[1];

      params[0] = "Hello Message";

      Object result = call.invoke(params);

      System.out.println("result is " + result);

    }

    catch(Exception e) {

      e.printStackTrace();

    }


 }


}

In order to invoke our Web Service we use the Service and Call objects. These are the

standard JAX-RPC objects that are used to store metadata about the service to invoke.

With this we set up our endpoint URL - this is the destination for our SOAP message.

call.setTargetEndpointAddress(new URL(url));

With this we define the operation (method) name of the Web Service.

call.setOperationName(new QName("HelloWorld", "hello"));

Then we actually invoke the desired service, passing in an array of parameters - in this case just one String.

Object result = call.invoke(params);

Obtaining WSDL for deployed services

When you make a service available using Axis, there is typically a unique URL associated with that service. For our service it's http://localhost:8080/axis/services/HelloWorld?wsdl

When you point your browser to that location, Axis will automatically generate a service description for the deployed service, and return it as XML in your browser :


<?xml version="1.0" encoding="UTF-8" ?>
<wsdl:definitions
 targetNamespace="http://localhost:8080/axis/services/HelloWorld"
 xmlns:apachesoap="http://xml.apache.org/xml-soap"
 xmlns:impl="http://localhost:8080/axis/services/HelloWorld"
 xmlns:intf="http://localhost:8080/axis/services/HelloWorld"
 xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
 xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <wsdl:message name="helloRequest">
  <wsdl:part name="in0" type="xsd:string" />
 </wsdl:message>
 <wsdl:message name="helloResponse">
  <wsdl:part name="helloReturn" type="xsd:string" />
 </wsdl:message>
 <wsdl:portType name="HelloWorld">
  <wsdl:operation name="hello" parameterOrder="in0">
   <wsdl:input message="impl:helloRequest" name="helloRequest" />
   <wsdl:output message="impl:helloResponse"
    name="helloResponse" />
  </wsdl:operation>
 </wsdl:portType>
 <wsdl:binding name="HelloWorldSoapBinding" type="impl:HelloWorld">
  <wsdlsoap:binding style="rpc"
   transport="http://schemas.xmlsoap.org/soap/http" />
  <wsdl:operation name="hello">
   <wsdlsoap:operation soapAction="" />
   <wsdl:input name="helloRequest">
    <wsdlsoap:body
     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
     namespace="http://test" use="encoded" />
   </wsdl:input>
   <wsdl:output name="helloResponse">
    <wsdlsoap:body
     encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
     namespace="http://localhost:8080/axis/services/HelloWorld"
     use="encoded" />
   </wsdl:output>
  </wsdl:operation>
 </wsdl:binding>
 <wsdl:service name="HelloWorldService">
  <wsdl:port binding="impl:HelloWorldSoapBinding"
   name="HelloWorld">
   <wsdlsoap:address
    location="http://localhost:8080/axis/services/HelloWorld" />
  </wsdl:port>
 </wsdl:service>
</wsdl:definitions>

Generating Java Classes from WSDL

Another approach is to generate Java Classes starting from WSDL contract. You can use the
AdminClient to follow this approach:

java -classpath %AXIS_HOME%/lib/wsdl4j-1.5.1.jar;%AXIS_HOME%/lib/axis.jar;%AXIS_HOME%/lib/commons-discovery-0.2.jar;%AXIS_HOME%/lib/commons-logging-1.0.4.jar;%AXIS_HOME%/lib/saaj.jar;%AXIS_HOME%/lib/jaxrpc.jar org.apache.axis.wsdl.WSDL2Java http://localhost:8080/axis/services/HelloWorld?wsdl

This will generate the following classes under the service namespace which is localhost\axis\services\HelloWorld

HelloWorld.java
HelloWorldService.java
HelloWorldServiceLocator.java
HelloWorldSoapBindingStub.java

Tomcat maxThreads configuration

2009-01-19T05:57:00.000-08:00

Tomcat maxThreads represents the maximum number of request
processing threads to be created by the HTTPConnector.


<Connector port="8080" address="localhost"     
     maxThreads="250" maxHttpHeaderSize="8192"
     emptySessionPath="true" protocol="HTTP/1.1"
     enableLookups="false" redirectPort="8443" acceptCount="100"
     connectionTimeout="20000" disableUploadTimeout="true" />

This determines the maximum number of simultaneous requests that can be handled. If not specified, this attribute is set to the default value of 200.

How the process works:

At server startup, the HTTP Connector will create a number of processing threads based on the value configured for the minSpareThreads attribute.
Each incoming request requires a thread for the duration of that request.
If the number of simultaneous requests cannot be handled by the currently available request processing threads, additional threads will be created up to the configured maximum (the value of the maxThreads attribute).
If still more simultaneous requests are received, they are stacked up up to the configured maximum (the value of the acceptCount attribute).
Any further simultaneous requests will receive "connection refused" errors, until resources are available to process them.

Guidelines for maxThreads:

maxThreads is an important tuning parameter, however if you are reaching an error like:

org.apache.tomcat.util.threads.ThreadPool logFull SEVERE: All threads (150) are
currently busy, waiting. Increase maxThreads (150) or check the servlet status

you should at first investigate if it's rather a problem of individual requests taking too long: are your threads returning to the pool? if, for example, database connections are not released, threads pile up waiting to obtain a database connection thereby making it impossible to process additional requests. This is a problem in your webapp.

Take a thread dump to find out where they're stuck. Increasing too much maxThreads will lead to :

Consume a good chunk of memory.
Your system will spend too much time context switching

So once you have already optimized your application try raising you maxThread attribute up to 500-750. I wouldn't advice to create larger Connectors, rather if 750 Connections are not enough create a Cluster configuration with several Tomcat instances. For example 2 instances of tomcat each one with maxThreads=500 instead of a single Tomcat with maxThreads=1000

If you want to learn more about JDK tuning read this tutorial which contains many tips valid also for tomcat:

http://www.mastertheboss.com/en/jboss-application-server/113-jboss-performance-tuning-1.html

Tomcat context listener example

2009-01-14T02:41:00.000-08:00

When a web application is deployed a servlet context object, ServletContext, is created and associated with the web application. There is a one-to-one relationship between a servlet context object and the web application. All resources within the web application, such as servlets and JSPs, can retrieve any information stored in the servlet context.
');

As a web application programmer, you may want to initialize objects and place them in the servlet context when it is created and destroy the objects when the servlet context is destroyed.

For example, you may decide to create a connection to a database when the servlet context is created and close the connection when the servlet context is destroyed.

To write an application lifecycle event listener that executes when the servlet context is created and destroyed, write a Java class that implements the javax.Servlet.ServletContextListener class.

This class has two methods with the following signatures (taken from the JavaDocs):

void contextDestroyed (ServletContextEvent sce) Notification that the Servlet context is about to be shut down.
void contextInitialized (ServletContextEvent sce) Notification that the Web Application is ready to process requests

The Servlet 2.3 specification allows for more interaction between the web application programmer and ServletContext. The programmer can now write an application lifecycle event listener that executes when the attributes of the ServletContext object have been modified.

If you want to execute some code when the attributes of the ServletContext object has been modified, write a Java class that implements the javax.Servlet.ServletContextAttributesListener interface. This interface defines three methods with the following signatures (this is taken from the JavaDocs):
');

void attributeAdded (ServletContextAttributeEvent scab) Notification that a new attribute was added to the servlet context.
void attributeRemoved (ServletContextAttributeEvent scab) Notification that an existing attribute has been removed from the servlet context.
void attributeReplaced (ServletContextAttributeEvent scab) Notification that an attribute on the servlet context has been replaced.

Here's a sample class which implements both ServletContextListener and ServletContextAttributesListener :


import javax.servlet.ServletContext;
import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;


public class ServletContextAttribListener
    implements ServletContextAttributeListener,ServletContextListener  {

  private ServletContext context = null;

  //This method is invoked when an attribute
  //is added to the ServletContext object
  public void attributeAdded (ServletContextAttributeEvent scab)
  {
    System.out.println("An attribute was added to the " +
      "ServletContext object");
  }

  //This method is invoked when an attribute
  //is removed from the ServletContext object
  public void attributeRemoved (ServletContextAttributeEvent scab)
  {
    System.out.println("An attribute was removed from " +
      "the ServletContext object");
  }

  //This method is invoked when an attribute
  //is replaced in the ServletContext object
  public void attributeReplaced (ServletContextAttributeEvent scab)
  {
    System.out.println("An attribute was replaced in the " +
      "ServletContext object");
  }


public void contextDestroyed(ServletContextEvent event)
  {

    //Output a simple message to the server's console
    System.out.println("The Simple Web App. Has Been Removed");
    this.context = null;

  }


  //This method is invoked when the Web Application
  //is ready to service requests

  public void contextInitialized(ServletContextEvent event)
  {
    this.context = event.getServletContext();

    //Output a simple message to the server's console
    System.out.println("The Simple Web App. Is Ready");

  }

}

Tomcat session listener example

2009-01-13T05:17:00.000-08:00

As part of Servlet 2.3 specification, we can now make use of session creation and destruction events. Our listener object will be called every time a session is created or destroyed by the server.

You can use two interfaces as listener for your Session:

HttpSessionListener triggers the listener when a new session is created or destroyed
HttpSessionBindingListener triggers the listener when an Object is bound/unbound from the Session

HttpSessionListener example:

package com.sample;

import javax.servlet.http.HttpSessionListener;
import javax.servlet.http.HttpSessionEvent;

public class SessionCounter implements HttpSessionListener {

private static int activeSessions = 0;

public void sessionCreated(HttpSessionEvent se) {
activeSessions++;
}

public void sessionDestroyed(HttpSessionEvent se) {

if(activeSessions > 0)
activeSessions--;
}

public static int getActiveSessions() {
return activeSessions;
}

}

As you can see, all you have to do is implementing two methods: sessionCreated() method
will be called by the server every time a session is created and sessionDestroyed() method will be called every time a session is invalidated or destroyed.

In order to activate the listener, you have to configure it in your web.xml

<listener>
<listener-class>
com.sample.SessionCounter
</listener-class>
</listener>

HttpSessionBindingListener example :


import java.sql.*;
import javax.servlet.http.*;

public class JDBCQueryBean implements HttpSessionBindingListener
{
  public void JDBCQueryBean() {   }

  private Connection conn = null;

  private void runQuery() {
    StringBuffer sb = new StringBuffer();
    Statement stmt = null;
    ResultSet rset = null;
    try {
      if (conn == null) {
        DriverManager.registerDriver(new .OracleDriver());
        conn = DriverManager.getConnection("jdbc:oracle:oci8:@",
                                           "scott", "tiger");

      }
   
      stmt = conn.createStatement();
      rset = stmt.executeQuery ("SELECT * from ....");
  
    } catch (SQLException e) {
       e.printStackTrace();
  }
    finally {
      try {
        if (rset != null) rset.close();
        if (stmt != null) stmt.close();
      }
      catch (SQLException ignored) {}
    }
  }

  public void valueBound(HttpSessionBindingEvent event) {
    // do nothing -- the session-scoped bean is already bound
  }

  public synchronized void valueUnbound(HttpSessionBindingEvent event) {
    try {
      if (conn != null) conn.close();
    }
    catch (SQLException ignored) {}
  }
}

This is a sample code for JDBCQueryBean, a JavaBean that implements the HttpSessionBindingListener interface. The Connection object is bound into the Session and the listener takes care to close the connection as soon as the Session expires.

Tomcat web xml reference

2009-01-08T07:03:00.000-08:00

According to the Servlet 2.4 specification, every Web application should include a deployment descriptor (web.xml file). This file must be placed in the WEB-INF/ directory of the Web application.

There is also a web.xml file under the $CATALINA_HOME/conf directory. This file is similar to a Web application’s web.xml file. However, this particular web.xml file is used to specify the default properties for all Web applications that are running within this server instance.

Be very careful when making modifications to this file (such as any additions or changes) because they will affect all Web applications running on the same server instance. Note also that other application servers may or may not support a global default web.xml, as this is not a requirement for Servlet 2.4 standard compliance.

Web.xml can be formally validated against a schema:

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-app_2_4.xsd"
version="2.4">

</web-app>

How to add a new Servlet mapping ?

<servlet>
<servlet-name>TestServlet</servlet-name>
<servlet-class>sample.TestServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>TestServlet</servlet-name>
<url-pattern>/sample</url-pattern>
</servlet-mapping>

How to add a parameter to your Context ?

<context-param>
<param-name>username</param-name>
<param-value>frank</param-value>
<description>parameter description</description>
</context-param>

String username = getServletContext().getInitParameter("username");
How to flag a web application as clusterable ?

<distributable/>

How to add an EJB reference in your web.xml ?

<ejb-ref>
<description>Sample EJB</description>
<ejb-ref-name>SampleBean</ejb-ref-name>
<ejb-ref-type>Session</ejb-ref-type>
<home>com.SampleHome</home>
<remote>com.Sample</remote>
</ejb-ref>

How to add a reference to an environment variable ?

<env-entry>
<env-entry-name>envVar</env-entry-name>
<env-entry-type>java.lang.Integer</env-entry-type>
<env-entry-value>15</env-entry-value>
</env-entry>

How to direct errors to error pages ?

<error-page>
<error-code>404</error-code>
<location>/myApp/jsp/notFound.jsp</location>
</error-page>

How to add a filter to your web.xml ?

<filter>
<filter-name>Compression Filter</filter-name>
<filter-class>compressionFilters.CompressionFilter</filter-class>
<init-param>
<param-name>compressionThreshold</param-name>
<param-value>10</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>Compression Filter</filter-name>
<url-pattern>/CompressionTest</url-pattern>
</filter-mapping>

How to reference a tag lib ?

<jsp-config>
<taglib>
<taglib-uri>http://jakarta.apache.org/tomcat/examples-taglib</taglib-uri>
<taglib-location>/WEB-INF/jsp/example-taglib.tld</taglib-location>
</taglib>
</jsp-config>

How to add a Context/Session listener ?

<listener>
<listener-class>listeners.ContextListener</listener-class>
</listener>
<listener>
<listener-class>listeners.SessionListener</listener-class>
</listener>

Here's an example how to use SessionListeners:

http://tomcat-configure.blogspot.com/2009/01/tomcat-session-listener-example.html

Here's an example how to use ContextListeners:

http://tomcat-configure.blogspot.com/2009/01/tomcat-context-listener-example.html

How to secure your application with JAAS ?

<login-config>
<auth-method>FORM</auth-method>
<realm-name>Example Form-Based Authentication Area</realm-name>
<form-login-config>
<form-login-page>/security/protected/login.jsp</form-login-page>
<form-error-page>/security/protected/error.jsp</form-error-page>
</form-login-config>
</login-config>

<security-constraint>
<display-name>Example Security Constraint</display-name>
<web-resource-collection>
<web-resource-name>Protected Area</web-resource-name>

<url-pattern>/security/protected/*</url-pattern>

<http-method>DELETE</http-method>
<http-method>GET</http-method>
<http-method>POST</http-method>
<http-method>PUT</http-method>

</web-resource-collection>
<auth-constraint>

<role-name>tomcat</role-name>
<role-name>role1</role-name>
</auth-constraint>
</security-constraint>

<security-role>
<role-name>role1</role-name>
</security-role>
<security-role>
<role-name>tomcat</role-name>
</security-role>

How to add a MIME mapping to your web.xml ?

<mime-mapping>
<extension>pdf</extension>
<mime-type>application/pdf</mime-type>
</mime-mapping>

How to add a reference to a Datasource ?


<resource-ref>
<description>The default JDBC datasource</description>
<res-ref-name>jdbc/DefaultDS</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>

How to configure the session timeout ?

<session-config>
<session-timeout>30</session-timeout>
</session-config>

How to add a welcome file list ?

<welcome-file-list>
<welcome-file>index.jsp<welcome-file>
<welcome-file>index.html<welcome-file>
<welcome-file>home.html<welcome-file>
</welcome-file-list>