Grundlegendes zu @Transactional in Spring Boot

Transaktionen in Spring Boot können mithilfe der @Transactional-Annotation verwaltet werden. In diesem Blogbeitrag untersuchen wir, wie Sie @Transactional verwenden, um die Datenkonsistenz sicherzustellen und die Fehlerbehandlung in Ihren Spring-Boot-Anwendungen zu vereinfachen.

1. Grundlegende Verwendung

Um @Transactional zu verwenden, platzieren Sie es normalerweise auf Methoden einer Serviceklasse, in der Sie das Transaktionsverhalten wünschen.

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService{

    @Transactional
    public void createUser() {
        // enter your transactional code here
    }
}

2. Ausbreitungs- und Isolationsstufen

Sie können die Ausbreitungs- und Isolationsstufen einer Transaktion angeben, um zu steuern, wie sich die Transaktion verhält:

• Weitergabe: Definiert, wie sich die Transaktion verhält, wenn bereits eine vorhandene Transaktion ausgeführt wird.

• Isolation: Definiert den Datensichtbarkeitsgrad der Transaktion.
  

@Transactional(propagation = Propagation.REQUIRED, 
              isolation = Isolation.READ_COMMITTED)
public void createUser() {
    // enter your transactional code here
}

3. Rollback-Regeln

Sie können angeben, welche Ausnahmen ein Rollback auslösen sollen:

@Transactional(rollbackFor = Exception.class)
public void createUser() {
    // your transactional code here
}

4. Nur-Lese-Transaktionen

Wenn Ihre Methode nur Daten liest und keine Schreibvorgänge ausführt, können Sie sie zur Leistungsoptimierung als schreibgeschützt markieren:

@Transactional(readOnly = true)
public void getUser() {
    // your read-only code here
}

5. Transaktionen für Klassen

Sie können @Transactional auch auf Klassenebene platzieren, um es auf alle Methoden in der Klasse anzuwenden:

@Service
@Transactional
public class UserService {

    public void getUser() {
        // transactional code
    }

    public void createUser() {
        // transactional code
    }
}

Beispieldienst mit Transaktionsmethoden

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Transactional
    public void saveUser() {
        // code to save data
    }

    @Transactional(readOnly = true)
    public void fetchUser() {
        // code to fetch data
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void newTransaction() {
        // code to execute in a new transaction
    }

    @Transactional(rollbackFor = {CustomException.class})
    public void performWithRollback() {
        // risky code that may throw CustomException
    }
}

Zusammenfassung

Mit @Transactional Spring Boot können Sie Transaktionen deklarativ verwalten und dabei genau angeben, wie sich Transaktionen in verschiedenen Szenarien verhalten sollen. Dies trägt zur Gewährleistung der Datenkonsistenz bei und vereinfacht die Fehlerbehandlung in Ihren Anwendungen.

Referenzen

https://www.baeldung.com/spring-transactions-read-only

https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Transactional.html

Github: https://github.com/tharindu1998/transactional-blog

Das obige ist der detaillierte Inhalt vonGrundlegendes zu @Transactional in Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!