Spring 的transaction 注解事务 传播性和隔离性的问题

Question

        @Autowired
ITestDAO dao ;
//设置timeout 2秒 超时就报异常  
@Transactional(timeout=2,rollbackFor=Exception.class)
public int save(Test t) throws Exception {
System.out.println("进入**");
for (int i = 0; i < 500000; i++) {
System.out.println("*");
}

System.out.println("进入保存");
dao.save(t);//数据库插入操作
System.out.println("退出保存");
         }
我设置了事务超时，但是为什么超时后  异常显示了，但是数据也插入却没用回滚？
spring中的timeout是默认为-1 就是永远不超时。但是我设置了2秒。 （for 循环50W 有2秒时间吧？） 异常报出来
但是hibernate在控制台也打印出sql语句 并且插入进去数据了。这并不是我预期的结果。
应该是异常后 回滚了。所以想请教下：这个timeout并不是我能设置出来的时间吗？
最近看这方面的知识，事务传播性和隔离性。为了防止脏读和重复读、幻读 
(isolation)的隔离级别我只能使用串行化？事务的传播性也正在努力测试中、

Answer 1

timeout应该是对应的connection的超时吧
System.out.println("进入保存");
dao.save(t);//数据库插入操作
throw new Exception();
System.out.println("退出保存");这样就可以测试了,如果数据插进去了,说明你的事务配置不正确,事务并没有开启

Answer 2

其实我想测试的是timeout的问题。我测试单独事务  是可以回滚的。如果在action中调用service 的不同方法，
1插 2 删 3修（设置一个异常抛出  ）
插入和删除都进去了。
却没有回滚。
修不存在。这是对的，但是前面俩个应该也回滚。
spring默认设置的是@Transactional(propagation=Propagation.REQUIRED)我设置了传播性  SUPPORTS  也不尽如意。1插  propagation=Propagation.REQUIREDS_NEW
2删  propagation=Propagation.MANDATORY
3修  propagation=Propagation.MANDATORY 然后在里面抛异常1插 入了  其他都回滚了。设置成propagation=Propagation.REQUIRED 也是插入进去的第一个总是能成功。
他们应该在同一个事务中啊、
不清楚为什么第一个会成功、如果我在一个service中写了propagation=Propagation.REQUIRED 和rollbackFor=Exception.class这个service中包含了那上面的三个方法的话  一个出错就全不执行。请问各位是怎么处理的，是action中调用不同的方法  还是在一个service中把需要的方法包含进来？

Answer 3

默认遇到throw new RuntimeException("...");会回滚
需要捕获的throw new Exception("...");不会回滚// 指定回滚
@Transactional(rollbackFor=Exception.class) 
    public void methodName() {
       // 不会回滚
       throw new Exception("...");
    } 
//指定不回滚
@Transactional(noRollbackFor=Exception.class)
    public ItimDaoImpl getItemDaoImpl() {
        // 会回滚
        throw new RuntimeException("注释");
    }     // 如果有事务,那么加入事务,没有的话新建一个(不写的情况下)
    @Transactional(propagation=Propagation.REQUIRED) 
    // 容器不为这个方法开启事务
    @Transactional(propagation=Propagation.NOT_SUPPORTED)
    // 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
    @Transactional(propagation=Propagation.REQUIRES_NEW) 
    // 必须在一个已有的事务中执行,否则抛出异常
    @Transactional(propagation=Propagation.MANDATORY)
    // 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
    @Transactional(propagation=Propagation.NEVER) 
    // 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
    @Transactional(propagation=Propagation.SUPPORTS) 
    
   
@Transactional(propagation=Propagation.NESTED) 
// readOnly=true只读,不能更新,删除 
@Transactional (propagation = Propagation.REQUIRED,readOnly=true) 
// 设置超时时间
@Transactional (propagation = Propagation.REQUIRED,timeout=30)
// 设置数据库隔离级别
@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)

Answer 4

请给dao和service都配置事物，另外，你这annotation配置的事物，你要区分声明式事物的xml配置的差异性。

Answer 5

// 指定回滚
@Transactional(rollbackFor=Exception.class)  
  public void methodName() {
  // 不会回滚
  throw new Exception("...");
  }  -------------你确定你的不会回滚？
都指定了还不回滚？

Answer 6

如何在1插
2修
3删 （throws new Exception("...");）如何保证这三个事务都回滚？是包含在一个事务中？还是propagation的设置顺序问题？

Answer 7

你是基于注解的配置。
@Transactional 注解应该只被应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 但是这个被注解的方法将不会展示已配置的事务设置。
默认的 @Transactional 设置如下：
    事务传播设置是 PROPAGATION_REQUIRED
    事务隔离级别是 ISOLATION_DEFAULT
    事务是 读/写
    事务超时默认是依赖于事务系统的，或者事务超时没有被支持。
    任何 RuntimeException 将触发事务回滚，但是任何 checked Exception 将不触发事务回滚，需要我们在外部用try/catch语法对调用该方法的地方进行包含 @Transactional，也就是在方法级别加如类似于@Transactional(rollbackFor=Exception.class)
在同一个类中一个方法调用另一个有事务的方法，事务是不会起作用的。public interface PersonService {
//删除指定id的person
public void delete(Integer personid) ;//删除指定id的person,flag
public void delete(Integer personid,boolean flag) ;
}public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;public void delete(Integer personid){
try{
this.delete(personid,true)
System.out.println("delete success");
}catch(Exception e){
System.out.println("delete failed");
}
} 1、你给你的service实现类的类级别添加事物@Transactional，将传播性给为
Propagation.REQUIRED，类似于如下：@Service("leaveService")
@Transactional(propagation=Propagation.REQUIRED)
public class LeaveServiceImpl implements LeaveService 注意：RunTimeException异常才会rollbck，否则不会rollback。
2、在xml中，使注解起作用：
<!-- enable the configuration of transactional behavior based on annotations -->
  <tx:annotation-driven transaction-manager="txManager"/>3、

Answer 8

可能是我表述不清楚、
重新理一遍：
service里
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void save() throws Exception{
  System.out.println("save");
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void update() throws Exception{
  System.out.println("update");
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void delete() throws Exception{
  System.out.println("delete");
  throw new Exception("My Exception!");
}这三个方法action 中 execute 里面可能会执行
先 save 后 update 最后在delete我执行了这个action后
里面的三个方法（最后的delete设置了一个异常抛出）
如何保持同时回滚、而我执行后 结果总是会save 其他的俩个会回滚、（这是没有在一个事务中的问题么？）而我新开一个service的方法比如
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void myService() throws Exception{
System.out.println("myService");
this.save();
this.update();
this.delete();
  
} 在action中 使用myService
会全部回滚、应该写在同一个事务中还是 我那三个方法都需要改传播性？

Answer 9

可能是我表述不清楚、
重新理一遍：
service里
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void save() throws Exception{
  System.out.println("save");
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void update() throws Exception{
  System.out.println("update");
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void delete() throws Exception{
  System.out.println("delete");
  throw new Exception("My Exception!");
}这三个方法action 中 execute 里面可能会执行
先 save 后 update 最后在delete我执行了这个action后
里面的三个方法（最后的delete设置了一个异常抛出）
如何保持同时回滚、而我执行后 结果总是会save 其他的俩个会回滚、（这是没有在一个事务中的问题么？）而我新开一个service的方法比如
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public void myService() throws Exception{
System.out.println("myService");
this.save();
this.update();
this.delete();
   
}  在action中 使用myService
会全部回滚、应该写在同一个事务中还是 我那三个方法都需要改传播性？

Answer 10

我确认我spring 的txannotion 配置了、
而且service 的接口方法 都是public  @Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)注解到了实现上、

Answer 11

如果是这样的话，你试着给dao层的方法上也加上事物。

Answer 12

本来操作就要放到一个service层的方法里才会回滚的