2. 程式人生 > >看了慕課的spring事務管理,然後整理了一下,以便以後自己學習

看了慕課的spring事務管理,然後整理了一下,以便以後自己學習

阿新 • • 發佈：2018-12-27
事務的特性:
    1. 原子性.
        事務是一個不可分割的整體,要麼都失敗,要麼都成功
    2. 一致性:
        事務前後性必須資料的完整性必須保持一致
    3. 隔離性:
        多個使用者併發訪問資料庫的時候,一個使用者的事務不能被其他使用者的事務給干擾,
        多個併發事務之間資料要相互隔離
    4. 永續性:
        永續性就是事務一旦提交,那麼對於資料庫中就是永久性的,不會因為資料庫傳送事故而改變
事務管理的三個主要介面
    platformTransactionManager
        事務管理器

        spring為不同的持久層框架提供了不同的介面
            對於 mybatis,jdbc 使用的是 org.springframework.jdbc.datasource.DataSourceTransaction
            對於 hibernate           org.springframework.orm.hibernate3.HibernateTransactionManager
            對於 jpa           org.springframework.orm.jpa.JpaTransactionManager
            對於 jdo           org.springframework.orm.jdo.JdoTransactionManager
            對於 jta(是一個分散式事務) org.springframework.orm.jta.JtaTransactionManager
    TransactionDefinition
        事務定義資訊 (隔離,傳播,超時,只讀)
    TransactionStatus
        事務具體執行狀態
事務中出現的問題:
    1. 髒讀:
        一個事務讀到了另一個事務改寫但還未提交的資料,如果這些資料回滾,則讀到的資料是無效的
    2. 不可重複讀:
        在同一事務中,多次讀取同一資料返回的結果有所不同
    3. 幻讀:
        在一個事務中讀取了幾行資料,當另一個事務插入了幾條資料後,在後來的查詢後,發現一些沒有的資料.
事務的隔離級別:
    DEFAULT        使用後端資料庫預設的隔離級別
            對於mysql 預設的隔離級別(REPEATABLE_READ)
                oracle  (READ_COMMITED)
    
    READ_UNCOMMITED    允許讀取修改還未提交的資料,可能會導致,髒,不可重複,幻讀的情況
    
    READ_COMMITED    允許在事務提交以後讀取,但不可避免不可重複,幻讀的情況
    
    REPEATABLE_READ 對於相同欄位多次讀取時一致的,除非資料被事務本身改變,可防止髒讀,不可重複..但幻讀不行
    
    SERIALIZABLE    完全服從ACID的隔離級別,確保不發生髒,幻,不可重複讀,這是所有隔離級別中最慢的,它是完全
            鎖在事務中涉及的資料表來完成的.



事務的傳播行為:
    當一個功能  需要呼叫 2個業務層的方法 才能完成, 每個service層的方法都有事務.\

    PROPAGATION_REQUIRED *    支援當前事務,如果不存在就新建一個

    PROPAGATION_SUPPORTS    支援當前事務,如果不存在就不適用事務,
    
    PROPAGATION_MANDATORY    支援當前事務,如果不存在,丟擲異常
    
    PROPAGATION_REQUIRED_NEW * 如果有事務存在,掛起當前事務,新建一個
    
    PROPAGATION_NOT_SUPPORTS 以非事務方式執行,如果事務存在,掛起當前事務

    PROPAGATION_NEVER    以非事務方式執行,丟擲異常

    PROPAGATION_NESTED *    如果當前事務存在咋巢狀事務執行

spring 支援兩種事務管理
    1. 程式設計式的事務管理
     1. 在實際應用中很少使用
     2. 通過TransactionTemplate手動管理事務
    使用XML配置宣告式事務
     1. 開發中推薦使用(程式碼侵入最小)

     2. Spring的宣告式事務式通過AOP實現的

            1. 基於 TransactionProxyFactoryBean (很少使用)
        2. 基於 AspectJ的XML方式 (經常使用)
            一旦配置好了,不需要在新增任何東西
        3. 基於 註解 (經常使用)
            配置簡單,需要在每個業務層類上面加 @Transcational 註解


做的一個例項 是   轉賬問題   a 轉 b  兩個人的賬戶相應增加,減少,當發生異常,則事務不進行提交,a,b的金額沒有發生改變

在 SpringTest 測試類中 需要加入
    @RunWith(SpringJUnit4ClassRunner.class) // //使用junit4進行測試  
    @ContextConfiguration("classpath:applicationContext.xml") // 載入配置檔案
    這兩個註解


 搭建測試環境

    userDao,userDaoImpl

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class UserDaoImpl extends JdbcDaoSupport  implements UserDao{

	
	@Override
	public void outPrice(String name, double price) {
		// TODO Auto-generated method stub
		String sql = "update user set price = price - ? where username = ?";
		this.getJdbcTemplate().update(sql,price,name);
	}

	@Override
	public void intPrice(String name, double price) {
		// TODO Auto-generated method stub
		String sql = "update user set price = price + ? where username = ?";
		this.getJdbcTemplate().update(sql,price,name);
	}
	
}

public interface UserDao {
	/**
	 * 轉賬
	 */
	public void outPrice(String name,double price);
	
	/**
	 * 收賬
	 */
	public void intPrice(String name,double price);
}

userService,userServiceImpl

public interface UserService {
	public void out(String name,String name2,double price);
}

import javax.annotation.Resource;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class UserServiceImpl implements UserService{

	@Resource(name="userDao")
	public UserDao userDao;
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	// 事務模板
	private TransactionTemplate transactionTemplate;
	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}

	@Override
	public void out(String name, String name2, double price) {
		// TODO Auto-generated method stub
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus tr) {
				// TODO Auto-generated method stub
				userDao.intPrice(name, price);
				int a = 1 / 0;
				userDao.outPrice(name2, price);
			}
		}
		);
	}

}


1. 程式設計式的事務管理

    在 service 中使用TransactionTemplate
    TransactionTemplate 依賴 DataSourceTransactionManager
    DataSourceTransactionManager依賴DataSource構造

    1.1 在 applicationContext 中配置事務管理器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd"
       >
    <!-- 資料庫配置檔案 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
	<!-- 建立資料來源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" >
		<property name="driverClassName" value="${driver}"></property>
		<property name="url" value="${url}"></property>
		<property name="username" value="${name}"></property>
		<property name="password" value="${password}"></property>
		<property name="maxActive" value="10"></property>
		<property name="maxIdle" value="5"></property>
	</bean>       
	 
	<!-- 配置資料層 -->
	<bean id="userDao" class="com.zyh.UserDaoImpl" scope="prototype">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置業務層 -->
	<bean id="userService" class="com.zyh.UserServiceImpl" scope="prototype">
		<property name="userDao" ref="userDao"></property>
		<!-- 注入事務管理的模板 -->
		<property name="transactionTemplate" ref="transactionTemplate"></property>
	</bean>
	
	
	<!-- 程式設計式的事務管理 -->
	
	<!-- 建立事務管理 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 將資料連線注入過來 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 建立一個 事務管理模板 簡化 底層程式碼   -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<!-- 將真正進行事務管理的 注入進來 -->
		<property name="transactionManager" ref="transactionManager"></property>
	</bean>
</beans>

1.2  在 service 實現類中注入 transactionTemplate 模板來實現事務管理

// 當在service 方法中注入了transactionTemplate 那麼在 applicationContext 中相應的 service 
		//	也注入transactionTemplate
		private TransactionTemplate transactionTemplate;

		public void setTransactionTemplate(TransactionTemplate transactionTemplate){
			this.transactionTemplate = transactionTemplate;
		}

		然後呼叫 transactionTemplate 中的方法 execute 
		此方法呢需要一個匿名內部類  new TransactionCallbackWithoutResult(){
				@Override
			protected void doInTransactionWithoutResult(TransactionStatus tr) {
				// TODO Auto-generated method stub
				userDao.intPrice(name, price);
				int a = 1 / 0;
				userDao.outPrice(name2, price);
			}
		}

1.3 然後進行測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest {

	@Resource(name="userService")
	public UserService userService;
	

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	@Test
	public void springDemo() {
		userService.out("aaa", "bbb", 200);
	}
}

然後檢視資料庫,發現中間發生異常,事務是不會提交的


2. spring宣告式的事務管理

    宣告式的事務管理是基於spring aop思想的

     將環境恢復到 一開始狀態,(將所有的關於 transactionTemplate 的都刪除)

1. 配置事務管理 
   <!-- 建立事務管理 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 將資料連線注入過來 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
2. 配置代理 
<!-- 配置 代理 -->
	<bean  id="userServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 配置目標物件 -->
		<property name="target" ref="userService"></property>
		<!-- 注入事務管理 -->
		<property name="transactionManager" ref="transactionManager"></property>
		<!-- 注入事務屬性 -->
		<property name="transactionAttributes">
			<props>
				<!-- 
					prop格式:
						PROPAGATION    : 事務的傳播行為
						ISOLATION      : 事務的隔離級別
						readOnly	   : 只讀
						-Exception	   : 發生哪些異常回滾事務
						+Exception	   : 發生那修異常事務不會滾
						
				 -->
				<prop key="out">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
然後service層不需要再進行修改了,只需要修改SpringTest

    將userService的 注入換為 userServiceProxy

import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest {

	/**
	 * 注入代理類
	 */
	
//	@Resource(name="userService")
	@Resource(name="userServiceProxy")
	public UserService userService;
	

	@Test
	public void springDemo() {
		userService.out("aaa", "bbb", 200);
	}
}

然後進行測試.成功,   當有異常的時候是不會進行 事務提交,沒有異常正常提交事務.

然後在 配置檔案 bean userServiceProxy 的 事務屬性中

<!-- 注入事務屬性 -->
		<property name="transactionAttributes">
			<props>
				<!-- 
					prop格式:
						PROPAGATION    : 事務的傳播行為
						ISOLATION      : 事務的隔離級別
						readOnly	   : 只讀
						-Exception	   : 發生哪些異常回滾事務
						+Exception	   : 發生那修異常事務不會滾
						
				 -->
				<prop key="out">PROPAGATION_REQUIRED,readOnly</prop>
			</props>
		</property>

多配置一個readonly 然後進行測試會 報異常


因為進行的是修改操作.所有當設定為只讀的話 就會報異常


上面那個是第一種方式 基於 TransactionProxyFactoryBean的原始方式
    
    缺點 只能對一個業務層類 管理,當有多個模組的話就需要配置多個Proxy來實現事務管理
    宣告式事務管理,第二種方式As

    在 applicationConext 中

    

<!-- 配置事務的通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 
				propagation	: 事務傳播行為
				isolation	: 事務隔離級別
				readOnly	: 只讀
				rollback-for : 發生哪些異常回滾
				no-rollback-for: 發生哪些異常不回滾
				timeout	: 過期資訊
			 -->
			<tx:method name="out" propagation="REQUIRED" isolation="DEFAULT" />
		</tx:attributes>
	</tx:advice>
	
	
	<!-- 配置切面 -->
	<aop:config>
		<!-- 配置切入點 -->
		<aop:pointcut expression="execution(* zyh.UserService+.*(..))" id="pointcut1"/>
		<aop:advisor advice-ref="pointcut1" pointcut="pointcut1"/>
	</aop:config>
	
	這種方式的只需要在配置檔案配置後就可以 實現對事務管理, 代理物件在對應類生成時生成



	第三種 基於註解的 宣告式事務管理


	<!-- 開啟事務註解 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>


	然後只需要在 指定的類上面新增Transactional

	/**
	 * 	propagation	: 事務傳播行為
				isolation	: 事務隔離級別
				readOnly	: 只讀
				rollback-for : 發生哪些異常回滾
				no-rollback-for: 發生哪些異常不回滾
				timeout	: 過期資訊
	 */
	@Transactional
	public class UserServiceImpl implements UserService


相關推薦

看了慕課的spring事務管理,然後整理了一下,以便以後自己學習

事務的特性:     1. 原子性.         事務是一個不可分割的整體,要麼都失敗,要麼都成功     2. 一致性:     &nb

Spring整理系列(17)————循序漸進了解spring事務管理的幾種方式

先從例項開始。。。。 一、例項基本業務為銀行轉賬，A賬戶向B賬戶轉賬，業務執行過程要保證A、B兩個帳號資料操作同時成功或失敗，此時就需要事務進行控制，基本例項程式碼如下： 轉賬DAO： public interface AccountDao {

spring事務管理 TransactionProxyFactoryBean源碼分析

java 事務管理 J2EE，當然離不開事務，事務又當然少不了Spring聲明式事務。spring聲明式事務，很多碼農門，應該和筆者一樣，停留在使用上，及僅僅了解點原理。如:Spring事務管理原理“代理+AOP”，再深入了解就不太清楚了。一直對聲明式事務實現特別感興趣，今天抽時間，剖析一下下。1.準

Spring事務管理

classpath 依賴 font word .get 執行 pointcut str 攔截 1、導入jar包 spring核心包 commons-logging.jar spring-beans.jar spring-context.jar spring-core.jar

Spring事務管理----------整合學習版

XML idt 類定義 dao mda info spring配置 讀取數據 blue 作者：學無先後 達者為先 Spring提供了一流的事務管理。在Spring中可以支持聲明式事務和編程式事務。 一 spring簡介 1 Spring的事務 事

spring事務管理，xml配置aop事務和註解配置aop事務

mov ref itcast template password nds eth poi ntc xml配置和註解配合共同代碼 AccountService.java public interface AccountService { //轉賬方法

spring 事務管理的簡單配置

ger string oot code nal chan 價格 nts 每次 1：事務的優點 　　事務管理對平時的業務邏輯的健壯性幫助很大，它保證了一個動作的原子性 　　本例中主要體現在，購票或者購書中，業務邏輯如下： 　　　　1：根據商品的ID查詢該商品的價格， 　　　　

（轉）spring事務管理幾種方式

pac jpg gets point aos load man classpath XML 轉自：http://blog.csdn.net/jeamking/article/details/43982435 前段時間對Spring的事務配置做了比較深入的研究，在此之間對

Spring事務管理API

logs 技術 -1 blog 9.png src es2017 http .cn Spring事務管理API

spring事務管理aop

jdbc tran err att get ted cor cep pack 達內12 note unit 09 01 1.spring事務管理 2.spring提供了對事務管理支持 spring采用aop機制完成事務控制 可以實現在不修改原有組件代碼情況下實現事務控制功能

Java Spring-事務管理概述

dot nat 框架 3.0 信息 commit int 效率 cti 2017-11-11 23:05:39 事務（Transaction）：是邏輯上一組操作，要麽全都成功，要麽全都失敗。 一、事務的特性 原子性:事務不可分割 一致性:事務執行的前後，數據完整性保持一致

（轉）Spring事務管理（詳解+實例）

Spring---AOP註解開發&jdbc模板&Spring事務管理

use oca update -m spl pub tex com att 一、AOP註解開發 　　此處需要回憶一遍AOP的概念。簡單的來說，AOP就是利用動態代理技術，做到不觸動源代碼但卻擴展了功能。那麽就需要一個被擴展的對象和一個“新的功能”，例如說給某類的saveUs

[Spring框架]Spring 事務管理基礎入門總結.

復制 tor junit4 dao img bubuko 說過 應該 pat 前言:在之前的博客中已經說過了數據庫的事務, 不過那裏面更多的是說明事務的一些鎖機制, 今天來說一下Spring管理事務的一些基礎知識. 之前的文章: [數據庫事務與鎖]詳解一: 徹底理解數據庫

Spring事務管理Transaction【轉】

集成 class advice nag batis spring3 ont weblogic tex Spring提供了許多內置事務管理器實現（原文鏈接：https://www.cnblogs.com/qiqiweige/p/5000086.html）： DataSo

spring-事務管理

ring 並發 有一個 不一致 狀態 隔離 src AC 分享圖片 事務是一系列的動作，一旦其中有一個動作出現錯誤，必須全部回滾，系統將事務中對數據庫的所有已完成的操作全部撤消，滾回到事務開始的狀態，避免出現由於數據不一致而導致的接下來一系列的錯誤。事務的出現是為了確保數據

Spring -事務管理

比較 代碼量 數據庫操作 manager 而在 異常類 transacti cti 管理 Java事務導引 事務：正確執行一系列操作(或動作)，使得數據庫從一種狀態轉移成另一種狀態，保證操作全部成功，或者全部失敗 事務原則：服從ISO/IEC指定的ACID原則

spring 事務管理

事務 spring 特性 一、事務的概念 事務（Transaction），一般是指要做的或所做的事情。在計算機術語中是指訪問並可能更新數據庫中各種數據項的一個程序執行單元(unit)。 二、事務的四個特性 1、原子性（Atomicity）：事務是一個原子操作，由一系列動作組成。事務

Spring事務管理總結

需求 應用 def 關系數據庫 stat 啟動 全部 test data 事務定義 　　事務管理對於企業應用來說是至關重要的，主要作用是用來保證數據的一致性，比如轉賬問題。如下偽代碼所示： transaction begin A賬戶扣100 B賬戶加100

Spring事務管理 與 SpringAOP

nsf 新建 spring事務 釋放資源 pre pan 基本配置 特定 details 1，Spring事務的核心接口 　　Spring事務管理的實現有許多細節，如果對整個接口框架有個大體了解會非常有利於我們理解事務，下面通過講解Spring的事務接口來了解Spring實