spring(4)------transaction

transaction--------事务

spring中事务的概念:

如果在业务层(Service)的"一个方法中"对数据访问层(Dao)层的方法,进行了多次调用,必须保证,这些操作,要么全部都要成功,如果有一条语句失败的,所有操作应该全部失败

事务的目的:保证服务层对数据访问层的调用,要么,全部都成功,要么,全部都失败,这样可以保证数据的准确性

spring事务的配置方式:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

2、创建事务代理（对InfoService形成代理）

<!-- 配置事务代理 -->

<bean id="proxyInfoService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">  <!-- 事务管理器 -->

<ref local="transactionManager" />

</property>

<property name="transactionAttributes"><!-- 代理的事务属性 -->

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop>

<prop key="delete*">PROPAGATION_REQUIRED</prop>

<prop key="*">readOnly</prop>

</props>

</property>

<property name="target">        <!-- 代理目标类 -->

<ref local="infoService"/>

</property>

</bean>

<prop key="add*">PROPAGATION_REQUIRED</prop>  如果正在访问的方法，是以add开始的，该方法中的所有操作都必须在事务的环境下运行

(所有操作都成功才提交，有一个操作失败就回滚)

不管用哪一种方式配置事务，第一步，都是相同的:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

事务配置的第二种方式:

把公共的代码抽取出来

事务代理类，必须有三种属性，才能创建：

1、事务管理器

2、事务代理属性

3、代理目标类

如果少了任何一个，创建的时候就会出错

第四种方式：声明式事务处理

它是对某一个路径下的文件配置事务

<aop:config>

<aop:pointcut></aop:pointcut>

</aop:config>

aop:pointcut ------------事务切入点，指，在什么时候执行事务

spring(4)

transaction--------事务

spring中事务的概念:

如果在业务层(Service)的"一个方法中"对数据访问层(Dao)层的方法,进行了多次调用,必须保证,这些操作,要么全部都要成功,如果有一条语句失败的,所有操作应该全部失败

事务的目的:保证服务层对数据访问层的调用,要么,全部都成功,要么,全部都失败,这样可以保证数据的准确性

spring事务的配置方式:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

2、创建事务代理（对InfoService形成代理）

<!-- 配置事务代理 -->

<bean id="proxyInfoService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">  <!-- 事务管理器 -->

<ref local="transactionManager" />

</property>

<property name="transactionAttributes"><!-- 代理的事务属性 -->

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop>

<prop key="delete*">PROPAGATION_REQUIRED</prop>

<prop key="*">readOnly</prop>

</props>

</property>

<property name="target">        <!-- 代理目标类 -->

<ref local="infoService"/>

</property>

</bean>

<prop key="add*">PROPAGATION_REQUIRED</prop>  如果正在访问的方法，是以add开始的，该方法中的所有操作都必须在事务的环境下运行

(所有操作都成功才提交，有一个操作失败就回滚)

不管用哪一种方式配置事务，第一步，都是相同的:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

事务配置的第二种方式:

把公共的代码抽取出来

事务代理类，必须有三种属性，才能创建：

1、事务管理器

2、事务代理属性

3、代理目标类

如果少了任何一个，创建的时候就会出错

第四种方式：声明式事务处理

它是对某一个路径下的文件配置事务

<aop:config>

<aop:pointcut></aop:pointcut>

</aop:config>

aop:pointcut ------------事务切入点，指，在什么时候执行事务

transaction--------事务

spring中事务的概念:

如果在业务层(Service)的"一个方法中"对数据访问层(Dao)层的方法,进行了多次调用,必须保证,这些操作,要么全部都要成功,如果有一条语句失败的,所有操作应该全部失败

事务的目的:保证服务层对数据访问层的调用,要么,全部都成功,要么,全部都失败,这样可以保证数据的准确性

spring事务的配置方式:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

2、创建事务代理（对InfoService形成代理）

<!-- 配置事务代理 -->

<bean id="proxyInfoService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">  <!-- 事务管理器 -->

<ref local="transactionManager" />

</property>

<property name="transactionAttributes"><!-- 代理的事务属性 -->

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop>

<prop key="delete*">PROPAGATION_REQUIRED</prop>

<prop key="*">readOnly</prop>

</props>

</property>

<property name="target">        <!-- 代理目标类 -->

<ref local="infoService"/>

</property>

</bean>

<prop key="add*">PROPAGATION_REQUIRED</prop>  如果正在访问的方法，是以add开始的，该方法中的所有操作都必须在事务的环境下运行

(所有操作都成功才提交，有一个操作失败就回滚)

不管用哪一种方式配置事务，第一步，都是相同的:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

事务配置的第二种方式:

把公共的代码抽取出来

事务代理类，必须有三种属性，才能创建：

1、事务管理器

2、事务代理属性

3、代理目标类

如果少了任何一个，创建的时候就会出错

第四种方式：声明式事务处理

它是对某一个路径下的文件配置事务

<aop:config>

<aop:pointcut></aop:pointcut>

</aop:config>

aop:pointcut ------------事务切入点，指，在什么时候执行事务

spring(4)

transaction--------事务

spring中事务的概念:

如果在业务层(Service)的"一个方法中"对数据访问层(Dao)层的方法,进行了多次调用,必须保证,这些操作,要么全部都要成功,如果有一条语句失败的,所有操作应该全部失败

事务的目的:保证服务层对数据访问层的调用,要么,全部都成功,要么,全部都失败,这样可以保证数据的准确性

spring事务的配置方式:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

2、创建事务代理（对InfoService形成代理）

<!-- 配置事务代理 -->

<bean id="proxyInfoService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">  <!-- 事务管理器 -->

<ref local="transactionManager" />

</property>

<property name="transactionAttributes"><!-- 代理的事务属性 -->

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop>

<prop key="delete*">PROPAGATION_REQUIRED</prop>

<prop key="*">readOnly</prop>

</props>

</property>

<property name="target">        <!-- 代理目标类 -->

<ref local="infoService"/>

</property>

</bean>

<prop key="add*">PROPAGATION_REQUIRED</prop>  如果正在访问的方法，是以add开始的，该方法中的所有操作都必须在事务的环境下运行

(所有操作都成功才提交，有一个操作失败就回滚)

不管用哪一种方式配置事务，第一步，都是相同的:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

事务配置的第二种方式:

把公共的代码抽取出来

事务代理类，必须有三种属性，才能创建：

1、事务管理器

2、事务代理属性

3、代理目标类

如果少了任何一个，创建的时候就会出错

第四种方式：声明式事务处理

它是对某一个路径下的文件配置事务

<aop:config>

<aop:pointcut></aop:pointcut>

</aop:config>

aop:pointcut ------------事务切入点，指，在什么时候执行事务

transaction--------事务

spring中事务的概念:

如果在业务层(Service)的"一个方法中"对数据访问层(Dao)层的方法,进行了多次调用,必须保证,这些操作,要么全部都要成功,如果有一条语句失败的,所有操作应该全部失败

事务的目的:保证服务层对数据访问层的调用,要么,全部都成功,要么,全部都失败,这样可以保证数据的准确性

spring事务的配置方式:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

2、创建事务代理（对InfoService形成代理）

<!-- 配置事务代理 -->

<bean id="proxyInfoService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">  <!-- 事务管理器 -->

<ref local="transactionManager" />

</property>

<property name="transactionAttributes"><!-- 代理的事务属性 -->

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="update*">PROPAGATION_REQUIRED</prop>

<prop key="delete*">PROPAGATION_REQUIRED</prop>

<prop key="*">readOnly</prop>

</props>

</property>

<property name="target">        <!-- 代理目标类 -->

<ref local="infoService"/>

</property>

</bean>

<prop key="add*">PROPAGATION_REQUIRED</prop>  如果正在访问的方法，是以add开始的，该方法中的所有操作都必须在事务的环境下运行

(所有操作都成功才提交，有一个操作失败就回滚)

不管用哪一种方式配置事务，第一步，都是相同的:

1、配置事务管理器

<bean id="transactionManager" class="HibernateTransactionManager">

<property name="sessionFactory">

<ref local="sessionFactory"/>

</property>

</bean>

事务配置的第二种方式:

把公共的代码抽取出来

事务代理类，必须有三种属性，才能创建：

1、事务管理器

2、事务代理属性

3、代理目标类

如果少了任何一个，创建的时候就会出错

第四种方式：声明式事务处理

它是对某一个路径下的文件配置事务

<aop:config>

<aop:pointcut></aop:pointcut>

</aop:config>

aop:pointcut ------------事务切入点，指，在什么时候执行事务