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 ------------事务切入点,指,在什么时候执行事务