როგორ მუშაობს @Transactional, propagation და rollback-ის ჩათვლით?

Question

IT Interview Practice · Accepted Answer

`@Transactional` მეთოდს database ტრანზაქციაში ახვევს: Spring მას მეთოდის გაშვებამდე ხსნის და ნორმალურად დაბრუნებისას commit-ს აკეთებს — ან **rollback-ს**, თუ ის შეცდომას გადააგდებს. კულისებში ეს **AOP proxy-ა**, საიდანაც gotcha-ების უმეტესობა მოდის.

## ბაზური გამოყენება

```java
@Service
public class TransferService {

@Transactional // commit on success, roll back on RuntimeException
    public void transfer(Long from, Long to, BigDecimal amount) {
        accounts.debit(from, amount);
        accounts.credit(to, amount); // if THIS throws, the debit is rolled back too
    }
}
```

## ნაგულისხმევი rollback წესი (კლასიკური ხაფანგი)

ნაგულისხმევად Spring rollback-ს მხოლოდ **unchecked** გამონაკლისებზე (`RuntimeException`) და `Error`-ზე აკეთებს — **და არა** checked გამონაკლისებზე. თუ checked გამონაკლისს გადააგდებ, ტრანზაქცია *commit-დება*. გადააჭარბე მას ცხადად:

```java
@Transactional(rollbackFor = Exception.class) // roll back on checked too
public void process() throws IOException { /* ... */ }
```

## Propagation

propagation წყვეტს, რა ხდება, როცა ტრანზაქციული მეთოდი სხვას იძახებს:

- **REQUIRED** (ნაგულისხმევი): შეუერთდი გამომძახებლის ტრანზაქციას, ან დაიწყე ახალი, თუ არცერთი არ არსებობს.
- **REQUIRES_NEW**: შეაჩერე გამომძახებლის ტრანზაქცია და გაუშვი ახალ, დამოუკიდებელში — სასარგებლოა audit ლოგებისთვის, რომლებიც უნდა შენარჩუნდეს მაშინაც კი, თუ გარე სამუშაო rollback-ს გააკეთებს.

```java
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void writeAuditLog(String event) { /* commits independently */ }
```

## self-invocation-ის ხაფანგი

რადგან `@Transactional` proxy-ს გავლით მუშაობს, ერთი `@Transactional` მეთოდის სხვა მეთოდიდან გამოძახება *იმავე კლასში* proxy-ს გვერდს უვლის — annotation ჩუმად იგნორირდება. გამოიძახე bean-ებს შორის, ან inject-ე თავად საკუთარი თავი.

## რატომ არის ეს მნიშვნელოვანი

ტრანზაქციებში ცხოვრობს მონაცემის სისწორე, ამიტომ ინტერვიუერები აქ ძლიერ აწვებიან. checked-გამონაკლისის rollback წესი და self-invocation ბაგი ის ორი კითხვაა, რომლებიც საიმედოდ განასხვავებს იმათ, ვისაც `@Transactional` *გამოუყენებია*, იმათგან, ვისაც ის *ესმის*.

ბაზური გამოყენება

ნაგულისხმევი rollback წესი (კლასიკური ხაფანგი)

Propagation

self-invocation-ის ხაფანგი

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები