Spring JDBC及声明式事务

已于 2024-09-26 08:46:40 修改
阅读量1k 收藏 19
点赞数 20
分类专栏： JAVA 文章标签： spring 数据库
于 2024-09-26 08:22:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xujinwei_gingko/article/details/142533202
版权

目录

Spring JDBC基础概念        

Spring声明式事务

 事务传播方式

Spring JDBC基础概念        

        Spring JDBC 封装了原生的JDBC API，使得处理关系型数据库更加简单。Spring JDBC的核心是JdbcTemplate，里面封装了大量数据库CRUD的操作。使用Spring JDBC有如下步骤：

1、pom增加依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.20.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.22.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

spring-context是spring的核心，负责容器中对象实例创建；spring-jdbc是对原生jdbc的封装；logback-classic主要为了数据库操作时辅助信息的日志输出。

2、IOC容器实例化数据源对象dataSource和JdbcTemplate对象

<?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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.text"/>

    <bean id="dataSource"  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://xxx.xxx.xxx.xxx:3306/test"></property>
        <property name="username" value="test"></property>
        <property name="password" value="test"></property>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

 3、在各个DAO实现类中注入JdbcTemplate对象，通过JdbcTemplate的API实现数据库CRUD

JdbcTemplate的API重要的API:

  • jdbcTemplate.query* ：各种查询方法
  • jdbcTemplate.update：各种新增、修改、删除等方法

示例：学生信息查询、新增

package com.text.dao.impl;

import com.text.dao.StudentDao;
import com.text.entity.Student;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository
public class StudentDaoImpl implements StudentDao {

    @Resource
    private JdbcTemplate jdbcTemplate;
    @Override
    public Student getById(String id) throws Exception {
        String sql = "select * from student where id = ?";
        Student student = jdbcTemplate.queryForObject(sql, new Object[]{id}, new BeanPropertyRowMapper<>(Student.class));
        return student;
    }

    @Override
    public void insert(Student student) throws Exception {
        String sql = "insert into student(id,name,age) values (?,?,?)";
        jdbcTemplate.update(sql,new Object[]{student.getId(),student.getName(),student.getAge()});
    }
}

Spring声明式事务

        上文的案例中，没有添加事务支持，如果在Service层封装了Dao层并且做了批量操作的动作，在批量操作时系统出现异常，会出现部分数据提交到数据库的情况，不满足数据同时提交、同时回滚的情况，参考代码如下：

1、Service服务类

package com.text.service;

import com.text.entity.Student;

public interface StudentService {
    void batchSave() throws Exception;
    Student searchById(String id) throws Exception;
}

package com.text.service.impl;

import com.text.dao.StudentDao;
import com.text.entity.Student;
import com.text.service.StudentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class StudentServiceImpl implements StudentService {

    @Resource
    private StudentDao studentDao;

    @Override
    public void batchSave() throws Exception {
        for(int i=10;i<=20;i++) {
            if(i==15) {
                throw new RuntimeException("系统出现异常");
            }
            Student student = new Student(i+"","张三"+i,20);
            this.studentDao.insert(student);
        }
    }

    @Override
    public Student searchById(String id) throws Exception {
        return this.studentDao.getById(id);
    }
}

 2、测试类

package com.text;

import com.text.entity.Student;
import com.text.service.StudentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Application {
    public static void main(String[] args) throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        StudentService studentService = context.getBean("studentServiceImpl", StudentService.class);
        Student student = studentService.searchById("1");
        System.out.println(student);
        studentService.batchSave();
    }
}

3、运行结果分析：

 

从程序运行结果可以看出，程序循环插入10条数据时，程序每次都获取新的数据库连接，程序执行到第15条时，系统发生异常，前面10-14条数据提交到了数据库，不满足10条数据同时提交或同时回滚，通过配置事务管理器可以解决此问题。

        Spring声明式事务是针对编程式事务而言的，编程式事务就是在程序内部手工的编写Commit和Rollback方法进行事务的提交和回滚，编写相对麻烦，本文重点讨论基于注解声明式事务。

        Spring声明式事务，实现的原理就是AOP的环绕通知，在程序全部执行正常后，自动提交事务，在程序出现异常时，自动回滚事务。实现基于注解Spring声明式事务，经过如下步骤：

1、配置事务管理器及开启注解形式的声明式事务

<?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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.text"/>

    <bean id="dataSource"  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://xxx.xxx.xxx.xxx:3306/test"></property>
        <property name="username" value="test"></property>
        <property name="password" value="test"></property>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--事务管理器-->
    <bean id="transactionManager"     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 启用注解形式声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

2、在需要事务的服务类上添加注解@Transactional

package com.text.service.impl;

import com.text.dao.StudentDao;
import com.text.entity.Student;
import com.text.service.StudentService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

@Service
public class StudentServiceImpl implements StudentService {

    @Resource
    private StudentDao studentDao;

    @Transactional //添加事务支持
    @Override
    public void batchSave() throws Exception {
        for(int i=10;i<=20;i++) {
            if(i==15) {
                throw new RuntimeException("系统出现异常");
            }
            Student student = new Student(i+"","张三"+i,20);
            this.studentDao.insert(student);
        }
    }

    @Override
    public Student searchById(String id) throws Exception {
        return this.studentDao.getById(id);
    }
}

3、测试类（和上面一致），运行后结果：

     

从运行结果看出，由于service的批量插入方法上添加了事务支持，批量新增时，用的是同一个数据库连接，系统发生异常后，数据没有出现部分提交的情况。

 事务传播方式

        Spring事务的默认的事务传播特性是Required，即当前环境没有事务，则创建一个事务，如果已经在一个事务中，则加入这个事务中。几种事务传播特性如下：

  1. required  如果有事务正在运行，当前方法就在这个事务内运行，否则就启动一个新的事务，并在自己的事务内运行；
  2. requires_new 总是主动开启事务；如果存在外层事务，就将外层事务挂起
  3. supports 如果不存在外层事务，就不开启事务；否则使用外层事务
  4. not_supported 当前的方法不应该运行在事务中，如果当前有运行的事务，将它挂起
  5. mandatory 当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
  6. never 当前的方法不应该运行在事务中，如果运行在事务中就抛出异常
  7. nested 如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行    

示例：requires_new 总是主动开启事务；如果存在外层事务，就将外层事务挂起

A方法调用了B和C，其中A，B和C采用的是requires_new 传播特性，则程序内部事务如下示意图：

xujinwei_gingko
关注
专栏目录
spring声明式事务管理+jdbc+连接池.zip
08-25
本资料包"spring声明式事务管理+jdbc+连接池.zip"显然是针对Spring框架在数据库操作方面的深入学习，特别是如何利用Spring进行声明式事务管理和JDBC操作，以及如何配置和使用数据库连接池。接下来，我们将详细探讨这...
Spring JDBC与事务管理
06-09
(2)(2) 在BookShopDao中添加一个purchase购书方法，其操作流程是获取书的单价->买书(更新库存)->更新账户余额，在BookShopDaoImp中实现该方法，并使用基于XML和Annotation的声明式事务管理来确保该购书过程能正常...
SpringJDBC与声明式事务操作
努力学习Java的彬彬的博客
04-24 1167
SpringJDBC以及声明式事务的基本使用
Spring声明式事务源码分析
他叫阿来
07-18 1122
它实现了SmartInstantiationAwareBeanPostProcessor，说明这是⼀个后置处理器，⽽且跟spring AOP 开启@EnableAspectJAutoProxy 时注册的 AnnotationAwareAspectJProxyCreator实现的是同⼀个接⼝，所以说，声明式事务是 springAOP 思想的⼀种应⽤。：在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务。：通过xml或者注解配置的⽅式达到事务控制的⽬的，叫做声明式事务。上述组件如何关联起来的？
Spring JDBC声明式事务管理
swadian2008的博客
01-26 1408
Java事务的类型有三种： (1)JDBC事务：可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。 (2)JTA（Java Transaction API）事务：事务可以跨越多个数据库或多个DAO，使用也比较复杂。 (3)容器事务：主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用使用。 Spring 实现JDBC声明式事务管理可以使用 Annotation 注解。使用注解实现可以减少代码之间的耦合度
Spring 声明式事务
m0_59748326的博客
05-04 960
本篇文章主要梳理ssm 声明式事务相关知识。
java干货，spring声明式事务
qq_51305563的博客
06-22 2148
java干货，spring声明式事务
Spring声明式事务管理实现及原理详解
11-07 2143
目录 1、实现步骤 1.1、配置事务管理器 1.2、启动事务注解 1.3、业务添加注解 2、代码演示 2.1、bean文件 2.2、目标类 2.3、测试类 3、Spring事务属性 3.1、传播行为 3.2、隔离级别 3.3、回滚属性 3.4、超时和只读 4、Spring事务回滚原则 5、Spring事务失效原因 5.1、数据库引擎 5.2、方法属性 5.3、抛...
详解 Spring 声明式事务
Jitwxs
06-13 4135
一、引言 Spring的事务机制包括声明式事务和编程式事务。 编程式事务管理：Spring推荐使用 TransactionTemplate，实际开发中使用声明式事务较多。 声明式事务管理：将我们从复杂的事务处理中解脱出来，获取连接，关闭连接、事务提交、回滚、异常处理等这些操作都不用我们处理了，Spring都会帮我们处理。 声明式事务管理使用了 AOP 实现的，本质就是在目标方法执行前后进行...
spring声明式事务
时光
06-29 2737
spring声明式事务
Spring的声明式事务底层原理
蓝田日暖玉生烟
11-17 8592
文章目录声明式事务的概述声明式事务的初探声明式事务的源码分析 声明式事务的概述 Spring 的声明式事务管理在底层是建立在 AOP 的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。 声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事...
spring声明式事务管理+jdbc+连接池
12-05
spring声明式事务管理+jdbc+连接池 包内为代码，下载可直接执行。 一直用s2sh,感觉hibernate不好用，所以写了一个spring声明式事务管理+jdbc+连接池。
spring声明式事务解析
09-01
【Spring声明式事务解析】 Spring声明式事务是Spring框架中的一种事务管理方式，它允许开发者在不编写任何事务管理代码的情况下，通过配置来控制事务的边界。这种方式极大地简化了事务管理，使得业务逻辑代码和事务...
Spring AOP - 配置文件方式实现
xujinwei_gingko的专栏
09-22 981
1、配置文件：applicationContext.xml。
Spring AOP实现原理-动态代理
最新发布
xujinwei_gingko的专栏
09-23 938
AOP是基于实现切点方法的动态扩展。当切点目标类实现了接口，AOP通过JDK自带的动态代理扩展被代理对象方法的功能；当切点目标类未实现接口，Spring 通过CGLib组件实现扩展被代理对象方法功能。代理模式的核心是创建一个代理对象，代理对象内部包含封装了被代理对象，最终通过执行被代理对象的方法达到动态扩展方法的功能，代理模式分为静态代理和动态代理。
Spring IOC容器Bean对象管理-注解方式
xujinwei_gingko的专栏
09-19 639
Resource 注解StudentServiceImpl 后，先从容器中找bean名称=studentDao的对象，没找到（系统中实例对象名称是studentDaoImpl）再通过类型StudentDao寻找，找到studentDaoImpl，注入studentServiceImpl对象的studentDao属性中，1、applicationContext.xml加入扫描的包，此包项下的类被IOC容器扫描，如有注解，则实例化对象。配置文件config.properties（示例jdbc连接）
Spring-IOC容器-ApplicationContext
xujinwei_gingko的专栏
09-16 621
Inversion of Control 控制反转，是一种设计原则，spring 中通过DI（dependency Injection）来具体实现。比如原本对象的实例化，是通过程序主动New出来，IOC中的对象实例交给Spring框架来实例化，程序使用时直接通过spring获取即可。
Mybatis批量操作
xujinwei_gingko的专栏
09-13 512
当1次插入的数据量过大，如100万，受限于网络包大小限制或者有些数据库有最大接受包的限制（如mysql 中max_allowed_packet 参数限制，默认值为4M），会出现如下sql异常：com.mysql.jdbc.PacketTooBigException。上述程序执行后，后台只会发送1条sql语句：INSERT INTO your_table (column1, column2, ...) VALUES(column1, column2, ...),(...)示例：批量insert多条语句。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值