@org.springframework.streotype.Repository
public class BusinessDataRepositoryImpl implements BusinessDataRepository {

     @javax.persistence.PersistenceContext
     private EntityManager em;

     @Override
     public BusinessData getBusinessDataBy(long id) {
         return this.em.find(BusinessData.class, id);
     }

     @Override
     public void mergeBusinessData(BusinessData businessData) {
         this.em.merge(buisnessData);
     }
}

@org.springframework.streotype.Repository
public class AuditDataRepositoryImpl implements AuditDataRepository {

     @javax.persistence.PersistenceContext
     private EntityManager em;

     @Override
     public void mergeAuditData(AuditData auditData) {
         this.em.merge(auditData);
     }
}

@org.springframework.streotype.Service
public class BusinessDataServiceImpl implements BusinessDataService {

    @javax.ejb.Resource //DAO dependency
    private BusinessDataRepository businessDataRepository;

    @javax.ejb.Resource //DAO dependency
    private AuditDataRepository auditDataRepository;

    @javax.ejb.Resource //Another business logic service depenency
    private AuthroizationService authorizationService;

    @org.springfreamwork.transaction.Transactional //Share one transaction.
    @Override
    public void changeBusinessData(BusinessData businessData) {
        BuisnessData oldBusinessData = this.businessDataRepository.getBusinesssDataById(businessData.getId());
        if (oldBusinessData == null) {
             throw new IllegalArgumentException(
                 "The business data whose data is \"" +
                 businessData.getId() +
                 " is not existing");
        }

        if (oldBusinessData.getSatate() != businessData.getState()) {
             User currentUser = this.authorizationService.getCurrentUser();
             AuditData auditData = new AuditData();
             auditData.setBusinessData(businessData);
             auditData.setOperator(currentUser);
             auditData.setTime(new Date());
             if (businessData.getState() == BusinessDataState.APPROVED) {
                 aduitData.setAction("approve");
             } else if (businessData.getState() == BusinessDataState.REJECTED) {
                 aduitData.setAction("reject");
             }
             this.auditDataRepository.merge(auditData); //Add audit data
        }
        this.businessDataRepository.merge(businessData); //Change business data
    }
}

@Transactional
public void complexBusinessLogic()
{
    moudleB.step1();
    moudleB.step2();
    moudleB.step3();
    moudleB.step4();
    ... other code ...
}

@Transaction(propagation = Propagation.REQUIRED) // or nothing
public void step1() { ... }

@Transaction(propagation = Propagation.REQUIRES_NEW)
public void step2() { ... }

@Transaction(propagation = Propagation.REQUIRED) // or nothing
public void step3() { ... }

@Transaction(propagation = Propagation.REQUIRES_NEW)
public void step4() { ... }

@Transactional(noRollbackFor = { AException.class, BException.class })
     No exception(Success) -> commit
     AException -> Commit
     BException -> Commit
     Other Exceptions or Errors -> Rollback

@Transactional(noRollbackFor = Throwable.class, rollbackFor = { AException.class, BException.class})
    No Exception(Success) -> Commit
    AException -> Rollback
    BException -> Rollback
    Other Exceptions or Errors -> Commit

public interface DbAction { //Database operation without return value
    void call(Session session);
}

public interface DbFunction<T> { //Database operation with return value
    T call(Session session);
}

public enum Propagation {
   REQUIRED,
   REQUIRES_NEW
}

public abstract class DbContext {

   private ThreadLocal<Stack<Session>> sessionStackLocal;
   
   protected DbContext() {
      this.sessionStackLocal = new ThreadLocal<>();
      this.sessionStackLocal.set(new Stack<Session>());
   }
   
   protected abstract Session createSession();
   
   public <T> T execute(Propagation propagation, final DbFunction<T> handler) {
      final T[] retvalWrapper = (T[])new Object[1];
      this.execute(propagation, new DbAction() {
         @Override
         public void call() {
            retvalWrapper[0] = handler.call();
         }
      });
      return retvalWrapper[0];
   }
      
   public void execute(Propagation propagation, DbAction handler) {
      if (propagation == Propagation.REQUIRES_NEW || this.sessionStackLocal.get().isEmpty()) {
         this.executeByNewSession(handler);
      } else {
         this.executeByExistingSession(this.sessionStackLocal.get().peek(), handler);
      }
   }
   
   private void executeByNewSession(DbAction handler) {
      Session session = this.createSession();
      try {
         this.sessionStackLocal.get().push(session);
         try {
            Transaction tx = session.beginTransaction();
            try {
               handler.call(session);
            } catch (RuntimeException | Error ex) {
               tx.rollback();
               throw ex;
            }
            tx.commit();
         } finally {
            this.sessionStackLocal.get().pop();
         }
      } finally {
         session.close();
      }
   }
   
   private void executeByExistingSession(Session session, DbAction handler) {
      handler.call(session);
   }
}

public class MyDbContext extends DbContext {

   private static final MyDbContext INSTANCE = new MyDbContext();
   
   private SessionFactory sessionFactory;
   
   private MyDbContext() { //Singleton, private constructor
      this.sessionFactory = ...Use your hibernate.cfg.xml to create SessionFactory...
   }
   
   @Override
   protected Session createSession() {
      return this.sessionFactory.openSession();
   }
   
   public static MyDbContext getInstance() {
      return INSTANCE;
   }
}

public class ModuleA {

   private ModuleB moudleB = new ModuleB();
   
   public void doAll() {
      
      MyDbContext.getInstance().execute(Propagation.REQUIRED, new DbAction() {
         @Override
         public void run(Session session) {
            ModuleA.this.moudleB.subStep1();
            ModuleA.this.moudleB.subStep2();
            ModuleA.this.moudleB.subStep3();
            ModuleA.this.moudleB.subStep4();
         }
      });
   }
}

public class MoudleB {

    public void subStep1() {
      MyDbContext.getInstance().execute(Propagation.REQUIRED, new DbAction() {
         @Override
         public void run(Session session) {
            // Use session to do db operation,
            // don't use it it beginTransaction, commit, rollback
            // don't close it too
            // because everything is manged by MyDbContext
         }
      });
   }
   
   public void subStep2() {
      MyDbContext.getInstance().execute(Propagation.REQUIRES_NEW, new DbAction() {
         @Override
         public void run(Session session) {
            // Use session to do db operation,
            // don't use it it beginTransaction, commit, rollback
            // don't close it too
            // because everything is manged by MyDbContext
         }
      });
   }
   
   public void subStep3() {
      MyDbContext.getInstance().execute(Propagation.REQUIRED, new DbAction() {
         @Override
         public void run(Session session) {
            // Use session to do db operation,
            // don't use it it beginTransaction, commit, rollback
            // don't close it too
            // because everything is manged by MyDbContext
         }
      });
   }
   
   public void subStep4() {
      MyDbContext.getInstance().execute(Propagation.REQUIRES_NEW, new DbAction() {
         @Override
         public void run(Session session) {
            // Use session to do db operation,
            // don't use it it beginTransaction, commit, rollback
            // don't close it too
            // because everything is manged by MyDbContext
         }
      });
   }
}

(1) Enter MoudleA.doAll, because stack is empty, so create a session(call it session1) and push it into stack
(2)     Enter MoudleB.subStep1, because propagation is REQUIRED, so execute it on session1 that is peeked from stack
(3)     Leave ModuleB.subStep1, nothing happend
(4)     Enter MoudleB.subStep2, because propagation is REQUIRES_NEW, so create a session(call it session2) and push it into stack
(5)     Leave ModuleB.subStep2, pop session2 from stack and close it
(6)     Enter MoudleB.subStep3, because propagation is REQUIRED, so execute it on session1 that is peeked from stack
(7)     Leave ModuleB.subStep3, nothing happend
(8)     Enter MoudleB.subStep4, because propagation is REQUIRES_NEW, so create a session(call it session3) and push it into stack
(9)     Leave ModuleB.subStep4, pop session3 from stack and close it
(10) Leave ModuleA.doAll, pop session1 from stack and close it

@Transactional
public void complexBusinessLogic()
{
  try{
    moudleB.step1();
    moudleB.step2();
    moudleB.step3();
    moudleB.step4();
}catch(Exception e){
}
    ... other code ...
}

@Transaction(propagation = Propagation.REQUIRED) // or nothing
public void step1() { ... }

@Transaction(propagation = Propagation.REQUIRES_NEW)
public void step2() { ... }

@Transaction(propagation = Propagation.REQUIRED) // or nothing
public void step3() { ... }

@Transaction(propagation = Propagation.REQUIRES_NEW)
public void step4() { ... }

public class ThrowableHolder {

    private Throwable throwable;

    public void set(RuntimeException ex) {
        this.setImpl(ex);
    }

    public void set(Error err) {
        this.setImpl(err);
    }

    public void rethrow() {
        if (this.throwable instanceof RuntimeException) {
            throw (RuntimeException)this.throwable;
        }
        if (this.throwable instanceof Error) {
            throw (Error)this.throwable;
        }
    }

    private void setImpl(Throwable throwable) {
        if (this.throwable == null) { // Only remember the first value
            this.throwable = throwable;
        }   
    }
}

@Transactional
public void complexBusinessLogic() {

    ExceptionHolder holder = new ExceptionHolder();

    try {
        this.moduleB.step1();
    } catch (AException ex) {
        holder.set(ex);
    }
    try {
        this.moduleB.step2();
    } catch (BException ex) {
        holder.set(ex);
    }
    try {
        this.moduleB.step3();
    } catch (CException ex) {
        holder.set(ex);
    }
    try {
        this.moduleB.step4();
    } catch (DException ex) {
        holder.set(ex);
    }

    holder.rethrow();
}