Persistence Context — Hibernate'in Hafızası

1
@Entity
2
@Table(name = "card_accounts")
3
public class CardAccount {
4

5
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
6
    private Long id;
7

8
    @Version
9
    private long version;           // UPDATE … SET version = version + 1 WHERE id = ? AND version = ?
10

11
    private BigDecimal creditLimit;
12
    private BigDecimal approvedMaxLimit;   // set by the credit risk decision, not by the branch
13
    private long bonusPoints;
14

15
    @Enumerated(EnumType.STRING)
16
    private CardStatus status;
17

18
    public void changeLimit(BigDecimal newLimit) {
19
        if (status != CardStatus.ACTIVE) {
20
            throw new IllegalStateException("limit can only change on an active card");
21
        }
22
        if (newLimit.compareTo(approvedMaxLimit) > 0) {
23
            throw new LimitAboveApprovalException(id, newLimit, approvedMaxLimit);
24
        }
25
        this.creditLimit = newLimit;
26
    }
27

28
    public void addBonus(long points) {
29
        this.bonusPoints += points;
30
    }
31

32
    public long getVersion() { return version; }
33
    // other getters omitted
34
}

1
@Service
2
class CardLimitCommands {
3

4
    private final CardAccountRepository cards;
5

6
    CardLimitCommands(CardAccountRepository cards) {
7
        this.cards = cards;
8
    }
9

10
    @Transactional
11
    public long changeLimit(long cardId, long expectedVersion, BigDecimal newLimit) {
12
        CardAccount card = cards.findById(cardId).orElseThrow(() -> new CardNotFoundException(cardId));
13

14
        // Two officers open the same customer; one lowers the limit after a missed payment,
15
        // the other raises it on the customer's request. Without this check the last
16
        // click wins silently and nobody knows the other decision was overwritten.
17
        if (card.getVersion() != expectedVersion) {
18
            throw new StaleCardException(cardId, expectedVersion, card.getVersion());
19
        }
20

21
        card.changeLimit(newLimit);     // no save(): dirty checking writes the UPDATE at commit
22
        return card.getVersion() + 1;   // the version the screen will see next
23
    }
24
}

1
@RestController
2
@RequestMapping("/cards/{id}/limit")
3
class CardLimitController {
4

5
    private final CardLimitCommands commands;
6

7
    CardLimitController(CardLimitCommands commands) {
8
        this.commands = commands;
9
    }
10

11
    @PutMapping
12
    ResponseEntity<Void> change(@PathVariable long id,
13
                                @RequestHeader(HttpHeaders.IF_MATCH) String ifMatch,
14
                                @RequestBody @Valid NewLimit body) {
15
        long expected = Long.parseLong(ifMatch.replace("\"", ""));
16
        long next = commands.changeLimit(id, expected, body.amount());
17
        return ResponseEntity.noContent().eTag(String.valueOf(next)).build();
18
    }
19
}

1
@RestControllerAdvice
2
class ConcurrencyErrors {
3

4
    // Our own check (the officer edited a stale screen) and Hibernate's (two requests
5
    // raced between our check and the commit) mean the same thing to the client.
6
    @ExceptionHandler({StaleCardException.class, ObjectOptimisticLockingFailureException.class})
7
    ProblemDetail conflict(RuntimeException ex) {
8
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT,
9
                "Kart bilgisi siz düzenlerken değişti. Güncel limiti yükleyip yeniden karar verin.");
10
        problem.setTitle("Güncel olmayan veri");
11
        return problem;
12
    }
13
}

1
@Service
2
class BonusAccrual {
3

4
    private final TransactionTemplate tx;
5
    private final CardAccountRepository cards;
6

7
    BonusAccrual(PlatformTransactionManager txManager, CardAccountRepository cards) {
8
        this.tx = new TransactionTemplate(txManager);
9
        this.cards = cards;
10
    }
11

12
    // Called for every card purchase; two purchases a second apart can collide.
13
    // No one to show a 409 to: retry the WHOLE unit of work with fresh data.
14
    // Retrying only the flush would reuse the stale entity and fail again.
15
    public void accrue(long cardId, long points) {
16
        for (int attempt = 1; ; attempt++) {
17
            try {
18
                tx.executeWithoutResult(status -> cards.findById(cardId).orElseThrow().addBonus(points));
19
                return;
20
            } catch (ObjectOptimisticLockingFailureException ex) {
21
                if (attempt == 3) throw ex;
22
            }
23
        }
24
    }
25
}

1
spring:
2
  jpa:
3
    open-in-view: false   # no persistence context during view rendering or JSON writing