2.3 Struts and Scope

The Struts framework uses various shared resource areas to store objects. The shared resource areas all have a lifetime and visibility rule that defines the scope of the resource. This section discusses these resources, their scopes, and how the framework uses them.

2.3.1 Request Scope

Each time a client issues an HTTP request, the server creates an object that implements the javax.servlet.http.HttpServletRequest interface. Among other things, this object contains a collection of key/value attribute pairs that can be used to store objects for the lifetime of the request. The key of each pair is a String, and the value can be any type of Object. The methods to store objects in and retrieve them from the request scope are:

public void setAttribute( String name, Object obj ); public Object getAttribute( String name );

Request-scope attributes can be removed using the removeAttribute() method; however, because the scope of the attribute is only for the lifetime of the request, it is not as important to remove them as it is for other scoped attributes. Once the server fulfills a request and a response is returned to the client, the request and its attributes are no longer available to the client and can be garbage-collected by the JVM.

The Struts framework provides the ability to store JavaBeans in a request, so that they can be used by presentation components such as JSP pages. This makes it much easier to access JavaBeans data, without having to do a manual cleanup of the objects later. There's seldom a need to remove objects from request scope; the web container takes care of it for you. Objects stored at the request level are visible only to resources that have access to that request. Once the response has been returned to the client, the visibility is gone. Objects that are stored in one request are not visible to any other client request.

2.3.2 Session Scope

The next-higher level of visibility is session scope. The web container creates an object that implements the javax.servlet.http.HttpSession interface to identify a user across multiple page requests. When the session is created depends on the application and the container implementation. The user's session will persist for a period of time that is based on how often the user makes requests. This allowed inactivity time is configurable through the application deployment descriptor. It also can be destroyed prematurely by calling the invalidate() method on the session object.

The session also allows for a collection of objects to be stored based on a key/value pair schema, as with the request object. The only difference between this one and the one provided by the request is the duration of the objects. Because sessions exist across multiple requests, objects stored in the session scope live longer than those at the request level. The Struts framework uses session attributes extensively. An example of an object that may be stored as a session attribute is the Locale object for the user. This allows the entire framework access to the user's locale to perform localized behavior. Objects stored in one user's session are not visible to users with a different session.

The web container provides no synchronization for objects stored in the session. If multiple threads attempt to access an object stored in the session and modify the value, it's up to the developer to provide synchronization. Although the need to synchronize access to the session is quite low, the developer is responsible for protecting the resources. For example, if your application uses frames, or if you have a process that takes a long time to complete, multiple threads might be accessing the session at the same time.

2.3.3 Application Scope

An even higher level of visibility and duration comes with objects stored at the application-scope level. Application-scoped objects are visible to all clients and threads of the current web application. They live until they are programmatically removed or until the application is terminated. The servlet container creates an object that implements the javax.servlet.ServletContext interface for each and every web application that is installed within the container. This is done when the container is first started.

Beyond the scope for the request and session objects, the ServletContext allows application objects to be stored and retrieved by the entire application and to persist for the lifetime of the application. The Struts framework uses application scope to store JavaBeans that need to be visible to all users. Normally, objects are stored in this scope during application startup and remain there until the application exits.

2.3.4 Page Scope

The last scope we will discuss, page scope, has to do exclusively with JSP pages. Objects with page scope are stored in the javax.servlet.jsp.PageContext for each page and are accessible only within the JSP page in which they were created. Once the response is sent to the client or the page forwards to another resource, the objects are no longer available.

Every JSP page has an implicit object reference named pageContext that can be used to store and retrieve page-level objects. It includes the same getAttribute( ) and setAttribute() methods that the other scopes offer, and they function in the same manner.

Programming Jakarta Struts
Programming Jakarta Struts, 2nd Edition
ISBN: 0596006519
EAN: 2147483647
Year: 2003
Pages: 180

Similar book on Amazon

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net