Using Java Servlets with Apache

Servlets are Java programs that execute in a Web server in response to requests from a Web browser. Servlets are more powerful than CGI programs commonly used as gateways between Web servers and other services such as databases. One drawback of CGI programs is that the Web server has to start a new process to run a standalone CGI program whenever the server receives data from an HTML form.

Servlets provide functionality similar to that of CGI programs, but servlets avoid the overhead of new process startup. Typically, the Web server runs a Java Virtual Machine (JVM), and that JVM, in turn, loads and runs the servlets. The JVM runs a servlet in a Java thread, which is faster and requires fewer operating system resources than a new process. Additionally, the JVM can keep a servlet loaded and running so that a single instance can handle many future requests. This makes servlets more responsive than other CGI programs, especially ones written in scripting languages such as Perl. At the same time, servlets are portable to any system that supports Java, just as Perl CGI programs can run on any system with a Perl interpreter.

Many websites already use servlets extensively. While browsing the Web, you may have accessed some servlets without even realizing it. A giveaway that the Web server is using a servlet is the occurrence of /servlet/ in the URL (in the same way that /cgi-bin/ commonly appears in URLs that refer to CGI programs).

Many websites use another Java-based approach to generate dynamic content. That approach is based on what is known as JavaServer Pages (JSP) technology. A Web page based on JSP uses XML tags and Java scripts along with other HTML tags. Typically, a JSP page has the .jsp file extension, which tells the Web server that the page should be processed by a server that understands JSP.

If you want to support Java servlets and JSP on your Apache Web server, you have to download and install the following software on your CentOS Linux system, in the order shown:

Java Development Kit (JDK) release (version 1.2 or later)-For writing Java servlets. Download the binary distribution for Linux from http://java.sun .com/j2se/downloads.html. You can download the RPM distribution, which is easy to install with the rpm command (after an additional step of unpacking). After installing JDK, set the environment variable JAVA_HOME to the pathname of the directory where you installed the JDK release.
Apache Tomcat-A server that runs servlets and can execute JSP documents. Tomcat version 5.0 implements the Servlet 2.4 and JSP 2.0 specifications from the Java Community Process (http://www.jcp.org). More information about Tomcat is available from the home page of the Apache Jakarta project at http://jakarta.apache.org/tomcat/. Download the Tomcat binary distribution from http://jakarta.apache.org/site/binindex.cgi. You should download what the Jakarta project calls Release Builds because they are considered ready to use by anyone.
Jakarta-Tomcat-Connector mod_jk-An Apache Web server module that enables the Apache Web server to communicate with Tomcat. Download the latest source files from http://jakarta.apache.org/builds/jakarta-tomcat-connectors/jk/release/. Online information about the jk connector is available at http://jakarta.apache.org/builds/jakarta-tomcat- connectors/jk/doc/.
You also need the Apache httpd source files before you can build the mod_jk module.

The following sections show how to install JDK, Tomcat, the Apache httpd source RPM, and build the mod_jk2 module that connects the Apache Web server to Tomcat.

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.

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.

Insider Insight

To make sure that this definition is available to everyone who use the Bash shell, create a text file named java.sh in /etc/profile.d directory and add the following lines in that file:

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

The /etc/profile script will then read and execute the java.sh script at login and set the JAVA_HOME environment variable and add the JDK binaries to the PATH.

Cross Ref

To learn about Java programming on CentOS Linux, consult Chapter 26.

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:

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
```
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
```
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.
Start Tomcat with the following commands
```
cd $CATALINA_HOME/bin
./startup.sh
```
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.
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 CentOS 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 CentOS 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 CentOS 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:

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
```
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.
Type the following commands:
```
cd jakarta-tomcat-connectors*
cd jk/native
./buildconf.sh 
```
This will create a file called configure in that directory.

Run the configure file with the following command:

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

Type the following commands to build mod_jk.so module:
```
make
cd apache-2.0
make mod_jk.so
```
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:

Log in as root and start Tomcat with the following command:
```
cd $CATALINA_HOME/bin
./startup.sh
```
Wait 10 seconds or so for Tomcat to start up.
Start Apache httpd with the following command:
```
service httpd start
```
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.
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.