【小家Spring】Spring-jdbc的使用以及Spring事务管理的8种方式介绍(声明式事务+编程式事务)(中)

简介: 【小家Spring】Spring-jdbc的使用以及Spring事务管理的8种方式介绍(声明式事务+编程式事务)(中)

Spring事务管理方式(声明式+编程式)


声明式事务(5种方式)


Spring同时支持编程式事务策略和声明式事务策略,只是大部分时候,我们都推荐采用声明式事务策略。它有十分明显的优势:

1、声明式事务能大大降低开发者的代码书写量,而且声明式事务几乎不影响应用的代码。因此,不论底层事务策略如何变化,应用程序都无需任何改变

2、应用程序代码无需任何事务处理代码,可以更专注于业务逻辑的实现

3、Spring可对任何POJO的方法提供事务管理,而且Spring的声明式事务管理无需容器的支持,可在任何环境下使用(无需要要web容器的支持)

4、Spring可指定事务在遇到特定异常时自动回滚。Spring不仅可在代码中使用setRollbackOnly回滚事务,也可在配置文件中(或者注解中)配置回滚规则

5、*由于Spring采用AOP的方式管理事务,因此,可以在事务回滚动作中插入用户自己的动作,而不仅仅是执行系统默认的回滚(此点非常的强大~~~~)*


Spring声明式事务管理的方式也有多种,下面主要介绍几种情况的使用方式:


  1. 单独配置每个Bean的代理(使用TransactionProxyFactoryBean)

在Spring1.X中,声明式事务使用TransactionProxyFactoryBean来配置事务代理Bean。正如它的类名所暗示的,它是一个专门为目标Bean生成事务代理的工厂Bean。

既然TransactionProxyFactoryBean产生的是事务代理Bean,可见Spring的声明式事务策略是基于Spring AOP的。


// @since 21.08.2003  它出现的时间非常的早
public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean    implements BeanFactoryAware {
  // 从内部可以看出来,它最终还是委托给TransactionInterceptor去管理事务的~~~ 
  private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
  @Nullable
  private Pointcut pointcut;
  ...
}
// 简单的说:它就是去生成的爱理对象的一个抽象实现。单例代理对象
// 它还有一个著名的实现类:`CacheProxyFactoryBean`  和 Cache相关的FactoryBean  不过他是从Spring3.1开始的
public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
    implements FactoryBean<Object>, BeanClassLoaderAware, InitializingBean {...}


示例配置如下(此处不使用XML配置,而使用Config类配置):


    @Bean
    public TransactionProxyFactoryBean transactionProxyFactoryBean(PlatformTransactionManager transactionManager) {
        TransactionProxyFactoryBean transactionProxyFactoryBean = new TransactionProxyFactoryBean();
        // 设置事务管理器  去管理这个Bean的事务关系
        transactionProxyFactoryBean.setTransactionManager(transactionManager);
        // 设置目标对象
        // 这里需要注意:这里设置了目标对象,你的HelloServiceImpl就不允许再交给Spring管理了  否则会有两个Bean,注入会报错的
        transactionProxyFactoryBean.setTarget(new HelloServiceImpl());
        // 设置事务相关的属性:transactionAttributes
        Properties transactionAttributes = new Properties();
        transactionAttributes.setProperty("*", "PROPAGATION_REQUIRED");
        transactionProxyFactoryBean.setTransactionAttributes(transactionAttributes);
        return transactionProxyFactoryBean;
    }


测试一把:


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RootConfig.class, JdbcConfig.class})
public class TestSpringBean {
    @Autowired
    private HelloService helloService;
    @Test
    public void test1() {
        System.out.println(helloService.getClass()); //class com.sun.proxy.$Proxy24
        helloService.hello();
    }
}


  1. 所有Bean共享一个代理基类
    这其实是第一种方式的一种变体,只需要把需要代理的Bean继承自TransactionProxyFactoryBean,然后自己setTarget()一下。或者在设置一些通用属性了,类似如下:
// 此处transactionBase就是它:TransactionProxyFactoryBean,并且标记为 abstract="true"
<bean id="userDao" parent="transactionBase" > 
  <property name="target" ref="userDaoTarget" />  
</bean>


  1. 使用拦截器(AOP方式的直接使用)


    // 配置一个事务的拦截器(相当于一个AOP的`环绕通知`)
    @Bean
    public TransactionInterceptor transactionInterceptor(PlatformTransactionManager transactionManager) {
        TransactionInterceptor transactionProxyFactoryBean = new TransactionInterceptor();
        // 设置事务管理器  去管理这个Bean的事务关系
        transactionProxyFactoryBean.setTransactionManager(transactionManager);
        // 设置事务相关的属性:transactionAttributes
        Properties transactionAttributes = new Properties();
        transactionAttributes.setProperty("*", "PROPAGATION_REQUIRED");
        transactionProxyFactoryBean.setTransactionAttributes(transactionAttributes);
        return transactionProxyFactoryBean;
    }
    // 配置一个自动代理创建器  决定这个事务拦截器要作用于哪些Bean上
    @Bean
    public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
        BeanNameAutoProxyCreator proxyCreator = new BeanNameAutoProxyCreator();
        proxyCreator.setBeanNames("*ServiceImpl");
        // 此处这个BeanName一定要对应上~~~~
        proxyCreator.setInterceptorNames("transactionInterceptor");
        return proxyCreator;
    }


  1. 使用tx标签配置的拦截器
    类似于xml的这种方式:
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
    <tx:method name="*" propagation="REQUIRED" />
  </tx:attributes>
</tx:advice>
<aop:config>
  <aop:pointcut id="interceptorPointCuts" expression="execution(* com.fsx.demo.*.*(..))" />
  <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />
</aop:config>


  1. 全注解@Transactional(当下最常用的一种方式~~~)
    该种方式也是今天要讲的一种主要的方式,下面会在详细讲述~


编程式事务(3种方式)


编程式事务使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。


和编程式事务相比,声明式事务唯一不足地方是,它的最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别


但是即便有这样的需求,也存在很多变通的方法,比如,可以将需要进行事务管理的代码块独立为方法即可达到通用的效果


方式一:使用TransactionTemplate(推荐)

先配置一个TransactionTemplate这个Bean到容器~~


    // 配置一个事务模版,用于编程式事务
    // 这里面也可以通过构造函数传入一个TransactionDefinition接口的实例。表示事务的一些属性~~~~
    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        return transactionTemplate;
    }


然后直接使用:


    @Override
    public Object hello() {
        return transactionTemplate.execute(transactionStatus -> {
            // 向数据库插入一条记录
            String sql = "insert into user (name,age) values ('fsx',21)";
            jdbcTemplate.update(sql);
            // 做其余的事情  可能抛出异常
            System.out.println(1 / 0);
            return "service hello";
        });
    }


就这样,相当于里面的逻辑在事务里面执行。可以实现非常精细的控制了~~~~


// 继承自DefaultTransactionDefinition表示会有一个默认的事务属性~~~
public class TransactionTemplate extends DefaultTransactionDefinition
    implements TransactionOperations, InitializingBean {
  // 内部真正管理事务的,肯定还是PlatformTransactionManager 
  @Nullable
  private PlatformTransactionManager transactionManager;
  // 构造函数
  public TransactionTemplate() {
  }
  public TransactionTemplate(PlatformTransactionManager transactionManager) {
    this.transactionManager = transactionManager;
  }
  // 自己可以指定一个TransactionDefinition,覆盖默认的行为
  public TransactionTemplate(PlatformTransactionManager transactionManager, TransactionDefinition transactionDefinition) {
    super(transactionDefinition);
    this.transactionManager = transactionManager;
  }
  // 真正给外面调用的,仅仅只有这一个方法而已~~~~用lambda来实现也非常的优雅~
  @Override
  @Nullable
  public <T> T execute(TransactionCallback<T> action) throws TransactionException { ... }
  ...
}

方式二:使用PlatformTransactionManager


当然我们也可以操作底层的API,直接使用PlatformTransactionManager来自己管理事务~~~


    @Autowired
    private PlatformTransactionManager transactionManager;
    @Override
    public Object hello() {
        // 构造一个准备使用此事务的定义信息~~~
        DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        transactionDefinition.setReadOnly(false);
        //隔离级别,-1表示使用数据库默认级别
        transactionDefinition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        transactionDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        // 根据此事务属性,拿到一个事务实例   注意此处的入参是一个:TransactionDefinition
        TransactionStatus transaction = transactionManager.getTransaction(transactionDefinition);
        try {
            // =================做你的逻辑start  必须try住,但无需写finally=======================
            // 向数据库插入一条记录
            String sql = "insert into user (name,age) values ('fsx',21)";
            jdbcTemplate.update(sql);
            // 做其余的事情  可能抛出异常
            System.out.println(1 / 0);
            // =================做你的逻辑start=======================
            // 提交事务
            transactionManager.commit(transaction);
        } catch (Exception e) {
            // 若发现异常  事务进行回滚
            transactionManager.rollback(transaction);
            throw e;
        }
        return "service hello";
    }


这样也实现了事务的控制。优点是更精细,缺点是侵入性太强,且编码负责。

相关文章
|
1天前
|
Java 关系型数据库 MySQL
深入分析Spring事务和底层原理
深入分析Spring事务和底层原理
9 1
|
15天前
|
Java 数据库 开发者
一文带你掌握Spring事务核心:TransactionDefinition详解!
TransactionDefinition是Spring框架中用于定义事务属性的核心接口。在Spring的事务管理中,这个接口扮演着至关重要的角色,它允许开发者定制事务的各种属性,如隔离级别、传播行为、超时时间以及是否只读。
一文带你掌握Spring事务核心:TransactionDefinition详解!
|
18天前
|
XML Java 数据库连接
无痛事务管理:Spring中的@Transactional和相关注解完全解析
无痛事务管理:Spring中的@Transactional和相关注解完全解析
45 0
|
21天前
|
XML 运维 Java
spring事务(3)基于XML的声明式事务
spring事务(3)基于XML的声明式事务
12 0
|
21天前
|
SQL Java 关系型数据库
spring事务(2)
spring事务(2)
38 0
|
21天前
|
人工智能 运维 Java
spring事务(1)
spring事务(1)
19 2
|
22天前
|
数据库
Spring5源码(49)-@Transactional声明式事物(七)嵌套事物回滚
Spring5源码(49)-@Transactional声明式事物(七)嵌套事物回滚
23 0
|
22天前
|
Java 数据库 Spring
Spring5源码(48)-@Transactional声明式事物(六)嵌套事物处理
Spring5源码(48)-@Transactional声明式事物(六)嵌套事物处理
27 0
|
1月前
|
Java Spring
springboot跨域配置
springboot跨域配置
21 0
|
1天前
|
缓存 Java Maven
Spring Boot自动配置原理
Spring Boot自动配置原理
10 0

相关产品

  • 云迁移中心