public class LoginAction extends ActionSupport {
private String username;
private String password;
@Override
public String execute() throws Exception {
ActionContext ctx = ActionContext.getContext();
Integer counter = (Integer)ctx.getApplication().get("counter");
// put counter into application
ctx.getApplication().put("counter", counter);
// put username into session
ctx.getSession().put("user", username);
if (getUsername().equals("crazyit.org")
&& getPassword().equals("leegang")) {
ctx.put("tip", "Login Success! ");
return SUCCESS;
}
else {
ctx.put("tip", "Login Falied!");
return ERROR;
}
}
}
I put "counter"
in application "user"
in session and "tip"
in ActionContext
. In JSP I can use ${session.user}
and ${sessionScope.user}
to reference the "user" property. ${request.tip}
and ${requestScope.tip}
to reference tip
.
My questions:
- Are session, request, application the same as
sessionScope
, requestScope
, applicationScope
in EL?
- What's the relationship between
ActionContext
and request(requestScope)
?
P.S.:
I test ${request == requestScope}
which is true, this means they are the same?
With expression language (EL), the scope items are value maps of attributes in the objects that they refer to. For instance, the requestScope is a map representation of values in the request object. This is explained in pretty clear detail on this page: Java Servlet and JSP. If you read through the EL sections, you'll notice a point about request vs request scope here: The requestScope is NOT request object.
I would recommend reading through this page to get a better understanding of servlet/jsp in general.
As far as how the ActionContext relates to these items, it is really a wrapper used by struts to encapsulate the servlet. You can read more specifics about it here: Accessing application, session, request objects.
There have been some references to implicit values given here, but I feel like just saying it's implicit doesn't really explain much. When you are using EL to access servlet variables, you can explicitly declare which scope you want to reference, such as:
${requestScope.myVariable}
You can also reference it implicitly by omitting the scope:
${myVariable}
Now, the problem that can arise here is that variables with the same name can cause collision. EL will check implicit values in a specific order: pageScope, requestScope, sessionScope, and applicationScope, param, paramValues, header, headervalues, initParam, cookie, pageContext. What this means is that if you have a variable in the request scope with the same name as a variable in session or application scope for instance, the request scoped value will be referenced.
By default page, request, session and application
objects are available to JSP pages.
So you can access then using EL syntax.
And following table shows IMPLICIT objects available to EL.
Implicit object Description
1. pageScope Scoped variables from page scope
2. requestScope Scoped variables from request scope
3. sessionScope Scoped variables from session scope
4. applicationScope Scoped variables from application scope
5. param Request parameters as strings
6. paramValues Request parameters as collections of strings
7. header HTTP request headers as strings
8. headerValues HTTP request headers as collections of strings
9. initParam Context-initialization parameters
10. cookie Cookie values
11. pageContext The JSP PageContext object for the current page
So session and sessionScope are same but differs in context they are used.More specifically session is object
and sessionScope is map (key, value) of Attribute and its value
.
- session, request, application are the actually
HttpSession
,HttpServletRequest
and ServletContext
objects while sessionScope, requestScope and applicationScope
provide access to all the session, request and application scoped attributes.
You can say that applicationScope > sessionScope > requestScope.
- applicationScope attributes will be accessible to all the sessions, all the requests across the web applications. These attributes stay alive as long as application is alive
- sessionScope attributes will be accessible to all the requests across the current HttpSession. These attributes stay alive as long as session is alive
- requestScope attributes will be accessible from the current request only. Once the response is completed, they are gone.
The ActionContext
is a Struts2 thing, and it's created in every request that is handled by the framework. When it's created the framework populates it along with the servlet stuff with it's own implementations of request
, session
, and applicaton
. And where you using it in the application these objects are referenced. To access the servlet stuff use the ServletActionContext
that helps to retrieve the appropriate resources. Struts2 also wraps the ServletRequest
to provide access to the action properties and valueStack
from the EL expressions. sessionScope
, requestScope
, and applicationScope
used with EL expressions to evaluate to the servlet stuff attributes. That are the differences.
Have a look over below given code I tried.
<body>
<%
FirstServlet first=new FirstServlet(); // it has a fileName property and getter setter for it
%>
<%
session.setMaxInactiveInterval(10); //jsp's implicit session object
request.setAttribute("session", first); //jsp's implicit request object
session.setAttribute("hello", "this worked!");
pageContext.getSession().setAttribute("hello", "now this also worked!");%> // same as above
${pageContext.session.maxInactiveInterval } // client's session object
${sessionScope.maxInactiveInterval}
${session.fileName } // FirstServlet Object and gives the fileName I gave.
${sessionScope.hello } // OP: "now this also worked!
${session==sessionScope } // gives false. If using struts2 than true
${request==requestScope } // gives false. If using struts2 than true
</body>
in EL
as stated by Prasad and Captain when you use ${sessionScope}
it only maps session-scoped variable names to their values.
if you want to get client's session object than you should use pageContext.session
but when you use ${session}
, el
searches for attribute maped with session name in order: page->request->session->application
scopes starting from left to right.
${request == requestScope}
gives false
because requestScope
is client's request object when request
will cause EL
to search for object maped with request
name in various scopes
. But in your case it is true
because of struts2