Servisler Arası İletişim Desenleri

1
@Service
2
class HomeScreenAggregator {
3

4
    private final AccountsClient accounts;
5
    private final CardsClient cards;
6
    private final CampaignsClient campaigns;
7
    private final ExecutorService io = Executors.newVirtualThreadPerTaskExecutor();
8

9
    HomeScreenAggregator(AccountsClient accounts, CardsClient cards, CampaignsClient campaigns) {
10
        this.accounts = accounts;
11
        this.cards = cards;
12
        this.campaigns = campaigns;
13
    }
14

15
    HomeScreen load(String customerNo, Deadline deadline) {
16
        Duration budget = deadline.remainingMinus(Duration.ofMillis(50));   // keep time to answer
17

18
        var accountList = supplyAsync(() -> accounts.of(customerNo), io).orTimeout(budget.toMillis(), MILLISECONDS);
19
        var cardList = supplyAsync(() -> cards.of(customerNo), io).orTimeout(budget.toMillis(), MILLISECONDS);
20
        // Optional: a failure here must not take the home screen down with it.
21
        var offers = supplyAsync(() -> campaigns.offersFor(customerNo), io)
22
                .completeOnTimeout(List.of(), budget.toMillis(), MILLISECONDS)
23
                .exceptionally(ex -> List.of());
24

25
        // Latency: the slowest of the three. Availability: accounts AND cards must answer.
26
        return new HomeScreen(accountList.join(), cardList.join(), offers.join());
27
    }
28
}

1
// "Answer by this instant", set once at the edge and passed down the chain.
2
public record Deadline(Instant at, Clock clock) {
3

4
    public static final String HEADER = "X-Deadline";
5

6
    public static Deadline fromHeader(String epochMillis, Clock clock, Duration fallback) {
7
        return epochMillis == null
8
                ? new Deadline(Instant.now(clock).plus(fallback), clock)
9
                : new Deadline(Instant.ofEpochMilli(Long.parseLong(epochMillis)), clock);
10
    }
11

12
    public Duration remainingMinus(Duration margin) {
13
        Duration left = Duration.between(Instant.now(clock), at).minus(margin);
14
        if (left.isNegative() || left.isZero()) {
15
            throw new DeadlineExceededException();   // the caller has already given up: do no work
16
        }
17
        return left;
18
    }
19
}

1
@Component
2
class DeadlinePropagation implements ClientHttpRequestInterceptor {
3

4
    @Override
5
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
6
            throws IOException {
7
        Deadline deadline = RequestDeadline.current();   // set by a filter from the incoming header
8
        if (deadline != null) {
9
            request.getHeaders().set(Deadline.HEADER, String.valueOf(deadline.at().toEpochMilli()));
10
        }
11
        return execution.execute(request, body);
12
    }
13
}

1
@RestController
2
@RequestMapping("/statements")
3
class StatementRequestController {
4

5
    private final StatementRequests requests;
6
    private final KafkaTemplate<String, StatementRequested> kafka;
7

8
    StatementRequestController(StatementRequests requests, KafkaTemplate<String, StatementRequested> kafka) {
9
        this.requests = requests;
10
        this.kafka = kafka;
11
    }
12

13
    // A year of movements takes a while: do not hold the phone's connection for it.
14
    @PostMapping
15
    ResponseEntity<StatementStatus> request(@RequestBody @Valid StatementQuery query) {
16
        StatementStatus status = requests.open(query);                     // PENDING, with an id
17
        kafka.send("statement-requests", query.iban(), StatementRequested.of(status.id(), query));
18
        return ResponseEntity.accepted().location(URI.create("/statements/" + status.id())).body(status);
19
    }
20

21
    @GetMapping("/{id}")
22
    StatementStatus status(@PathVariable UUID id) {
23
        return requests.get(id);                                           // PENDING, READY (with a link) or FAILED
24
    }
25
}

1
@Component
2
class StatementRequestedConsumer {
3

4
    private final StatementRequests requests;
5
    private final StatementPdf pdf;
6

7
    StatementRequestedConsumer(StatementRequests requests, StatementPdf pdf) {
8
        this.requests = requests;
9
        this.pdf = pdf;
10
    }
11

12
    // At-least-once delivery: the same request may arrive twice.
13
    @KafkaListener(topics = "statement-requests", groupId = "statement-builder")
14
    @Transactional
15
    void on(StatementRequested event) {
16
        if (!requests.claimIfPending(event.requestId())) return;   // already built or building
17
        URI file = pdf.build(event.iban(), event.from(), event.to());
18
        requests.markReady(event.requestId(), file);               // the app's next poll sees READY
19
    }
20
}