IoC ve Dependency Injection

1
@Service
2
public class TransferService {
3

4
    private final List<TransferRail> rails;   // every TransferRail bean, in @Order order
5
    private final FraudCheck fraud;
6
    private final Clock clock;
7

8
    // One constructor: no @Autowired needed. Fields are final, the object is complete after `new`.
9
    public TransferService(List<TransferRail> rails, FraudCheck fraud, Clock clock) {
10
        this.rails = rails;
11
        this.fraud = fraud;
12
        this.clock = clock;
13
    }
14

15
    public TransferResult send(TransferOrder order) {
16
        if (fraud.score(order) == Risk.BLOCK) {
17
            return TransferResult.rejected(order.id(), "FRAUD_SUSPECTED");
18
        }
19
        ZonedDateTime now = ZonedDateTime.now(clock);
20
        // First rail that can carry this amount at this moment wins: FAST, then EFT.
21
        return rails.stream()
22
                .filter(rail -> rail.accepts(order, now))
23
                .findFirst()
24
                .map(rail -> rail.submit(order))
25
                .orElseGet(() -> TransferResult.scheduled(order.id(), "NEXT_BUSINESS_DAY"));
26
    }
27
}

1
public interface TransferRail {
2

3
    boolean accepts(TransferOrder order, ZonedDateTime now);
4

5
    TransferResult submit(TransferOrder order);
6
}
7

8
// Amounts are BigDecimal, never double: 0.1 + 0.2 != 0.3 is not a rounding error a bank can afford.
9
public record TransferOrder(UUID id, String fromIban, String toIban, BigDecimal amount, String description) { }

1
@Component
2
@Order(1)                     // tried first: instant, 7/24, but only up to a per-transaction limit
3
class FastRail implements TransferRail {
4

5
    private final FastClient client;
6
    private final BigDecimal maxAmount;
7

8
    // The limit is set by the scheme operator and changes over time, so it lives in config.
9
    FastRail(FastClient client, @Value("${transfer.fast.max-amount}") BigDecimal maxAmount) {
10
        this.client = client;
11
        this.maxAmount = maxAmount;
12
    }
13

14
    @Override
15
    public boolean accepts(TransferOrder order, ZonedDateTime now) {
16
        return order.amount().compareTo(maxAmount) <= 0;
17
    }
18

19
    @Override
20
    public TransferResult submit(TransferOrder order) {
21
        return client.send(order);
22
    }
23
}
24

25
@Component
26
@Order(2)                     // fallback: no amount limit, but only inside the business-day window
27
class EftRail implements TransferRail {
28

29
    private final EftClient client;
30
    private final BusinessCalendar calendar;
31

32
    EftRail(EftClient client, BusinessCalendar calendar) {
33
        this.client = client;
34
        this.calendar = calendar;
35
    }
36

37
    @Override
38
    public boolean accepts(TransferOrder order, ZonedDateTime now) {
39
        return calendar.isEftOpen(now);   // weekends and public holidays included
40
    }
41

42
    @Override
43
    public TransferResult submit(TransferOrder order) {
44
        return client.send(order);
45
    }
46
}

1
public interface FraudCheck {
2

3
    Risk score(TransferOrder order);
4
}
5

6
@Component
7
@Profile("!dev")              // everywhere except a developer laptop
8
class ScoringFraudCheck implements FraudCheck {
9

10
    private final FraudScoringClient scoring;
11

12
    ScoringFraudCheck(FraudScoringClient scoring) {
13
        this.scoring = scoring;
14
    }
15

16
    @Override
17
    public Risk score(TransferOrder order) {
18
        return scoring.evaluate(order.fromIban(), order.toIban(), order.amount());
19
    }
20
}
21

22
@Component
23
@Profile("dev")               // exactly one FraudCheck exists per profile, so no @Primary is needed
24
class AllowAllFraudCheck implements FraudCheck {
25

26
    @Override
27
    public Risk score(TransferOrder order) {
28
        return Risk.ALLOW;
29
    }
30
}

1
@Configuration
2
class TimeConfig {
3

4
    // Clock is a JDK class: no @Component to put on it, so a @Bean method registers it.
5
    // Cut-off times depend on "now"; an injected Clock makes them testable.
6
    @Bean
7
    Clock clock() {
8
        return Clock.system(ZoneId.of("Europe/Istanbul"));
9
    }
10
}

1
class TransferServiceTest {
2

3
    // A Saturday: the EFT window is closed.
4
    private final Clock saturday = Clock.fixed(Instant.parse("2026-09-26T10:00:00Z"), ZoneOffset.UTC);
5

6
    @Test
7
    void bigTransferOnSaturdayWaitsForTheNextBusinessDay() {
8
        var fast = new FakeRail(false);   // over the FAST limit
9
        var eft = new FakeRail(false);    // window closed
10
        var service = new TransferService(List.of(fast, eft), order -> Risk.ALLOW, saturday);
11

12
        TransferResult result = service.send(order("250000.00"));
13

14
        assertThat(result.status()).isEqualTo(TransferStatus.SCHEDULED);
15
        assertThat(fast.submitted).isEmpty();
16
        assertThat(eft.submitted).isEmpty();
17
    }
18

19
    @Test
20
    void fraudBlockNeverReachesARail() {
21
        var fast = new FakeRail(true);
22
        var service = new TransferService(List.of(fast), order -> Risk.BLOCK, saturday);
23

24
        assertThat(service.send(order("100.00")).status()).isEqualTo(TransferStatus.REJECTED);
25
        assertThat(fast.submitted).isEmpty();
26
    }
27

28
    // Hand-written fakes and a lambda for FraudCheck: no Mockito, no Spring context, milliseconds.
29
    static final class FakeRail implements TransferRail {
30
        final boolean open;
31
        final List<TransferOrder> submitted = new ArrayList<>();
32

33
        FakeRail(boolean open) { this.open = open; }
34

35
        @Override
36
        public boolean accepts(TransferOrder order, ZonedDateTime now) { return open; }
37

38
        @Override
39
        public TransferResult submit(TransferOrder order) {
40
            submitted.add(order);
41
            return TransferResult.sent(order.id());
42
        }
43
    }
44

45
    private static TransferOrder order(String amount) {
46
        return new TransferOrder(UUID.randomUUID(), "TR330006100519786457841326",
47
                "TR320010009999901234567890", new BigDecimal(amount), "kira");
48
    }
49
}