[SpringBoot][6][SpringBoot整合数据库事务]

最新推荐文章于 2023-08-04 14:34:35 发布
最新推荐文章于 2023-08-04 14:34:35 发布
阅读量177 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w2857820060/article/details/104785888
版权

第 6 章 SpringBoot整合数据库事务

在互联网数据库的使用中，对于那些电商和金融网站，最关注的内容毫无疑问就是数据库事务。它们的业务存在高并发，数据库的数据一般在一个多事务的场景下运行，如果不采取一定手段就会造成数据的不一致。面对这样的高井发场景，掌握数据库事务机制是至关重要的，它能够帮助我们在一定程度上保证数据的一致性，并且有效提高系
统性能，避免系统产生宕机。

在Spring中，数据库事务是通过AOP技术来提供服务的。它擦除了JDBC中的大量冗余代码。

在Spring数据库事务中可以使用编程式事务，也可以使用声明式事务(@Transactional)。大部分的情况下，会使用更加简单的声明式事务。

6.1 JDBC的数据库事务

首先看看如何以JDBC的方式完成插入用户的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

@Service
public class JdbcServiceimpl implements JdbcService{
    @Autowired
    private DataSource dataSource = null;
    @Override
    public int insertUser(String userName , String note){
        Connection conn = null;
        int result = 0;
        try{
            //获取连接
            conn = dataSource.getConnection();
            //开启事务
            conn.setAutoCornrnit(false);
            //设置隔离级别
            conn.setTransactionIsolation(TransactionIsolationLevel.READ_COMMITTED.getLevel());
            //执行SQL
            PreparedStatement ps = conn.prepareStatement("insert into t_user(user name, note) values(?, ?)");
            ps.setString(1, userName);
            ps.setString(2, note);
            result=ps.executeUpdate();
            //提交事务
            conn.commit();
        }catch (Exception e){
            //回滚事务
            if(conn != null){
                try{
                    conn.rollback();
                }catch(SQLException el){
                    el.printStackTrace();
                    e.printStackTrace();
                }finally{
                    //关闭数据库连接
                    try{
                        if(conn !=null && !conn.isClosed()){
                            conn.close() ;
                        }
                    }catch (SQLException e){
                        e.printStackTrace ();
                    }
                } 
            }
        }
        return result;
    }
}

我们看到了数据库连接的获取和关闭以及事务的提交和回滚、大量的try...catch ...finally...语句。于是人们就开始不断地优化，使用Hibernate、MyBatis都可以减少这些代码，但是依旧不能完全去除开闭数据库连接和事务控制的代码，而AOP允许我们把那些公共的代码抽取出来，单独实现，如下面流程图所示

这个流程与我们AOP约定流程十分接近，而在图中，有业务逻辑的部分也只是执行SQL那一步骤，其他的步骤都是比较固定的，按照AOP的设计思想，就可以把除执行SQL这步之外的步骤抽取出来单独实现，这便是Spring数据库事务编程的思想。

6.2 Spring声明式事务的使用

6.2.1 Spring声明式数据库事务约定

对于声明式事务，需要通过@Transactional进行标注的，告诉Spring在什么地方启用数据库事务功能。这个注解可以标注在类或者方法上，当它标注在类上时，代表这个类所有公共(public)非静态的方法都将启用事务功能。

在@Transactional中，还允许配置许多的属性，如事务的隔离级别、异常类型和传播行为等。这些配置内容，是Spring IoC容器在加载时就会将这些配置信息解析出来，然后它把这些信息存到TransactionDefinition里，并且记录哪些类或者方法需要启动事务功能，采取什么策略去执行事务等。

Spring数据库事务约定如下

当Spring的上下文开始调用被@Transactional标注的类或者方法时，Spring就会产生AOP的功能。那么当它启动事务时，就会根据事务定义器内的配置去设置事务，首先是根据传播行为去确定事务的策略然后是隔离级别、超时时间、只读等内容的设置，设置事务并不需要开发者完成，而是Spring事务拦截器(Interpretor)根据@Transactional配置的内容来完成的。Spring就会开始调用开发者编写的业务代码。执行开发者的业务代码。如果都没有发生异常，Spring拦截器就会帮助我们提交事务，如果发生异常，就要判断一次事务定义器内的配置，如果事务定义器己经约定了该类型的异常不回滚事务就提交事务，如果没有任何配置，则会回滚事务，并且将异常抛出。无论发生异常与否，Spring都会释放事务资源，以保证数据库连接池正常可用。

一个使用@Transaction的例子。仅仅是使用一个@Transactional注解，标识insertUser方法需要启动事务机制，那么Spring就会按照上图那样，把insertUser方法织入约定的流程中，这样对于数据库连接的闭合、事务提交与回滚都不再需要我们编写任何代码了

1
2
3
4
5
6
7
8
9
10
11
12

/**** imports ****/
@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao = null;

	@Transactional
	public int insertUser(User user) {
		return userDao.insertUser(user);
	}
}
6.2.2 @Transcational的配置项

下面我们之前通过源码，查看@Transcational标签的配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package org.springframework.transaction.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    //通过bean name指定事务管理器
    @AliasFor("transactionManager")
    String value() default "";

    //同上
    @AliasFor("value")
    String transactionManager() default "";

    //指定传播行为
    Propagation propagation() default Propagation.REQUIRED;

    //指定隔离级别
    Isolation isolation() default Isolation.DEFAULT;

    //指定超时时间
    int timeout() default -1;

    //是否只读事务
    boolean readOnly() default false;

    //规定发生哪些异常时回滚
    Class<? extends Throwable>[] rollbackFor() default {};

    //规定发生哪些异常时回滚
    String[] rollbackForClassName() default {};

    //规定发生哪些异常时不回滚
    Class<? extends Throwable>[] noRollbackFor() default {};

    //规定发生哪些异常时不回滚
    String[] noRollbackForClassName() default {};
}
6.2.3 Spring事务管理器

在Spring事务流程中，事务的打开、回滚和提交是由事务管理器来完成的。事务管理器相关类图如下，其顶层接口为PlatformTransactionManager，最常用到的事务管理器是DataSourceTransactionManager。类图如下

1
2
3
4
5
6
7
8
9
10
11
12

package org.springframework.transaction;

import org.springframework.lang.Nullable;

public interface PlatformTransactionManager extends TransactionManager{
    //获取事务
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    //提交事务
    void commit(TransactionStatus var1) throws TransactionException;
    //回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}

Spring在事务管理时，就是将这些方法按照约定织入对应的流程中的，在SpringBoot中，当你依赖于mybatis-spring-boot-starter之后，它会自动创建一个DataSourceTransactionManager对象作为事务管理器。如果依赖于spring-boot-starter-data-jpa，则它会自动创建JpaTransactionManager对象作为事务管理器，所以我们一般不需要自己创建事务管理器而直接使用它们即可。

6.3 隔离级别

6.3.1 丢失更新

在多个事务同时操作数据的情况下，会引发丢失更新的场景。

第一类丢失更新是指一个事务回滚另外一个事务提交而引发的数据不一致的情况。例子如下表所示，T5时刻事务l回滚，导致原本库存为99的变为了100，显然事务2的结果就丢失了，这就是一个错误的值。然而目前大部分数据库已经克服了第一类丢失更新的问题。

时刻事务1事务2
T1初始库存100初始库存100
T2扣减库存，余99
T3扣减库存，余99
T4提交事务，库存变为99
T5回滚事务，库存100

第二类丢失更新是指多个事务都提交引发的丢失更新，这是我们互联网系统需要关注的重点内容。例子如下表所示，T5时刻提交的事务。因为在事务l中，无法感知事务2的操作，这样它就不知道事务2己经修改过了数据，因此它依旧认为只是发生了一笔业务，所以库存变为了99 ，而这个结果又是一个错误的结果。

时刻事务1事务2
T1初始库存100初始库存100
T2扣减库存，余99
T3扣减库存，余99
T4提交事务，库存变为99
T5提交事务，库存变为99
6.3.2 详解隔离级别

为了压制丢失更新，数据库标准提出了4类隔离级别，在不同的程度上压制丢失更新，这4类隔离级别是未提交读、读写提交、可重复读和串行化

6.3.2.1 未提交读

未提交读(read uncommitted)是最低的隔离级别，其含义是允许一个事务读取另外一个事务没有提交的数据。
它的最大坏处是出现脏读。让我们看看可能发生的脏读场景，如下表所示。

时刻事务1事务2备注
T1商品库存初始化为2
T2读取库存为2
T3扣减库存库存为1
T4读取库存为1因为开启了未提交读，可以读取事务1中的库存为1
T5扣减库存事务2库存为0
T6提交事务数据库更新为0
T7回滚事务由于第一类丢失更新已经克服，此时不会回滚为2，库存为0，结束

因为采用未提交读，所以事务2可以读取事务l未提交的库存数据为1,这里当它扣减库存后则数据为0，然后它提交了事务，库存就变为了0，而事务l在T7时刻回滚事务，因为第一类丢失更新已经被克服，所以它不会将库存回滚到2，那么最后的结果就变为了0，这样就出现了错误。

6.3.2.2 读写提交

读写提交(read committed)隔离级别，是指一个事务只能读取另外一个事务已经提交的数据，不能读取未提交的数据。它可以克服脏读，如下表所示

时刻事务1事务2备注
T1商品库存初始化为2
T2读取库存为2
T3扣减库存库存为1
T4读取库存为2因为开启了读写提交，读取数据库中的库存为2
T5扣减库存事务2库存为1
T6提交事务数据库更新为1
T7回滚事务由于第一类丢失更新已经克服，此时不会回滚为2，库存为1，结束

在T4时刻，由于采用了读写提交的隔离级别，因此事务2不能读取到事务l中未提交的库存1,所以扣减库存的结果依旧为1，然后它提交事务，则库存在T6时刻就变为了l。T7时刻，事务l回滚，因为第一类丢失更新己经克服，所以最后结果库存为1，这是一个正确的结果。

但是读写提交可能会发生不可重复读的问题

时刻事务1事务2备注
T1商品库存初始化为1
T2读取库存为1
T3扣减库存此时不提交事务
T4读取库存为1认为可扣除
T5提交事务数据库库存为0
T6扣除库存失败，不可扣除，也因为此时库存已经是0

这里的问题在于事务2之前认为可以扣减，而到扣减那一步却发现已经不可以扣减

6.3.2.3 可重复读

可重复读的目标是克服读写提交中出现的不可重复读的现象，当尝试读取其他事务正在操作但未提交的数据时，数据库会阻塞这次读取，如下表所示

时刻事务1事务2备注
T1商品库存初始化为1
T2读取库存为1
T3扣减库存此时不提交事务
T4尝试读取库存不允许读取，等待事务1提交，阻塞事务2
T5提交事务库存为0
T6读取库存库存为0

但是可重复读无法克服最后一个问题——幻读，下面举一个例子，假设现在商品交易正在进行中，而后台有人也在
进行查询分析和打印的业务，如下表

时刻事务1事务2备注
T1读取库存50件商品库存初始化为100，现在已经销售50笔，库存50件
T2查询(count)销售记录50笔
T3扣减库存
T4插入1笔提交记录
T5提交事务库存为49件，销售记录51笔
T6打印销售记录51笔这里与查询的不一致，在事务2看来有1笔是虚幻的，与之前查询的不一致

因为销售记录的笔数是通过count统计销售记录表得到的，而商品库存则是存储在商品表中的字段。所以可重复读并不能进行阻塞，这就导致了幻读的问题

6.3.2.4 串行化

串行化(Serializable)是数据库最高的隔离级别，它会要求所有的SQL都会按照顺序执行，这样就可以克服上述隔离级别出现的各种问题，所以它能够完全保证数据的一致性。

6.3.2.5 使用合理的隔离等级

上述内容可总结为下表

项目类型脏读不可重复读幻读
未提交读yesyesyes
读写提交noyesyes
可重复读nonoyes
串行化nonono

追求更高的隔离级别，它能更好地保证了数据的一致性，但是也要付出锁的代价。有了锁，就意味着性能的丢失，
而且隔离级别越高，性能就越是直线地下降。在现实中一般而言，选择隔离级别会以读写提交为主，它能够防止脏读，而不能避免不可重复读和幻读。为了克服数据不一致和性能问题，程序开发者还设计了乐观锁，甚至不再使用数据库而使用其他的手段。例如，使用Redis作为数据载体。

使用隔离级别很简单，只需要在@Transactional配置对应即可

1
2
3
4
5
6
7
8
9
10
11
12

/**** imports ****/
@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao = null;

	@Transactional(isolation=Isolation.SERIALIZABLE)
	public int insertUser(User user) {
		return userDao.insertUser(user);
	}
}

有时候一个个地指定隔离级别会很不方便，也可以通过SpringBoot配置文件指定默认的隔离级别。

1
2
3
4
5
6
7
8
9
10

# 隔离级别数字配置的含义
# -1 数据库默认隔离级别
# 1 未提交读
# 2 读写提交
# 4 可重复读
# 8 串行化
#tomcat 数据源默认隔离级别
spring.datasource.tomcat.default-traηsaction-isolation=2
#dbcp2 数据库连接池默认隔离级别
#spring.datasource dbcp2.default-traηsaction-isolation=2

6.4 传播行为

传播行为是方法之间调用事务采取的策略问题。在绝大部分的情况下，我们会认为数据库事务要么全部成功， 要么全部失败。但现实中也许会有特殊的情况。例如，执行一个批量程序，它会处理很多的交易，绝大部分交易是可以顺利完成的，但是也有极少数的交易不能完成而发生异常，这时我们不应该因为极少数的交易不能完成而回滚批量任务调用的其他交易，应该只是回滚那些出现异常的交易，而不是整个批量任务，如下图所示

在Spring中，当一个方法调用另外一个方法时，可以让事务采取不同的策略工作，批量任务我们称之为当前方法，那么批量事务就称为当前事务，当它调用单个交易时，称单个交易为子方法，当前方法调用子方法的时候，让每一个子方法不在当前事务中执行，而是创建一个新的事务去执行子方法，我们就说当前方法调用子方法的传播行为为新建事务。此外， 还可能让子方法在无事务、独立事务中执行，这些完全取决于你的业务需求。

6.4.1 传播行为的定义

在Spring事务机制中队数据库存在7种传播机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package org.springframework.transaction.annotation;

public enum Propagation{
    //需要事务，它是默认传播行为，如果当前存在事务，就沿用当前事务，否则新建一个事务来运行子方法
    REQUIRED(0),
    //支持事务，如果当前存在事务，就沿用当前事务，否则继续采用无事务的方式运行子方法
    SUPPORTS(1),
    //必须使用事务，如果当前存在事务，就沿用当前事务，否则抛出异常
    MANDATORY(2),
    //无论当前事务是否存在，都会创建新事物运行方法，与当前事务相互独立
    REQUIRES_NEW(3),
    //不支持事务，当前存在事务时，会挂起事务，运行方法
    NOT_SUPPORTED(4),
    //不支持事务，如果当前方法存在事务，则抛出异常，否则继续使用无事务机制运行
    NEVER(5),
    //在当前方法调用子方法时，如果子方法发生异常，只回滚子方法执行过的SQL，而不回滚当前方法的事务
    NESTED(6);

    private final int value;

    private Propagation(int value){
        this.value = value;
    }

    public int value(){
        return this.value;
    }
}
6.4.2 测试传播行为

上述传播行为中，只有REQUIRED，REQUIRES_NEW和NESTED比较常用

下面我们用批量插入用户为例，演示传播行为的用法

1
2
3

public interface UserBatchService{
    public int insertUsers(List<User> userList);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Service
public class UserBatchServiceImpl implements UserBatchService{
    @Autowired
    private UserService userService = null;
    @Override
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.REQUIRED)
    public int insertUsers(List<User> userList){
        int count = 0;
        for(User user : userList){
            count += userService.insertUser(user);
        }
        return count;
    }
}

1
2
3
4
5
6
7

@Service
public class UserServiceImpl{
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.Nested)
    public int insertUser(User user){
        return userDao.insertUser(user);
    }
}

这里我们使用UserBatchService调用UserService，会使用UserService的传播行为:NESTED

6.5 @Transcational自调用失效问题

@Transcatoinal在某些场景下会失效，类之间自己方法的调用称为自调用，自调用不会启动AOP，从而导致事务失效

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Service
public class UserServiceImpl{
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.Nested)
    public int insertUser(User user){
        return userDao.insertUser(user);
    }
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.REQUIRED)
    public int insertUsers(List<User> userList){
        int count = 0;
        for(User user : userList){
            // 调用自己类的方法，产生自调用问题
            count += insertUser(user);
        }
        return count;
    }
}

为了克服自调用问题，最好像6.4中那样，用一个Service去调用另一个Service，这样可以正常启用AOP

TOUGH6
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot配置数据库事务
不投降的专栏
12-24 6016
springboot配置事务
springboot mysql事物_Springboot中的数据库事务
weixin_39562928的博客
01-19 204
Springboot中的数据库事务对于一些业务网站而言 ， 产 品库存的扣减、 交易记录以及账户都必须是要么 同时成功， 要么 同时失败 ，这便是一种事务机制，而在一些特殊的场景下 ，如一个批处理 ，它将处理多个交易 ，但是在一些交易中发生了异常 ， 这个时候则不能将所有的交易都回滚。如果所有的交易都回渎，那么那些本能够正常处理的业务也无端地被回滚。 通过 Spring 的数据库事务传播行为，可以...
springboot---mybatis操作事务配置的处理
喜欢猪猪
06-01 3747
目前大多数的项目都是通过spring或者springboot来开发的，并且项目里面操作数据库常用的有mybatis\mybatis-plus等，在操作数据库的时候，经常会使用事务的处理，因为在操作数据库的时候，如果出现异常的话，所有的数据库操作都能够回滚操作，避免造成一些异常数据的问题。目前网络上搜索的都是原始的配置方式，比如说使用xml进行bean的配置，或者说直接在方法头上面进行添加注解的方式进行调用的，本文主要介绍通过配置类进行管理实务的方式，统一的管理、统一的处理方式。
SpringBoot 事务
Pluto372的博客
04-23 1305
在Spring中，事务有两种实现方式，分别是编程式事务管理和声明式事务管理两种方式。
SpringBoot多数据源配置以及事务如何处理
婉君
08-04 1880
【代码】SpringBoot多数据源配置以及事务如何处理。
SpringBoot事务详解
Shawn的个人博客
09-28 2万+
事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。
SpringBoot事务配置管理
liyuuhuvnjjv的博客
03-12 7148
1.事务 使用功能场景： 由于数据操作在顺序执行的过程中，线上可能有各种无法预知的问题，任何一步操作都有可能发生异常，异常则会导致后续的操作无法完成，此时由于业务逻辑并未正确的完成，所以在之前操作数据库的动作并不可靠，需要在这种情况下进行数据的回滚。 事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务未进行操作的状态。 事务管理是SpringBoot框架中最为常用的功能之一，我们在实际应用开发时，基本上在service层处理业务逻辑的时候都要加上事
SpringBoot2 整合 ClickHouse数据库案例解析
08-25
SpringBoot2 整合 ClickHouse数据库案例解析是一个深入讲解如何在SpringBoot2应用程序中集成ClickHouse数据库的过程。ClickHouse是一个由Yandex开发的开源数据库，专门用于数据分析（OLAP）场景，尤其适合处理大规模...
国产数据库+ Springboot操作示例
03-16
TiDB则是一款开源的新一代分布式SQL数据库，支持在线事务处理（OLTP）和在线分析处理（OLAP）。 集成SpringBoot与国产数据库，首先需要在项目中引入相应的数据库驱动依赖。例如，对于TiDB，可以在`pom.xml`文件中...
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
SpringBoot数据库增删改查 事务管理
06-18
SpringBoot数据库增删改查 事务管理
详解Spring Boot中整合Sharding-JDBC读写分离示例
08-26
主要介绍了详解Spring Boot中整合Sharding-JDBC读写分离示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解在Spring Boot中使用数据库事务
08-30
本篇文章主要介绍了详解在Spring Boot中使用数据库事务，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于SpringBoot的网上超市源码数据库.zip
最新发布
03-13
SSM整合是Java Web开发中的常见实践，Spring提供整体的控制和事务管理，SpringMVC处理Web请求，MyBatis则专注于数据访问，三者协同工作，构建出高效、灵活的Web应用。 JSP（JavaServer Pages）是一种动态网页技术，...
springboot mybatis 事务_第014课：Spring Boot 事务管理
weixin_39832348的博客
12-05 363
1. 事务相关场景：我们在开发企业应用时，由于数据操作在顺序执行的过程中，线上可能有各种无法预知的问题，任何一步操作都有可能发生异常，异常则会导致后续的操作无法完成。此时由于业务逻辑并未正确的完成，所以在之前操作过数据库的动作并不可靠，需要在这种情况下进行数据的回滚。事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态。...
SpringBoot 全局事务配置
sout-lanys
11-02 8448
传统springboot实现事务只需要在方法上添加@Transactional注解，但是需要在所有的service都加上事务，相对比较麻烦，随着项目的庞大，功能模块会随之增多，所以就需要采用AOP的方式实现全局事务处理。 全局事务配置通过AOP切面指定方法前缀切入点，从而对指定的方法统一进行事务控制，根据方法名前缀来匹配到具体方法，进行事务配置
SpringBoot中事务配置
m0_67401499的博客
04-08 3339
做个学习笔记。SpringBoot创建的项目由于不存在xml配置文件了，对于用惯Spring的xml配置事务犯了难，百度了下，大多文章都是用@Transactional对每一个方法或类手动添加任务，这样很麻烦，就自己摸索了下，实现了对指定切点事务的统一添加。有两种方式。PS：启动类，对，就是包含main方法的那个类一定要放在包的最外层，不然有很多坑。包括但不限于不能扫描到你配置的类，连接ES时自定义接口无法自动注入等等。 1.Xml方式 跟Spring中差不多两步骤 ①.在resources文件夹下创建xm
在Spring Boot中使用数据库事务
热门推荐
江南一点雨的专栏
01-05 2万+
我们在前面已经分别介绍了如何在Spring Boot中使用JPA（初识在Spring Boot中使用JPA）以及如何在Spring Boot中输出REST资源（ 在Spring Boot中输出REST资源）。那么关于数据库访问还有一个核心操作那就是事务的处理了，前面两篇博客小伙伴们已经见识到Spring Boot带给我们的巨大便利了，其实不用猜，我们也知道Spring Boot在数据库事务处理问题上
#SpringBoot# 数据库操作之整合Mybaties和事务
自学it的攻城狮
02-16 163
SpringBoot2.x持久化数据方式 近几年常用的访问数据库的方式和优缺点 1、原始java访问数据库 开发流程麻烦 1、注册驱动/加载驱动 Class.forName("com.mysql.jdbc.Driver") 2、建立连接 Connection con = DriverManager.getConnection("jdbc:mysql://localhost:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值