Spring Data JPA事务管理

最新推荐文章于 2024-06-07 17:20:46 发布
最新推荐文章于 2024-06-07 17:20:46 发布
阅读量2w 收藏 43
点赞数 14
分类专栏： Spring 研发管理 文章标签： Spring Data JPA事务管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiahao1186/article/details/90604813
版权

1、事务基础概念_四大特性

　数据库中事务的四大特性（ACID），如果一个数据库声称支持事务的操作，那么该数据库必须要具备以下四个特性：

　⑴ 原子性（Atomicity）

　　原子性，是指事务包含的所有操作，要么全部成功，要么全部失败回滚。因此，事务的操作如果成功就必须要完全持久化到数据库，如果操作失败则不能对数据库有任何影响。

　⑵ 一致性（Consistency）

　　一致性，是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

　　举例：假设用户甲和用户乙两者的钱加起来一共是10000，那么不管甲和乙之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还是10000，这即是事务的一致性。

　⑶ 隔离性（Isolation）

　　隔离性，是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

       在介绍数据库提供的各种隔离级别之前，我们先看看如果不考虑事务的隔离性，会发生的几种问题：

       第一、脏读

　　脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

　　当一个事务正在多次修改某个数据，而在这个事务中这多次的修改都还未提交，这时一个并发的事务来访问该数据，就会造成两个事务得到的数据不一致。例如：用户A向用户B转账100元，对应SQL命令如下

    update account set money=money+100 where name=’B’;  (此时A通知B)

    update account set money=money - 100 where name=’A’;

　　当只执行第一条SQL时，A通知B查看账户，B发现确实钱已到账（此时即发生了脏读），而之后无论第二条SQL是否执行，只要该事务不提交，则所有操作都将回滚，那么当B以后再次查看账户时就会发现钱其实并没有转。

       第二、不可重复读

　　不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。

　　例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。

　　不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。

　　在某些情况下，不可重复读并不是问题，比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题，例如对于同一个数据A和B依次查询就可能不同，A和B就可能打起来了……

       第三、虚读(幻读)

　　幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

　　幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）

　　关于事务的隔离性数据库提供了多种隔离级别，mySQL数据库为我们提供的四种隔离级别：

　　① Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。

　　② Repeatable read (可重复读)：可避免脏读、不可重复读的发生。

　　③ Read committed (读已提交)：可避免脏读的发生。

　　④ Read uncommitted (读未提交)：最低级别，任何情况都无法保证。

　    以上四种隔离级别最高的是Serializable级别，最低的是Read uncommitted级别，当然级别越高，执行效率就越低。像Serializable这样的级别，就是以锁表的方式(类似于Java多线程中的锁)使得其他的线程只能在锁外等待，所以平时选用何种隔离级别应该根据实际情况。在MySQL数据库中默认的隔离级别为Repeatable read (可重复读)。

　　在MySQL数据库中，支持上面四种隔离级别，默认的为Repeatable read (可重复读)；而在Oracle数据库中，只支持Serializable (串行化)级别和Read committed (读已提交)这两种级别，其中默认的为Read committed级别。

查看mysql数据库事务的默认隔离级别

SELECT @@tx_isolation;

 

　⑷ 持久性（Durability）

　　持久性，是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

　　例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

2、spring-data-jpa事务管理

1）默认事务

 　　Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。确保了单个请求过程数据的一致性。

　　对于自定义的方法，如需改变 SpringData 提供的事务默认方式，可以在方法上注解@Transactional声明进行多个 Repository操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要在Service 层实现对多个 Repository的调用，并在相应的方法上声明事务。 

    Repository概念：按照最初提出者的介绍，它是衔接数据映射层和域之间的一个纽带，作用相当于一个在内存中的域对象集合。客户端对象把查询的一些实体进行组合，并把它们提交给Repository。对象能够从Repository中移除或者添加，就好比这些对象在一个Collection对象上就行数据操作，同时映射层的代码会对应的从数据库中取出相应的数据。

    从概念上讲，Repository是把一个数据存储区的数据给封装成对象的集合并提供了对这些集合的操作。

    广义上可以理解为我们常说的DAO

2）dao层代码

@Modifying
@Query(value="UPDATE hr_employee_contract t SET t.deleteStatus=1 WHERE t.id=?1",nativeQuery = true)
void delete(Long id);

说明：@Modifying注解

①在@Query注解中，编写JPQL实现DELETE和UPDATE操作的时候，必须加上@modifying注解，以通知Spring Data 这是一个DELETE或UPDATE操作。

②UPDATE或者DELETE操作需要使用事务，此时需要定义Service层，在Service层的方法上添加事务操作。

③注意JPQL不支持INSERT操作。　

3）service层代码

使用@Transactional手动开启事务管理

@Transactional
@Override
public void delete(Long id) {
    employeeContractDao.delete(id);
}

@Transactional注解支持9个属性的设置，其中使用较多的三个属性：readOnly、propagation、isolation。其中propagation属性用来枚举事务的传播行为，isolation用来设置事务隔离级别，readOnly进行读写事务控制。

 

① readOnly

从这一点设置的时间点开始（时间点a）到这个事务结束的过程中，其他事务所提交的数据，该事务将看不见！（查询中不会出现别人在时间点a之后提交的数据）

应用场合：

NO.1、如果你一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持SQL执行期间的读一致性； 
NO.2、如果你一次执行多条查询语句，例如统计查询，报表查询，在这种场景下，多条查询SQL必须保证整体的读一致性，否则，在前条SQL查询之后，后条SQL查询之前，数据被其他用户改变，则该次整体的统计查询将会出现读数据不一致的状态，此时，应该启用事务支持。
【注意是一次执行多次查询来统计某些信息，这时为了保证数据整体的一致性，要用只读事务】

怎样设置：

对于只读查询，可以指定事务类型为readonly，即只读事务。
由于只读事务不存在数据的修改，因此数据库将会为只读事务提供一些优化手段，例如Oracle对于只读事务，不启动回滚段，不记录回滚log。

（1）在JDBC中，指定只读事务的办法为： connection.setReadOnly(true);

（2）在Hibernate中，指定只读事务的办法为： session.setFlushMode(FlushMode.NEVER); 
此时，Hibernate也会为只读事务提供Session方面的一些优化手段

（3）在Spring的Hibernate封装中，指定只读事务的办法为： bean配置文件中，prop属性增加“readOnly”
或者用注解方式@Transactional(readOnly=true)
【 if the transaction is marked as read-only, Spring will set the Hibernate Session’s flush mode to FLUSH_NEVER, 
and will set the JDBC transaction to read-only】也就是说在Spring中设置只读事务是利用上面两种方式

 

② propagation

//支持当前事务，如果当前没有事务，就新建一个事务。Spring默认事务级别。

int PROPAGATION_REQUIRED = 0;  

//支持当前事务，如果当前没有事务，就以非事务方式执行。

int PROPAGATION_SUPPORTS = 1;  

//支持当前事务，如果当前没有事务，就抛出异常。

int PROPAGATION_MANDATORY = 2;  

//新建事务，如果当前存在事务，把当前事务挂起。执行新事务后，再激活当前事务。

int PROPAGATION_REQUIRES_NEW = 3;  

//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

int PROPAGATION_NOT_SUPPORTED = 4;  

//以非事务方式执行，如果当前存在事务，则抛出异常。

int PROPAGATION_NEVER = 5;

//如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

//嵌套时由外部事务决定，子事务是否是commit还是rollback。

//一般在外部事务是使用try{}catch(嵌套事务方法){}进行编码。

int PROPAGATION_NESTED = 6; 
 

案例分析1：

@Service
class A{
    @Autowired
    B b;
 
    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            //doSomething....
            //不抛异常，则A无法提交
        }
        //doSomething....
    }
}
 
@Service
class B{
    @Transactional(propagation = Propagation.REQUIRED)
    void call(){}
}


A和B共用事务，如果B异常。A未使用try..catch..捕获，则AB一起回滚。

如果B异常。A捕获，但并未抛出。则A最终也无法提交，因为B的事务已经被设置为rollback-only了。

案例分析2：

@Service
class A{
    @Autowired
    B b;
 
    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            throw e; //或者不抛
        }
        //doSomething....
    }
}
 
@Service
class B{
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void call(){}
}


执行b.call()时A事务挂起，此时如果B执行异常。被A捕获，如果抛出异常，则AB回滚；如果A捕获未抛异常，则A继续执行不回滚。

执行b.call()时A事务挂起，此时如果B正常执行，而在A中出现异常。则B不回滚，A回滚。

案例分析3：

@Service
class A{
    @Autowired
    B b;
 
    @Transactional(propagation = Propagation.REQUIRED)    
    void call(){
        try{
            b.call();
        } catch(Exception e){
            throw e; //或者不抛
        }
        //doSomething....
    }
}
 
@Service
class B{
    @Transactional(propagation = Propagation.NESTED)
    void call(){}
}


执行b.call()时A事务挂起，B新起事务并设置SavePoint。如果B正常执行，A出现异常，则AB一起回滚。

如果B失败异常，此时A如果捕获但未抛出，后续A正常执行的话，A可以提交，而B已经回滚。

如果B失败异常，此时A如果捕获且抛出，则AB一起回滚。

以上案例，我们可以得出第1种和第3种模式的区别，第3种在嵌套模式下，可以在内部异常下执行其它业务且外部正常提交，而第1种不可以这么操作。

 

③ isolation 

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void test() {
        User user = userMapper.getOne(1L);
        System.out.println(user.getName());
 
        userMapper.updateUser();
        try {
            Thread.sleep(10000); // 10 s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }

 @Transactional

默认值

 

3、spring事务详解

    Spring 为事务管理提供了丰富的功能支持。

    Spring 事务管理分为编码式和声明式的两种方式。编程式事务指的是通过编码方式实现事务；声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明式事务用的比较多。

    声明式事务有两种方式：一种是在配置文件（xml）中做相关的事务规则声明，另一种是基于@Transactional 注解的方式。注释配置是目前流行的使用方式，此处重介绍基于@Transactional 注解的事务管理。

1）@Transactional 注解管理事务的实现步骤

使用@Transactional 注解管理事务的实现步骤分为两步。

第一步，配置

在 xml 配置类或配置文件中添加如的事务配置信息。除了用配置文件的方式，@EnableTransactionManagement 注解也可以启用事务管理功能。这里以简单的 DataSourceTransactionManager 为例。

1、配置类


package com.myfutech.market.service.provider.config;

import com.myfutech.common.spring.jpa.base.impl.BaseJpaRepositoryImpl;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@ConditionalOnClass(HikariDataSource.class)
@EnableConfigurationProperties(ConnectionPoolProperties.class)
@EnableJpaRepositories(entityManagerFactoryRef = "marketServiceEntityManagerFactory",
		transactionManagerRef = "marketServiceTransactionManager", basePackages="com.myfutech.market.service.provider.dao",
		repositoryBaseClass = BaseJpaRepositoryImpl.class)
public class JpaConfig {
	
	@Value("${marketService.url}")
	private String url;
	@Value("${marketService.username}")
	private String username;
	@Value("${marketService.password}")
	private String password;
	
    @Autowired
    private ConnectionPoolProperties properties;
	

	@Bean("marketServiceTransactionManager")
	PlatformTransactionManager marketServiceTransactionManager() {
		return new JpaTransactionManager(marketServiceEntityManagerFactory().getObject());
	}

	@Bean("marketServiceEntityManagerFactory")
	LocalContainerEntityManagerFactoryBean marketServiceEntityManagerFactory() {

		HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
		vendorAdapter.setGenerateDdl(true);

		LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
		Properties properties = new Properties();
		properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
		properties.setProperty("hibernate.jdbc.batch_size", "20");
		properties.setProperty("current_session_context_class", "jpa");
		properties.setProperty("hibernate.ejb.entitymanager_factory_name", "marketServiceEntityManagerFactory");
		properties.setProperty("hibernate.hbm2ddl.auto", "none");
		
		factoryBean.setJpaProperties(properties);
		factoryBean.setDataSource(marketServiceDataSource());
		factoryBean.setJpaVendorAdapter(vendorAdapter);
		factoryBean.setPackagesToScan("com.myfutech.market.service.provider.model");
		return factoryBean;
	}

	@Bean
	JdbcTemplate initJdbcTemplate(){
		return new JdbcTemplate(marketServiceDataSource());
	}

	@Bean("marketServiceDataSource")
	DataSource marketServiceDataSource() {
		HikariDataSource dataSource = new HikariDataSource();
		dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setJdbcUrl(url);
        dataSource.setDriverClassName(properties.getDriverClass());
	    dataSource.addDataSourceProperty("cachePrepStmts", properties.isCachePrepStmts());
        dataSource.addDataSourceProperty("prepStmtCacheSize", properties.getPrepStmtCacheSize());
        dataSource.addDataSourceProperty("prepStmtCacheSqlLimit", properties.getPrepStmtCacheSqlLimit());
        dataSource.addDataSourceProperty("useServerPrepStmts", properties.isUseServerPrepStmts());
        dataSource.addDataSourceProperty("useLocalSessionState", properties.isUseLocalSessionState());
        dataSource.addDataSourceProperty("rewriteBatchedStatements", properties.isRewriteBatchedStatements());
        dataSource.addDataSourceProperty("cacheResultSetMetadata", properties.isCacheResultSetMetadata());
        dataSource.addDataSourceProperty("cacheServerConfiguration", properties.isCacheServerConfiguration());
        dataSource.addDataSourceProperty("elideSetAutoCommits", properties.isElideSetAutoCommits());
        dataSource.addDataSourceProperty("maintainTimeStats", properties.isMaintainTimeStats());
        return dataSource;
	}
}

2、或者在 xml 配置中的事务配置信息 

清单1

<tx:annotation-driven />

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource" />

</bean>

第二步，添加

将@Transactional 注解添加到合适的方法上，并设置合适的属性信息。@Transactional 注解的属性信息如表 1 展示。

表 1. @Transactional 注解的属性信息

属性名说明
name当在配置文件中有多个 TransactionManager , 可以用该属性指定选择哪个事务管理器。
propagation事务的传播行为，默认值为 REQUIRED。
isolation事务的隔离度，默认值采用 DEFAULT。
timeout事务的超时时间，默认值为-1。如果超过该时间限制但事务还没有完成，则自动回滚事务。
read-only指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。
rollback-for用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
no-rollback- for抛出 no-rollback-for 指定的异常类型，不回滚事务。

此外，

① @Transactional 注解也可添加在类级别上。当把@Transactional 注解放在类级别时，表示所有该类的公共方法都配置相同的事务属性信息。如下面类，EmployeeService 的所有方法都支持事务并且是只读。

② 当类级别配置了@Transactional，方法级别也配置了@Transactional，应用程序会以方法级别的事务属性信息来管理事务，换言之，方法级别的事务属性信息会覆盖类级别的相关配置信息。

@Transactional 注解的类级别支持

清单 2

@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)
@Service(value ="employeeService")
public class EmployeeService

        到此，您会发觉使用@Transactional 注解管理事务的实现步骤很简单。但是如果对 Spring 中的 @transaction 注解的事务管理理解的不够透彻，就很容易出现错误，比如事务应该回滚（rollback）而没有回滚事务的问题。接下来，将首先分析 Spring 的注解方式的事务实现机制，然后列出相关的注意事项，以最终达到帮助开发人员准确而熟练的使用 Spring 的事务的目的。

2）Spring 的注解方式的事务实现机制

        在应用系统调用声明@Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据@Transactional 的属性配置信息，这个代理对象决定该声明@Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，会在在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器(图 2 有相关介绍)AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务, 如图 1 所示。

                                                               图 1. Spring 事务实现机制

 

        Spring AOP 代理有 CglibAopProxy 和 JdkDynamicAopProxy 两种，图 1 是以 CglibAopProxy 为例，对于 CglibAopProxy，需要调用其内部类的 DynamicAdvisedInterceptor 的 intercept 方法。对于 JdkDynamicAopProxy，需要调用其 invoke 方法。

        正如上文提到的，事务管理的框架是由抽象事务管理器 AbstractPlatformTransactionManager 来提供的，而具体的底层事务处理实现，由 PlatformTransactionManager 的具体实现类来实现，如事务管理器 DataSourceTransactionManager。不同的事务管理器管理不同的数据资源 DataSource，比如 DataSourceTransactionManager 管理 JDBC 的 Connection。

PlatformTransactionManager，AbstractPlatformTransactionManager 及具体实现类关系如图 2 所示。

                                                            图 2. TransactionManager 类结构

 

3）注解方式的事务使用注意事项

    当您对 Spring 的基于注解方式的实现步骤和事务内在实现机制有较好的理解之后，就会更好的使用注解方式的事务管理，避免当系统抛出异常，数据不能回滚的问题。

正确的设置@Transactional 的 propagation 属性

需要注意下面三种 propagation 可以不启动事务。本来期望目标方法进行事务管理，但若是错误的配置这三种 propagation，事务将不会发生回滚。

  1. TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
  2. TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
  3. TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

正确的设置@Transactional 的 rollbackFor 属性

默认情况下，如果在事务中抛出了未检查异常（继承自 RuntimeException 的异常）或者 Error，则 Spring 将回滚事务；除此之外，Spring 不会回滚事务。

如果在事务中抛出其他类型的异常，并期望 Spring 能够回滚事务，可以指定 rollbackFor。例：

@Transactional(propagation= Propagation.REQUIRED,rollbackFor= MyException.class)

通过分析 Spring 源码可以知道，若在目标方法中抛出的异常是 rollbackFor 指定的异常的子类，事务同样会回滚。

清单 3. RollbackRuleAttribute 的 getDepth 方法

private int getDepth(Class<?> exceptionClass, int depth) {

        if (exceptionClass.getName().contains(this.exceptionName)) {

            // Found it!

            return depth;

}

        // If we've gone as far as we can go and haven't found it...

        if (exceptionClass == Throwable.class) {

            return -1;

}

return getDepth(exceptionClass.getSuperclass(), depth + 1);

}

@Transactional 只能应用到 public 方法才有效

只有@Transactional 注解应用到 public 方法，才能进行事务管理。这是因为在使用 Spring AOP 代理时，Spring 在调用在图 1 中的 TransactionInterceptor 在目标方法执行前后进行拦截之前，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource（Spring 通过这个类获取表 1. @Transactional 注解的事务属性配置属性信息）的 computeTransactionAttribute 方法。

清单 4. AbstractFallbackTransactionAttributeSource

protected TransactionAttribute computeTransactionAttribute(Method method,

    Class<?> targetClass) {

        // Don't allow no-public methods as required.

        if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {

return null;}

这个方法会检查目标方法的修饰符是不是 public，若不是 public，就不会获取@Transactional 的属性配置信息，最终会造成不会用 TransactionInterceptor 来拦截该目标方法进行事务管理。

避免 Spring 的 AOP 的自调用问题

在 Spring 的 AOP 代理下，只有目标方法由外部调用，目标方法才由 Spring 生成的代理对象来管理，这会造成自调用问题。若同一类中的其他没有@Transactional 注解的方法内部调用有@Transactional 注解的方法，有@Transactional 注解的方法的事务被忽略，不会发生回滚。见清单 5 举例代码展示。

清单 5.自调用问题举例

    @Service

    public class OrderService {

        private void insert() {
    
        insertOrder();

    }

    @Transactional

    public void insertOrder() {

        //insert log info

        //insertOrder

        //updateAccount

       }

}

insertOrder 尽管有@Transactional 注解，但它被内部方法 insert 调用，事务被忽略，出现异常事务不会发生回滚。

上面的两个问题@Transactional 注解只应用到 public 方法和自调用问题，是由于使用 Spring AOP 代理造成的。为解决这两个问题，使用 AspectJ 取代 Spring AOP 代理。

需要将下面的 AspectJ 信息添加到 xml 配置信息中。

清单 6. AspectJ 的 xml 配置信息

<tx:annotation-driven mode="aspectj" />

<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
    <property name="transactionManager" ref="transactionManager" />
</bean>

同时在 Maven 的 pom 文件中加入 spring-aspects 和 aspectjrt 的 dependency 以及 aspectj-maven-plugin。

清单 7. AspectJ 的 pom 配置信息

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.9</version>
</dependency>
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.9</version>
    <configuration>
        <showWeaveInfo>true</showWeaveInfo>
        <aspectLibraries>
            <aspectLibrary>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </aspectLibrary>
        </aspectLibraries>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

 

春风化作秋雨
关注
  • 14
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Spring Data JPA手动管理事务
loushangdeanshi的博客
05-24 3454
1、简介 通常在开发中，我们都会直接使用Spring提供的@Transactional注解来管理事务。但是在某些特殊的情况下，需要我们进行手动的事务管理。例如：将数据保存到数据库后，才能发送消息到队列中的这种情况。 Spring Data JPA中提供的方法的默认实现都自带@Transactional注解，例如SimpleJpaRepository中的实现。这就意味着，即使我们不显示的标注@Transactional，也会自动的添加事务。 @Repository // 默认添加只读事务 @Transacti
Spring JPA事务
oschina_40914891的博客
09-05 604
[TOC] 1. 概述 本文将讨论 配置Spring Transactions的正确方法, 如何使用 @Transactional 注解和常见陷阱。 有关核心持久性配置的更深入讨论，请查看 Spring JPA教程。 通常，有两种不同的方式来配置事务： 注解和AOP， 每个都有自己的优势。 我们将在这里讨论更常见的注解配置。 促进阅读： 为测试配置单独的Spring DataSource 有关在...
SpringDataJPA的事务支持
Flying_Fish_roe的博客
05-07 918
Spring Data JPA是一个用于简化数据访问层开发的框架，它整合了Spring和JPA，提供了一种便捷的方式来进行数据库操作。在Spring Data JPA中，事务是通过使用@Transactional注解来实现的。事务的支持是通过Spring的事务管理器来实现的，可以配置多种不同的事务管理器，如JpaTransactionManager、HibernateTransactionManager等。使用@Transactional注解可以将一个方法或类标记为一个事务。
【源码】Spring Data JPA原理解析之事务执行原理
最新发布
JingAi_jia917的博客
06-07 1483
本篇从源码的角度分析了Spring Data JPA事务Transaction的处理过程。重点分析了TransactionAspectSupport、AbstractPlatformTransactionManager、JpaTransactionManager的源码。
Spring Data JPA 原理与实战第十一天 JPAS事务、Hibernate和Persistence Context
fegus的博客
05-21 1691
19 如何搞清楚事务、连接池的关系？正确配置是怎样的？ 你好，欢迎继续学习 Spring Data JPA 原理与实战。上一课时，我们讲解了数据源的基本原理和工作方式，你知道了数据源是创建数据连接的入口，数据源里面获得连接的时候也采用了连接池。那么这一讲我们来看下事务在 JPA 和 Spring 里面的详细配置和原理。 事务的基本原理 在学习 Spring 的事务之前，你首先要了解数据库的事务原理，我们以 MySQL 5.7 为例，讲解一下数据库事务的基础知识。 我们都知道 当 MySQL 使用 Inno
创新实训个人进度博客（13）——JPA事务简析
qq_26777045的博客
07-01 205
创新实训个人进度博客（13）——JPA事务简析什么是数据库事务事务的特性通俗易懂的例子SpringBoot中实现事务的方法 在写学生创建创新实训的接口时，需要一步进行两个sql存放操作。首先是根据学生传来的项目申请的有关信息，创建项目实体并存入表project中，因为项目ID是数据库中设置的自增的所以必须先存进去然后根据申请人查出来项目ID，再结合学生信息存入student_project表中。这两个存放步骤必须按顺序进行，且必须同时成功或同时失败。即如果第一步成功了，但是第二步失败了，那么就要回滚第一步
spring中使用jpa编程式事务管理
yys79的专栏
06-15 1192
老久不玩这个了，记录下备查。去掉方法不能有Transaction注解，spring要配置个TransactionTemplate：&lt;bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"&gt; &lt;property name="timeou...
SpringDataJpa入门(太阿)
LuckFairyLuckBaby的博客
09-23 896
Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence，详细内容可参考https://github.com/javaee/jpa-spec） JPA的出现主要是为了简化持久层开发以及整合ORM技术，结束Hib...
JPA事务处理（坑）
天才小站
09-06 1742
1、JPA事务 JPA的确没有提供事务级别的设置，只提供了@TransactionAttribute注释用作定义一个需要事务的方法。 它可以有以下参数： 1.REQUIRED:方法在一个事务中执行，如果调用的方法已经在一个事务中，则使用该事务，否则将创建一个 新的事务。 2.MANDATORY:方法必须在一个事务中执行，也就是说调用的方法必须已经有一个事务，否则新抛出一个错 误（ERROR）...
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
8. ** Transactions**：Spring Data JPA 使用 Spring 的事务管理支持，可以方便地配置事务边界，确保数据操作的一致性。 9. **JPA Querydsl Support**：Spring Data JPA 还支持 Querydsl，这是一个强大的类型安全的...
Spring Data JPA的优点和难点.pdf
12-05
- Spring Data JPA可以无缝地与Spring Boot、Spring MVC、Spring Transaction管理等组件集成，为开发者提供了完整的解决方案，降低了系统的复杂性。 然而，尽管Spring Data JPA带来了诸多便利，但在实际使用中也会...
Spring data Jpa
02-17
总的来说，Spring Data JPA 和事务管理是现代Java应用开发中不可或缺的工具，它们大大提高了开发效率并保证了数据操作的正确性。在实际项目中，我们需要根据业务需求灵活运用这些技术，确保系统的稳定性和可维护性。...
spring注解+spring data jpa文档+JPA文档.rar
04-05
此外，`@Transactional`用于声明方法级别的事务管理，`@RequestMapping`和`@GetMapping`等用于处理HTTP请求。 Spring Data JPA是Spring的一个模块，它简化了使用JPA进行数据访问的操作。Spring Data JPA提供了强大...
后端 Java Spring Data Jpa @Transactional 介绍
03-17
在Java后端开发中，Spring框架提供了强大的事务管理能力，特别是在使用Spring Data JPA时，`@Transactional`注解使得事务处理变得简单易用。这个注解是Spring框架中的核心部分，它允许开发者声明性地控制事务边界，...
Spring整合JPA
m0_64892750的博客
04-05 1606
依赖 <!-- 父项目依赖 统一管理SpringData子项目版本--> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-dat
Spring入门——事务管理Transaction Manager
忘忧的博客
04-24 5986
1、事务初识 事务是逻辑上的一组操作，要么全部成功，要么全部失败。 事务具有ACID特性，参考百度百科，具体如下： 原子性（Atomicity）：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。 一致性（Consistency）：事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。 隔离性（Isolation）：隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。 持久性（Durability）：在事务完成以后，该事务对数据库所作的更
JPA的基本操作
weixin_40055163的博客
10-21 449
JPA的基本操作 1 api对象 jpa操作的操作步骤 1.加载配置文件创建实体管理器工厂 Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）。 createEntityMnagerFactory（持久化单元名称）作用：创建实体管理器工厂。 2.根据实体管理器工厂，创建实体管理器 EntityManagerFactory ：获取EntityManager对象 方法：createEntityManager 内部维护的很多的内容： 内部维护了数据库信息。 维护了缓存信息。 维护了
spring+jpa+hibernate实现多数据源
java编程
10-01 1637
关键配置：AbstractRoutingDataSource 使用这个动态管理DataSource的数据源就可以实现动态切换数据源了，亲测可用。 给出部分配置代码： spring-datasource.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.o...
JPA与Spring2.5整合时发生不能创建entityManagerFactory的问题解决方法
jhacker7的专栏
02-18 630
今天在做jpa与spring整合时,发现个异常... 如下 异常内容: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in class path resource [beans.xml]:: Invocatio...
Spring Data JPA
07-09
Spring Data JPA 是什么？ Spring Data JPA 是 Spring 框架中的一个模块，它提供了一种方便的方式来访问和操作数据库，同时也简化了开发人员的工作。它基于 JPA 规范，提供了一些常用的 CRUD 操作方法，同时也支持自定义查询和分页查询等功能。 Spring Data JPA 的优点是什么？ Spring Data JPA 的优点包括： 1. 简化了数据访问层的开发，提高了开发效率。 2. 提供了一些常用的 CRUD 操作方法，减少了重复的代码编写。 3. 支持自定义查询和分页查询等功能，提高了查询效率。 4. 可以与 Spring 框架无缝集成，方便使用。 5. 支持多种数据库，包括关系型数据库和 NoSQL 数据库等。 6. 提供了一些高级特性，如二级缓存、延迟加载等。 Spring Data JPA 的缺点是什么？ Spring Data JPA 的缺点包括： 1. 学习曲线较陡峭，需要掌握 JPA 规范和 Spring 框架的相关知识。 2. 对于复杂的查询，需要编写自定义查询语句，增加了开发难度。 3. 对于大规模数据的查询和操作，可能会出现性能问题。 4. 对于一些特殊的需求，可能需要使用原生 SQL 或其他 ORM 框架来实现。 Spring Data JPA 和 Hibernate 有什么区别？ Spring Data JPA 是基于 JPA 规范的，而 Hibernate 是一个 ORM 框架，它实现了 JPA 规范。因此，Spring Data JPA 和 Hibernate 之间的区别主要在以下几个方面： 1. Spring Data JPA 是一个数据访问层框架，而 Hibernate 是一个 ORM 框架。 2. Spring Data JPA 提供了一些常用的 CRUD 操作方法，而 Hibernate 更加灵活，可以编写任意复杂的查询语句。 3. Spring Data JPA 可以与 Spring 框架无缝集成，而 Hibernate 可以与任何 Java 应用程序集成。 4. Spring Data JPA 支持多种数据库，包括关系型数据库和 NoSQL 数据库等，而 Hibernate 主要支持关系型数据库。 5. Spring Data JPA 提供了一些高级特性，如二级缓存、延迟加载等，而 Hibernate 也提供了类似的特性。 如何使用 Spring Data JPA？ 使用 Spring Data JPA 的步骤如下： 1. 添加依赖：在项目的 pom.xml 文件中添加 Spring Data JPA 的依赖。 2. 配置数据源：在 Spring 的配置文件中配置数据源。 3. 定义实体类：定义与数据库表对应的实体类，并使用 JPA 注解进行映射。 4. 定义 DAO 接口：定义一个继承 JpaRepository 接口的 DAO 接口。 5. 编写业务逻辑：在 Service 层中编写业务逻辑，调用 DAO 接口中的方法进行数据操作。 6. 运行程序：启动应用程序，测试数据访问和操作是否正常。 如何进行分页查询？ 使用 Spring Data JPA 进行分页查询的步骤如下： 1. 在 DAO 接口中定义一个继承 PagingAndSortingRepository 接口的方法。 2. 在 Service 层中调用 DAO 接口中的分页查询方法，并指定分页参数。 3. 在控制器中接收分页参数，并将查询结果传递给前端页面。 4. 在前端页面中显示分页信息和查询结果。 如何进行自定义查询？ 使用 Spring Data JPA 进行自定义查询的步骤如下： 1. 在 DAO 接口中定义一个自定义查询方法，并使用 @Query 注解指定查询语句。 2. 在 Service 层中调用 DAO 接口中的自定义查询方法。 3. 在控制器中接收查询结果，并将结果传递给前端页面。 4. 在前端页面中显示查询结果。 如何进行事务管理？ 使用 Spring Data JPA 进行事务管理的步骤如下： 1. 在 Spring 的配置文件中配置事务管理器。 2. 在 Service 层中使用 @Transactional 注解标记需要进行事务管理的方法。 3. 在控制器中调用 Service 层中的方法。 4. 如果方法执行成功，则事务会自动提交，否则事务会自动回滚。 如何进行多表查询？ 使用 Spring Data JPA 进行多表查询的步骤如下： 1. 在 DAO 接口中定义一个自定义查询方法，并使用 @Query 注解指定查询语句。 2. 在查询语句中使用 JOIN 关键字连接多个表。 3. 在 Service 层中调用 DAO 接口中的自定义查询方法。 4. 在控制器中接收查询结果，并将结果传递给前端页面。 5. 在前端页面中显示查询结果。 如何进行级联操作？ 使用 Spring Data JPA 进行级联操作的步骤如下： 1. 在实体类中使用 @OneToMany 或 @ManyToOne 注解定义关联关系。 2. 在 Service 层中编写业务逻辑，调用 DAO 接口中的方法进行级联操作。 3. 在控制器中接收操作结果，并将结果传递给前端页面。 4. 在前端页面中显示操作结果。 如何进行缓存管理？ 使用 Spring Data JPA 进行缓存管理的步骤如下： 1. 在 Spring 的配置文件中配置缓存管理器。 2. 在实体类中使用 @Cacheable 或 @CacheEvict 注解指定缓存策略。 3. 在 Service 层中编写业务逻辑，调用 DAO 接口中的方法进行数据操作。 4. 在控制器中接收操作结果，并将结果传递给前端页面。 5. 在前端页面中显示操作结果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

春风化作秋雨

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

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

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

打赏作者

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

抵扣说明：

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

余额充值