Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 10 Next »

Wstęp

Zarządzanie transakcjami jest możliwe za pomocą adnotacji @Transactonal, @UserTransactional, oraz @SharkTransactional. Adnotacje te możemy używać tylko w klasach zarządzanych przez kontekst aplikacji. 

  • @Transactional - tworzy transakcję Hibernate
  • @SharkTransactional - tworzy transakcję SharkTransaction
  • @UserTransactional - tworzy transakcję UserTransaction

Dobre praktyki

Zaleca się stosowanie adnotacji do zarządzania transakcjami w klasach oznaczonych adnotacją @Sevice

Przykłady użycia

Wykonanie kilku operacj w jednej transakcji
@Service
public class CustomServiceImpl
    implements CustomService
{
	@Autowired
    private StructureService structureService;

    @Transactional
    public void addPositionAndOu()
    {
        Position p = new Position( "name", "symbol" );
        OrganizationalUnit ou = new OrganizationalUnit();
        ou.setName( "name" );
        ou.setSymbol( "symbol" );
        structureService.createPosition( p );
        structureService.createOrganizationalUnit( ou );
    }

    public void addPositionAndOuNonTransactional()
    {
        Position p = new Position( "name", "symbol" );
        OrganizationalUnit ou = new OrganizationalUnit();
        ou.setName( "name" );
        ou.setSymbol( "symbol" );
        structureService.createPosition( p );
        structureService.createOrganizationalUnit( ou );
    }
}

W powyższym przykładzie funkcja bez adnotacji @Transactional utworzy osobne transakcje dla każdej funkcji save, natomiast w funkcji oznaczonej @Transactional obie operacje będą działać na jednej tej samej transakcji.

Pobranie własnego serwisu w zadaniu automatycznym
    public static void execute()
    {
        ClientService cs = SpringContext.getBean( ClientService.class );
		cs.addPositionAndOu();
    }

Manualne zarządzanie transakcjami

Możliwe jest manualne zarządzanie transakcjami bez potrzeby tworzenia nowych klas. W tym celu możemy wykorzystać klasę TransactionManagerFactory

 

 

Zarządzanie transakcjami poprzez TransactionTemplate
        
		TransactionTemplate tt = new TransactionTemplate( TransactionManagerFactory.getHibernateTransactionManager() );
        tt.execute( new TransactionCallbackWithoutResult()
        {
            @Override
            protected void doInTransactionWithoutResult( TransactionStatus status )
            {
                QueryExecutor qe = ComponentFactory.getQueryExecutor();
                SQLQuery sql = qe.createSQLQuery( ... );
                ...
                sql.executeUpdate();
            }
        } );

 

Zarządzanie transakcjami poprzez TransactionTemplate
        final SharkTransactionManager mgr= TransactionManagerFactory.getSharkTransactionManager();
		TransactionTemplate tt = new TransactionTemplate( mgr );
        tt.execute( new TransactionCallbackWithoutResult()
        {
            @Override
            protected void doInTransactionWithoutResult( TransactionStatus status )
            {
                SharkTransaction sharkTransaction = mgr.getSharkTransaction();
				...
		    }
        } );


Manualne zarządzanie transakcjami
      SharkTransactionManager= TransactionManagerFactory.getSharkTransactionManager();
      TransactionStatus txStatus = null;
      try
      {
            txStatus = mgr.getTransaction( new DefaultTransactionDefinition() );
            SharkTransaction sharkTransaction = mgr.getSharkTransaction();
            ...//wykonywanie operacji na transakcji
            mgr.commit( txStatus  );
      }
	  catch ( Exception ex )
      { 
		    mgr.rollback( txStatus );
	  }
Przydatne zasoby:

 

 

  • No labels