How to integrate Spring and JSF

Question

How to integrate Spring and JSF? I followed Spring documentation (which is sparse on this subject) and googled some more and currently I found two working ways:

1. JSF Managed Bean will be Spring @Component / @Named (but there doesn't seem to work JSF scopes, but only Spring scopes):

   @Component
   @Scope("request")
   public class ItemController {
   
     @Autowired
     private ItemService itemService;
   
   }
   

2. I will use @ManagedBean, JSF scopes work, but I cannot autowire Spring bean using @Autowired, the bean must contain setter and I'm not sure if this is best practice:

   @ManagedBean
   @RequestScoped
   public class ItemController {
   
     @ManagedProperty("#{itemService}")
     private ItemService itemService;
   
     public void setItemService(ItemService itemService) {
       this.itemService = itemService;
     }
   
   }
   

3. Something else?

Answer 1

I would definitely go with way number 1 (and did so in quite some projects). It makes no real sense to mix JSF managed beans with Spring beans, unless you have a good reason to do so. With Spring managed beans, you have far more possibilities and you can use the full power of Spring even for your managed beans.

Theoretically, there is a third way: You could use CDI for the UI layer and Spring in the background. This might be an option if you don't want to use a full blown Java EE environment but still want to benefit from CDI and Myfaces CODI/Deltaspike in the UI layer. But in this case you would additionally need a CDI setup and a CDI to Spring bridge.

Answer 2

I was having the same issue a while back.

Although there also is an option of a spring EL enhancement to lookup spring beans there, I still found the differences between JSF and spring to be too wide a gap to try to cross in a seamless manner.

My recommendation is therefore to make the gap explicit and not try to cross it.

In my case I ended up with a service locator pattern, gaining access to spring context and lookup there..

@ManagedBean
@ApplicationScoped
public class ServiceLocator {
   public <T> T getServiceByType(Class<T> serviceType) {
     getSpringContext().getBean(serviceType);
   }

   public ApplicationContext getSpringContext() {
     return FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());
   }
}


@ManagedBean
@ViewScoped
public class ViewBean {

   @ManagedProperty("#{serviceLocator}")
   protected ServiceLocator serviceLocator;


   public void actionMethod() {
     serviceLocator.getService(BookingService.class).book(roomId, fromDate, toDate);
  }
}

Written from memory, but you might get the gist

Answer 3

You can use @AutowiredBean from JSF-Spring integration project to inject JSF managed beans into Spring beans:

@Component
@Scope(WebApplicationContext.SCOPE_REQUEST)
public class JsfTest implements Serializable {
    private static final long serialVersionUID = 1L;

    @AutowiredBean
    private JsfBean jsfBean;

    ...
}

Add Maven artifact com.intersult:jsf-spring:2.2.0.1-SNAPSHOT to your project, see https://www.intersult.com/wiki/page/JSF%20Spring%20Integration (use translation button).

Answer 4

One approach is let Spring manage all your bean, definitely you need to use SpringBeanFacesELResolver in faces-config.xml

Bean:

@Component
@Scope("view")
public class UserBean

faces-config.xml:

<el-resolver>
    org.springframework.web.jsf.el.SpringBeanFacesELResolver
</el-resolver>

Spring provides option to add your custom scope, you need to implement org.springframework.beans.factory.config.Scope interface. Use applicationcontext.xml for registration with Spring.

applicationcontext.xml on a custom 'view' scope implementation : [ViewScope is my implementation of Scope interface]

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
    <property name="scopes">
        <map>
            <entry key="view">
                <bean class="com.org.common.ViewScope"/>
            </entry>
        </map>
    </property>
</bean>