[Notes] à partir de zéro pour apprendre la gestion des transactions de Spring Spring

Nous pouvons nous concentrer sur le compte de l'auteur, l'accent sur l'apprentissage à partir de zéro note Spring Collection. Nous pouvons également apprendre d'un catalogue visiter le blog de jardin blog de l'auteur. Les documents de film l'apprentissage et le partage d'informations sur les programmeurs basés sur l'emploi vidéo sombre classe cheval, et d'enregistrer des notes et leurs propres vues. Bienvenue à apprendre et discuter.

[Notes] Ressort apprendre à partir de zéro parcours d'apprentissage

ce qui importe

Transaction: un ensemble d'opérations logiques sur la composition des unités respectives de l'opération de jeu, que ce soit tout réussir ou tout échec.

Caractéristiques de la transaction

Atomique: Une transaction indivisible
cohérence: exécutée avant et après l'intégrité des données de transaction cohérente
Isolation: l' exécution d' une transaction ne devrait pas être soumis à des interférences d'autres opérations
persistance: Une fois la fin de la transaction, les données sont à la base de données a persisté

Si vous ne considérez pas l'isolement causé par des problèmes de sécurité

• Problèmes de lecture
  sale lire: Une transaction lit les données d' une autre transaction non validée
  ne peut pas répéter lecture: Une transaction lit mise à jour des données d' une autre transaction a été soumise, ce qui entraîne dans une transaction plusieurs résultats de la requête à différents
  lit fantôme, fantôme lit comme suit: les données de transaction insert lire une autre transaction a été soumise, ce qui dans un multiple de transaction interroge des résultats incohérents.
• problème d' écriture
  des mises à jour perdues

La lecture résoudre le problème

Réglez le niveau d'isolation des transactions

• Lecture non validée: lecture non validée, lire tout problème ne peut être résolu. (Efficacité le plus élevé, mais moins sûr)
  la lecture validée: Read Committed pour résoudre le sale lire, mais les lectures non reproductibles et les lectures fantômes peuvent se produire.
  lecture répétable: lecture répétable, résoudre sale lit et les lectures non reproductibles, mais les lectures fantômes peuvent se produire.
  Serializable: lecture résoudre tous les problèmes.

API de gestion des transactions de printemps

PlatformTransactionManager: Plate-forme Gestionnaire de transactions

Plate-forme Gestionnaire de transactions: Interface, est la cible réelle pour les transactions gérées par Spring.

• DataSourceTransactionManager: la gestion des transactions sous - jacente en utilisant JDBC
  HibernateTransactionManager: la gestion des transactions sous - jacente en utilisant Hibernate

TransactionDefinition: informations de définition de transaction

Transaction Définition: informations connexes utilisés pour définir le niveau d'isolation des transactions, des informations de délai d'attente, le comportement de communication, que ce soit ou non en lecture seule

TransactionStatus: état des choses

L'état des choses: l'état des affaires de l'objet enregistré dans le processus de gestion des transactions.

: Transaction API Relationship Management
lorsque la gestion des transactions Spring Première plate - forme Gestionnaire de transactions La définition de transaction de la transaction de gestion de l' information, le processus de gestion des transactions, ce qui dans divers états, ces états d' enregistrement d' informations à l' état de transaction objets dans.

comportement de propagation ressort

Dans le développement réel, en particulier, vous pouvez rencontrer couche logique métier complexe, de nombreuses affaires, peuvent également appeler les uns les autres. Cette fois , nous devons procéder à une gestion du comportement de propagation des transactions.
Spring fournit le comportement de propagation de la transaction sept:
pour assurer une pluralité d'opérations dans la même transaction
$ \ color {red} {** } PROPAGATION_REQUIRED $: valeur par défaut, s'il y a une transaction en utilisant la transaction A, l'opération il inclus. Si A ne crée pas une nouvelle transaction, l'opération comprendra qu'il
PROPAGATION_SUPPORTS: Services de soutien, si A a une transaction, utilisez les transactions A. A S'il n'y a pas de transaction, la transaction n'est pas utilisé.
PROPAGATION_MANDATORY: A S'il y a une transaction, utilisez les transactions A. A S'il n'y a pas de transaction, lancer une exception.

Assurez -vous de multiples opérations dans une transaction non dans le même
$ \ color {red} {** } $ PROPAGATION_REQUIRES_NEW: A S'il y a une transaction, la transaction Un coup (pause), créer une nouvelle transaction, ne contenant que ses propres opérations. Si A est pas une transaction, créez une nouvelle transaction, y compris ses propres opérations.
PROPAGATION_NOT_SUPPORTED: A S'il y a une transaction, la transaction A en attente. Ne pas utiliser la gestion des transactions.
PROPAGATION_NEVER: A S'il y a une transaction, a rapporté anormale.

Emboîtée transaction
$ \ color {red} {** } $ PROPAGATION_NESTED: transactions imbriquées, si la transaction A, une transaction est effectuée conformément à, l'exécution est terminée, la fixation d' un point de sauvegarde, une opération B, s'il n'y a pas anomalie, est effectuée par, si anormale, peut sélectionner le plus rollback à la position initiale, elle peut être restaurée vers le point de sauvegarde.

environnement bâti gestion des transactions de printemps

Étape 1: Créer Senvice de classe d'interface et la mise en œuvre

package com.tyust.tx.demo1;

public interface AccountService {
		
	public void transfer(String form, String to ,Double money);

}

package com.tyust.tx.demo1;

public class AccountServiceImpl implements AccountService {
	
	private AccountDao accountDao; 

	@Override
	/**
	 * from:传出账户
	 * to:转入账户
	 * money：金额
	 */
	public void transfer(String form, String to, Double money) {
		accountDao.outMoney(form, money);
		accountDao.inMoney(to, money);
		
	}

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	

}

Étape 2: Création d'une interface DAO et la classe de mise en œuvre

package com.tyust.tx.demo1;

import org.springframework.jdbc.core.JdbcTemplate;

public interface AccountDao {

	public void outMoney(String from, double money);

	public void inMoney(String to, double money);

}
package com.tyust.tx.demo1;

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

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

	@Override
	public void outMoney(String from, double money) {
		this.getJdbcTemplate().update("update account set money = money - ? where name = ?", money, from);

	}

	@Override
	public void inMoney(String to, double money) {
		this.getJdbcTemplate().update("update account set money = money + ? where name = ?", money, to);

	}

}

Troisième étape: Configurer Senvice et DAO: Spring pour gérer

<bean id = "accountDao" class="com.tyust.tx.demo1.AccountDaoImpl">
	<property name="dataSource" ref="ds"></property>
	</bean>
	<bean id = "accountService" class="com.tyust.tx.demo1.AccountServiceImpl">
	<property name="accountDao" ref="accountDao"></property>
	</bean>

Quatrième étape: Configuration du pool de connexion JDBC et modèles

 <context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置C3p0连接池 -->
	<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"></property>
	</bean>

Cinquième étape: Test

package com.tyust.tx.demo1;

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:tx.xml")
public class SpringDemo {
	
	@Resource(name = "accountService")
	private AccountService accountService;
	

	@Test
	public void demo() {
		accountService.transfer("关羽", "张飞", 1000d);
	}
}

sortie

Pourquoi des affaires d'introduction

Le cas est pas de méthode de mise en œuvre de la transaction, si la méthode de transfert de transit () et un transfert anormal entre, il se révélera à réaliser, et le transfert ne se matérialiser, ce qui dans la vie réelle n'est pas autorisé. Il est donc nécessaire de protéger la transaction

La gestion des transactions de printemps - transaction programmatique (besoin d'écrire du code manuellement)

Étape 1: Configurer la plate-forme Gestionnaire de transactions

	<!-- 配置事务平台管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

Deuxième étape: Spring fournit une gestion des transactions de classe modèle

<bean id="transactionTemplate"
		class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"></property>
	</bean>

La troisième étape: la gestion des transactions modèle dans l'injection de la couche d'affaires

//注入事务管理的模板
	private TransactionTemplate transactionTemplate;

</bean>
	<bean id="accountService"
		class="com.tyust.tx.demo1.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"></property>
		<property name="transactionTemplate"
			ref="transactionTemplate"></property>
	</bean>

La quatrième étape: le code de gestion des transactions d'écriture

public void transfer(final String form,final String to, final Double money) {
		
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
				accountDao.outMoney(form, money);
				int i =1/0;
				accountDao.inMoney(to, money);
			}
		});
}

Cinquième étape: test les
résultats ne semblent pas réaliser le déploiement, mais ne se rendent pas compte de la situation en

La gestion des transactions de printemps - la gestion déclarative des transactions (en configurant) --- AOP

approche XML de gestion déclarative des transactions

La première étape: l'introduction aop Development Kit

Deuxième étape: Transfert pour restaurer l'environnement
à ajouter un exemple d'un éditeur de code de transaction pour supprimer toutes
Troisième étape: Configurer le gestionnaire de transactions

<bean id ="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

Quatrième étape: Configurer Enhanced

        <!-- 配置事务的增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
	 <tx:method name="*" propagation="REQUIRED"/>
	</tx:attributes>
</tx:advice>

事务管理规范
<tx: nom de la méthode = "Enregistrer " propagation = "nécessaire" isolement = "DEFAULT" />
<tx: nom de la méthode = "mise à jour " propagation = "EXIGE" />
<tx: nom de la méthode = "supprimer " propagation = "EXIGE" />
<tx: nom de la méthode = "trouver " lecture seule = "true" />

lecture seule: lecture seule, ajouts et suppressions vérifier non seulement
délai d' attente: -1 -> été efficace

Cinquième étape: configuration AOP

    <aop:config>
	<aop:pointcut expression="execution(* com.tyust.tx.demo2.AccountServiceImpl.*(..) )" id="pointcut1"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>

Sixième étape: tester les
résultats ne semblent pas réaliser le déploiement, mais ne se rendent pas compte de la situation en

notes d'approche de gestion des transactions déclarative

La première étape: Kit de développement introduit aop de
deuxième étape: Transfert à restaurer l'environnement
Troisième étape: Configurer le gestionnaire de transactions
trois premières étapes avant que l'
étape 4: Activer les notes des affaires

<tx:annotation-driven transaction-manager="transactionManager"/>

Cinquième étape: annotations ajoutez dans la couche d'affaires

Seuls doivent AccountServiceImplsaisir ci - dessus plus des @Transactionnotes à
la sixième étape: tester les
résultats ne semblent pas réaliser le déploiement, mais ne se rendent pas compte de la situation en