JavaEE简单示例——Spring的事务管理

于 2023-03-24 08:00:00 发布
阅读量292 收藏 1
点赞数
文章标签： spring java-ee java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hssjsh/article/details/129698296
版权

简单介绍：

在之前我们介绍Spring框架中，提到了有一个模块叫做数据访问与集成(Data Access/Intergration)，而在这个模块中，除了jdbc之外，还有一个比较重要的地方，也是我们学习这一模块必须掌握的地方，那就是事务管理（Transaction）。

首先来认识一下什么是事务，事务是数据库中的一个概念，主要是为了在我们执行多条SQL语句的时候，如果中间有一条 语句出现了错误，则之前执行成功的语句全都不算数，全部操作都撤销，最主要的是如果有对于数据的操作的部分也全部都 回到事务开始之前的状态。 这个多条SQL语句的集合就被称之为事务，而事务的管理主要就是负责在多条SQL语句执行的时候，如果这时候出现了 错误，就帮我们设置到事务开始之前的状态。

然后我们来介绍一下在Spring中的事务管理。Spring提供了专门用于事务管理的API，可以很方便的帮助我们进行 事务的管理。我们学习这些API是为了更好的理解如何在XML的配置文件里编写我们的事务管理器，毕竟我们之后主要 是使用XML配置文件的方式以及注解这种方式来声明事务的管理。

使用方法：

首先是PlatformTransactionManager接口，译名叫做平台事务管理器。 这个接口的主要作用是用来进行事物的管理的，接口中包含有获取事务状态的方法，提交事务的方法和回滚事务的方法 在实际的医用中，Spring事务的管理实际是由集体的持久化技术完成的，而PlatformTransactionManager只是提供 一个统一的抽象方法。 比如在Spring中就为Spring JDBC和Mybatis等依赖于DataSource（数据源）持久化技术提供了实现类 DataSourcePlatformTransactionManager，这样我们就可以通过这个类来管理我们的事务。

然后是TransactionDefinition接口，这个接口定义了用于描述事务相关的常量，其中包括事务的隔离级别，事务的传播行为 事务的超时时间以及是否为只读。 事务的隔离级别就是指事务之间的隔离程度，比如我在执行某个事务的时候，我已经开始对数据进行修改了，但是这个 修改并没有提交到数据库中，也就是说数据库中的数据并没有开始被修改，而另一个事务可不可以来访问我没有提交的数据。 对于事务的隔离级别，Spring提供了五种固定的常量，其中比较常用的有： ISOLATION_REPEATBLE_READ：读已提交，一个事务修改的数据提交后才能被另一个事务读取，可以避免脏读 ISOLATION_REPEATABLE_READ：默认属性，允许重复读，可以避免脏读，资源消耗上升 还有就是关于事务的传播行为，事务的传播行为指的就是指当我们进行业务嵌套的时候，外层的业务和内层的业务是进行单独的业务管理 还是合并成为一个业务进行管理，其中常用的属性有： PROPAGATION_REQUIRED：默认值，如果已经存在事务，则加入该事务；如果没有事务，则创建一个新的事务。 表示将合并嵌套事务。 PROPAGATION_REQUIRS_NEW：创建一个新的事务，如果已经存在一个事务，则将旧的事务挂起。表示只能执行一个事务 管理，并且在进入内层的事务管理的时候将外层的事务暂时挂起，知道完成内层的事务管理之后在继续执行外层的事务管理。

还有一些其他的设置项，但是这些设置项我们一般不会做更改，我们只需要知道有这些配置项即可 事务的超时时间，指的是如果事务的执行超过了我们预定的时间，则回滚事务。 是否为只读，当事务为只读的时候，该事务不具有向数据库写入数据的能力，如果在只读属性的事务中修改数据 会引发异常，有助于提升性能。

还有最后的TransactionStatus，这个属性主要用于编程式的事务管理的时候用于界定事务的状态，在我们的 声明式事务管理并不会用到。

代码实现：

在了解了这些基础知识之后，我们就可以开始进入我们的编写配置文件的过程了 首先，如果我们是第一次使用XML配置文件的方式去配置声明式的事务管理，那么我们首先要在pom文件中引入依赖项

<!--        spring的核心依赖坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.21.RELEASE</version>
        </dependency>
<!--        spring的Jdbc包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.21.RELEASE</version>
        </dependency>
<!--        spring的用于事务管理的依赖坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.21.RELEASE</version>
        </dependency>
<!--        用于解析切入点表达式-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.7.2</version>
        </dependency>

然后在我们的Bean管理XML配置文件中添加事务管理有关的约束

<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:bean="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.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">

继续在Bean管理XML配置文件中添加dataSource类，我们以后就叫他数据源类，洋文不喜欢，在数据源类中我们需要添加四个属性

分别是driverClassName： 表示数据库驱动的类

url：表示数据库的链接地址

username：表示数据库的用户名

password：表示数据库用户的密码

这都是我们之前登录数据库的时候所必须的参数

<!--    创建数据源对象-->
    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/jdbc"/>
        <property name="username" value="root"/>
        <property name="password" value="@gaoyang1"/>
    </bean>

jdbcTemplate类，用于定义模板类，因为这个类中有我们需要的对于数据库的操作的方法，并且我们需要将数据源类通过依赖注入的方式注入进模板类中的dabaSource属性中

<!--    创建模板类对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"/>
    </bean>

自定义数据库操作类，这个类是我们自己编写的，这个类中必须要包含一个属性，属性的类型必须是模板类的类型，然后我们将我们刚才配置的模板类通过依赖注入的方式注入到我们的自定义数据库操作类的jdbcTemplat属性中 以及我们的DataSourceTransactionManager事务管理类，这个类就是我们之前介绍的Spring基于dataSource实现的数据库管理类，表示这个类也是依赖于数据源的，所以我们也需要将之前的数据源类通过依赖注入的方式注入到事务管理类的dataSource属性中

<!--    创建自定义数据库操作类的对象,最终我们只需要或者这个对象就可以了-->
    <bean id="manipulatingDatabase" class="Semester_4.SpringJDBC.TransactionManagement.ByNote.ManipulatingDatabase">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
package Semester_4.SpringJDBC.TransactionManagement.ByConfigurationFile;

import org.springframework.jdbc.core.JdbcTemplate;

public class ManipulatingDatabase {
    private JdbcTemplate jdbcTemplate;

    @Override
    public String toString() {
        return "ManipulatingDatabase{" +
                "jdbcTemplate=" + jdbcTemplate +
                '}';
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public ManipulatingDatabase(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public ManipulatingDatabase() {
    }
//    模拟一个转账的事务，在Java中，事务的封装是通过方法来完成的，即多条SQL语句放在同一个方法中，这个方法就成为了一个事务
    public void Transfer(String payer , String payee , int money){
//        定义数据的调整的SQL语句
        String SQL1 = "update user set money = money - ? where name = ?";
        String SQL2 = "update user set money = money + ? where name = ?";
        this.jdbcTemplate.update(SQL1,money,payer);
//        模拟在执行事务的时候，如果中间有一个异常发生了
        int i = 1/0;
        this.jdbcTemplate.update(SQL2,money,payee);
    }
}

 这个类中除了要定义JDBC操作类的对象，还要创建一个封装了事务的方法

基于XML配置文件的事务管理其实就是将我们的事务管理类当作切面，增强到我们已有的事务方法中 所以说，我们可以将事务管理类当作是一个切面，只不过这个切面在使用之前需要进行一些特殊的配置

<!--    然后开始进行对事务管理的配置-->
    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
<!--            name并不是名字的意思，而是要指定匹配的方法名-->
<!--            表示这个事务是可读可写的，使用默认的隔离级别，使用默认的传播行为-->
            <tx:method name="*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--        然后将事务管理器作为切面将增强插入到已有的方法中-->
    <aop:config>
<!--        配置切入点，切入点就是我们的转账方法-->
        <aop:pointcut id="pointcut" expression="execution(* Semester_4.SpringJDBC.TransactionManagement.ByConfigurationFile.ManipulatingDatabase.*(..))"/>
<!--        配置切面，因为我们的切入点和切面都已经写好了，并且因为我们的切面是一个事务管理器，所以他也自己封装了和增强和切入点的关系，所我们只需要去引入即可-->
        <aop:advisor advice-ref="interceptor" pointcut-ref="pointcut"/>
    </aop:config>

我们所有的对于事务管理类的操作全部都是在tx:advice根标签下面的，这个根标签有两个属性，id就是唯一标识 transaction_manager属性的值就是我们刚才的事务管理类的id的值，表示引用这个类进行事务的管理 在根标签下面，就是tx:attributes标签，这个标签主要用于包含多个tx:methods，而tx:methods才是用来设置 事务管理的标签，主要用于设置我们之前说过的，比如隔离级别，传播行为之类的这些属性

其中tx:methods的重要的属性有以下几个：

name：用于指定方法名的匹配模式，这个属性是必选属性

propagation：指定事务的传播范围

isolation：指定事务的隔离级别

read-only：指定事务是否为只读

然后我们还需要定义一个用来封装查询结果的类，并且将其注册到IoC中：

<!--    创建结果集映射类的bean-->
    <bean id="user" class="Semester_4.SpringJDBC.TransactionManagement.ByNote.user"/>
package Semester_4.SpringJDBC.TransactionManagement.ByConfigurationFile;

public class user {
    private int id;
    private String name;
    private int money;

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getMoney() {
        return money;
    }

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

    public user(int id, String name, int money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    public user() {
    }
}

 最后，我们总结一下我们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:bean="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.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">
    <!--    创建数据源对象-->
    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/jdbc"/>
        <property name="username" value="root"/>
        <property name="password" value="@gaoyang1"/>
    </bean>
    <!--    创建模板类对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSource"/>
    </bean>
    <!--    创建自定义数据库操作类的对象,最终我们只需要或者这个对象就可以了-->
    <bean id="manipulatingDatabase" class="Semester_4.SpringJDBC.TransactionManagement.ByNote.ManipulatingDatabase">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
<!--    创建结果集映射类的bean-->
    <bean id="user" class="Semester_4.SpringJDBC.TransactionManagement.ByNote.user"/>
<!--    创建事务管理类的bean-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        因为这个类需要依赖与数据源，所以将数据源对象使用依赖注入的方式进行赋值-->
        <property name="dataSource" ref="dateSource"/>
    </bean>

<!--    然后开始进行对事务管理的配置-->
    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
<!--            name并不是名字的意思，而是要指定匹配的方法名-->
<!--            表示这个事务是可读可写的，使用默认的隔离级别，使用默认的传播行为-->
            <tx:method name="*" isolation="DEFAULT" read-only="false" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--        然后将事务管理器作为切面将增强插入到已有的方法中-->
    <aop:config>
<!--        配置切入点，切入点就是我们的转账方法-->
        <aop:pointcut id="pointcut" expression="execution(* Semester_4.SpringJDBC.TransactionManagement.ByConfigurationFile.ManipulatingDatabase.*(..))"/>
<!--        配置切面，因为我们的切入点和切面都已经写好了，并且因为我们的切面是一个事务管理器，所以他也自己封装了和增强和切入点的关系，所我们只需要去引入即可-->
        <aop:advisor advice-ref="interceptor" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

 然后创建测试类并进行测试：

package Semester_4.SpringJDBC.TransactionManagement.ByConfigurationFile;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;

import java.util.List;

public class test {
    public static void main(String[] args) {
//        创建IoC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("TeansactionManager.xml");
//        获取自定义数据库操作类的对象
        ManipulatingDatabase md = (ManipulatingDatabase)ac.getBean("manipulatingDatabase");
//        创建结果集封装类
        RowMapper<user> mapper = new BeanPropertyRowMapper<>(user.class);
//        输出修改之前的代码
        System.out.println("更改之前的数据：");
        List<user> queryBefore = md.getJdbcTemplate().query("select * from user", mapper);
        for(user u : queryBefore){
            System.out.println(u.toString());
        }
//        调用方法,对数据库中的多条数据进行修改
        md.Transfer("张三","李四",100);
//        输出修改后的结果
        List<user> queryAfter = md.getJdbcTemplate().query("select * from user", mapper);
        System.out.println("更改之后的数据：");
        for(user u : queryAfter){
            System.out.println(u.toString());
        }
    }
}

运行结果：

首先，我们来看数据库中准备的数据：

数据库中有三个人，并且此时他们的money都是300，现在我们要实现一个需求，就是让张三的钱转给李四一百。

正常我们的逻辑都是张三的钱会减少一百，李四的钱会增加一百，我们就按照这个逻辑开始编写我们的方法：

//    模拟一个转账的事务，在Java中，事务的封装是通过方法来完成的，即多条SQL语句放在同一个方法中，这个方法就成为了一个事务
    public void Transfer(String payer , String payee , int money){
//        定义数据的调整的SQL语句
        String SQL1 = "update user set money = money - ? where name = ?";
        String SQL2 = "update user set money = money + ? where name = ?";
        this.jdbcTemplate.update(SQL1,money,payer);
//        模拟在执行事务的时候，如果中间有一个异常发生了
        int i = 1/0;
        this.jdbcTemplate.update(SQL2,money,payee);
    }

我们正常的调用方法对数据进行更新，但是如果在更新的时候出现了一个错误，会导致方法执行失败，那么这时候，如果我们不做事务管理，就会发生下面的这种情况：

方法报错，程序终止，但是数据库中的数据发生了变化： 

 因为我们在方法失败之前，我们已经执行了一条SQL语句，并且向数据库中写入了数据，这就会导致我们的数据发生错误，现在我们添加事务管理：

正常还是模拟报错，方法终止，我们继续来看数据库中的数据：

 数据库中的数据没有发生变化，因为方法报错，事务管理会检测，只有当整个方法成功执行之后，才会将数据的修改写入到数据库中，完成数据的持久化操作，所以，如果当方法中出现异常导致方法无法顺利的执行完成，事务管理器是不会让数据的修改写入到数据库中的，这就是事务管理的基本逻辑。

注意点：

关于本章的知识点主要在如事务管理器的配置，以及如何将事务管理与需要被事务管理的方法联系起来，主要是使用到了切面增强的方法。

Error_exception_worn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaEE的Spring JDBC与事务管理 实验
06-08
一、 实验目的 1、掌握Spring JDBC的配置； 2、掌握JdbcTemplae类中增删改查方法的使用； 3、了解Spring事务管理的3个核心接口； 4、了解Spring事务管理的两种方式； 5、掌握基于XML和Annotation的声明式事务管理的使用。 二、 实验内容 1、在MySQL中创建以下三张表，其中account为账户表，book为书籍信息表，book_stock为书籍库存表。 (1)使用Spring JDBC实现书店的购书过程，即有如下一个BookShopDao接口，编写BookShopDaoImp类实现该接口中的所有方法，并通过JUnit测试这些方法。 public i
Java EE中事务处理
suwu150
05-18 725
1、事务情景：在银行转账时，要对数据库进行两个操作，即将一个账户的钱减少，将另一个账户的钱增多。但是由于操作的先后顺序，如果在两个操作之间发生故障，则会导致数据不一致。因此，需要设计一个事务，在两条语句都被执行成功后，数据修改才被真正提交（Commit）放入数据库，否则数据操作回滚（Rollback在默认情况下，executeUpdate函数会在数据库中提交改变的结果，此时，可以用Connection来定义该函数是否自动提交改变结果，并进行事务的提交或者回滚。 Class.forName（"sun.jdb
JavaEE 事务管理和AOP
qq_45692619的博客
03-31 169
顶层文件的pom文件中有aop和aspecj两个依赖，今天就靠他俩 <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop&lt
JavaEE中的事务管理——事务概述
郗晓勇|利己者生,利人者恒
02-27 2220
今天打算说一说事务管理，读者可能了解也有可能不了解，其实很简单（大牛请自行绕过）。本来想引用个成语的啥的来描述事务的特点，但是搜肠刮肚也没有发现合适的，于是就找了下面几组成语来描述事务性。其实在官方文档中对于事务的描述也是分四个方面来说的。这里算是用自己的理解解释一下罢了。第一对词语是：“开弓没有回头箭”和“前功尽弃”（功亏一篑？功败垂成？）这一对词语结合起来看就是事务的原子性，就是我们平时说的要
设计Java EE应用程序--事务管理
xiecg2000的博客
09-10 487
[size=medium][size=x-small]事务管理是一种简化分布式多用户企业应用程序开发的机制。同时，它也是J2EE平台提供的标准服务之一。通过在应用程序访问和更新数据中加入一系列严格的规则，事务管理保证了数据完整性。事务性的系统保证工作的单元或者完全执行，或者完全不执行。事务管理将应用程序开发者从复杂的数据访问问题中解放出来，包括通过更新，故障恢复，和多用户编程。 本章以事务的...
JavaEE精讲之Spring框架实战 ——学习笔记.zip
09-18
4. **Spring AOP事务管理**：Spring提供了声明式事务管理，允许开发者在不编写事务管理代码的情况下，通过配置控制事务的边界。这大大减少了处理事务时的复杂性。 5. **Spring JDBC和ORM支持**：Spring提供了JDBC...
javaEE轻量级框架应用与开发——随书代码
06-07
此外，可能会介绍如何使用Spring的AOP（面向切面编程）实现事务管理，以及Struts2的拦截器和Action配置，以便实现灵活的请求处理。 通过学习这些代码，开发者将能掌握如何在实际项目中集成和优化这些框架，提升应用...
精通Java EE项目案例-基于Eclipse Spring Struts Hibernate光盘源码（带数据库）
12-20
Spring还支持数据访问、Web应用、事务管理等多个方面，极大地简化了企业级应用的复杂性。在本案例中，Spring将用于管理对象之间的依赖关系，实现业务逻辑，并与数据库进行交互。 Struts是MVC（模型-视图-控制器）...
求精要诀——JavaEE编程开发案例精讲 源代码
04-09
《求精要诀——JavaEE编程开发案例精讲》是一本深入浅出的JavaEE编程教程，由清华大学出版社出版。本书旨在通过丰富的实例讲解，帮助读者掌握JavaEE平台上的核心开发技术，提升实际项目开发能力。书中源代码的提供，...
Sistema demo con arquitectura monolítica JavaEE.zip
最新发布
12-29
【描述】"Sistema demo con arquitectura monolítica JavaEE.zip" 指出这是一个使用JavaEE技术的单体架构示例系统。单体架构意味着所有应用组件——包括前端、业务逻辑和数据访问层——都被集成在一个单一的可部署...
JavaEE-JDBC基础-事务管理
http://lioil.win
01-28 382
1.事务概念事务:一组操作要么同时完成、要么同时不完成。事务四大特性ACID 原子性Atomicity: 事务的一组操作是原子不可再分割的,要么同时完成、要么同时不完成。 一致性Consistency: 事务在执行前后数据完整性(约束)不变。 隔离性Isolation: 多个事务同时操作数据库时,应保证各事务隔离,互相不干扰。 持久性Durability: 事务一旦被提交,数据库永久改变,不能
事物java例子_spring事务详解（二）实例
weixin_42523326的博客
02-27 145
在Spring中，事务有两种实现方式：编程式事务管理： 编程式事务管理使用底层源码可实现更细粒度的事务控制。spring推荐使用TransactionTemplate,典型的模板模式。申明式事务管理： 添加@Transactional注解，并定义传播机制+回滚策略。基于Spring AOP实现，本质是对方法前后进行拦截，方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚...
JavaEE中的事务管理——事务划界
郗晓勇|利己者生,利人者恒
02-28 2158
前面博文中大致介绍了一下事务，其实在企业应用服务器中事务是在不同的级别上存在的。比较简单的事务是最底层的事务，就是位于资源级别的事务管理。假设数据最终要存储在一个关系型数据库中，那么最底层的事务就是位于这里。我们把这种事务称之为资源本地事务（resource-localtransaction）在不用容器的大部分情况下开发人员要面对的事务都属于这里（其他的事务面对不到是因为水平不够！）。理解了数据的
JavaEE事物管理
hanni_xie的博客
06-02 249
** 链接：https://pan.baidu.com/s/1uhmjUUJcYjqouzS6h5-PPA 提取码：zmse ** 求大神帮我看看这个代码是哪里出问题了 上面有着百度网盘的链接，里面有源文件
【JavaEE】Spring 事务（回顾mysql中的事务）
xqs196301的博客
09-04 677
【JavaEE】Spring 事务（回顾mysql中的事务）
Java JDBC 事务管理示例
allway2的博客
04-06 1080
本教程解释了 JDBC 事务类型、数据类型、事务管理方法，以及如何在 Java 程序中使用它们： 在JDBC 教程系列的JDBC ResultSet教程中，我们学习了使用 JDBC ResultSet 来检索数据。 在本教程中，我们将讨论 JDBC 中的事务类型。我们已经在之前的教程中看到了对事务类型的简要介绍。在这里，我们将详细了解。我们还将介绍 JDBC 中的数据类型以及如何在 Java 程序中使用它。 数据库将具有不同的数据类型，Java 将具有不同的数据类型。JDBC 将管理这种差异化。让我们
笑着学Spring - (3) - Spring事务管理
xx12321q的博客
04-05 2441
前言 ladies and gentleman,你们好😊 ,我是羡羡 ,这里是笑着学 Spring 第三期 , 关于Spring事务管理的讲解, 老样子, 记得笑着学,不然学不会😎 目录 👑什么是事务? 👑Spring事务配置 👑Spring事务传播行为 👓1. PROPAGATION_REQUIRED 👓2. PROPAGATION_SUPPORTS 👓3. PROPAGATION_REQUIRES_NEW 👑声明式事务失效 什么是事务? 事务...
Java程序设计——事务管理（JDBC编程）
Mr_John
07-05 1336
事务是由一步或几步数据库操作序列组成的逻辑执行单元，这些序列要么都执行，要么都不执行事务的四个特性：事务处理过程的三个概念：事务操作的具体步骤：注意：Connection接口在默认情况下会自动提交，即事务是关闭的，即一条SQL语句执行成功后，系统会立即调用commit()方法提交到数据库，而无法对其进行rollback回滚操作通过调用Connection对象的setAutoCommit(boolean bool)方法可以开启或者关闭自动提交模式代码： 实例演示： 根据结果集返回的数据可知，JDBC似
java事务写法_从零开始手写 mybatis（四）- mybatis 事务管理机制详解
weixin_39802784的博客
02-27 420
前景回顾第一节 从零开始手写 mybatis(一)MVP 版本 中我们实现了一个最基本的可以运行的 mybatis。本节我们一起来学习一下 mybatis 中的事务管理。mybatis 中的事务管理mybatis 事务有两种使用方式：使用JDBC的事务管理机制：即使用 java.Sql.Connection对象完成对事务的提交，回滚和关闭操作。使用MANAGED的事务管理机制：mybatis本身不...
JavaEE：Spring+Struts2+Hibernate三大框架整合与事务管理
"Spring+Struts2+Spring3+Hibernate3三大框架整合是JavaEE开发中的常见模式，重点在于Spring的事务管理。" 在JavaEE应用开发中，Spring、Struts2和Hibernate3的整合提供了强大的模型-视图-控制器（MVC）架构支持，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值