Skip to content

August 17, 2010

Spring 3 and the JSF 2 View Scope

Introduction

In addition to the existing JSF 1.x scopes – Request, Session, and Application, JSF 2 introduced two new scopes to the managed bean lifecycle.

View Scope

This scope persists the state of request parameters in the FacesContext View Map until the current view being rendered is discarded. As long as a user is interacting with the current page, request parameter state is maintained.

Flash Scope

First seen in the Ruby on Rails framework, this scope is for short lived conversations that only need to propagate parameters from one request to the next in the request processing lifecycle. Thereafter, the state of request parameters is discarded from the FacesContext View Map.

Implementing the JSF View Scope in Spring 3

Spring 3 supports the following bean scopes out-of-the-box:

  • singleton – Scopes a single bean definition to a single object instance per Spring IoC container.
  • prototype – Scopes a single bean definition to any number of object instances.
  • request – Scopes a single bean definition to the lifecycle of a single HTTP request; that is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
  • session – Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
  • globalSession – Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

In addition to the above scopes it is possible to create custom scopes. To support the JSF2 managed bean View Scope in the Spring Spring IoC container it is necessary to create a custom scope which implements the org.springframework.beans.factory.config.Scope interface. Beans created using this interface should then be registered with the Spring Custom Scope Configurer.

Create the View Scope implementation

First, create the View Scope bean implementing the required logic for the get() and remove() methods.

package net.comdynamics.myapp.web.spring.customscope;

import java.util.Map;

import javax.faces.context.FacesContext;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

/**
 * Implements the JSF View Scope for use by Spring. This class is registered as a Spring bean with the CustomScopeConfigurer.
*/
public class ViewScope implements Scope {

	public Object get(String name, ObjectFactory<?> objectFactory) {
		if (FacesContext.getCurrentInstance().getViewRoot() != null) {
			Map<String, Object> viewMap = FacesContext.getCurrentInstance().getViewRoot().getViewMap();
			if (viewMap.containsKey(name)) {
				return viewMap.get(name);
			} else {
				Object object = objectFactory.getObject();
				viewMap.put(name, object);
				return object;
			}
		} else {
			return null;
		}
	}

	public Object remove(String name) {
		if (FacesContext.getCurrentInstance().getViewRoot() != null) {
			return FacesContext.getCurrentInstance().getViewRoot().getViewMap().remove(name);
		} else {
			return null;
		}
	}

	public void registerDestructionCallback(String name, Runnable callback) {
		// Do nothing
	}

	public Object resolveContextualObject(String key) {
		return null;
	}

	public String getConversationId() {
		return null;
	}

}

Register the View Scope implementation

To enable the View Scope implementation in your web application, register the custom Scope implementation in your application context.

<?xml version="1.0" encoding="UTF-8"?>
<b:beans xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<b:bean
		class="org.springframework.beans.factory.config.CustomScopeConfigurer">
		<b:property name="scopes">
			<b:map>
				<b:entry key="view">
					<b:bean class="net.comdynamics.myapp.web.spring.customscope.ViewScope" />
				</b:entry>
			</b:map>
		</b:property>
	</b:bean>

</b:beans>

Important

If you specify @Scope("view") in your managed bean and the JSF page is loaded, failure to register the custom scope bean in your Spring application context will result in an error similar to the following:

javax.servlet.ServletException: No Scope registered for scope 'view'
	javax.faces.webapp.FacesServlet.service(FacesServlet.java:323)

Create your JSF managed bean

The following class from a previous article on the JSF2 JSR-330 annotations has been updated to use the new View Scope in the @Scope annotation.

package net.comdynamics.myapp.web;

import javax.inject.Named;
import org.springframework.context.annotation.Scope;

/**
 * ReportListPage JSF backing bean.
 */
@Named("reportListPage")
@Scope("view")
public class ReportListPage extends BasePage {

    @Inject
    @Named("reportService")
    private ReportService reportService;

    public ReportListPage() {
    }

    public ReportService getReportService() {
        return reportService;
    }

    public void setReportService(ReportService ReportService) {
        this.reportService = reportService;
    }

    // etc…

}

When the user loads the page bound to the above backing bean, request parameters entered in form fields will be persisted in the FacesContext View Map on form submissions until they navigate to another page in the application.

Conclusion

Support for the JSF 2 View Scope in Spring 3 can be realised by implementing a custom Scope and registering it as a bean in the Spring application context.

Key benefits provided by View Scope are persisting of request parameters across form submissions for the same page, thereby removing the need to manage request parameter state within the web application session.

Read more from JSF, Spring

Comments are closed.