...
Eroare Spring Boot · Relații și tranzacții

Transaction silently rolled back because it has been marked as rollback-only

Pe scurt

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

Greșit
JAVA
@Transactional
public void plaseaza(Comanda c) {
    repo.save(c);
    try { stoc.rezerva(c); }      // @Transactional, aruncă
    catch (RuntimeException e) { }
}
Corect
JAVA
@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

Greșit
JAVA
@Transactional
public void jurnal(String mesaj) { ... }
Corect
JAVA
@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ă tu

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.

Codul care dă eroarea
JAVA
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);
    }
}
După reparație, programul afișează
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.

Alte forme ale mesajului

  • org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only
  • Transaction 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, un Optional).
  • 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

← Toate erorile Spring Boot

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.