tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Craig R. McClanahan" <>
Subject Re: cvs commit: jakarta-tomcat/src/share/org/apache/tomcat/core
Date Fri, 15 Oct 1999 01:54:11 GMT
"Anil K. Vijendran" wrote:

> Ok. Let me understand this better. We're trying to
>   1. change the name from servlet.classpath to org.apache.jasper.classpath,
>   2. it would show in getAttributeNames()
>   3. it wouldn't be modified in setAttribute() -- what is the right thing to
>      do throw an exception? i don't like it. ignore it silently?

I would like to suggest an alternative approach to this (and other analogous
situations that come up in the future).  It's based on a design philosophy I
feel pretty strongly about:  if you are going to pass around private
implementation details, do not use public interface mechanisms.

You can avoid the whole issue of using context attributes at all if you
modified the JSP engine code to do something like this:

    String classpath = null;
    ServletContext context = getServletContext();
    if (context instanceof org.apache.tomcat.core.Context) {
        classpath =
          ((org.apache.tomcat.core.Context) context).getClassPath();
    } else {
        classpath = ...;    // Initialized some other way

With this approach, there are no implementation-specific context attributes to
worry about, so there is no reason to hard code mangling into getAttribute()
and getAttributeNames(), and the intent is perfectly clear.

In Apache JServ, I codified this by taking a slightly different approach
(you'll hear more about this in the future):

* The analogue to Context is an interface not a class.
  It contains only those methods that I felt were important
  in any implementation of the servlet context concept.

* There is an additional interface InternalContext that
  extended Context, and defines the stuff specific to
  this implementation.

* StandardContext is the implementation class and implements
  InternalContext (and therefore Context).

* Other places that dealt with generic Context variables could
  use all the public methods at will.  If they needed to refer to
  implementation-specific stuff, they cast it to InternalContext.

Craig McClanahan

View raw message