Spring事务属性

最新推荐文章于 2024-10-05 11:27:00 发布
最新推荐文章于 2024-10-05 11:27:00 发布
阅读量338 收藏
点赞数
分类专栏： JAVA 文章标签： spring java nested null jdbc 活动

Spring 声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。


我们在使用Spring 声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。


Spring 在TransactionDefinition 接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是spring 事务管理的核心接口。

 

Java代码 复制代码
  1. TransactionDefinition     
  2. public interface TransactionDefinition {     
  3.     int getPropagationBehavior();     
  4.     int getIsolationLevel();     
  5.     int getTimeout();     
  6.     boolean isReadOnly();     
  7. }    
 TransactionDefinition  
 public interface TransactionDefinition {  
     int getPropagationBehavior();  
     int getIsolationLevel();  
     int getTimeout();  
     boolean isReadOnly();  
 }

 

getTimeout()方法，它返回事务必须在多少秒内完成。
isReadOnly(),事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。
getIsolationLevel()方法返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。

在TransactionDefinition接口中定义了五个不同的事务隔离级别
ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应
ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
  例如:
  Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务

 

Java代码 复制代码
  1. Connection con1 = getConnection();     
  2. con.setAutoCommit(false);     
  3. update employee set salary = 8000 where empId ="Mary";    
Connection con1 = getConnection();  
con.setAutoCommit(false);  
update employee set salary = 8000 where empId ="Mary";

 

 Mary发现自己的工资变为了8000，欢天喜地！
而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000

 

Java代码 复制代码
  1. //con1     
  2.    con1.rollback();    
//con1  
   con1.rollback();

 

像这样,Mary记取的工资数8000是一个脏数据。

ISOLATION_READ_COMMITTED  保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。

ISOLATION_REPEATABLE_READ  这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。

在事务1中，Mary 读取了自己的工资为1000,操作并没有完成

 

Java代码 复制代码
  1. con1 = getConnection();     
  2. select salary from employee empId ="Mary";    
 con1 = getConnection();  
 select salary from employee empId ="Mary";

 

在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.

 

Java代码 复制代码
  1. con2 = getConnection();     
  2. update employee set salary = 2000;     
  3. con2.commit();    
 con2 = getConnection();  
 update employee set salary = 2000;  
 con2.commit();

 

在事务1中，Mary 再次读取自己的工资时，工资变为了2000

 

Java代码 复制代码
  1. //con1     
  2. select salary from employee empId ="Mary";    
 //con1  
 select salary from employee empId ="Mary";

 

在一个事务中前后两次读取的结果并不致，导致了不可重复读。
使用ISOLATION_REPEATABLE_READ可以避免这种情况发生。

ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

目前工资为1000的员工有10人。
事务1,读取所有工资为1000的员工。

 

Java代码 复制代码
  1. con1 = getConnection();     
  2. Select * from employee where salary =1000;    
 con1 = getConnection();  
 Select * from employee where salary =1000;

 共读取10条记录

这时另一个事务向employee表插入了一条员工记录，工资也为1000

Java代码 复制代码
  1. con2 = getConnection();     
  2. Insert into employee(empId,salary) values("Lili",1000);     
  3. con2.commit();    
 con2 = getConnection();  
 Insert into employee(empId,salary) values("Lili",1000);  
 con2.commit();

 

事务1再次读取所有工资为1000的员工

Java代码 复制代码
  1. //con1     
  2. select * from employee where salary =1000;    
 //con1  
 select * from employee where salary =1000;

 

共读取到了11条记录，这就产生了幻像读。
ISOLATION_SERIALIZABLE能避免这样的情况发生。但是这样也耗费了最大的资源。

getPropagationBehavior() 返回事务的传播行为，由是否有一个活动的事务来决定一个事务调用。

在TransactionDefinition接口中定义了七个事务传播行为 。

PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED     
  2. methodA{     
  3. ……     
  4. methodB();     
  5. ……     
  6. }     
  7.      
  8. //事务属性 PROPAGATION_REQUIRED     
  9. methodB{     
  10.    ……     
  11. }    
 //事务属性 PROPAGATION_REQUIRED  
 methodA{  
 ……  
 methodB();  
 ……  
 }  
   
 //事务属性 PROPAGATION_REQUIRED  
 methodB{  
    ……  
 }

 

使用spring 声明式事务，spring 使用AOP来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

单独调用methodB方法

Java代码 复制代码
  1. main{     
  2.   metodB();     
  3. }    
 main{  
   metodB();  
 }

 

相当于

 

Java代码 复制代码
  1.  Main{     
  2.  Connection con=null;     
  3.       
  4.     rry{     
  5.        con = getConnection();     
  6.        con.setAutoCommit(false);     
  7.  //方法调用     
  8.  methodB();     
  9.  //提交事务     
  10.  con.commit();     
  11.  }     
  12.  Catch(RuntimeException ex){     
  13.    //回滚事务     
  14.    con.rollback();       
  15.  }     
  16.  finally{     
  17.    //释放资源     
  18.    closeCon();     
  19.  }     
  20. }    
 Main{  
 Connection con=null;  
   
    rry{  
       con = getConnection();  
       con.setAutoCommit(false);  
 //方法调用  
 methodB();  
 //提交事务  
 con.commit();  
 }  
 Catch(RuntimeException ex){  
   //回滚事务  
   con.rollback();    
 }  
 finally{  
   //释放资源  
   closeCon();  
 }  
}

 

Spring 保证在methodB方法中所有的调用都获得到一个相同的连接。在调用methodB时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。

单独调用MethodA时，在MethodA内又会调用MethodB.

执行效果相当于

 

Java代码 复制代码
  1. main{     
  2.    Connection con = null;     
  3.    try{     
  4.       con = getConnection();     
  5.       methodA();     
  6.       con.commit();     
  7. }     
  8. cathc(RuntimeException ex){     
  9.  con.rollback();     
  10. }     
  11. finally{     
  12.   closeCon();     
  13. }      
  14. }    
 main{  
    Connection con = null;  
    try{  
       con = getConnection();  
       methodA();  
       con.commit();  
 }  
 cathc(RuntimeException ex){  
  con.rollback();  
 }  
 finally{  
   closeCon();  
 }   
 }

 

调用MethodA时，环境中没有事务，所以开启一个新的事务.
当在MethodA中调用MethodB时，环境中已经有了一个事务，所以methodB就加入当前事务。

PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED      
  2. methodA(){     
  3.   methodB();     
  4. }     
  5.     
  6. //事务属性 PROPAGATION_SUPPORTS      
  7. methodB(){     
  8.   ……     
  9.     
 //事务属性 PROPAGATION_REQUIRED   
 methodA(){  
   methodB();  
 }  
  
 //事务属性 PROPAGATION_SUPPORTS   
 methodB(){  
   ……  
}

 

单纯的调用methodB时，methodB方法是非事务的执行的。
当调用methdA时,methodB则加入了methodA的事务中,事务地执行。

PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED      
  2. methodA(){     
  3.   methodB();     
  4. }     
  5.      
  6. //事务属性 PROPAGATION_MANDATORY      
  7. methodB(){     
  8.   ……     
  9. }    
 //事务属性 PROPAGATION_REQUIRED   
 methodA(){  
   methodB();  
 }  
   
 //事务属性 PROPAGATION_MANDATORY   
 methodB(){  
   ……  
 }

 

当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常
throw new IllegalTransactionStateException("Transaction propagation 'mandatory' but no existing transaction found");

当调用methodA时，methodB则加入到methodA的事务中，事务地执行。

PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED      
  2. methodA(){     
  3.   doSomeThingA();     
  4.   methodB();     
  5.   doSomeThingB();     
  6. }     
  7.      
  8. //事务属性 PROPAGATION_REQUIRES_NEW      
  9. methodB(){     
  10.   ……     
  11. }    
 //事务属性 PROPAGATION_REQUIRED   
 methodA(){  
   doSomeThingA();  
   methodB();  
   doSomeThingB();  
 }  
   
 //事务属性 PROPAGATION_REQUIRES_NEW   
 methodB(){  
   ……  
 }

 

当单独调用methodB时，相当于把methodb声明为REQUIRED。开启一个新的事务，事务地执行。

当调用methodA时

Java代码 复制代码
  1. main(){     
  2.   methodA();     
  3. }    
 main(){  
   methodA();  
 }

 

情况有些大不一样.相当于下面的效果。

 

Java代码 复制代码
  1. main(){     
  2.  TransactionManager tm = null;     
  3. try{     
  4.   //获得一个JTA事务管理器     
  5.    tm = getTransactionManager();     
  6.    tm.begin();//开启一个新的事务     
  7.    Transaction ts1 = tm.getTransaction();     
  8.    doSomeThing();     
  9.    tm.suspend();//挂起当前事务     
  10.    try{     
  11.      tm.begin();//重新开启第二个事务     
  12.      Transaction ts2 = tm.getTransaction();     
  13.      methodB();     
  14.      ts2.commit();//提交第二个事务     
  15.           
  16.    }     
  17.   Catch(RunTimeException ex){     
  18.      ts2.rollback();//回滚第二个事务     
  19.   }     
  20.   finally{     
  21.     //释放资源     
  22.   }     
  23.    //methodB执行完后，复恢第一个事务     
  24.    tm.resume(ts1);     
  25.   doSomeThingB();     
  26.    ts1.commit();//提交第一个事务     
  27. }     
  28. catch(RunTimeException ex){     
  29.   ts1.rollback();//回滚第一个事务     
  30. }     
  31. finally{     
  32.   //释放资源     
  33. }     
  34. }    
 main(){  
  TransactionManager tm = null;  
 try{  
   //获得一个JTA事务管理器  
    tm = getTransactionManager();  
    tm.begin();//开启一个新的事务  
    Transaction ts1 = tm.getTransaction();  
    doSomeThing();  
    tm.suspend();//挂起当前事务  
    try{  
      tm.begin();//重新开启第二个事务  
      Transaction ts2 = tm.getTransaction();  
      methodB();  
      ts2.commit();//提交第二个事务  
        
    }  
   Catch(RunTimeException ex){  
      ts2.rollback();//回滚第二个事务  
   }  
   finally{  
     //释放资源  
   }  
    //methodB执行完后，复恢第一个事务  
    tm.resume(ts1);  
   doSomeThingB();  
    ts1.commit();//提交第一个事务  
 }  
 catch(RunTimeException ex){  
   ts1.rollback();//回滚第一个事务  
 }  
 finally{  
   //释放资源  
 }  
 }

 

在这里，我把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。Ts2是否成功并不依赖于 ts1。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了 methodB之外的其它代码导致的结果却被回滚了。
使用PROPAGATION_REQUIRES_NEW,需要使用JtaTransactionManager作为事务管理器。

PROPAGATION_NOT_SUPPORTED   总是非事务地执行，并挂起任何存在的事务。

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED      
  2. methodA(){     
  3.   doSomeThingA();     
  4.   methodB();     
  5.   doSomeThingB();     
  6. }     
  7.      
  8. //事务属性 PROPAGATION_NOT_SUPPORTED      
  9. methodB(){     
  10.   ……     
  11. }    
 //事务属性 PROPAGATION_REQUIRED   
 methodA(){  
   doSomeThingA();  
   methodB();  
   doSomeThingB();  
 }  
   
 //事务属性 PROPAGATION_NOT_SUPPORTED   
 methodB(){  
   ……  
 }

 

当单独调用methodB时，不启用任何事务机制，非事务地执行。
当调用methodA时，相当于下面的效果

Java代码 复制代码
  1. main(){     
  2.  TransactionManager tm = null;     
  3. try{     
  4.   //获得一个JTA事务管理器     
  5.    tm = getTransactionManager();     
  6.    tm.begin();//开启一个新的事务     
  7.    Transaction ts1 = tm.getTransaction();     
  8.    doSomeThing();     
  9.    tm.suspend();//挂起当前事务     
  10.      methodB();     
  11.    //methodB执行完后，复恢第一个事务     
  12.    tm.resume(ts1);     
  13.   doSomeThingB();     
  14.    ts1.commit();//提交第一个事务     
  15. }     
  16. catch(RunTimeException ex){     
  17.   ts1.rollback();//回滚第一个事务     
  18. }     
  19.  finally{     
  20.     //释放资源     
  21.   }     
  22. }    
 main(){  
  TransactionManager tm = null;  
 try{  
   //获得一个JTA事务管理器  
    tm = getTransactionManager();  
    tm.begin();//开启一个新的事务  
    Transaction ts1 = tm.getTransaction();  
    doSomeThing();  
    tm.suspend();//挂起当前事务  
      methodB();  
    //methodB执行完后，复恢第一个事务  
    tm.resume(ts1);  
   doSomeThingB();  
    ts1.commit();//提交第一个事务  
 }  
 catch(RunTimeException ex){  
   ts1.rollback();//回滚第一个事务  
 }  
  finally{  
     //释放资源  
   }  
 }

 

使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常

 

Java代码 复制代码
  1.  //事务属性 PROPAGATION_REQUIRED      
  2.  methodA(){     
  3.    doSomeThingA();     
  4.  methodB();     
  5.  doSomeThingB();     
  6. }     
  7.      
  8. //事务属性 PROPAGATION_NEVER      
  9.  methodB(){     
  10.  ……     
  11.     
    //事务属性 PROPAGATION_REQUIRED   
    methodA(){  
      doSomeThingA();  
    methodB();  
    doSomeThingB();  
   }  
     
   //事务属性 PROPAGATION_NEVER   
    methodB(){  
    ……  
  }

 

单独调用methodB，则非事务的执行。
调用methodA则会抛出异常
throw new IllegalTransactionStateException(
"Transaction propagation 'never' but existing transaction found");


PROPAGATION_NESTED 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。

使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;
而nestedTransactionAllowed属性值默认为false;

 

Java代码 复制代码
  1. //事务属性 PROPAGATION_REQUIRED      
  2.  methodA(){     
  3.   doSomeThingA();     
  4.  methodB();     
  5.  doSomeThingB();     
  6.  }     
  7.       
  8.  //事务属性 PROPAGATION_NESTED     
  9. methodB(){     
  10.   ……     
  11.     
   //事务属性 PROPAGATION_REQUIRED   
    methodA(){  
     doSomeThingA();  
    methodB();  
    doSomeThingB();  
    }  
      
    //事务属性 PROPAGATION_NESTED  
   methodB(){  
     ……  
  }

 

如果单独调用methodB方法，则按REQUIRED属性执行。

如果调用methodA方法，相当于下面的效果

 

Java代码 复制代码
  1.  main(){     
  2.  Connection con = null;     
  3.  Savepoint savepoint = null;     
  4.  try{     
  5.    con = getConnection();     
  6.    con.setAutoCommit(false);     
  7.   doSomeThingA();     
  8.    savepoint = con2.setSavepoint();     
  9.    try     
  10.       methodB();     
  11.   }catch(RuntimeException ex){     
  12.      con.rollback(savepoint);     
  13.   }     
  14.   finally{     
  15.     //释放资源     
  16.   }     
  17.      
  18.   doSomeThingB();     
  19.  con.commit();     
  20. }     
  21. catch(RuntimeException ex){     
  22.   con.rollback();     
  23.      
  24. finally{     
  25.   //释放资源     
  26. }     
  27.     
    main(){  
    Connection con = null;  
    Savepoint savepoint = null;  
    try{  
      con = getConnection();  
      con.setAutoCommit(false);  
     doSomeThingA();  
      savepoint = con2.setSavepoint();  
      try  
         methodB();  
     }catch(RuntimeException ex){  
        con.rollback(savepoint);  
     }  
     finally{  
       //释放资源  
     }  
     
     doSomeThingB();  
    con.commit();  
   }  
   catch(RuntimeException ex){  
     con.rollback();  
  }  
   finally{  
     //释放资源  
   }  
  }

 

当methodB方法调用之前，调用setSavepoint方法，保存当前的状态到savepoint。如果methodB方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括methodB方法的所有操作。

嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚 。

PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别 :它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要 JTA事务管理器的支持。
使用PROPAGATION_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager使用savepoint支持PROPAGATION_NESTED时，需要 JDBC 3.0以上驱动及1.4以上的JDK版本支持。其它的JTA TrasactionManager实现可能有不同的支持方式。

PROPAGATION_REQUIRED应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

w7822055
关注
专栏目录
Spring事务处理原理步骤详解
08-19
TransactionInterceptor是一个MethodInterceptor，它会保存事务属性信息，事务管理器，并在目标方法执行的时候，执行拦截器链。如果异常，获取到事务管理器，利用事务管理回滚操作；如果正常，利用事务管理器，提交...
主题：详解spring事务属性.doc
10-21
通过配置这些事务属性，我们可以精确地控制Spring声明式事务的行为，以满足不同业务场景的需求。在实际开发中，应根据具体的应用需求和数据库特性来选择合适的事务属性，以保证数据的一致性和事务的正确性，同时兼顾...
Spring事务传播属性
qishiheyongshi的专栏
07-16 1554
Spring事务传播属性
注解驱动事务：Spring中基于注解的事务属性配置详解
学而时习之，不亦说乎？温故而知新，可以为师矣！
01-08 9365
Spring的基于注解的事务配置为开发者提供了更为便捷和直观的方式来定义事务属性。本文将深入讨论如何使用注解来配置Spring事务的隔离级别、传播行为等关键属性。我们将详细介绍@Transactional注解的各种参数，并提供实际案例演示如何应用这些注解来管理事务。
spring事务的五种属性
Never stop for the code
08-27 3207
spring 事务深入理解
Spring事务属性详解
零度的博客专栏
04-07 4230
Spring，是一个Java开源框架，是为了解决企业应用程序开发复杂性由Rod Johnson创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
Spring 事务
lfm1010123的博客
10-31 2505
一、Spring 事务的实现方式 二、Spring 事务的隔离级别 三、Spring 事务的传播机制
Spring的事务机制
ITwolf的博客
09-02 1154
Spring的事务机制
Spring事务：事务属性之7种传播行为
abel004的专栏
06-12 4089
原文：https://blog.csdn.net/soonfly/article/details/70305683 事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：metho...
Spring事务源码详解
景川的博客
05-26 6064
事务是逻辑上的一组操作，要么都执行，要么都不执行，关于事务的基本知识可以看 Spring事务： Spring 支持两种方式的事务管理：编程式事务管理、声明式事务管理
Spring的事务步骤
weixin_53676834的博客
06-16 1520
这种方式用的就是spring框架自己提供的事务的处理机制，@Transactional注解的机制是AOP的环绕通知：在方法执行之前开启事务，方法执行之后回滚或者提交事务。使用 XML 配置文件的方式可以自动为每个符合切入点表达式的类和方法生成事务代理，使用aspectj框架功能，在spring配置文件中声明类和方法需要的事务。这种方式的业务方法和事务配置完全分离的，业务代码就是业务代码，事务就是事务。spring框架自己用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务，
Spring事务传播属性和隔离级别详细介绍
08-29
Spring事务传播属性和隔離级别详细介绍 Spring事务传播属性（Propagation）是指在事务中如何处理事务边界的规则。它定义了事务如何与其他事务进行交互，例如是否支持当前事务、创建新的事务、抛出异常等。 1. ...
Spring中事务的传播属性详解
03-11
### Spring中事务的传播属性详解 #### 一、引言 在使用Spring框架进行应用程序开发时，事务管理是一项非常重要的特性。Spring提供了两种事务管理方式：编程式事务管理和声明式事务管理。其中，声明式事务管理因其...
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
最新发布
qq_51321722的博客
10-05 565
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
Spring MVC的运行流程详解
J老熊
10-03 994
Spring MVC作为一个广泛使用的框架，提供了灵活且强大的MVC架构支持。尤其在业务系统中，Spring MVC能够有效地处理大量并发请求，提供良好的用户体验。本文将详细讲解Spring MVC的运行流程，以电商交易系统为案例，帮助读者深入理解其工作原理。
netty之SpringBoot+Netty+Elasticsearch收集日志信息数据存储
CSDN_LiMingfly的博客
10-04 734
将大量的业务以及用户行为数据存储起来用于分析处理，但是由于数据量较大且需要具备可分析功能所以将数据存储到文件系统更为合理。尤其是一些互联网高并发级应用，往往数据库都采用分库分表设计，那么将这些分散的数据通过binlog汇总到一个统一的文件系统就显得非常有必要。#开发环境环境准备windows安装包 下载注意 es是以来java环境 所以需要安装jdk 支持1.7以上es-hander下载可视化操作插件@Id//姓名//年龄//级别//时间//电话//邮箱//地址。
毕业设计_基于springboot+layui+mybatisPlus的中小型仓库物流管理系统源码+SQL+教程+可运行】41004
pingguocu3的博客
10-04 877
毕业设计--课程设计--springboot--java 登录管理员账号：system 密码：123456 验证码输入：注意验证码字母要大写。启动项目后运行http://locahost:8080跳转到登录界面即可。后端：springboot、mybatis-plus、shiro。application.yml文件中的数据库连接信息。运行sql目录下的warehouse.sql文件。1.基础管理：商品管理、客户管理、供应商管理；2.物流管理：进货管理、发货管理、交付管理...
spring事务属性
09-01
Spring事务属性是用于定义在方法执行期间如何管理事务的一组规则。它们定义了事务的隔离级别、传播行为和回滚规则等。 1. 隔离级别（Isolation Level）：用于控制并发事务之间的相互影响程度。常见的隔离级别有READ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值