by October 9, 2006 0 comments

This time we are not going to talk about integrating two frameworks of the
same language or platform. We’ll take you through a different path altogether.
As we have been saying earlier, more often than not you might find yourself
working with different technologies. Reasons may vary from adding a module to
your Web application or simply deploying an application that has been built by
teams working with two different technologies as per their skill set.

So this time , we look into different techniques involved in case you are
deploying a Web application with both PHP and JSP pages. Integration between
different Java based frameworks has become easier as frameworks now provide
built-in support for this. Such kind of an integration has become a necessity
thanks to the ‘Frameworkitis’ that Java language seems to be suffering from.
But you are on a different path altogether when it comes to integrating
technologies different from each other. Much like what we are talking about

Web app developers
Configuring different servers to work for the same application
PHP, JSP, integration

Three different approaches
You can get the desired integration in three different ways in case of PHP and
JSP pages in the same Web application. The first is to make Tomcat the default
request handler and to allow PHP requests to be passed to the Apache HTTP

The second is the reverse of the first, where you make Apache HTTP server the
default request processor while passing JSP, Servlet requests to Tomcat. And the
third, actually the simplest of them all, is allowing Tomcat to natively handle
PHP pages as well. However, the last solution is not so recommended as Apache
provides better container and security when it comes to PHP/CGI pages in
comparison to Tomcat’s capabilities regarding the same.

We’ll take up the first option in this article. And we would like to
clarify that this article is not about the coding that needs to be done in such
a process. Rather we talk about how the respective servers need to be configured
for achieving our goal. We used Apache 2.2 and Tomcat 5.5 for this exercise.

Configuring connectors
The first step involved in our approach is to configure Tomcat with Apache. The
Apache Software Foundation ships the mod_jk and mod_jk2 connectors for this
purpose. It is recommended not to use the latter, as no modifications have been
made to it since 2004 and its current status stands ‘deprecated.’

Tomcat Server is the default handler with Apache Web Server Works for intercepting only the native requests viz. PHP and CGI pages

You can download the latest, stable binary release from the URL
http://tomcat. After you have installed both
Apache and Tomcat correctly and defined the environment variables viz. JAVA_HOME,
TOMCAT_ HOME, proceed with configuration of the connectors to make these two
talk to each other. The procedure differs with the versions of servers being
used. For a combination of Apache 1.3 and Tomcat 4.x, first of all you need to
tell the Tomcat server that it has to listen to AJP 1.3 requests, the protocol
used for these communications. Add the following entries to your server.xml file
for this:

<Connector className="org.apache.ajp.tomcat4.
port="8009" minProcessors="5"
acceptCount="10" debug="0"/>

In case of Apache 2.x and Tomcat 5.x this is not required as the connector
definition is provided by default. The port attribute specifies the port to
which Tomcat needs to listen to for the AJP 1.3 protocol, whereas ‘className’
specifies that the requests are to be processed by the connector class
AJP13Connector. Next, configure the Apache server which is a bit tedious though
not overly complicated.

Create a Tomcat worker that defines the semantics of communication with
Tomcat to the Apache server we will be using. You can simply copy the sample file of the connector from the <connector-home>\conf
directory to <TOMCAT_HOME>\conf directory.
A few sample lines of the worker file are as follows:


After this you need to copy the downloaded mod_jk connector to the <APACHE_HOME>\libexec
directory and edit the httpd.conf file as follows:

LoadModule mod_jk libexec\<mod-jk file>
AddModule mod_jk.c

In case of Apache 2.x and Tomcat 5.x the steps are different and simpler. You
can build the mod_jk module by compiling it using Visual C++ 6.0 and pasting the
compiled file in the ‘module’ directory of your Apache Server. The syntax of
the ‘LoadModule’ only changes with respect to the path being specified. Also
it is better to create an ‘APACHE_HOME’ variable in this case, which points
to the home directory of your Apache 2.x installation.

Final steps
Simply create a Virtual Host for specifying the Tomcat server to not handle the
PHP requests, by editing the httpd.conf file of Apache server as follows:

<VirtualHost *:80>
DocumentRoot www/webappps/ROOT
SetEnvIf Rquest_URI /.php no_jk
SetEnvIf Rquest_URI /.cgi no_jk
JKMount pcqWorker

It’s a simple solution for making things work. While deploying the
application on Tomcat you can keep the PHP pages directly under the root
directory or specify a sub-directory that contains the PHP pages of your
application. It uses the same resources and scripts, be it style—sheets or
JavaScripts, as used by PHP and JSP in your Web application.

No Comments so far

Jump into a conversation

No Comments Yet!

You can be the one to start a conversation.