Transaction silently rolled back because it has been marked as rollback-only
O metodă @Transactional apelată din interiorul altei tranzacții a aruncat o excepție, iar tranzacția comună a fost marcată pentru anulare. Metoda exterioară a prins excepția și a vrut să confirme, așa că Spring aruncă UnexpectedRollbackException. Nu ignora excepțiile metodelor tranzacționale interioare: întoarce un rezultat sau lasă excepția să urce.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Când un bean cu @Transactional (propagare implicită REQUIRED) apelează alt bean cu @Transactional, amândouă folosesc aceeași tranzacție fizică. Dacă metoda interioară aruncă o RuntimeException, proxy-ul ei marchează tranzacția comună ca rollback-only: ea nu mai poate fi confirmată, indiferent ce se întâmplă după.
Dacă metoda exterioară prinde excepția cu try/catch și continuă ca și cum nimic nu s-ar fi întâmplat, la final Spring încearcă commit, vede marcajul și anulează totul, apoi aruncă UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only. Clientul primește 500, iar datele salvate de metoda exterioară dispar, deși codul ei „a reușit”.
Excepția e un semnal că logica de tratare a erorilor e în locul greșit: o eroare de business nu trebuie aruncată dintr-o metodă tranzacțională doar ca să fie prinsă imediat.
De ce apare: cauzele frecvente
1Prinzi excepția unei metode tranzacționale din alt bean
@Transactional
public void plaseaza(Comanda c) {
repo.save(c);
try { stoc.rezerva(c); } // @Transactional, aruncă
catch (RuntimeException e) { }
}@Transactional
public void plaseaza(Comanda c) {
repo.save(c);
if (!stoc.poateRezerva(c)) { // fără excepție
c.setStatus("IN_ASTEPTARE");
}
}O verificare care întoarce un rezultat nu marchează tranzacția pentru anulare.
2Vrei ca pasul interior să fie independent
@Transactional
public void jurnal(String mesaj) { ... }@Transactional(propagation = Propagation.REQUIRES_NEW)
public void jurnal(String mesaj) { ... }REQUIRES_NEW deschide o tranzacție separată, deci eșecul ei nu o afectează pe cea exterioară.
Repară eroarea, direct în pagină
ComandaService.plaseaza prinde excepția aruncată de StocService.rezerva (ambele @Transactional), iar în aplicația reală asta dă Transaction silently rolled back because it has been marked as rollback-only. Înlocuiește excepția cu o verificare: StocService.disponibil(cod) întoarce boolean, iar comanda primește statusul IN_ASTEPTARE când stocul lipsește.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.*;
import jakarta.persistence.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Entity
class Comanda {
@Id
@GeneratedValue
private Long id;
private String cod;
private String status;
protected Comanda() {
}
Comanda(String cod, String status) {
this.cod = cod;
this.status = status;
}
public Long getId() { return id; }
public String getCod() { return cod; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
}
interface ComandaRepository extends JpaRepository<Comanda, Long> {
}
@Service
class StocService {
private final Set<String> inStoc = Set.of("A1", "B2");
@Transactional
public void rezerva(String cod) {
if (!inStoc.contains(cod)) {
throw new IllegalStateException("Stoc epuizat pentru " + cod);
}
}
}
@Service
class ComandaService {
private final ComandaRepository repo;
private final StocService stoc;
ComandaService(ComandaRepository repo, StocService stoc) {
this.repo = repo;
this.stoc = stoc;
}
@Transactional
public Comanda plaseaza(String cod) {
Comanda c = repo.save(new Comanda(cod, "CONFIRMATA"));
try {
stoc.rezerva(cod);
} catch (IllegalStateException e) {
c.setStatus("IN_ASTEPTARE");
}
return c;
}
}
@RestController
class ComandaController {
private final ComandaService service;
ComandaController(ComandaService service) {
this.service = service;
}
@PostMapping("/comenzi")
Comanda plaseaza(@RequestParam String cod) {
return service.plaseaza(cod);
}
}Tomcat started on port 8080 (http)
Started Application
POST /comenzi?cod=A1 → 200
{"id":1,"cod":"A1","status":"CONFIRMATA"}
POST /comenzi?cod=Z9 → 200
{"id":2,"cod":"Z9","status":"IN_ASTEPTARE"}Indiciu
StocService nu mai aruncă excepție: întoarce true sau false, iar ComandaService decide statusul.
Reparația
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.*;
import jakarta.persistence.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Entity
class Comanda {
@Id
@GeneratedValue
private Long id;
private String cod;
private String status;
protected Comanda() {
}
Comanda(String cod, String status) {
this.cod = cod;
this.status = status;
}
public Long getId() { return id; }
public String getCod() { return cod; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
}
interface ComandaRepository extends JpaRepository<Comanda, Long> {
}
@Service
class StocService {
private final Set<String> inStoc = Set.of("A1", "B2");
@Transactional(readOnly = true)
public boolean disponibil(String cod) {
return inStoc.contains(cod);
}
}
@Service
class ComandaService {
private final ComandaRepository repo;
private final StocService stoc;
ComandaService(ComandaRepository repo, StocService stoc) {
this.repo = repo;
this.stoc = stoc;
}
@Transactional
public Comanda plaseaza(String cod) {
Comanda c = repo.save(new Comanda(cod, "CONFIRMATA"));
if (!stoc.disponibil(cod)) {
c.setStatus("IN_ASTEPTARE");
}
return c;
}
}
@RestController
class ComandaController {
private final ComandaService service;
ComandaController(ComandaService service) {
this.service = service;
}
@PostMapping("/comenzi")
Comanda plaseaza(@RequestParam String cod) {
return service.plaseaza(cod);
}
}De ce merge
Excepția aruncată de rezerva trecea prin proxy-ul tranzacțional al lui StocService și marca tranzacția comună pentru anulare. Prinderea ei în ComandaService nu mai putea salva tranzacția: la commit, Spring o anula și arunca UnexpectedRollbackException. Acum lipsa stocului e un rezultat normal (false), nu o excepție, deci tranzacția se confirmă cu statusul potrivit.
Alte forme ale mesajului
org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-onlyTransaction rolled back because it has been marked as rollback-only
Cum o eviți pe viitor
- Nu folosi excepții pentru decizii de business pe care le prinzi imediat; întoarce un rezultat (
boolean, un enum, unOptional). - Dacă un pas trebuie să reușească sau să eșueze independent (jurnal, audit), folosește
Propagation.REQUIRES_NEW. - Prinde excepțiile la marginea aplicației (
@RestControllerAdvice), nu în mijlocul tranzacției. - Testează și drumul cu eroare, nu doar pe cel fericit.
Întrebări frecvente
De ce excepția apare la final, nu în metoda interioară?
Metoda interioară doar marchează tranzacția. Problema se descoperă la commit, când metoda exterioară se termină și Spring vede marcajul.
Laboratorul confirmă datele fără eroare. De ce?
Simulatorul nu implementează marcajul rollback-only între bean-uri. În aplicația reală, varianta inițială dă UnexpectedRollbackException; reparația din exercițiu e cea folosită în proiect.
Erori înrudite
LazyInitializationException: failed to lazily initialize a collection of role: Categorie.produse: could not initialize proxy - no Session Ai citit o relație LAZY (de obicei o colecție @OneToMany) după ce tranzacția s-a închis, de exemplu când Jackson serializează entitatea în controller. Încarcă datele de care ai nevoie în service, într-o metodă @Transactional(readOnly = true), și întoarce un DTO (sau folosește JOIN FETCH). detached entity passed to persist: Categorie Hibernate a primit pentru persist un obiect care are deja id (deci pare să existe în bază), dar nu e gestionat de sesiunea curentă. Apare des când pui cascade = ALL pe @ManyToOne și legi un obiect creat cu new și cu id setat. Încarcă obiectul din bază și scoate cascada de pe @ManyToOne. Învață Spring Boot de la zero, cu exerciții la fiecare lecție
Curs Spring Boot și REST API: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 18 lecții sunt gratuite.
