Prev |  | Next

## Chapter 24. Spring Framework integration

The Spring integration module allows easy migration of Spring-based projects to Seam and allows Spring applications to take advantage of key Seam features like conversations and Seam's more sophisticated persistence context management.

## Technology preview

Spring integration in Seam is marked as technology preview, so standard support is not guaranteed.

Note! The Spring integration code is included in the jboss-seam-ioc library. This dependency is required for all seam-spring integration techniques covered in this chapter.

Seam's support for Spring provides the ability to:

- inject Seam component instances into Spring beans

- inject Spring beans into Seam components

- turn Spring beans into Seam components

- allow Spring beans to live in any Seam context

- start a spring WebApplicationContext with a Seam component

- Support for Spring PlatformTransactionManagement

- provides a Seam managed replacement for Spring's `OpenEntityManagerInViewFilter` and `OpenSessionInViewFilter`

- Support for Spring `TaskExecutors` to back `@Asynchronous` calls

## 24.1. Injecting Seam components into Spring beans

Injecting Seam component instances into Spring beans is accomplished using the `<seam:instance/>` namespace handler. To enable the Seam namespace handler, the Seam namespace must be added to the Spring beans definition file:

    <beans xmlns="http://www.springframework.org/schema/beans"

        xmlns:seam="http://jboss.com/products/seam/spring-seam"

        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-2.0.xsd

                            http://jboss.com/products/seam/spring-seam

                            http://jboss.com/products/seam/spring-seam-2.1.xsd">

Now any Seam component may be injected into any Spring bean:

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="prototype">

        <property name="someProperty">

            <seam:instance name="someComponent"/>

        </property>

    </bean>

An EL expression may be used instead of a component name:

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="prototype">

        <property name="someProperty">

            <seam:instance name="#{someExpression}"/>

        </property>

    </bean>

Seam component instances may even be made available for injection into Spring beans by a Spring bean id.

    <seam:instance name="someComponent" id="someSeamComponentInstance"/>

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="prototype">

        <property name="someProperty" ref="someSeamComponentInstance">

    </bean>

Now for the caveat!

Seam was designed from the ground up to support a stateful component model with multiple contexts. Spring was not. Unlike Seam bijection, Spring injection does not occur at method invocation time. Instead, injection happens only when the Spring bean is instantiated. So the instance available when the bean is instantiated will be the same instance that the bean uses for the entire life of the bean. For example, if a Seam `CONVERSATION`-scoped component instance is directly injected into a singleton Spring bean, that singleton will hold a reference to the same instance long after the conversation is over! We call this problem scope impedance. Seam bijection ensures that scope impedance is maintained naturally as an invocation flows through the system. In Spring, we need to inject a proxy of the Seam component, and resolve the reference when the proxy is invoked.

The `<seam:instance/>` tag lets us automatically proxy the Seam component.

    <seam:instance id="seamManagedEM" name="someManagedEMComponent" proxy="true"/>

    <bean id="someSpringBean" class="SomeSpringBeanClass">

        <property name="entityManager" ref="seamManagedEM">

    </bean>

This example shows one way to use a Seam-managed persistence context from a Spring bean. (For a more robust way to use Seam-managed persistence contexts as a replacement for the Spring `OpenEntityManagerInView` filter see section on Using a Seam Managed Persistence Context in Spring)

## 24.2. Injecting Spring beans into Seam components

It is even easier to inject Spring beans into Seam component instances. Actually, there are two possible approaches:

- inject a Spring bean using an EL expression

- make the Spring bean a Seam component

We'll discuss the second option in the next section. The easiest approach is to access the Spring beans via EL.

The Spring `DelegatingVariableResolver` is an integration point Spring provides for integrating Spring with JSF. This `VariableResolver` makes all Spring beans available in EL by their bean id. You'll need to add the `DelegatingVariableResolver` to `faces-config.xml`:

    <application>

        <variable-resolver>

            org.springframework.web.jsf.DelegatingVariableResolver

        </variable-resolver>

    </application>

Then you can inject Spring beans using `@In`:

    @In("#{bookingService}")

    private BookingService bookingService;

The use of Spring beans in EL is not limited to injection. Spring beans may be used anywhere that EL expressions are used in Seam: process and pageflow definitions, working memory assertions, etc...

## 24.3. Making a Spring bean into a Seam component

The `<seam:component/>` namespace handler can be used to make any Spring bean a Seam component. Just place the `<seam:component/>` tag within the declaration of the bean that you wish to be a Seam component:

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="prototype">

        <seam:component/>

    </bean>

By default, `<seam:component/>` will create a `STATELESS` Seam component with class and name provided in the bean definition. Occasionally, such as when a `FactoryBean` is used, the class of the Spring bean may not be the class appearing in the bean definition. In such cases the `class` should be explicitly specified. A Seam component name may be explicitly specified in cases where there is potential for a naming conflict.

The `scope` attribute of `<seam:component/>` may be used if you wish the Spring bean to be managed in a particular Seam scope. The Spring bean must be scoped to `prototype` if the Seam scope specified is anything other than `STATELESS`. Pre-existing Spring beans usually have a fundamentally stateless character, so this attribute is not usually needed.

## 24.4. Seam-scoped Spring beans

The Seam integration package also lets you use Seam's contexts as Spring 2.0 style custom scopes. This lets you declare any Spring bean in any of Seam's contexts. However, note once again that Spring's component model was never architected to support statefulness, so please use this feature with great care. In particular, clustering of session or conversation scoped Spring beans is deeply problematic, and care must be taken when injecting a bean or component from a wider scope into a bean of a narrower scope.

By specifying `<seam:configure-scopes/>` once in a Spring bean factory configuration, all of the Seam scopes will be available to Spring beans as custom scopes. To associate a Spring bean with a particular Seam scope, specify the Seam scope in the `scope` attribute of the bean definition.

    <!-- Only needs to be specified once per bean factory-->

    <seam:configure-scopes/>

    ...

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="seam.CONVERSATION"/>

The prefix of the scope name may be changed by specifying the `prefix` attribute in the `configure-scopes` definition. (The default prefix is `seam.`)

By default an instance of a Spring Component registered in this way is not automatically created when referenced using `@In`. To have an instance auto-created you must either specify `@In(create=true)` at the injection point to identify a specific bean to be auto created or you can use the `default-auto-create` attribute of `configure-scopes` to make all spring beans who use a seam scope auto created.

Seam-scoped Spring beans defined this way can be injected into other Spring beans without the use of `<seam:instance/>`. However, care must be taken to ensure scope impedance is maintained. The normal approach used in Spring is to specify `<aop:scoped-proxy/>` in the bean definition. However, Seam-scoped Spring beans are not compatible with `<aop:scoped-proxy/>`. So if you need to inject a Seam-scoped Spring bean into a singleton, `<seam:instance/>` must be used:

    <bean id="someSpringBean" class="SomeSpringBeanClass" scope="seam.CONVERSATION"/>

    ...

    <bean id="someSingleton">

        <property name="someSeamScopedSpringBean">

            <seam:instance name="someSpringBean" proxy="true"/>

        </property>

    </bean>

## 24.5. Using Spring PlatformTransactionManagement

Spring provides an extensible transaction management abstraction with support for many transaction APIs (JPA, Hibernate, JDO, and JTA) Spring also provides tight integrations with many application server TransactionManagers such as Websphere and Weblogic. Spring transaction management exposes support for many advanced features such as nested transactions and supports full Java EE transaction propagation rules like REQUIRES_NEW and NOT_SUPPORTED. For more information see the spring documentation here.

To configure Seam to use Spring transactions enable the SpringTransaction component like so:

    <spring:spring-transaction platform-transaction-manager="#{transactionManager}"/>

The `spring:spring-transaction` component will utilize Springs transaction synchronization capabilities for synchronization callbacks.

## 24.6. Using a Seam Managed Persistence Context in Spring

One of the most powerful features of Seam is its conversation scope and the ability to have an EntityManager open for the life of a conversation. This eliminates many of the problems associated with the detachment and re-attachment of entities as well as mitigates occurrences of the dreaded `LazyInitializationException`. Spring does not provide a way to manage an persistence context beyond the scope of a single web request (`OpenEntityManagerInViewFilter`). So, it would be nice if Spring developers could have access to a Seam managed persistence context using all of the same tools Spring provides for integration with JPA(e.g. `PersistenceAnnotationBeanPostProcessor`, `JpaTemplate`, etc.)

Seam provides a way for Spring to access a Seam managed persistence context with Spring's provided JPA tools bringing conversation scoped persistence context capabilities to Spring applications.

This integration work provides the following functionality:

- transparent access to a Seam managed persistence context using Spring provided tools

- access to Seam conversation scoped persistence contexts in a non web request (e.g. asynchronous quartz job)

- allows for using Seam managed persistence contexts with Spring managed transactions (will need to flush the persistence context manually)

Spring's persistence context propagation model allows only one open EntityManager per EntityManagerFactory so the Seam integration works by wrapping an EntityManagerFactory around a Seam managed persistence context.

    <bean id="seamEntityManagerFactory" class="org.jboss.seam.ioc.spring.SeamManagedEntityManagerFactoryBean">

        <property name="persistenceContextName" value="entityManager"/>

    </bean>

Where 'persistenceContextName' is the name of the Seam managed persistence context component. By default this EntityManagerFactory has a unitName equal to the Seam component name or in this case 'entityManager'. If you wish to provide a different unitName you can do so by providing a persistenceUnitName like so:

    <bean id="seamEntityManagerFactory" class="org.jboss.seam.ioc.spring.SeamManagedEntityManagerFactoryBean">

        <property name="persistenceContextName" value="entityManager"/>

        <property name="persistenceUnitName" value="bookingDatabase:extended"/>

    </bean>

This EntityManagerFactory can then be used in any Spring provided tools. For example, using Spring's `PersistenceAnnotationBeanPostProcessor` is the exact same as before.

    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

If you define your real EntityManagerFactory in Spring but wish to use a Seam managed persistence context you can tell the `PersistenceAnnotationBeanPostProcessor` which persistenctUnitName you wish to use by default by specifying the `defaultPersistenceUnitName` property.

The `applicationContext.xml` might look like:

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">

        <property name="persistenceUnitName" value="bookingDatabase"/>

    </bean>

    <bean id="seamEntityManagerFactory" class="org.jboss.seam.ioc.spring.SeamManagedEntityManagerFactoryBean">

        <property name="persistenceContextName" value="entityManager"/>

        <property name="persistenceUnitName" value="bookingDatabase:extended"/>

    </bean>

    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor">

        <property name="defaultPersistenceUnitName" value="bookingDatabase:extended"/>

    </bean>

The `component.xml` might look like:

    <persistence:managed-persistence-context name="entityManager"

        auto-create="true" entity-manager-factory="#{entityManagerFactory}"/>

`JpaTemplate` and `JpaDaoSupport` are configured the same way for a Seam managed persistence context as they would be fore a Seam managed persistence context.

    <bean id="bookingService" class="org.jboss.seam.example.spring.BookingService">

        <property name="entityManagerFactory" ref="seamEntityManagerFactory"/>

    </bean>

## 24.7. Using a Seam Managed Hibernate Session in Spring

The Seam Spring integration also provides support for complete access to a Seam managed Hibernate session using spring's tools. This integration is very similar to the JPA integration.

Like Spring's JPA integration spring's propagation model allows only one open EntityManager per EntityManagerFactory per transaction??? to be available to spring tools. So, the Seam Session integration works by wrapping a proxy SessionFactory around a Seam managed Hibernate session context.

    <bean id="seamSessionFactory" class="org.jboss.seam.ioc.spring.SeamManagedSessionFactoryBean">

        <property name="sessionName" value="hibernateSession"/>

    </bean>

Where 'sessionName' is the name of the `persistence:managed-hibernate-session` component. This SessionFactory can then be used in any Spring provided tools. The integration also provides support for calls to `SessionFactory.getCurrentInstance()` as long as you call getCurrentInstance() on the `SeamManagedSessionFactory`.

## 24.8. Spring Application Context as a Seam Component

Although it is possible to use the Spring `ContextLoaderListener` to start your application's Spring ApplicationContext there are a couple of limitations.

- the Spring ApplicationContext must be started after the `SeamListener`

- it can be tricky starting a Spring ApplicationContext for use in Seam unit and integration tests

To overcome these two limitations the Spring integration includes a Seam component that will start a Spring ApplicationContext. To use this Seam component place the `<spring:context-loader/>` definition in the `components.xml`. Specify your Spring context file location in the `config-locations` attribute. If more than one config file is needed you can place them in the nested `<spring:config-locations/>` element following standard `components.xml` multi value practices.

    <components xmlns="http://jboss.com/products/seam/components"

                xmlns:spring="http://jboss.com/products/seam/spring"

                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                xsi:schemaLocation="http://jboss.com/products/seam/components

                                    http://jboss.com/products/seam/components-2.1.xsd

                                    http://jboss.com/products/seam/spring

                                    http://jboss.com/products/seam/spring-2.1.xsd">

        <spring:context-loader config-locations="/WEB-INF/applicationContext.xml"/>

    </components>

## 24.9. Using a Spring TaskExecutor for @Asynchronous

Spring provides an abstraction for executing code asynchronously called a `TaskExecutor`. The Spring Seam integration allows for the use of a Spring `TaskExecutor` for executing immediate `@Asynchronous` method calls. To enable this functionality install the `SpringTaskExecutorDispatchor` and provide a spring bean defined taskExecutor like so:

    <spring:task-executor-dispatcher task-executor="#{springThreadPoolTaskExecutor}"/>

Because a Spring `TaskExecutor` does not support scheduling of an asynchronous event a fallback Seam `Dispatcher` can be provided to handle scheduled asynchronous event like so:

                <!-- Install a ThreadPoolDispatcher to handle scheduled asynchronous event -->

    <core:thread-pool-dispatcher name="threadPoolDispatcher"/>

    <!-- Install the SpringDispatcher as default -->

    <spring:task-executor-dispatcher task-executor="#{springThreadPoolTaskExecutor}" schedule-dispatcher="#{threadPoolDispatcher}"/>

Prev |  | Front page | Next