Java Doc for TransactionProxyFactoryBean.java in  » J2EE » spring-framework-2.5 » org » springframework » transaction » interceptor » Java Source Code / Java DocumentationJava Source Code and Java Documentation

This class is intended to cover the typical case of declarative transaction demarcation: namely, wrapping a singleton target object with a transactional proxy, proxying all the interfaces that the target implements.

There are three main properties that need to be specified:

• "transactionManager": the PlatformTransactionManager implementation to use (for example, a org.springframework.transaction.jta.JtaTransactionManager instance)
• "target": the target object that a transactional proxy should be created for
• "transactionAttributes": the transaction attributes (for example, propagation behavior and "readOnly" flag) per target method name (or method name pattern)

If the "transactionManager" property is not set explicitly and this FactoryBean is running in a ListableBeanFactory , a single matching bean of type PlatformTransactionManager will be fetched from the BeanFactory .

In contrast to TransactionInterceptor , the transaction attributes are specified as properties, with method names as keys and transaction attribute descriptors as values. Method names are always applied to the target class.

Internally, a TransactionInterceptor instance is used, but the user of this class does not have to care. Optionally, a method pointcut can be specified to cause conditional invocation of the underlying TransactionInterceptor .

The "preInterceptors" and "postInterceptors" properties can be set to add additional interceptors to the mix, like org.springframework.aop.interceptor.PerformanceMonitorInterceptor or org.springframework.orm.hibernate3.HibernateInterceptor / org.springframework.orm.jdo.JdoInterceptor .

HINT: This class is often used with parent / child bean definitions. Typically, you will define the transaction manager and default transaction attributes (for method name patterns) in an abstract parent bean definition, deriving concrete child bean definitions for specific target objects. This reduces the per-bean definition effort to a minimum.

 <bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
 abstract="true">
 <property name="transactionManager" ref="transactionManager"/>
 <property name="transactionAttributes">
 <props>
 <prop key="insert*">PROPAGATION_REQUIRED</prop>
 <prop key="update*">PROPAGATION_REQUIRED</prop>
 <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
 </props>
 </property>
 </bean>
 <bean id="myProxy" parent="baseTransactionProxy">
 <property name="target" ref="myTarget"/>
 </bean>
 <bean id="yourProxy" parent="baseTransactionProxy">
 <property name="target" ref="yourTarget"/>
 </bean>

Note: Method names are always applied to the target class, no matter if defined in an interface or the class itself.

Internally, a NameMatchTransactionAttributeSource will be created from the given properties.
See Also:   TransactionProxyFactoryBean.setTransactionAttributeSource
See Also:   TransactionInterceptor.setTransactionAttributes
See Also:   TransactionAttributeEditor
See Also:   NameMatchTransactionAttributeSource