Spring JDBC与事务管理

最新推荐文章于 2024-03-23 10:16:25 发布
最新推荐文章于 2024-03-23 10:16:25 发布
阅读量107 收藏
点赞数
分类专栏： Spring学习 文章标签： 数据库 mysql spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GiantApe/article/details/112261381
版权

Spring JDBC与事务管理

Spring JDBC

  • Spring JDBC是Spring框架用于处理关系型数据库的模块
  • Spring JDBC对JDBC API进行封装，极大简化开发工作量
  • JdbcTemplate是Spring JDBC核心类，提供数据CRUD方法

Spring JDBC的使用步骤

  • Maven工程引入依赖spring-jdbc
  • applicationContext.xml配置DataSource数据源
  • 在Dao注入JdbcTemplate对象，实现数据CRUD

JdbcTemplate实现增删改查

Spring JDBC配置过程代码示例：

applicationContext.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:context="http://www.springframework.org/schema/context"
       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">

    <!-- 数据源 -->
    <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://localhost:3306/imooc?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!--JdbcTemplate提供CRUD的API-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean id="employeeDao" class="com.imooc.spring.jdbc.dao.EmployeeDao">
        <!--为Dao注入JdbcTemplate对象-->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
</beans>

Employee.java

package com.imooc.spring.jdbc.entity;

import java.util.Date;

/**
 * @author Rex
 * @create 2021-01-05 14:44
 */
public class Employee {
    private Integer eno;
    private String ename;
    private Float salary;
    private String dname;
    private Date hiredate;

    public Integer getEno() {
        return eno;
    }

    public void setEno(Integer eno) {
        this.eno = eno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Float getSalary() {
        return salary;
    }

    public void setSalary(Float salary) {
        this.salary = salary;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eno=" + eno +
                ", ename='" + ename + '\'' +
                ", salary=" + salary +
                ", dname='" + dname + '\'' +
                ", hiredate=" + hiredate +
                '}';
    }
}

EmployeeDao.java

package com.imooc.spring.jdbc.dao;

import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author Rex
 * @create 2021-01-05 14:46
 */
@Repository
public class EmployeeDao {

    private JdbcTemplate jdbcTemplate;

    public Employee findById(Integer eno){
        String sql = "select * from employee where eno = ?";
        Employee employee = jdbcTemplate.queryForObject(sql, new Object[]{eno}, new BeanPropertyRowMapper<Employee>(Employee.class));
        return employee;
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

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

SpringApplication.java

package com.imooc.spring.jdbc;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Rex
 * @create 2021-01-05 14:52
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        EmployeeDao employeeDao = context.getBean("employeeDao", EmployeeDao.class);
        Employee employee = employeeDao.findById(3308);
        System.out.println(employee);
    }
}

JDBC Template的数据查询代码示例：

EmployeeDao.java

public Employee findById(Integer eno){
    String sql = "select * from employee where eno = ?";
    //查询单条数据
    Employee employee = jdbcTemplate.queryForObject(sql, new Object[]{eno}, new BeanPropertyRowMapper<Employee>(Employee.class));
    return employee;
}

public List<Employee> findByDname(String dname){
    String sql = "select * from Employee where dname = ?";
    //查询复合数据
    List<Employee> list = jdbcTemplate.query(sql, new Object[]{dname}, new BeanPropertyRowMapper<Employee>(Employee.class));
    return list;
}

public List<Map<String, Object>> findMapByDname(String dname){
    String sql = "select eno as empno, salary as s from employee where dname=?";
    //将查询结果作为Map进行封装
    List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql, new Object[]{dname});
    return maps;
}

单条查询测试

@Test
public void testFindById(){
    Employee employee = employeeDao.findById(3308);
    System.out.println(employee);
}

查询结果：

[Employee{eno=3308, ename='张三', salary=6000.0, dname='研发部', hiredate=2011-05-08 00:00:00.0}, Employee{eno=3420, ename='李四', salary=8700.0, dname='研发部', hiredate=2006-11-11 00:00:00.0}]

多条记录查询测试

@Test
public void testFindByDname(){
    List<Employee> list = employeeDao.findByDname("研发部");
    System.out.println(list);
}

查询结果：

Employee{eno=3308, ename='张三', salary=6000.0, dname='研发部', hiredate=2011-05-08 00:00:00.0}

将查询结果以Map作为封装测试

@Test
public void testFindMapByDname(){
    System.out.println(employeeDao.findMapByDname("研发部"));
}

查询结果：

[{empno=3308, s=6000.0}, {empno=3420, s=8700.0}]

JdbcTemplate数据写入代码示例

数据新增：

public int insert(Employee employee){
    String sql = "insert into employee(eno, ename, salary, dname, hiredate) values(?, ?, ?, ?, ?)";
    //利用update方法实现数据写入操作
    return jdbcTemplate.update(sql, new Object[]{employee.getEno(), employee.getEname(), employee.getSalary(), employee.getDname(), employee.getHiredate()});
}

测试代码：

@Test
public void testInsert(){
    Employee employee = new Employee();
    employee.setEno(8888);
    employee.setEname("赵六");
    employee.setSalary(6666f);
    employee.setDname("研发部");
    employee.setHiredate(new Date());
    int count = employeeDao.insert(employee);
    System.out.println("本次新增"+count+"条数据");
}

测试结果：

本次插入1条数据

数据修改：

public int update(Employee employee){
    String sql = "update employee set ename = ?, salary = ?, dname = ?, hiredate = ? where eno = ?";
    int count = jdbcTemplate.update(sql, new Object[]{employee.getEname(), employee.getSalary(), employee.getDname(), employee.getHiredate(), employee.getEno()});
    return count;
}

测试代码：

@Test
public void testUpdate(){
    Employee employee = employeeDao.findById(8888);
    employee.setSalary(employee.getSalary()+1000f);
    int count = employeeDao.update(employee);
    System.out.println("本次更新"+count+"条数据");
}

测试结果：

本次更新1条数据

数据删除：

public int delete(Integer eno){
    String sql = "delete from employee where eno = ?";
    return jdbcTemplate.update(sql, new Object[]{eno});
}

测试代码：

@Test
public void testDelete(){
    int count = employeeDao.delete(8888);
    System.out.println("本次删除"+count+"条数据");
}

测试结果：

本次删除1条数据

Spring编程式事务

什么是事务

  • 事务以一种可靠的、一致的方式，访问和造作数据库的程序单元
  • 说人话：要么把事情做完，要么什么都不做，不要做一半
  • 事务依赖于数据库实现，MySQL通过事务区作为数据缓冲地带

编程式事务

  • 编程式事务是指通过代码手动提交回滚事务的事务控制方法
  • SpringJDBC通过TransactionManage事务管理器实现事务控制
  • 事务管理器提供commit/rollback方法进行事务提交与回滚

代码示例：

ApplicationContext.xml

<bean id="employeeService" class="com.imooc.spring.jdbc.service.EmployeeService">
    <property name="employeeDao" ref="employeeDao"></property>
    <property name="transactionManager" ref="transactionManager"></property>
</bean>

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

EmployeeService.java

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.Date;

/**
 * @author Rex
 * @create 2021-01-05 16:31
 */
public class EmployeeService {
    private EmployeeDao employeeDao;
    private DataSourceTransactionManager transactionManager;

    public void batchImport(){

        //定义了事务默认的标准配置
        TransactionDefinition definition = new DefaultTransactionDefinition();
        //开始一个事务
        TransactionStatus status = transactionManager.getTransaction(definition);
        try {
            for (int i = 0; i < 10; i++) {
                if ( i == 3) {
                    throw new RuntimeException("意料之外的异常");
                }
                Employee employee = new Employee();
                employee.setEno(8000 + i);
                employee.setEname("员工" + i);
                employee.setSalary(4000f);
                employee.setDname("市场部");
                employee.setHiredate(new Date());
                employeeDao.insert(employee);
            }
//          //提交事务
            transactionManager.commit(status);
        }catch (RuntimeException e){
            transactionManager.rollback(status);
            throw e;
        }
    }
    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    public DataSourceTransactionManager getTransactionManager() {
        return transactionManager;
    }

    public void setTransactionManager(DataSourceTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
}

JdbcTemplateTestor.java

@Test
public void testBatchImport(){
    employeeService.batchImport();
    System.out.println("批量导入成功");
}

测试结果：

...
16:55:40.411 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [insert into employee(eno, ename, salary, dname, hiredate) values(?, ?, ?, ?, ?)]
16:55:40.490 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - SQLWarning ignored: SQL state '22007', error code '1292', message [Incorrect date value: '2021-01-05 16:55:40.405' for column 'hiredate' at row 1]
16:55:40.498 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL update
16:55:40.498 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [insert into employee(eno, ename, salary, dname, hiredate) values(?, ?, ?, ?, ?)]
16:55:40.502 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - SQLWarning ignored: SQL state '22007', error code '1292', message [Incorrect date value: '2021-01-05 16:55:40.498' for column 'hiredate' at row 1]
16:55:40.502 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL update
16:55:40.503 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [insert into employee(eno, ename, salary, dname, hiredate) values(?, ?, ?, ?, ?)]
16:55:40.507 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - SQLWarning ignored: SQL state '22007', error code '1292', message [Incorrect date value: '2021-01-05 16:55:40.502' for column 'hiredate' at row 1]
16:55:40.507 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Initiating transaction rollback
16:55:40.507 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Rolling back JDBC transaction on Connection [com.mysql.cj.jdbc.ConnectionImpl@3646a422]
16:55:40.521 [main] DEBUG 
...

java.lang.RuntimeException: 意料之外的异常...

Spring声明式事务

声明式事务

  • 声明式事务指在不修改源码情况下通过配置形式自动实现事务控制，声明式事务本质就是AOP环绕通知
  • 当目标方法执行成功时，自动提交事务
  • 当目标方法抛出运行时异常时，自动事务回滚

配置过程

  • 配置TransactionManager事务管理器
  • 配置事务通知与事务属性
  • 为事务通知绑定PointCut切点

代码示例：

applicationContext.xml

<!--1.事务管理器，用于创建事务/提交/回滚-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--2.事务通知配置，决定哪些方法使用事务，哪些方法不使用事务-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--目标方法名为batchImport时，启用声明式事务，成功提交，运行时异常回滚-->
        <tx:method name="batchImport" propagation="REQUIRED"/>
        <tx:method name="batch*" propagation="REQUIRED"></tx:method>
        <!--设置所有findXXX方法不需要使用事务-->
        <tx:method name="find*" propagation="NOT_SUPPORTED" read-only="true"/>
        <tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true"/>

        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<!--3.定义声明式事务的作用范围-->
<aop:config>
    <aop:pointcut id="pointcut" expression="execution(public * com.imooc..*Service.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
</aop:config>

EmployeeService.java

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import java.util.Date;

public class EmployeeService {
    private EmployeeDao employeeDao;

    public void batchImport() {
        for (int i = 1; i <= 10; i++) {
            if(i == 3){
                throw new RuntimeException("意料之外的异常");
            }
            Employee employee = new Employee();
            employee.setEno(8000 + i);
            employee.setEname("员工" + i);
            employee.setSalary(4000f);
            employee.setDname("市场部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }
}

执行结果：
同上

事务传播行为

  • 事务传播行为是指多个拥有事务的方法在嵌套调用时的事务控制方式
  • XML：<tx:method name="…" propagation=“REQUIRED”>
  • 注解：@Transactional(propagation=Propagation.REQUIRED)
事务传播行为七种类型
事务传播类型说明
PROPAGATION_REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务，加入到这个事务中。这是最常见的选择
PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_MANADATORY使用当前的事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，就把当前事务挂起
PROPAGATION_NOT_SUPPORT以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
PROPAGATION_NEVER以非事务方式执行，如果当前存在事务，则抛出异常
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作

Spring注解配置声明式事务

代码示例

applicationContext.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: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.imooc"/>
    <!--数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/imooc?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=Asia/Shanghai&amp;usePublicKeyRetrieval=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

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

    <!--启用注解形式声明式事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

Employee.java

package com.imooc.spring.jdbc.entity;

import java.util.Date;

public class Employee {
    private Integer eno;
    private String ename;
    private Float salary;
    private String dname;
    private Date hiredate;

    public Integer getEno() {
        return eno;
    }

    public void setEno(Integer eno) {
        this.eno = eno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Float getSalary() {
        return salary;
    }

    public void setSalary(Float salary) {
        this.salary = salary;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "eno=" + eno +
                ", ename='" + ename + '\'' +
                ", salary=" + salary +
                ", dname='" + dname + '\'' +
                ", hiredate=" + hiredate +
                '}';
    }
}

EmployeeDao.java

package com.imooc.spring.jdbc.dao;

import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Repository
public class EmployeeDao {
    @Resource
    private JdbcTemplate jdbcTemplate;

    public Employee findById(Integer eno){
        String sql = "select * from employee where eno = ?";
        //查询单条数据
        Employee employee = jdbcTemplate.queryForObject(sql, new Object[]{eno}, new BeanPropertyRowMapper<Employee>(Employee.class));
        return employee;
    }

    public List<Employee> findByDname(String dname){
        String sql = "select * from employee where dname = ?";
        //查询复合数据
        List<Employee> list = jdbcTemplate.query(sql, new Object[]{dname}, new BeanPropertyRowMapper<Employee>(Employee.class));
        return list;
    }

    public List<Map<String, Object>> findMapByDname(String dname){
        String sql = "select eno as empno , salary as s from employee where dname = ?";
        //将查询结果作为Map进行封装
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql, new Object[]{dname});
        return maps;
    }

    public void insert(Employee employee){
        String sql = "insert into employee(eno,ename,salary,dname,hiredate) values(?,?,?,?,?)";
        //利用update方法实现数据写入操作
        jdbcTemplate.update(sql,new Object[]{
           employee.getEno() , employee.getEname(),employee.getSalary(),employee.getDname() , employee.getHiredate()
        });
    }

    public int update(Employee employee){
        String sql = "UPDATE employee SET ename = ?, salary = ?, dname = ?, hiredate = ? WHERE eno = ?";
        int count = jdbcTemplate.update(sql, new Object[]{employee.getEname(), employee.getSalary(), employee.getDname(), employee.getHiredate(), employee.getEno()});
        return count;
    }

    public int delete(Integer eno){
        String sql = "delete from employee where eno = ?";
        return jdbcTemplate.update(sql, new Object[]{eno});
    }


    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

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

BatchService.java

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;

@Service
@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
public class BatchService {
    @Resource
    private EmployeeDao employeeDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void importJob1(){
        for (int i = 1; i <= 10; i++) {
            Employee employee = new Employee();
            employee.setEno(8000 + i);
            employee.setEname("研发部员工" + i);
            employee.setSalary(4000f);
            employee.setDname("研发部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void importJob2(){
        for (int i = 1; i <= 10; i++) {
            Employee employee = new Employee();
            employee.setEno(9000 + i);
            employee.setEname("市场部员工" + i);
            employee.setSalary(4500f);
            employee.setDname("市场部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }
}

EmployeeService.java

package com.imooc.spring.jdbc.service;

import com.imooc.spring.jdbc.dao.EmployeeDao;
import com.imooc.spring.jdbc.entity.Employee;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;

@Service
//声明式事务核心注解
//放在类上，将声明式事务配置应用于当前类所有方法，默认事务传播为REQUIRED
@Transactional
public class EmployeeService {
    @Resource
    private EmployeeDao employeeDao;
    @Resource
    private BatchService batchService;

    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public Employee findById(Integer eno){
        return employeeDao.findById(eno);
    }

    public void batchImport() {
        for (int i = 1; i <= 10; i++) {
            /*if(i==3){
                throw new RuntimeException("意料之外的异常");
            }*/
            Employee employee = new Employee();
            employee.setEno(8000 + i);
            employee.setEname("员工" + i);
            employee.setSalary(4000f);
            employee.setDname("市场部");
            employee.setHiredate(new Date());
            employeeDao.insert(employee);
        }
    }

    public void startImportJob(){
        batchService.importJob1();
        if(1==1){
            throw new RuntimeException("意料之外的异常");
        }
        batchService.importJob2();
        System.out.println("批量导入成功");
    }

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    public BatchService getBatchService() {
        return batchService;
    }

    public void setBatchService(BatchService batchService) {
        this.batchService = batchService;
    }
}
Rex·Lin
关注
专栏目录
事务简述
weixin_36741151的博客
09-21 292
1、概述： 此篇博文，将以编码角度来写写事务，一位码农写的，非DBA，并且以mysql和spring+mybatis经验来写，看此播文，也许无收获，也许收获满满。 2、事务特性： 网上很多将事务，定义为4大特性，即原子性、一致性、隔离性、持久性，其实我认为，还有一个传播性。 2.1、原子性： 原子性，即加锁，编码时开启事务（@Transactional），然后代码里出现的insert、update、delete和select的for update，都会锁住，直到事务提交、回滚或者连结断掉（后续会说
【笔记】Java核心技术卷1-第七章_异常、断言和日志
Ethan_997的博客
09-10 365
7.1.1 异常分类 所有异常由Throwable继承而来，下一层分解为两个：Error和Exception。 Error描述Java运行时内部错误和资源耗尽错误。少见。 Exception分解为RuntimeException（程序错误）和其他异常（程序本身没错）。 7.1.2 声明受查异常 一个方法必须声明所有可能抛出的受查异常，而非受查异常要么不可控制（Error), 要么就应该避免发生（ RuntimeException)。如果方法没有声明所有可能发生的受查异常， 编译器就会发出一个错误消息。 7.
asp.net core TransactionScope 提交或回滚事务
q8812345qaz的博客
10-07 1023
在 efcore 中如果 有多次 保存，如果 没有 TransactionScope。成功的保存 就会真正的保存在数据库中，业务 可能是 如果 在代码段中 仅有一次 错误，则全部 回滚。使用的方法 就是 需要 using(TransactionScope) {} 这 using的代码块中 如果 有任何 错误，全部就会回滚 如果没有任何 错误 ts.Complete();但 TransactionScope 不局限在 efcore中 如 文件读写 等操作。
TransactionScope事务处理方法介绍及.NET Core中的注意事项
依乐祝的博客
12-24 8485
TransactionScope事务处理方法介绍及.NET Core中的注意事项 作者：依乐祝 原文链接：https://www.cnblogs.com/yilezhu/p/10170712.html 今天在写CzarCms的UnitOfWork的使用使用到了这个TransactionScope事务，因此对它进行了相关资料的查阅并记录如下，希望...
事务问题
weixin_33735077的博客
07-08 337
用事务时出现 The current TransactionScope is already complete 事务已提交完成 通常是因为在事务提交完成后又进行了其他操作，所以用事务时，提交完成之后就不要在进行其他操作 转载于:https://www.cnblogs.com/mmnyjq/archive/2011/07/08/2100970.html...
JavaEE的Spring JDBC与事务管理 实验
06-08
3、了解Spring事务管理的3个核心接口； 4、了解Spring事务管理的两种方式； 5、掌握基于XML和Annotation的声明式事务管理的使用。 二、 实验内容 1、在MySQL中创建以下三张表，其中account为账户表，book为书籍信息...
Spring JDBC与事务管理源代码
06-17
1、掌握Spring JDBC的配置； 2、掌握JdbcTemplae类中增删改查方法的使用； 3、了解Spring事务管理的3个核心接口； 4、了解Spring事务管理的两种方式； 5、掌握基于XML和Annotation的声明式事务管理的使用。
基于Spring JDBC的事务管理
08-26
本资源主要介绍基于Spring JDBC的事务管理，包括事务的定义、使用 @Transactional 注解、Spring JDBC的事务管理机制、事务的ACID特性、事务的传播、事务的隔离等内容。 事务的定义 事务是一种数据库中能够保证一...
spring JDBC事务管理
04-08
标题中的“Spring JDBC事务管理”是指在Spring框架中如何利用JDBC进行数据库操作时的事务控制。Spring提供了多种方式来管理事务，使得开发者能够在复杂的业务逻辑中更好地控制数据的持久化过程，确保数据的一致性和...
.net core 实例教程（八）事务提交配置、TransactionScope使用
最新发布
03-23 770
文章中讲解了数据库增删改查基本操作，数据库保存是在仓储代码中实现的。本文讲解利用IAsyncActionFilter过滤器统计进行事务提交配置。在需要事务提交的控制器或action上使用[UnitOfWork(typeof(SignUpDbContext))]特性即可。然后将仓储保存代码删除。一、UnitOfWorkFilter实现代码。
SpringMVC--异常处理
weixin_41978551的博客
09-15 723
给方法上随便写一个Exception，用来接收发生的异常 要携带的异常信息不能给参数位置写Model 返回ModelAndView就行 如果有多个@ExceptionHandler都能处理这个异常，精确优先 全局异常处理与本类同时存在，本类优先 Spring MVC处理异常有3种方式： 1）使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver； 2）实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器；.
.NET开发问题记录——TransactionScope出错：“与基础事务管理器的通信失败”的解决方法
鹏鹏2077
05-15 5383
最近在做.NET项目，使用的是SQLServer数据库，其中有个功能涉及到多数据源的操作，那么多数据源就要确保多个数据源之间数据的一致性，这里就用到了分布式事物。DTC（分布式事务协调器）是用于管理分布式事务的组件，它负责协调多个参与者之间的操作，并确保事务的一致性、隔离性、持久性和原子性。DTC是Microsoft Windows操作系统的一个组件，用于协调分布式事务。它提供了一个可靠的机制，确保多个参与者在分布式环境中的事务操作能够一致地协调和执行。
译文：TransactionScope 与 Async/Await
weixin_30384217的博客
11-18 129
你可能不知道这一点，在 .NET Framework 4.5.0 版本中包含有一个关于 System.Transactions.TransactionScope 在与 async/await 一起工作时会产生的一个严重的 bug 。由于这个错误，TransactionScope 不能在异步代码中正常操作，它可能更改事务的线程上下文，导致在处理事务作用域时抛出异常。 这是一个很大的问题...
C# 事务异常TransactionScope处理
shumixys的博客
04-27 1272
1、异常信息为："MSDTC on server '{Server Name}' is unavailable."。      解决方案：我的电脑--右键管理--服务--启动Distributed Transaction Coordinator服务 2、异常信息为："Network access for Distributed Transaction Manager (
c#报错 ：System . Invalid Operation Exception:“线程间操作无效: 从不是创建控件的线程访问它
weixin_48822802的博客
03-14 1万+
一、问题来源 跨线程操作时会报错：System.InvalidOperationException:“线程间操作无效: 从不是创建控件的线程访问它。 二、问题代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Net; using System.N.
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
.Net Core 使用CAP框架实现异步化分布式事务
qq_26900081的博客
09-10 6819
CAP是一款基于.net标准的库，该库是处理分布式事务的解决方案；它具有轻量级的、开源、易于使用、具有EventBus（事件总线）功能、持久化等特点。官方中文文档：https://cap.dotnetcore.xyz/user-guide/zh/getting-started/quick-start/ 基础核心Nuget包：DotNetCore.CAP EventBus（事件总线）Nuget包：DotNetCore.CAP.RabbitMQ、DotNetCore.CAP.Kafka、DotNetCore
浅谈.NET Core异步方法
weixin_45191758的博客
08-04 4489
什么是异步编程？ 同步程序中的代码运行在单一线程上。 异步操作：从其它线程发起后，在一个新的单独线程上运行的操作。发起异步操作的线程不必等待异步操作完成 为什么使用异步编程？ 对于需要长时间运行的操作，异步编程可以更大限度更有效地利用设备资源。 通过异步执行 CPU 或 I/O 绑定操作，提高 UI 程序的响应性 并行计算 什么时候使用异步编程 异步适用于 CPU 绑定或 I/O 绑定操作，例如： I/O 从网络检索数据 CPU 密集操作，例如使用大量数据进行科学计算 I/O 读写硬盘 最适合应用异步编程的
spring jdbc与事务管理
05-17
Spring JDBC 与事务管理密切相关，因为在实际应用中，数据操作常常需要保证事务的一致性。 Spring JDBC 提供了 JdbcTemplate 类，该类封装了 JDBC 操作，可以直接使用该类来进行数据库操作。在进行事务管理时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Rex·Lin

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

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

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

打赏作者

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

抵扣说明：

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

余额充值