Bean Yaşam Döngüsü ve Scope'lar

1
@Component
2
class StatementSftpClient {
3

4
    private static final Logger log = LoggerFactory.getLogger(StatementSftpClient.class);
5

6
    private final StatementDeliveryProperties props;
7
    private SftpSession session;
8

9
    StatementSftpClient(StatementDeliveryProperties props) {
10
        this.props = props;
11
    }
12

13
    // Runs once, after dependencies are injected, before anyone can call this bean.
14
    // Corporate customers pull their end-of-day statements from this server.
15
    @PostConstruct
16
    void connect() {
17
        session = SftpSession.open(props.host(), props.user(), props.keyPath());
18
        log.info("statement SFTP session opened to {}", props.host());
19
    }
20

21
    // Runs on context close for singletons. Never runs for prototype beans.
22
    @PreDestroy
23
    void disconnect() {
24
        if (session != null) session.close();
25
        log.info("statement SFTP session closed");
26
    }
27

28
    void deliver(Path statementFile, String customerNo) {
29
        session.put(statementFile, props.remoteDir().resolve(customerNo));
30
    }
31
}

1
@Component
2
class IncomingPaymentPoller implements SmartLifecycle {
3

4
    private final IncomingPaymentInbox inbox;   // messages received from the clearing system
5
    private final ExecutorService loop = Executors.newSingleThreadExecutor();
6
    private volatile boolean running;
7

8
    IncomingPaymentPoller(IncomingPaymentInbox inbox) {
9
        this.inbox = inbox;
10
    }
11

12
    @Override
13
    public void start() {                     // after all singletons are ready
14
        running = true;
15
        loop.submit(this::pollUntilStopped);
16
    }
17

18
    private void pollUntilStopped() {
19
        while (running) {
20
            // Each batch credits the beneficiary accounts in one transaction and marks the
21
            // messages processed, so a crash mid-batch replays it instead of losing money.
22
            int credited = inbox.creditNextBatch(50);
23
            if (credited == 0) {
24
                try {
25
                    Thread.sleep(500);        // nothing to do: back off instead of spinning
26
                } catch (InterruptedException ex) {
27
                    Thread.currentThread().interrupt();
28
                    return;
29
                }
30
            }
31
        }
32
    }
33

34
    @Override
35
    public void stop() {                      // on shutdown, before @PreDestroy of its dependencies
36
        running = false;
37
        loop.shutdown();
38
    }
39

40
    @Override
41
    public boolean isRunning() {
42
        return running;
43
    }
44

45
    @Override
46
    public int getPhase() {
47
        // Higher phase: started later, stopped earlier. The poller stops before
48
        // lower-phase beans such as the web server and its graceful shutdown.
49
        return Integer.MAX_VALUE - 1000;
50
    }
51
}

1
@Component
2
class FxRateWarmup implements ApplicationRunner {
3

4
    private final FxRateService rates;
5

6
    FxRateWarmup(FxRateService rates) {
7
        this.rates = rates;
8
    }
9

10
    // Runs once the context is fully started: today's buy/sell rates are loaded before
11
    // the first currency exchange is priced. rates.loadToday() goes through a proxy,
12
    // so its @Transactional applies — unlike a call from this bean's own @PostConstruct.
13
    @Override
14
    public void run(ApplicationArguments args) {
15
        rates.loadToday();
16
    }
17
}

1
@Component
2
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
3
class StatementWriter implements AutoCloseable {
4

5
    private final BufferedWriter out;
6
    private final Path file;
7

8
    StatementWriter(StatementDeliveryProperties props) throws IOException {
9
        this.file = props.workDir().resolve(UUID.randomUUID() + ".csv");
10
        this.out = Files.newBufferedWriter(file);
11
    }
12

13
    void line(LocalDate valueDate, String description, BigDecimal amount, BigDecimal balance) throws IOException {
14
        out.write(String.join(";", valueDate.toString(), description,
15
                amount.toPlainString(), balance.toPlainString()));
16
        out.newLine();
17
    }
18

19
    Path file() {
20
        return file;
21
    }
22

23
    @Override
24
    public void close() throws IOException {  // Spring will not call this: the caller must
25
        out.close();
26
    }
27
}
28

29
@Service
30
class EndOfDayStatements {
31

32
    private final ObjectProvider<StatementWriter> writers;   // a fresh writer per account
33
    private final AccountMovements movements;
34
    private final StatementSftpClient sftp;
35

36
    EndOfDayStatements(ObjectProvider<StatementWriter> writers, AccountMovements movements,
37
                       StatementSftpClient sftp) {
38
        this.writers = writers;
39
        this.movements = movements;
40
        this.sftp = sftp;
41
    }
42

43
    void produce(String customerNo, String iban, LocalDate day) throws IOException {
44
        Path file;
45
        try (StatementWriter writer = writers.getObject()) {
46
            for (Movement m : movements.of(iban, day)) {
47
                writer.line(m.valueDate(), m.description(), m.amount(), m.balanceAfter());
48
            }
49
            file = writer.file();
50
        }
51
        sftp.deliver(file, customerNo);       // only after the file is flushed and closed
52
    }
53
}

1
@Component
2
class LifecycleEvents {
3

4
    private static final Logger log = LoggerFactory.getLogger(LifecycleEvents.class);
5

6
    @EventListener
7
    void started(ApplicationStartedEvent event) {
8
        log.info("context refreshed, payment poller started, FX warmup not yet run");
9
    }
10

11
    @EventListener
12
    void ready(ApplicationReadyEvent event) {
13
        log.info("FX rates loaded, application is ready to serve traffic");
14
    }
15

16
    @EventListener
17
    void closing(ContextClosedEvent event) {
18
        log.info("closing: poller stops first, then @PreDestroy closes the SFTP session");
19
    }
20
}