Operações de transação de primavera
1. O conceito de negócios
a) O que é uma transação
(1) A transação é a unidade mais básica das operações do banco de dados. Logicamente, um grupo de operações será bem-sucedido. Se um falhar, todas as operações falharão.
(2) Cenário típico: transferência bancária Zhang San transfere 100 yuans para Li Si; Zhang Sanshao 100, Li Sidao 100
b) quatro propriedades de transação (o átomo ACID (. 1) de (2) Consistência (3) isolamento) (4) artigo de visão persistente descrito
2. Operação de transação (simulando o ambiente de operação de transação)
A) Criar serviço, construir dao, criação completa de objetos e relacionamento de injeção
//（1）service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource
@Service
public class UserService {
//注入 dao
@Autowired
private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
}
B) Crie dois métodos no dao: método de mais dinheiro e menos dinheiro, método de criação de serviço (método de transferência)
@Repository
public class UserDaoImpl implements UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
//lucy 转账 100 给 mary
//少钱
@Override
public void reduceMoney() {
String sql = "update t_account set money=money-? where username=?";
jdbcTemplate.update(sql,100,"lucy");
}
//多钱
@Override
public void addMoney() {
String sql = "update t_account set money=money+? where username=?";
jdbcTemplate.update(sql,100,"mary");
}
}
@Service
public class UserService {
//注入 dao
@Autowired
private UserDao userDao;
//转账的方法
public void accountMoney() {
//lucy 少 100
userDao.reduceMoney();
//mary 多 100
userDao.addMoney();
}
}
/**
上边代码正常执行没有问题，
但是如果代码执行过程中出现异常，有问题，如下模拟异常！
*/
@Service
public class UserService {
//这里执行后将会产生错误（异常），lucy 少 100后，mary不会多 100，这就不对了！！
private UserDao userDao;
//转账方法
public void accountMoney(){
userDao.reduceMoney();//lucy 少 100
int x=10/0;
userDao.addMoney(); //mary 多 100
}
}
//解决上边的异常方法——【编程式事务（传统方法）】
//转账的方法
public void accountMoney() {
try {
//第一步 开启事务
//第二步 进行业务操作
//lucy少100
userDao.reduceMoney();
//模拟异常
int i = 10/0;
//mary多100
userDao.addMoney();
//第三步 没有发生异常，提交事务
}catch(Exception e) {
//第四步 出现异常，事务回滚
}
}
3. Operação de transação (introdução ao gerenciamento de transações Spring)
1. A transação é adicionada à camada de serviço (camada de lógica de negócios) na estrutura de três camadas JavaEE
2. Realizar operações de gerenciamento de transações no Spring; dois métodos: gerenciamento de transações programáticas, gerenciamento de transações declarativas (recomendado)
3. Gerenciamento de transação declarativa (1) Com base no método de anotação (recomendado) (2) Com base no método de arquivo de configuração xml
4. Gerenciamento de transações declarativas no Spring,Use AOP na parte inferior princípio
5. API de gerenciamento de transações Spring: Fornece uma interface que representa o gerenciador de transações.Esta interface fornece diferentes classes de implementação para diferentes estruturas
4. Gerenciamento de transações declarativas anotadas
<!--1、在 spring 配置文件配置事务管理器-->
<!--创建事务管理器-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2、在 spring 配置文件，开启事务注解,引入名称空间！-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--开启事务注解-->
<tx:annotation-driven transactionmanager="transactionManager"></tx:annotation-driven>
<!--3、在 service 类上面（或者 service 类里面方法上面）添加事务注解-->
<!--
（1）@Transactional，这个注解添加到类上面，也可以添加方法上面
（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务
（3）如果把这个注解添加方法上面，为这个方法添加事务——@Transactional
-->
5. Operação de transação (configuração de parâmetro de gerenciamento de transação declarativa)
Transacional (comportamento de propagação da transação)
A) Adicione a anotação @Transactional à classe de serviço, e você pode configurar os parâmetros relacionados à transação nesta anotação
B) propagação (comportamento de propagação da transação): vários métodos de transação são chamados diretamente, como as transações são gerenciadas neste processo
C) Existem sete tipos de comportamentos de propagação de transação do Spring Framework: apenas dois comportamentos de propagação comumente usados são apresentados abaixo
@Transactional(propagation = Propagation.REQUIRED,) //事务一 public void add(){ //调用update方法 update(); } public void update(){ //事务二 }
(1) OBRIGATÓRIO : Se o próprio método add tiver uma transação, após chamar o método update, update usa a transação no método add atual;
Se o próprio método add não tiver nenhuma transação, depois de chamar o método update, crie uma nova transação
(2) REQUIRED_NEW : Use add para chamar o método de atualização, independentemente de o método add ter uma transação, uma nova transação será criada.
ioslação (nível de isolamento de transação)
A) As transações têm características de isolamento, não havendo impacto entre as operações multi-transações. Existem muitos problemas sem considerar o isolamento
b) Existem três problemas para ler: leituras sujas, leituras não repetíveis imaginária (fantasma) Visualização de leitura apresentada aqui
Leitura suja: uma transação não confirmada lê dados de outra transação não confirmada
Leitura não repetível: uma transação não confirmada lê para outra transação confirmada para modificar dados
Leitura virtual: uma transação não confirmada lê para outra transação confirmada para adicionar dados
C)) Resolver: resolver o problema de leitura, definindo o nível de isolamento da transação
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
tempo limite: período de tempo limite
(1) A transação precisa ser enviada dentro de um determinado período de tempo, se não for enviada, será revertida (2) O valor padrão é -1 (sem tempo limite), e o tempo definido é calculado em segundos
somente leitura: seja somente leitura
(1) Ler: operação de consulta, gravação: adicionar, modificar, excluir operação
(2) O valor padrão de readOnly é falso, o que significa que pode ser consultado e adicionado, modificado e excluído.
(3) Defina o valor readOnly como verdadeiro, depois de defini-lo como verdadeiro, você só pode consultar
rollbackFor: rollback
Defina quais exceções ocorrem para reversão de transação
noRollbackFor: não reverter
Defina quais exceções ocorrem sem reversão de transação
6. Operação de transação (gerenciamento de transação declarativa XML)
a) Configure no arquivo de configuração do spring: a primeira etapa é configurar o gerenciador de transações, a segunda etapa é configurar a notificação, a terceira etapa é configurar o ponto de entrada e aspecto
<!--1 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2 配置通知-->
<tx:advice id="txadvice">
<!--配置事务参数-->
<tx:attributes>
<!--指定哪种规则的方法上面添加事务-->
<tx:method name="accountMoney" propagation="REQUIRED"/>
<!--<tx:method name="account*"/>-->
</tx:attributes>
</tx:advice>
<!--3 配置切入点和切面-->
<aop:config>
<!--配置切入点-->
<aop:pointcut id="pt" expression="execution(*
com.atguigu.spring5.service.UserService.*(..))"/>
<!--配置切面-->
<aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>
7. Operação de transação (gerenciamento de transação declarativa totalmente anotada)
//1、创建配置类，使用配置类替代 xml 配置文件
@Configuration //配置类
@ComponentScan(basePackages = "com.atguigu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
//创建数据库连接池
@Bean
public DruidDataSource getDruidDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///test");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}
//创建 JdbcTemplate 对象
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
//从IOC容器中拿到配置注入的数据源
//到 ioc 容器中根据类型找到 dataSource
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//注入 dataSource
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
//创建事务管理器
@Bean
public DataSourceTransactionManager
getDataSourceTransactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}