Optional'ı Doğru Kullanmak — Yokluğu Tipe Yazmak

1
public class Customer {
2

3
    private final long id;
4
    private final String name;
5
    private final String referralCode;     // code used at onboarding; may be null: plain field, NOT Optional<String>
6

7
    public Customer(long id, String name, String referralCode) {
8
        this.id = id;
9
        this.name = name;
10
        this.referralCode = referralCode;
11
    }
12

13
    public long id() { return id; }
14
    public String name() { return name; }
15

16
    // The absence is part of the getter's contract, so it shows up in the return type.
17
    public Optional<String> referralCode() {
18
        return Optional.ofNullable(referralCode);
19
    }
20
}

1
public interface CustomerRepository {
2

3
    Optional<Customer> findById(long id);           // not found is a normal outcome
4

5
    Optional<Customer> findByReferralCode(String code);
6

7
    List<Customer> findByBranch(String branchCode); // empty list, never Optional<List<…>>
8

9
    List<Customer> findAll();
10
}

1
public class ReferralService {
2

3
    private final CustomerRepository customers;
4

5
    public ReferralService(CustomerRepository customers) {
6
        this.customers = customers;
7
    }
8

9
    // Who referred this customer, so the campaign bonus goes to the right account?
10
    // Each step may be missing; no null checks, no get().
11
    public Optional<String> referrerName(long customerId) {
12
        return customers.findById(customerId)             // Optional<Customer>
13
                .flatMap(Customer::referralCode)          // Optional<String> (not Optional<Optional<…>>)
14
                .filter(code -> !code.isBlank())
15
                .flatMap(customers::findByReferralCode)   // Optional<Customer>
16
                .map(Customer::name);                     // Optional<String>
17
    }
18

19
    public Customer require(long customerId) {
20
        return customers.findById(customerId)
21
                .orElseThrow(() -> new CustomerNotFoundException(customerId));
22
    }
23

24
    // orElse evaluates its argument ALWAYS; orElseGet only when empty.
25
    public String displayName(long customerId) {
26
        return customers.findById(customerId)
27
                .map(Customer::name)
28
                .orElseGet(() -> Placeholders.anonymousName());   // not orElse(Placeholders.anonymousName())
29
    }
30
}

1
public class Search {
2

3
    private final CustomerRepository customers;
4

5
    public Search(CustomerRepository customers) {
6
        this.customers = customers;
7
    }
8

9
    // Not search(Optional<String> branchCode): callers would pass Optional.empty(), or null.
10
    // Two methods say it more clearly than an Optional parameter.
11
    public List<Customer> all() {
12
        return customers.findAll();
13
    }
14

15
    public List<Customer> atBranch(String branchCode) {
16
        return customers.findByBranch(Objects.requireNonNull(branchCode));
17
    }
18
}

1
public class CustomerNotFoundException extends RuntimeException {
2

3
    public CustomerNotFoundException(long id) {
4
        super("customer " + id + " not found");
5
    }
6
}