|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface Context
The Context
interface is used to give a view of the
file system to the ResourceEngine
. This provides the
information to the ResourceEngine
that it needs in
order to serve content to the client browser. This provides the
path translations for the HTTP request URI. This also provides
the Format
object that is used to create directory
listings and error messages.
This object essentially provides a mechanism that allows the file
engine to convert the HTTP request URI into OS system paths and
system objects such as the File
object. A context
is rooted a a certain directory in the system. This directory is
where the resources are gathered from. For example suppose that
a Context
implementation is rooted at the directory
"c:\web\html\" on a DOS system. Now if the target of the browser
was "http://some.host/web/pub/README". The context needs to be
consulted to convert "/web/pub/README" into the real path within
the system. So Context.getRealPath
is invoked with
the path "/web/pub/README", which responds with the system path
"c:\web\html\web\pub\README". Also if this was a UNIX system
with the same context rooted at "/home/user/html" then the same
URL would result in "/home/user/html/web/pub/README".
The meaning of HTTP URI in this instance is the request URI from a HTTP/x.x request, as RFC 2616 and RFC 2396 defines it
Request-Line = Method SP Request-URI SP HTTP-Version CRLF Request-URI = "*" | absoluteURI | abs_path | authority absoluteURI = "http:" "//" host [":" port] [abs_path ["?" query]] abs_path = "/" path_segments path_segments = segment *( "/" segment )So the
Context
object must be prepared to accept
the request URI that come in the form outlined above. These can
include formats like
http://some.host/pub;param=value/bin/index.html?name=value http://some.host:8080/index.en_US.html some.host:8080/index.html /usr/bin;param=value/README.txt /usr/bin/compress.tar.gzThe
Context
implementation should be able to
directly take a Request-URI as defined in RFC 2616 and translate
this into a path compatible with the OS specific file system.
This keeps the objects semantics simple and explicit, although
at the expense of performance.
URIParser
,
PathParser
Method Summary | |
---|---|
java.lang.String |
getBasePath()
This is used to retrieve the base path of the context. |
Content |
getContent(java.lang.String target)
This enables the contents of some resource to be acquired using a request URI. |
java.lang.String |
getContentType(java.lang.String target)
This method will extract the type attribute of this URI. |
java.io.File |
getDirectory(java.lang.String target)
This is used to translate the HTTP request URI into the File object that it represent the parent directory
of the URI. |
java.io.File |
getFile(java.lang.String target)
This is used to translate the HTTP request URI into the File object that it represents. |
Format |
getFormat()
Each Context object must be coupled with an instance
of the Format object. |
Index |
getIndex(java.lang.String target)
This is an all in one method that allows all the information on the target URI to be gathered at once. |
java.util.Locale |
getLocale(java.lang.String target)
This will parse the HTTP request URI specified and return the Locale for that resource. |
Locator |
getLocator()
Each Context must supply a Locator to
enable the system to locate configuration information and other
resources that reside outside the context path. |
java.lang.String |
getName(java.lang.String target)
This will parse and return the file name that this request URI references. |
Path |
getPath(java.lang.String target)
This is used to translate the HTTP request URI into the Path object that it represents. |
java.util.Properties |
getProperties(java.lang.String target)
This provides a convenient way for a Java properties file to be loaded. |
java.lang.String |
getRealPath(java.lang.String target)
This is used to translate the HTTP request URI into the OS specific path that it represents. |
java.lang.String |
getRequestPath(java.lang.String target)
This is used to translate the HTTP request URI into the URI path normalized and without query or parameter parts. |
Method Detail |
---|
java.lang.String getBasePath()
ResourceEngine
to map the URIs
onto the specific OS. The base path is the OS file system
specific path. So on UNIX it could be "/home/user/" and
on a DOS system it could be "c:\web\html" for example.
java.lang.String getRealPath(java.lang.String target)
target
- this is the HTTP request URI path that is to
be translated into the OS specific path
java.lang.String getRequestPath(java.lang.String target)
target
- this is the HTTP request URI that is to be
converted into a normalized relative URI path
Path getPath(java.lang.String target)
Path
object that it represents. This enables the
HTTP request URI to be examined thoroughly an allows various
other files to be examined relative to it. For example if the
URI referenced a path "/usr/bin/file" and some resource
in the same directory is required then the Path
can be used to acquire the relative path. This is useful if
links within a HTML page are to be dynamically generated. The
Path.getRelative
provides this functionality.
target
- this is the HTTP request URI path that is used
to retrieve the Path
object
Path
for the given pathjava.io.File getFile(java.lang.String target)
File
object that it represents. This will convert
the URI to a format that the system can use and then create
the File
object for that path. So if for example
the context path was "c:\path" on a DOS system and the HTTP
URI given was "/index.html" this returns the File
"c:\path\index.html". This is basically for convenience as the
same could be achieved using the getRealPath
and
then creating the File
from that OS specific path.
target
- this is the HTTP request URI path that is used
to retrieve the File
object
File
for the given pathjava.io.File getDirectory(java.lang.String target)
File
object that it represent the parent directory
of the URI. This will convert the URI to a format that the host
system can use and then create the File
object for
that path. So if for example the context path was "c:\path" on
a DOS system and the HTTP URI given was "/index.html" this
returns the File
"c:\path\". This is basically
for convenience as the same could be achieved using the file
retrieved from getFile
and acquiring the parent.
target
- this is the HTTP request URI path that is used
to retrieve the File
object
File
for the directoryjava.util.Locale getLocale(java.lang.String target)
Locale
for that resource. The Locale
is extracted from the target by examining the path segment of
the HTTP request URI. The path segment is the abs_path token
defined in RFC 2396. It is extracted from a second extension
in the file name. So for example if the HTTP request URI was
"http://some.host/usr;param=value/index.en_US.html" then the
file name "index.en_US.html" would have the second file
extension en_US converted into a Locale
. This
will not interfere if the file name was "compressed.tar.gz",
it will simply ignore the "tar" second file extension and
return Locale.getDefault
.
target
- the request URI to be parsed for its locale
java.lang.String getContentType(java.lang.String target)
Context
is the last path
segment is the token defined by RFC 2396 as path_segments. So
for example if the target was "some.host:8080/bin/index.html"
then the name for that resource would be "index.html". Once
the name has been extracted the MIME is defined by the file
extension which, for the example is text/html.
Implementations of the Context
may also choose to
implement a method that consults the underlying resource and
inspect its contents to determine its MIME type. Or for a MAC
it may contain its MIME type. If the MIME type cannot be found
by any of the above methods RFC 2616 suggests that the resource
be given the MIME type application/octetstream. This should also
make not predictions as to how the file will be served. So if
the target references a directory this does not mean that the
Format.getContentType
can be used.
target
- the request URI to be parsed for its type
java.lang.String getName(java.lang.String target)
Context
is the last
path segment is the token defined by RFC 2396 as path_segments.
So for example if the target was "some.host:8080/home/user/"
then the name for that resource would be "user". If the path
references the root path "/" then null should be returned.
target
- the request URI to be parsed for its name
Index getIndex(java.lang.String target)
ResourceEngine
when the Context
implementation is synchronized.
This will enable the ResourceEngine
to gather the
information on the target by acquiring the lock for the object
instance only once.
target
- this is the request URI that is to be parsedContent getContent(java.lang.String target) throws java.io.IOException
Content
is a resource that can
be transmitted using an OutputStream
which avoids
having to deal with FileInputStream
objects for
files and also facilitates dynamic content. The purpose of this
is to discourage the use of chaining which does not result
in transferring control, that is, avoid the Java Servlet include
technique used by javax.servlet.RequestDispatcher
.
target
- the request URI that refers to a resource
Content
interface
java.io.IOException
- this is thrown if the resource does not
exist or cannot be accessedjava.util.Properties getProperties(java.lang.String target) throws java.io.IOException
getFile
method would return. Once the file has been acquired the Java
properties file is loaded, each time, there is no caching of
the loaded properties. This ensures that changes to a loaded
object does not affect other users of the properties file.
target
- the request URI that refers to the properties
Properties
object
using the specified Java properties file
java.io.IOException
- this is thrown if the resource does not
exist or cannot be accessedLocator getLocator()
Context
must supply a Locator
to
enable the system to locate configuration information and other
resources that reside outside the context path. This is useful
when there are Java properties and XML configuration files
required by objects interacting with a Context
.
The Locator
employs a search to locate resources,
which are identified either by name or using aliases.
Format getFormat()
Context
object must be coupled with an instance
of the Format
object. This is required because each
ResourceEngine
needs to serve the directory listing
and the error messages in a consistent format. The resources of
the instances can thus be pooled by comparing the equality of the
various Context
objects. When there is an object that
requires a ResourceEngine
it can create an instance
of the Context
and using a static factory method
ResourceEngine
with the context object there is a
search for an active instance of the ResourceEngine
.
If one is found that uses a similar context object then it is
returned to the caller. This enables instances and thus resources
to be shared transparently.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |