Spring学习记录-05

最新推荐文章于 2024-07-09 17:58:26 发布

韩雨泽_97

最新推荐文章于 2024-07-09 17:58:26 发布

阅读量124

点赞数

分类专栏： spring学习记录文章标签： spring java

本文链接：https://blog.csdn.net/qq_43572551/article/details/105575797

版权

spring学习记录专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、事务

1.什么是事务？

事务是指数据库中的一组逻辑操作，这个操作的特点就是在该组逻辑中，所有的操作要么全部成功，要么全部失败。在各个数据具有特别紧密的联系时，最好是使用数据库的事务来完成逻辑处理。例如转账业务就是一个事务。

MySQL数据库默认事务是自动提交的，也就是发一条SQL数据库就执行一条。如果想将多条SQL放置在一个事务中执行，就必须使用如下语句：

start  transaction
sql1
sql2
…
commit

当开启事务后(start transaction)，无论数据库是否对其中的多条SQL语句是否执行成功，只要没有提交事务(commit)，都会将之前执行的SQL进行回滚。使数据回到开启事务之前的值。

2.事务的四大特性（ACID）

2.1.原子性（Atomicity）

原子性指事务包含的所有操作要么全部成功，要么全部失败然后回滚；事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

2.2.一致性（Consistency）

一致性指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
例如转账，假设用户A和用户B两者钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户钱相加起来应该还得是5000，这就是事务的一致性。

2.3.隔离性（Isolation）

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事物的操作所干扰，多个并发事务之间要相互隔离。
关于事务的隔离性，数据库提供了多种隔离级别。
即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

2.4.持久性（Durability）

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

3.事务的隔离性

当多个线程都开启事务操作数据库中的数据时，数据库系统要能进行隔离操作，以保证各个线程获取数据的准确性。如果不考虑事务的隔离性，会发生的几种问题：

3.1.脏读

脏读是指一个事务处理过程里读取了另一个未提交的事务中的数据。当一个事务正在多次修改某个数据，而在这个事务中这多次的修改都还没提交，这时一个并发的事务来访问该数据，就会造成两个事务得到的数据不一致。

3.2.不可重复读

不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。
例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务給数据库，事务T1再次读取该数据就得到了不同的结果，发生了不可重复读。

3.3.虚读（幻读）

幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果在查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

3.4.不可重复读和幻读的区别

不可重复读和幻读的区别：不可重复读是读取到了另一事务的更新；而幻读是读取到了另一事务的插入（MySQL中无法测试到幻读）；

4.事务的四大隔离级别

4个等级的事务隔离级别，在相同数据环境下，使用相同的输入，执行相同的工作，根据不同的隔离级别，可以导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力是不同的。
在MySQL中的默认隔离级别为REPEATABLE READ

4.1.SERIALIZABLE（串行化）

不会出现任何并发问题，因为它是对同一数据的访问是串行的，非并发访问的；
性能最差。

4.2.REPEATABLE READ（可重复读）（MySQL）

防止脏读和不可重复读，不能处理幻读的问题；
性能比SERIALIZABLE好。

4.3.READ COMMITTED（读已提交数据）（Oracle）

防止脏读，没有处理不可重复读，也没有处理幻读；
性能比REPEATABLE READ好。

4.4.READ UNCOMMITTED（读未提交数据）

可能出现任何事务并发问题；
性能最好.

二、Spring中的事务控制

1.Spring事务控制的API

1.1.PlatformTransactionManager

在这里插入图片描述
在我们的开发中都是使用它的实现类，如下：
真正管理事务的对象

org.springframework.jdbc.datasource.DataSourceTransactionManager 使用 SpringJDBC 或 iBatis 进行持久化数据时使用
org.springframework.orm.hibernate5.HibernateTransactionManager 使用Hibernate 版本进行持久化数据时使用

1.2.TransactionDefinition

它是事务的定义信息对象，里面有如下方法：在这里插入图片描述

事务的传播行为
在这里插入图片描述
超时时间
默认值是-1，没有超时限制。如果有，以秒为单位进行设置。

是否是只读事务
建议查询时设置为只读。

1.3.TransactionStatus

此接口提供的是事务具体的运行状态，方法介绍如下图：在这里插入图片描述

2.基于XML的声明式事务控制

2.1.导入依赖和约束

pom.xml中代码如下：

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
		
		
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        
		// 事务控制
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
		
		// 事务控制是基于 AOP 的
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

bean.xml中代码如下：

<?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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

2.2.代码

实体类：

/**
 * 账户的实体类
 */
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

持久层：

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    @Override
    public Account findAccountByName(String accountName) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
    }
}

业务层/事务控制：

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;

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

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }



    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0; 

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

2.3.bean.xml中配置业务层、持久层、数据源

<!-- 配置业务层-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

2.4.基于XML 的声明式事务控制配置步骤

1.配置事务管理器

2.配置事务的通知

<!-- 事务的配置 --> 
	<tx:advice id="txAdvice" transaction-manager="transactionManager"> 
	</tx:advice>

3.配置事务的属性

<tx:advice id=“txAdvice” transaction-manager=“transactionManager”>

tx:attributes
<tx:method name="" propagation=“REQUIRED” read-only=“false”/>
<tx:method name="find" propagation=“SUPPORTS” read-only=“true”></tx:method>
</tx:attributes>
</tx:advice>
4.配置AOP切入点表达式

<!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
    </aop:config>

5.配置切入点表达式和事务通知的对应关系

<!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>

3.基于注解的配置方式

3.1.导入依赖和约束，并配置扫描的包

bean.xml配置

<?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.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.smallbeef"></context:component-scan>
	
	// 因为jdbcDaoSupport不支持注解，所以我们得用jdbcTemplate
	 <!-- 配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

3.2.使用注解把Dao层和Serice层给Spring管理

@Repository("accountDao")

@Service("accountService")

3.3.基于注解的声明式事务控制配置步骤

1.配置事务管理器并注入数据源

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

2.开启Spring对注解事务的支持

<!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

可以在配置类中用注解 @EnableTransactionManagement 替换
3.在需要事务支持的地方（业务层）使用@Transational注解

@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService{

    @Autowired
    private IAccountDao accountDao;


    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }


    //读写型事务配置
    @Transactional(propagation= Propagation.REQUIRED,readOnly=false)
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

该注解的属性和 xml 中的属性含义一致。
该注解可以出现在接口上，类上和方法上。

出现接口上，表示该接口的所有实现类都有事务支持。
出现在类上，表示类中所有方法有事务支持
出现在方法上，表示该方法有事务支持。

以上三个位置的优先级：方法 > 类 > 接口

韩雨泽_97

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习记录-05

目录一、事务1.什么是事务？2.事务的四大特性（ACID）2.1.原子性（Atomicity）2.2.一致性（Consistency）2.3.隔离性（Isolation）2.4.持久性（Durability）3.事务的隔离性3.1.脏读3.2.不可重复读3.3.虚读（幻读）3.4.不可重复读和幻读的区别4.事务的四大隔离级别4.1.SERIALIZABLE（串行化）4.2.REPEATABLE R...
复制链接

扫一扫