KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > jxpath > servlet > JXPathServletContexts


1 /*
2  * Copyright 1999-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.commons.jxpath.servlet;
17
18 import javax.servlet.ServletContext JavaDoc;
19 import javax.servlet.ServletRequest JavaDoc;
20 import javax.servlet.http.HttpServletRequest JavaDoc;
21 import javax.servlet.http.HttpSession JavaDoc;
22 import javax.servlet.jsp.PageContext JavaDoc;
23 import org.apache.commons.jxpath.JXPathContext;
24 import org.apache.commons.jxpath.JXPathContextFactory;
25 import org.apache.commons.jxpath.JXPathIntrospector;
26
27 /**
28  * Static methods that allocate and cache JXPathContexts bound to PageContext,
29  * ServletRequest, HttpSession and ServletContext.
30  * <p>
31  * The JXPathContext returned by {@link #getPageContext getPageContext()}
32  * provides access to all scopes via the PageContext.findAttribute()
33  * method. Thus, an expression like "foo" will first look for the attribute
34  * named "foo" in the "page" context, then the "request" context, then
35  * the "session" one and finally in the "application" context.
36  * <p>
37  * If you need to limit the attibute lookup to just one scope, you can use the
38  * pre-definded variables "page", "request", "session" and "application".
39  * For example, the expression "$session/foo" extracts the value of the
40  * session attribute named "foo".
41  * <p>
42  * Following are some implementation details. There is a separate JXPathContext
43  * for each of the four scopes. These contexts are chained according to the
44  * nesting of the scopes. So, the parent of the "page" JXPathContext is a
45  * "request" JXPathContext, whose parent is a "session" JXPathContext (that is
46  * if there is a session), whose parent is an "application" context.
47  * <p>
48  * The XPath context node for each context is the corresponding object:
49  * PageContext, ServletRequest, HttpSession or ServletContext. This feature can
50  * be used by servlets. A servlet can use one of the methods declared by this
51  * class and work with a specific JXPathContext for any scope.
52  * <p>
53  * Since JXPath chains lookups for variables and extension functions, variables
54  * and extension function declared in the outer scopes are also available in
55  * the inner scopes.
56  * <p>
57  * Each of the four context declares exactly one variable, the value of which
58  * is the corresponding object: PageContext, etc.
59  * <p>
60  * The "session" variable will be undefined if there is no session for this
61  * servlet. JXPath does not automatically create sessions.
62  *
63  * @author Dmitri Plotnikov
64  * @version $Revision: 1.6 $ $Date: 2004/05/08 15:10:49 $
65  */
66 public final class JXPathServletContexts {
67
68     private static JXPathContextFactory factory;
69
70     static {
71         JXPathIntrospector.registerDynamicClass(
72                 PageScopeContext.class,
73                 PageScopeContextHandler.class);
74         JXPathIntrospector.registerDynamicClass(
75                 PageContext JavaDoc.class,
76                 PageContextHandler.class);
77         JXPathIntrospector.registerDynamicClass(
78                 ServletContext JavaDoc.class,
79                 ServletContextHandler.class);
80         JXPathIntrospector.registerDynamicClass(
81                 ServletRequestAndContext.class,
82                 ServletRequestHandler.class);
83         JXPathIntrospector.registerDynamicClass(
84                 HttpSessionAndServletContext.class,
85                 HttpSessionHandler.class);
86         factory = JXPathContextFactory.newInstance();
87     }
88
89     /**
90      * Returns a JXPathContext bound to the "page" scope. Caches that context
91      * within the PageContext itself.
92      */
93     public static JXPathContext getPageContext(PageContext JavaDoc pageContext) {
94         JXPathContext context =
95             (JXPathContext) pageContext.getAttribute(Constants.JXPATH_CONTEXT);
96         if (context == null) {
97             JXPathContext parentContext =
98                 getRequestContext(
99                     pageContext.getRequest(),
100                     pageContext.getServletContext());
101             context = factory.newContext(parentContext, pageContext);
102             context.setVariables(
103                 new KeywordVariables(
104                     Constants.PAGE_SCOPE,
105                     new PageScopeContext(pageContext)));
106             pageContext.setAttribute(Constants.JXPATH_CONTEXT, context);
107         }
108         return context;
109     }
110
111     /**
112      * Returns a JXPathContext bound to the "request" scope. Caches that context
113      * within the request itself.
114      */
115     public static JXPathContext getRequestContext(
116         ServletRequest JavaDoc request,
117         ServletContext JavaDoc servletContext)
118     {
119         JXPathContext context =
120             (JXPathContext) request.getAttribute(Constants.JXPATH_CONTEXT);
121         // If we are in an included JSP or Servlet, the request parameter
122 // will represent the included URL, but the JXPathContext we have
123 // just acquired will represent the outer request.
124 if (context != null) {
125             ServletRequestAndContext handle =
126                 (ServletRequestAndContext) context.getContextBean();
127             if (handle.getServletRequest() == request) {
128                 return context;
129             }
130         }
131         
132         JXPathContext parentContext = null;
133         if (request instanceof HttpServletRequest JavaDoc) {
134             HttpSession JavaDoc session =
135                 ((HttpServletRequest JavaDoc) request).getSession(false);
136             if (session != null) {
137                 parentContext = getSessionContext(session, servletContext);
138             }
139             else {
140                 parentContext = getApplicationContext(servletContext);
141             }
142         }
143         ServletRequestAndContext handle =
144             new ServletRequestAndContext(request, servletContext);
145         context = factory.newContext(parentContext, handle);
146         context.setVariables(
147             new KeywordVariables(Constants.REQUEST_SCOPE, handle));
148         request.setAttribute(Constants.JXPATH_CONTEXT, context);
149         return context;
150     }
151
152     /**
153      * Returns a JXPathContext bound to the "session" scope. Caches that context
154      * within the session itself.
155      */
156     public static JXPathContext getSessionContext(
157         HttpSession JavaDoc session,
158         ServletContext JavaDoc servletContext)
159     {
160         JXPathContext context =
161             (JXPathContext) session.getAttribute(Constants.JXPATH_CONTEXT);
162         if (context == null) {
163             JXPathContext parentContext = getApplicationContext(servletContext);
164             HttpSessionAndServletContext handle =
165                 new HttpSessionAndServletContext(session, servletContext);
166             context = factory.newContext(parentContext, handle);
167             context.setVariables(
168                 new KeywordVariables(Constants.SESSION_SCOPE, handle));
169             session.setAttribute(Constants.JXPATH_CONTEXT, context);
170         }
171         return context;
172     }
173
174     /**
175      * Returns a JXPathContext bound to the "application" scope. Caches that
176      * context within the servlet context itself.
177      */
178     public static JXPathContext getApplicationContext(
179             ServletContext JavaDoc servletContext)
180     {
181         JXPathContext context =
182             (JXPathContext) servletContext.getAttribute(
183                 Constants.JXPATH_CONTEXT);
184         if (context == null) {
185             context = factory.newContext(null, servletContext);
186             context.setVariables(
187                 new KeywordVariables(
188                     Constants.APPLICATION_SCOPE,
189                     servletContext));
190             servletContext.setAttribute(Constants.JXPATH_CONTEXT, context);
191         }
192         return context;
193     }
194 }
195
Popular Tags