JDBC：实现原生事务

已于 2023-05-08 22:10:11 修改
阅读量223 收藏 1
点赞数
分类专栏： ORM 文章标签： java 后端 数据库
于 2023-05-08 22:05:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45427648/article/details/130568210
版权

实现JDBC事务

依赖

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>

配置文件jdbc.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db_demo
username=root
password=root
initialSize=10
maxActive=20
maxWait=10000

JDBC工具类

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * 功能1：从数据源获取数据库连接
 * 功能2：从数据库获取到数据库连接后，绑定到本地线程（借助 ThreadLocal）
 * 功能3：释放线程时和本地线程解除绑定
 */
public class JDBCUtils {

    // 数据源成员变量设置为静态资源，保证大对象的单例性；同时保证静态方法中可以访问
    private static DataSource dataSource;

    // 由于 ThreadLocal 对象需要作为绑定数据时 k-v 对中的 key，所以要保证唯一性
    // 加 static 声明为静态资源即可保证唯一性
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    // 在静态代码块中初始化数据源
    static {

        try {
            // 操作思路分析：
            // 从 jdbc.properties 文件中读取连接数据库的信息
            // 为了保证程序代码的可移植性，需要基于一个确定的基准来读取这个文件
            // 确定的基准：类路径的根目录。resources 目录下的内容经过构建操作中的打包操作后会确定放在 WEB-INF/classes 目录下。
            // WEB-INF/classes 目录存放编译好的 *.class 字节码文件，所以这个目录我们就称之为类路径。
            // 类路径无论在本地运行还是在服务器端运行都是一个确定的基准。
            // 操作具体代码：
            // 1、获取当前类的类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();

            // 2、通过类加载器对象从类路径根目录下读取文件
            InputStream stream = classLoader.getResourceAsStream("jdbc.properties");

            // 3、使用 Properties 类封装属性文件中的数据
            Properties properties = new Properties();
            properties.load(stream);

            // 4、根据 Properties 对象（已封装了数据库连接信息）来创建数据源对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();

            // 为了避免在真正抛出异常后，catch 块捕获到异常从而掩盖问题，
            // 这里将所捕获到的异常封装为运行时异常继续抛出
            throw new RuntimeException(e);
        }
    }

    /**
     * 工具方法：获取数据库连接并返回
     * @return
     */
    public static Connection getConnection() {

        Connection connection = null;

        try {
            // 1、尝试从当前线程检查是否存在已经绑定的 Connection 对象
            connection = threadLocal.get();

            // 2、检查 Connection 对象是否为 null
            if (connection == null) {

                // 3、如果为 null，则从数据源获取数据库连接
                connection = dataSource.getConnection();

                // 4、获取到数据库连接后绑定到当前线程
                threadLocal.set(connection);
            }
        } catch (SQLException e) {
            e.printStackTrace();

            // 为了调用工具方法方便，编译时异常不往外抛
            // 为了不掩盖问题，捕获到的编译时异常封装为运行时异常抛出
            throw new RuntimeException(e);
        }

        return connection;
    }

    /**
     * 释放数据库连接
     */
    public static void releaseConnection(Connection connection) {

        if (connection != null) {

            try {
                // 在数据库连接池中将当前连接对象标记为空闲
                connection.close();

                // 将当前数据库连接从当前线程上移除
                threadLocal.remove();

            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }

        }

    }

}

过滤器Filter

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.Set;

public class TransactionFilter implements Filter {

    // 声明集合保存静态资源扩展名
    private static Set<String> staticResourceExtNameSet;

    static {
        staticResourceExtNameSet = new HashSet<>();
        staticResourceExtNameSet.add(".png");
        staticResourceExtNameSet.add(".jpg");
        staticResourceExtNameSet.add(".css");
        staticResourceExtNameSet.add(".js");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        // 前置操作：排除静态资源
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String servletPath = request.getServletPath();
        if (servletPath.contains(".")) {
            String extName = servletPath.substring(servletPath.lastIndexOf("."));

            if (staticResourceExtNameSet.contains(extName)) {

                // 如果检测到当前请求确实是静态资源，则直接放行，不做事务操作
                filterChain.doFilter(servletRequest, servletResponse);

                // 当前方法立即返回
                return;
            }

        }

        Connection connection = null;

        try {

            // 1、获取数据库连接
            connection = JDBCUtils.getConnection();

            // 重要操作：关闭自动提交功能
            connection.setAutoCommit(false);

            // 2、核心操作
            filterChain.doFilter(servletRequest, servletResponse);

            // 3、提交事务
            connection.commit();

        } catch (Exception e) {

            try {
                // 4、回滚事务
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }

            // 页面显示：将这里捕获到的异常发送到指定页面显示
            // 获取异常信息
            String message = e.getMessage();

            // 将异常信息存入请求域
            request.setAttribute("systemMessage", message);

            // 将请求转发到指定页面
            request.getRequestDispatcher("/").forward(request, servletResponse);

        } finally {

            // 5、释放数据库连接
            JDBCUtils.releaseConnection(connection);

        }

    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void destroy() {
    }
}

配置 web.xml

<filter>
    <filter-name>txFilter</filter-name>
    <filter-class>com.wuxian.filter.TransactionFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>txFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

基类Dao

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * BaseDao 类：所有 Dao 实现类的基类
 * @param <T> 实体类的类型
 */
public class BaseDao<T> {

    // DBUtils 工具包提供的数据库操作对象
    private QueryRunner runner = new QueryRunner();

    /**
     * 查询返回多个对象的方法
     * @param sql 执行查询操作的 SQL 语句
     * @param entityClass 实体类的 Class 对象
     * @param parameters SQL 语句的参数
     * @return 查询结果
     */
    public List<T> getBeanList(String sql, Class<T> entityClass, Object ... parameters) {
        try {
            // 获取数据库连接
            Connection connection = JDBCUtils.getConnection();

            return runner.query(connection, sql, new BeanListHandler<>(entityClass), parameters);

        } catch (SQLException e) {
            e.printStackTrace();

            // 如果真的抛出异常，则将编译时异常封装为运行时异常抛出
            new RuntimeException(e);
        }

        return null;
    }

    /**
     * 查询单个对象
     * @param sql 执行查询的 SQL 语句
     * @param entityClass 实体类对应的 Class 对象
     * @param parameters 传给 SQL 语句的参数
     * @return 查询到的实体类对象
     */
    public T getSingleBean(String sql, Class<T> entityClass, Object ... parameters) {

        try {
            // 获取数据库连接
            Connection connection = JDBCUtils.getConnection();

            return runner.query(connection, sql, new BeanHandler<>(entityClass), parameters);

        } catch (SQLException e) {
            e.printStackTrace();

            // 如果真的抛出异常，则将编译时异常封装为运行时异常抛出
            new RuntimeException(e);
        }

        return null;
    }

    /**
     * 通用的增删改方法，insert、delete、update 操作都可以用这个方法
     * @param sql 执行操作的 SQL 语句
     * @param parameters SQL 语句的参数
     * @return 受影响的行数
     */
    public int update(String sql, Object ... parameters) {

        try {
            Connection connection = JDBCUtils.getConnection();

            int affectedRowNumbers = runner.update(connection, sql, parameters);

            return affectedRowNumbers;
        } catch (SQLException e) {
            e.printStackTrace();

            // 如果真的抛出异常，则将编译时异常封装为运行时异常抛出
            new RuntimeException(e);

            return 0;
        }
    }
}

DemoDao

public interface DemoDao {
    Demo getById(Integer id);
}

DemoDaoimpl

public class DemoDaoImpl extends BaseDao<Demo> implements DemoDao {

    @Override
    public Demo getById(Integer id) {

        // 1、编写 SQL 语句
        String sql = "select id," +
                "name," +
                "type," +
                "code " +
                "from t_demo where id=?";

        // 2、调用父类方法查询单个对象
        return super.getSingleBean(sql, Demo.class, id);
    }
}

注意事项

  • 确保异常回滚
    在程序执行的过程中，必须让所有 catch 块都把编译时异常转换为运行时异常抛出；如果不这么做，在 TransactionFilter 中 catch 就无法捕获到底层抛出的异常，那么该回滚的时候就无法回滚。

  • 谨防数据库连接提前释放
    由于诸多操作都是在使用同一个数据库连接，那么中间任何一个环节释放数据库连接都会导致后续操作无法正常完成。

程序员无羡
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JDBC事务操作
weixin_62458944的博客
07-10 1458
逻辑上的一组SQL语句（一个或者多个）执行的时候要么全部执行成功，要么全部执行失败。事务的案例：转账案例：一个账户中的余额减少，另一个账户中的余额增加。更新数据：update set 余额=原有的余数 - 要转账的余额 where 转出账户的账户更新语句：update set 余额=原有的余额+ 要转账的余额 where 转入账户的账户要执行的SQL语句是两个update语句，要么都成功，要么都失败，不允许一个执行成功，另一个执行失败。同一组SQL语句，就是用同一个数据库连接对象执行的！数据准备。
零基础SSM入门教程(37)–在原生JDBC上使用事务
程序员大阳
02-02 1104
概述 Spring事务是对原生事务的封装，我们还是需要了解如果直接使用JDBC的话，如何实现事务。 我们将向blog表插入两条数据（两次更新操作）定义为一个原子性操作，所以我们是期望这两个操作能同时成功、或者同时失败的。 不使用事务 如果不使用事务，有可能会发生一个操作成功、另一个操作失败的情况，所以我们预期的原子性操作不成立。代码如下，可以看出因为执行过程中出现异常，导致最终只插入了一条数据，数...
JDBC 中数据库事务实现
weixin_45417821的博客
01-04 984
1，使用jdbc代码,添加数据库事务动作!3，事务提交 / 事务回滚。
JDBC操作事务
qq_61727355的博客
08-16 2026
1.点击侧边栏‘Database’中的‘+’号如果没有此侧边栏的话，可以点击左下角类窗口图标，查看是否进行了折叠2.在‘Data Source’中选择需要的数据库类型，这里以MySQL为例3.输入用户名密码，可测试是否连接成功4.选择连接至哪个库直接勾选需连接的对象即可5.选中一个表双击便可显示其内容6.调出console执行SQL语句。......
JDBC事务
小橘子的博客
09-04 1329
JDBC事务（ 1、什么是事务 2、java中（jdbc）如何控制事务。 事务—重点 指的的逻辑上的一组（一组sql,insert update ,delete）操作，组成这组操作的各个单元(各个sql)，要不全部成功，要么全部失败。 举例： 转账 a 给b 转账 100 a原来有1000 b原来也有1000 account 是一个表名 表示的 账务表，...
JDBC事务实现
m0_56627229的博客
11-17 292
因为实际开发中，每次获取的连接，不一定是新的连接，而是从连接池中获取的旧的连接，而且关闭也不是真关闭，而是还给连接池，供别人接着用。以防别人拿到后，以为是自动提交的，而没有commit。，最终数据没有成功。希望这两个语句要么一起成功，要么一起回滚。）在订单明细表中添加多条订单明细的记录，表示该订单买了什么东西。执行多条语句，并要求组成一个事务一起执行的话。默认每一个连接是自动提交事务的。、在执行之前关闭自动提交，设置手动提交事务。的对象之前，把连接对象设置回自动提交，、如果执行成功，手动提交事务。
JDBC的实现
qq_55680233的博客
01-02 321
一：什么是JDBC JDBC的全称是Java数据库连接(Java Dalabase Connectivity),它是一套用于执行soL语句的Java API应用程序可通过这套API连接到关系型数据库，并使用SQL语句来完成对数据库中数据的查询、更新、新增和删除的操作 二：实现第一个JDBC程序 在MySQL中创建一个名称为jdbc的数据库，然后在该数据库中创建一个users表，创建数据库和表的SQL语句如下所示。 CREATE DATABASE jdbc; USE jdbc; CREATE T
原生jdbc超市订单管理系统
11-28
原生JDBC（Java Database Connectivity）是Java编程语言中用于与关系数据库进行交互的一种标准接口。在"原生jdbc超市订单管理系统"项目中，开发者直接使用JDBC API进行数据库操作，而不是依赖于任何ORM（对象关系...
JDBC_Lecture:JDBC
03-17
JDBC支持事务处理，`Connection`对象提供了`setAutoCommit()`方法来开启或关闭自动提交。当手动管理事务时，可以调用`commit()`提交事务或`rollback()`回滚事务。 **连接池** 为了提高性能和资源利用率，开发中...
jdbc jar包
12-24
JDBC Jar包是实现这一连接功能的核心库，它包含了所有必要的类和接口，使得Java开发者能够编写程序来访问和操作数据库。在Java应用程序中，JDBC扮演着桥梁的角色，允许程序执行SQL语句，进行数据查询、插入、更新和...
JDBC非常实用的工具类
12-21
非常实用的JDBC 工具类，用起来非常的方便 适合新手练习使用
JDBC事务管理的简单实现
10-14
对于Transaction 管理 为了实现数据一致性，对于数据库的JDBC编程通常需要在代码中显示的调用Connection方法的事务相关API来完成工作。
基于原生 servlet 和 JDBC实现的设备维修管理系统.zip
最新发布
10-10
【基于原生Servlet和JDBC实现的设备维修管理系统】 Servlet是Java编程语言中用于Web应用程序的一种服务器端组件，它扩展了Web服务器的功能，允许开发者创建动态、交互式的Web应用。在本系统中，Servlet主要负责处理...
原生JavaWeb项目的事务管理
廖奕泽的博客
06-06 103
原生JavaWeb项目的事务管理
JDBC如何实现事务
2301_78145658的博客
05-19 227
语句都是一个单独的事务，如果设置为。内层的异常抛出到外层捕获也会回滚。设置是否为自动提交事务，如果。开启注解事务 打开事务驱动。，那么相当于开启了事务。（）：提交结束事务。（）：回滚结束事务。内外层事务全部不回滚，中处理事务，都是通过。交，也就是每条执行的。
JDBC中数据库事务实现
qq_54664881的博客
05-08 326
原子性指事务是一个不可分割的单元，要么整个事务操作成功，要么全部失败回滚；隔离性指多个并发事务之间是互相隔离的，一个事务执行时，它所读取的数据和操作的数据对其他事务是隔离的；一个事务内任意一条语句失败,及事务失败,我们可以触发rollback回滚结束事务, 数据回到事务之前状态!事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
java jdbc实现事务_java原生代码实现JDBC使用事务示例
weixin_34828705的博客
03-04 472
下面代码演示如何使用JDBC的事务。JDBC事务操作需要在执行操作之前调用Connection类的setAutoCommit(false)方法。在执行完操作之后，需要调用Connection实例的commit()方法来提交事务。下面是示例代码：import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLEx...
一天搞定JDBC02：开启事务
那人独钓寒江雪
08-02 688
代码】一天搞定JDBC02开启事务。
手动处理原生Java事务
HaleyTiger的博客
04-30 607
// 获取数据库连接 Connection conn = DBSql.open();//根据实际情况获取自己的连接池中的连接 if (conn != null) { try { // 1.关闭数据库事务 conn.setAutoCommit(false); // 2.处理账户操作 //TODO 业务代码 // 3.提交事务 conn.commit(); } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员无羡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值