Tomcat Vs Weblogic .. jsp/html file path issue..

Question

Tomcat gurus, please help !!!
Development Env. :
OS: Window NT 4.0 SP6
Web Server: Tomcat 4.1.12
Sun JDK 1.3.1
IDE : Eclipse 2.1
Deployment/Testing/Prod Env:
OS: Sun Solaris 2.8
Web Server: Weblogic 5.1 SP 12
Sun JDK 1.3.1 IDE : N/A
Confession: New to Tomcat world.
Note: Reason why I'm using Tomcat for development though I can use Weblogic, Eclipse IDE with Tomcat plugin provides debuging functionality, thus the problem. I have an enterprise application being built and kind of stepped into a problem. I have a Servlet that marshals all the calls and process them through java beans ( about 50+ ) and content displayed through JSPs.
Here is the directory structure,
/AppContext
| +- src
| +- com.xyz.wfservices
+- jsp
main.jsp
+- WEB-INF
|
+ classes
+ com.xyz.wfservices ( compiled classes )
For Weblogic: It has 2 parameters to specify where the compiled code is and where the docs are,
=> weblogic.httpd.servlet.classpath=c:/wfservices/WEB-INF/classes
=> weblogic.httpd.documentRoot= c:/wfservices/src/html
and to register instance,
weblogic.httpd.register.WfServices=com.xyz.wfservices.WfSvcsController
weblogic.httpd.initArgs.WfServices=\
     main.properties=c:/wfservices/src/properties/wfservices.properties
But, I looked at Tomcat it is quite different.. it has <Context path="/wfs" docBase="L:\app_services\wfservices" workDir="L:\app_services\wfservices\work" /> Servlet def in web.xml
<servlet>
<servlet-name>WfServices</servlet-name>
<servlet-class>com.xyz.wfservices.WfSvcsController</servlet-class>
<init-param>
<param-name>main.properties</param-name>
<param-value>c:\wfservices\properties\config.properties</param-value>
</init-param>
     <servlet-mapping>
          <servlet-name>WfServices</servlet-name>
          <url-pattern>/WfServices</url-pattern>
     </servlet-mapping>
</servlet>
Probem: Accessing JSP/Html ... documents. weblogic accessing / calling jsp ..
     rd = req.getRequestDispatcher("/main.jsp");      //req is HttpRequest
     if (rd != null)
          rd.forward(req, resp);
The same does not work under Tomcat because it can find files relative to the context, thus it fails. I have to change the code like below to make it work.
     rd = req.getRequestDispatcher("/src/jsp/main.jsp");
     if (rd != null)
          rd.forward(req, resp);
It is a nightmare now to maintain two different environments and more over changing all the references and and its internal references is not feasible. The question is, is there a way to configure docBase in tomcat so that I won't need a code change.
Any help or inputs are greatly appreciated.
Thanks
Meher

Answer 1

I ran into this same problem before, so I created a utility class that would map out a URI or URL given a relative path. It's nice because it will detect and include non-standard ports for both the HTTP and HTTPS protocols. If you access a servlet/jsp using HTTP, it will return a URL for the HTTP protocol and the same for HTTPS. So, that means you don't need any code changes to access things through HTTP or HTTPS :) Here it is, hope it helps you out:
import javax.servlet.*;
import javax.servlet.http.*;
public class ContextMapper
    private static final int HTTP_PORT = 80;
    private static final int HTTPS_PORT = 443;
     * This method will return a URI to access a resource given its relative
     * path.  Please note that the relative path should start in the directory
     * where the web application is deployed to.
     * @param HttpServletRequest request
     * @param HttpServletResponse response
     * @param String relativePath
     * @return String
    public static String getUri (HttpServletRequest request, HttpServletResponse response, String relativePath)
        return request.getContextPath() + relativePath;
     * This method will return a URL to access a resource given its relative
     * path.  Please note that the relative path should start in the directory
     * where the web application is deployed to.  Also, the protocol will be
     * automatically detected from the request.  Supported protocols include
     * HTTP and HTTPS.  For all other protocols, the relative path will be
     * returned unmodified.
     * @param HttpServletRequest request
     * @param HttpServletResponse response
     * @param String relativePath
     * @return String
    public static String getUrl (HttpServletRequest request, HttpServletResponse response, String relativePath)
        if (request.getProtocol().startsWith("HTTP/") == true)
            switch (request.getServerPort())
                case HTTP_PORT:
                    return "http://" + request.getServerName() + request.getContextPath() + relativePath;
                default:
                    return "http://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + relativePath;
        else if (request.getProtocol().startsWith("HTTPS/") == true)
            switch (request.getServerPort())
                case HTTPS_PORT:
                    return "https://" + request.getServerName() + request.getContextPath() + relativePath;
                default:
                    return "https://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + relativePath;
        else
            return relativePath;
}Here are a few examples of using this class:
String uri = ContextMapper.getUri(request, response, "/css/basic.css");
String url = ContextMapper.getUrl(request, response, "/css/basic.css");
String uri = ContextMapper.getUri(request, response, "/images/image.gif");
String url = ContextMapper.getUrl(request, response, "/images/image.gif");
String uri = ContextMapper.getUri(request, response, "/jsp/HelloWorld.jsp");
String url = ContextMapper.getUrl(request, response, "/jsp/HelloWorld.jsp");
String uri = ContextMapper.getUri(request, response, "/servlet/HelloWorld");
String url = ContextMapper.getUrl(request, response, "/servlet/HelloWorld");