了解交易服务-春季

Question

I have a service implementation with a particular method like so:

public class ExampleServiceImpl implements ExampleService {
  @AutoWired
  @Resource
  private RecordRepository recordRepository;

  private void processRecord() {
     // some code here
  }
  @Transactional(readOnly=false)
  public void processRecord(Record a) {
     Record original = getOriginal(a);
     recordRepository.saveChanges(a,original);
  }
}

Where the Record class is the root object of an object graph. RecordRepository looks something like the following with sub repositories to save various children of the objects in the graph.

public class RecordRepository extends BaseRepository<Record> {
   @AutoWired
   @Resource
   private IDao databaseDao;

   @AutoWired
   @Resource
   private SubRecordRepository subRecordRepository;

   public void saveChanges(Record a, Record b) {
      //Perform some processing on a, b
      for(SubRecord subA : a.getSubRecords()) {
         subRecordRepository.saveChanges(subA);
      }
      databaseDao.updateRecord(a);
   }
}

public class DatabaseDao extends NamedParameterJdbcDaoSupport implements IDao {

   @Autowired
   public DatabaseDao(@Qualifier("org.somewhere.Datasource") DataSource ds) {
       super();
       this.setDataSource(ds);
   }

   public void updateRecord(Record inRecord) {
       String query = (String) sql.get("updateRecord");
       SqlParameterSource parms = new BeanPropertySqlParameterSource(inRecord);
       getNamedParameterJdbcTemplate().update(query, parms);
   }

   public void insertSubRecord(SubRecord inSubRecord) {
       String query = (String) sql.get("insertSubRecord");
       SqlParameterSource parms = new BeanPropertySqlParameterSource(inSubRecord);
       getNamedParameterJdbcTemplate().insert(query, parms);
   }

   // other update and insert methods
} 

Will the transaction be applied across all involved inserts\\updates from the processRecord call? In other words, if an insert or update fails, will all previously called inserts and updates from ExampleServiceImpl.processRecord get rolled back?

Answer 1

Yes. The transactional aspect makes sure that a transaction is started before the annotated method is called, and that the transaction (if started by this method) is committed or rollbacked once the method returns.

The transactional interceptor doesn't know (and doesn't care) about which other methods are called inside the annotated method. Every read and write to the DataSource handled by the Spring transaction manager will be included in the same transaction.