Using Java Servlets with Apache

Installing the Java 2 Software Development Kit

After you download and save the Linux RPM binaries for Java, you'll see a file with a name ending in .bin. You have to go through an extra step before you can use RPM commands to install this file.

Secret

Sun provides the RPM file wrapped in a shell script. You have to make the file executable by using the chmod +x command. Execute the file (by typing its name on the command line), accept the license agreement, and the script generates a RPM file that you can install.

For example, when I downloaded the Linux RPM distribution of JDK 1.4.0 binaries, the file name was j2sdk-1_4_0_03-linux-i586-rpm.bin (the file was about 39MB in size, so it can take you a while to download unless you have a high-speed Internet connection). I logged in as root and made that file executable by typing:

chmod +x j2sdk*.bin

Then, I executed the file with the following command:

./j2sdk*.bin

That displayed the license agreement, a page at a time, followed by the prompt:

Do you agree to the above license terms? [yes or no]

I typed yes and that started the unpacking and ended with the RPM file:

j2sdk-1_4_0_03-fcs-linux-i586.rpm

Then, I installed the JDK with the following command:

rpm -ivh j2sdk*.rpm

In this case, the JDK is installed in the directory /usr/java/j2sdk1.4.0_03. Therefore, I set the environment variable JAVA_HOME to this directory with the command export JAVA_HOME=/usr/java/j2sdk1.4.0_03.

export JAVA_HOME=/usr/java/j2sdk1.4.0_03
PATH=$JAVA_HOME/bin:$PATH

Installing Apache Tomcat

Download the latest binary for the Release Build of Tomcat. If you have JDK 1.4, you should download the file with a name that ends in -LE-jdk14. That's the lightweight binary that does not include the XML parser-the XML parser is already included in the 1.4.x versions of Java.

To install and test the Tomcat binaries, log in as root and follow these steps:

1. Copy the downloaded Tomcat compressed tar archive to a suitable directory such as /usr/local with the following command:

   mv tomcat-*LE-jdk*.gz /usr/local

2. Unpack with the tar zxvf command in its new location (for example, /usr/local) with the following commands:

   cd /usr/local
   tar zxvf tomcat-*.tar.gz

3. Set the CATALINA_HOME environment variable to the full pathname of the directory where you installed Tomcat. For example, I installed version 4.1.18 of Tomcat in the directory /usr/local/jakarta-tomcat-4.1.18-LE-jdk14, so I define CATALINA_HOME as follows:

   export CATALINA_HOME=/usr/local/jakarta-tomcat-4.1.18-LE-jdk14

   You need the CATALINA_HOME environment variable in the future. Therefore, you should create a file named tomcat.sh in /etc/profile.d directory with the following line in that file:

   export CATALINA_HOME=/usr/local/jakarta-tomcat-4.1.18-LE-jdk14

   Then, whenever you log in, the CATALINA_HOME environment variable would be defined.

4. Start Tomcat with the following commands

   cd $CATALINA_HOME/bin
   ./startup.sh
   

5. To see if Tomcat is working, start a Web browser on your system or another system on the LAN. Point the browser to your system at port 8080 by using the following URL:

   http://localhost:8080/examples

   If Tomcat is up and running, you should see three directories named images, jsp, and servlets. Browse through the jsp and servlets directories and try out the JSP and servlet examples.

6. Shut down Tomcat with the following command:

   cd $CATALINA_HOME/bin
   ./shutdown.sh

Now, you can proceed to install the Apache httpd source files and then go on to build the mod_jk connector module.

Installing the Apache httpd Source RPMs

To build mod_jk from source files, you also need the Apache httpd source files. You can download the source files in the form of an RPM from one of the sites listed in http://www.redhat.com/download/mirror.html. Click one of the Distribution links, and then click the folder for the Red Hat Linux version (for example, 8.0). You will find the source RPMs in the SRPMS folder corresponding to your language (en for English) and processor architecture (i386 for Intel). For example, for Red Hat Linux 8.0, I found the source RPM for Apache httpd 2.0.40 in the 8.0/en/os/i386/SRPMS directory of the download site.

The source RPM is about 4.5MB in size. Download it and use the following command to install on your Red Hat Linux system:

rpm -ivh httpd-*.rpm

After you install the RPM, you find a compressed tar file, as well as several other files, in the /usr/src/redhat/SOURCES directory. For example, for Apache 2.0.40, the source archive is named httpd-2.0.40.tar.gz.

Unpack the file with the following command:

tar zxvf httpd-2.0.40.tar.gz

This creates a subdirectory named httpd-2.0.40 and places the Apache httpd source files, organized into further subdirectories. Type the following commands to configure the Apache httpd directory:

cd httpd-2.0.40
./configure

That's all you have to do. To build mod_jk, all you need is the full pathname of the directory where the Apache httpd source files are located. For example, in my case, the directory name is

/usr/src/redhat/SOURCES/httpd-2.0.40

Building the mod_jk Module

You have to download and build the mod_jk module (also referred to as JK) before you can use Tomcat with the Apache httpd server. Point your Web browser to http:// jakarta.apache.org/builds/jakarta-tomcat-connectors/jk/release/ and download the latest source files for JK. For example, for version 1.2.2 of JK, the source file is at http://jakarta.apache.org/builds/jakarta-tomcat-connectors/jk/release/ v1.2.2/src/. From this location, I downloaded jakarta-tomcat-connectors-jk-1.2.2-src.tar.gz, which is about 559K in size.

After downloading the source archive, follow these steps to build the mod_jk.so file:

1. Log in as root and copy the file to a suitable directory. I moved it to /usr/local directory with the command:

   mv jakarta-tomcat-connectors-jk-1.2.2-src.tar.gz /usr/local

2. Unpack the file in the /usr/local directory by typing commands such as the following:

   cd /usr/local
   tar zxvf jakarta-tomcat-connectors-jk-1.2.2-src.tar.gz

   The files are now in /usr/local/jakarta-tomcat-connectors-jk-1.2.2-src directory.

3. Type the following commands:

   cd jakarta-tomcat-connectors*
   cd jk/native
   ./buildconf.sh 

   This will create a file called configure in that directory.

4. Run the configure file with the following command:

   ./configure --with-java-home=${JAVA_HOME} --with-apache=/usr/src/redhat/SOURCES/httpd-2.0.40

5. Type the following commands to build mod_jk.so module:

   make
   cd apache-2.0
   make mod_jk.so

6. Type the following command to copy the module to the location where all Apache httpd modules are stored:

   cp mod_jk.so /usr/lib/httpd/modules

Now, all you have to do is configure Apache httpd, Tomcat, and mod_jk to complete the connection between Apache httpd and Tomcat.

Connecting Apache httpd Server to Tomcat

The first step is to configure Tomcat. Edit the server.xml file located in the $CATALINA_HOME/conf directory (you should define the CATALINA_HOME environment variable as the directory where Tomcat is installed). Make the following changes in $CATALINA_HOME/conf/server.xml:

• Look for a line that begins with <Server port="8005". Add the following directly below that line:

  <Listener className="org.apache.ajp.tomcat4.config.ApacheConfig" modJk="/usr/lib/httpd/modules/mod_jk.so" /> 

  Make sure that the last pathname matches the directory where you have placed the mod_jk.so file.

• Locate the line that starts with <Host name="localhost". Add the following immediately after this line:

  <Listener className="org.apache.ajp.tomcat4.config.ApacheConfig" append="true" forwardAll="false" modJk="/usr/lib/httpd/modules/mod_jk.so" /> 

  Make sure that the last pathname matches the directory where you have placed the mod_jk.so file.

• Change the name parameter in the <Host name="localhost" line from localhost to whatever name you have used in the ServerName directive in the Apache httpd.conf file.

Next, edit the Apache httpd configuration file-/etc/httpd/conf/httpd.conf-as follows:

• Make sure that the name specified with the ServerName directive matches the name used in the <Host name= line in Tomcat's server.xml file.

• At the very end of the configuration file, add the following line:

  Include /usr/local/jakarta-tomcat-4.1.18-LE-jdk14/conf/auto/mod_jk.conf

  Make sure that the first part of the directory name-/usr/local/jakarta- tomcat-4.1.18-LE-jdk14-matches the definition of the CATALINA_HOME environment variable (the directory where you installed Tomcat).

  Insider Insight

  Everytime Tomcat starts, it creates the mod_jk.conf file referenced in the last line in httpd.conf file. Thus, the configuration of mod_jk module is all done automatically.

The final configuration step is to create the workers.properties file in the $CATALINA_HOME/conf/jk directory (if the directory does not exist, first create it). Here's an example of that file from my installation (the comments tell you what you have to change):

# workers.tomcat_home should point to the location where you
# installed Tomcat. Change as necessary.
workers.tomcat_home=/usr/local/jakarta-tomcat-4.1.18-LE-jdk14

# workers.java_home should point to your Java installation. Change
# as needed.
workers.java_home=/usr/java/j2sdk1.4.0_03
ps=/
# Workers to be created
worker.list=ajp13
#
# Define a worker named ajp13 and of type ajp13.
# Note that the name and the type do not have to match.
#
worker.ajp13.port=8009
# Make sure the hostname matches what's in ServerName (httpd.conf)
# and Host name (server.xml). Change if necessary.
worker.ajp13.host=localhost
worker.ajp13.type=ajp13

Testing Apache httpd with Tomcat

To test whether Apache httpd is working with Tomcat, perform the following steps:

1. Log in as root and start Tomcat with the following command:

   cd $CATALINA_HOME/bin
   ./startup.sh

2. Wait 10 seconds or so for Tomcat to start up.

3. Start Apache httpd with the following command:

   service httpd start

4. Open a Web browser on the same system and point the Web browser to the URL http://localhost:8080/examples. You should see the jsp and servlets directory and be able to execute the examples. This shows that Tomcat is working correctly.

5. Now, type the following URL in the Web browser:

   http://localhost/examples

   You should again see the same directories as you did when you connected to port 8080. This shows that Apache httpd is correctly handing over the JSP and servlet requests to Tomcat.