public class TransactionProxyFactoryBean
extends org.springframework.aop.framework.AbstractSingletonProxyFactoryBean
implements org.springframework.beans.factory.BeanFactoryAware
ProxyFactoryBean
 with a separate TransactionInterceptor definition.
 HISTORICAL NOTE: This class was originally designed 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. However, in Spring versions 2.0 and beyond, the functionality provided here
 is superseded by the more convenient tx: XML namespace. See the
 declarative transaction management
 section of the Spring reference documentation to understand modern options for managing
 transactions in Spring applications. For these reasons, users should favor
 the tx: XML namespace as well as
 the @Transactional
 and @EnableTransactionManagement annotations.
 
There are three main properties that need to be specified:
PlatformTransactionManager implementation to use
 (for example, a JtaTransactionManager instance)
 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.
 
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>setTransactionManager(org.springframework.transaction.PlatformTransactionManager), 
AbstractSingletonProxyFactoryBean.setTarget(java.lang.Object), 
setTransactionAttributes(java.util.Properties), 
TransactionInterceptor, 
ProxyFactoryBean, 
Serialized Form| Constructor and Description | 
|---|
| TransactionProxyFactoryBean() | 
| Modifier and Type | Method and Description | 
|---|---|
| protected Object | createMainInterceptor()Creates an advisor for this FactoryBean's TransactionInterceptor. | 
| protected void | postProcessProxyFactory(org.springframework.aop.framework.ProxyFactory proxyFactory)As of 4.2, this method adds  TransactionalProxyto the set of
 proxy interfaces in order to avoid re-processing of transaction metadata. | 
| void | setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)This callback is optional: If running in a BeanFactory and no transaction
 manager has been set explicitly, a single matching bean of type
  PlatformTransactionManagerwill be fetched from the BeanFactory. | 
| void | setPointcut(org.springframework.aop.Pointcut pointcut)Set a pointcut, i.e a bean that can cause conditional invocation
 of the TransactionInterceptor depending on method and attributes passed. | 
| void | setTransactionAttributes(Properties transactionAttributes)Set properties with method names as keys and transaction attribute
 descriptors (parsed via TransactionAttributeEditor) as values:
 e.g. | 
| void | setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)Set the transaction attribute source which is used to find transaction
 attributes. | 
| void | setTransactionManager(PlatformTransactionManager transactionManager)Set the default transaction manager. | 
afterPropertiesSet, createTargetSource, getObject, getObjectType, isSingleton, setAdvisorAdapterRegistry, setBeanClassLoader, setPostInterceptors, setPreInterceptors, setProxyClassLoader, setProxyInterfaces, setTargetpublic void setTransactionManager(PlatformTransactionManager transactionManager)
public void setTransactionAttributes(Properties transactionAttributes)
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.
public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)
setTransactionAttributes(java.util.Properties), 
TransactionAspectSupport.setTransactionAttributeSource(org.springframework.transaction.interceptor.TransactionAttributeSource), 
TransactionAttributeSourceEditor, 
MethodMapTransactionAttributeSource, 
NameMatchTransactionAttributeSource, 
AnnotationTransactionAttributeSourcepublic void setPointcut(org.springframework.aop.Pointcut pointcut)
AbstractSingletonProxyFactoryBean.setPreInterceptors(java.lang.Object[]), 
AbstractSingletonProxyFactoryBean.setPostInterceptors(java.lang.Object[])public void setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)
PlatformTransactionManager will be fetched from the BeanFactory.setBeanFactory in interface org.springframework.beans.factory.BeanFactoryAwareBeanFactory.getBean(Class), 
PlatformTransactionManagerprotected Object createMainInterceptor()
createMainInterceptor in class org.springframework.aop.framework.AbstractSingletonProxyFactoryBeanprotected void postProcessProxyFactory(org.springframework.aop.framework.ProxyFactory proxyFactory)
TransactionalProxy to the set of
 proxy interfaces in order to avoid re-processing of transaction metadata.postProcessProxyFactory in class org.springframework.aop.framework.AbstractSingletonProxyFactoryBean