Optional 제대로 쓰기 — null과 작별하는 모던 자바의 방법

// null 체크 지옥
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity();
        if (city != null) return city.toUpperCase();
    }
}
return "UNKNOWN";

// null이 아닌 값만 받는다
Optional<String> opt = Optional.of("hello");

// null을 넣으면? 바로 NullPointerException!
Optional<String> boom = Optional.of(null); // NPE 발생

// null이 들어올 수 있을 때
String name = getUserName(); // null일 수 있음
Optional<String> opt = Optional.ofNullable(name);

// 명시적으로 "값 없음"을 표현
Optional<String> empty = Optional.empty();

public Optional<User> findByEmail(String email) {
    User user = userRepository.findByEmail(email);
    if (user == null) {
        return Optional.empty(); // null 대신 빈 Optional
    }
    return Optional.of(user);
}

// 위 코드를 한 줄로 줄이면
public Optional<User> findByEmail(String email) {
    return Optional.ofNullable(userRepository.findByEmail(email));
}

Optional<String> opt = Optional.of("hello");

// isPresent — 값이 있는지 boolean으로 확인
if (opt.isPresent()) {
    System.out.println(opt.get());
}

// ifPresent — 값이 있을 때만 Consumer 실행
opt.ifPresent(value -> System.out.println(value));

Optional<String> opt = Optional.empty();
if (opt.isEmpty()) {
    System.out.println("값이 없습니다");
}

Optional<String> name = Optional.of("libra");

// 값이 있으면 변환, 없으면 빈 Optional 그대로
Optional<String> upper = name.map(String::toUpperCase);
// Optional["LIBRA"]

Optional<String> empty = Optional.<String>empty().map(String::toUpperCase);
// Optional.empty — 에러 없이 빈 상태 유지

// getAddress()가 Optional<Address>를 반환하는 경우
public Optional<Address> getAddress() {
    return Optional.ofNullable(this.address);
}

// map을 쓰면 Optional이 중첩된다
Optional<Optional<Address>> nested = user.map(User::getAddress); // 이중 래핑!

// flatMap은 중첩을 풀어준다
Optional<Address> address = user.flatMap(User::getAddress); // 깔끔

Optional<Integer> age = Optional.of(25);

// 조건을 만족하면 그대로, 아니면 빈 Optional
Optional<Integer> adult = age.filter(a -> a >= 20);
// Optional[25]

Optional<Integer> minor = age.filter(a -> a < 20);
// Optional.empty

// Before: null 체크 지옥
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity();
        if (city != null) {
            return city.toUpperCase();
        }
    }
}
return "UNKNOWN";

// After: Optional 체이닝
return Optional.ofNullable(user)
        .map(User::getAddress)
        .map(Address::getCity)
        .map(String::toUpperCase)
        .orElse("UNKNOWN");

// 값이 없으면 대체값 반환
String name = Optional.<String>empty().orElse("default");
// "default"

public String getDefault() {
    System.out.println("getDefault 호출됨!"); // 비용이 큰 연산이라 가정
    return "default";
}

// 값이 있는데도 getDefault()가 호출된다!
String name = Optional.of("libra").orElse(getDefault());
// 콘솔 출력: "getDefault 호출됨!"
// 결과: "libra" (반환값은 정상이지만 불필요한 연산이 실행됨)

// Supplier는 Optional이 비어있을 때만 실행된다
String name = Optional.of("libra").orElseGet(() -> getDefault());
// getDefault()가 호출되지 않는다!

String name2 = Optional.<String>empty().orElseGet(() -> getDefault());
// 이때만 getDefault()가 호출된다

// 값이 없으면 예외를 던진다
User user = findById(id)
        .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다: " + id));

// NoSuchElementException을 던진다
User user = findById(id).orElseThrow();

// 값이 없으면 다른 Optional로 대체
Optional<String> result = findInCache(key)
        .or(() -> findInDB(key))
        .or(() -> findInExternalAPI(key));

findById(id).ifPresentOrElse(
        user -> sendWelcomeEmail(user),      // 값이 있을 때
        () -> log.warn("사용자를 찾을 수 없습니다") // 값이 없을 때
);

List<Optional<String>> optionals = List.of(
        Optional.of("a"),
        Optional.empty(),
        Optional.of("b"),
        Optional.empty(),
        Optional.of("c")
);

// Optional에서 값이 있는 것만 추출
List<String> values = optionals.stream()
        .flatMap(Optional::stream) // 비어있으면 빈 Stream, 있으면 1개짜리 Stream
        .toList();
// ["a", "b", "c"]

Optional<User> activeUser = users.stream()
        .filter(User::isActive)
        .findFirst(); // Optional<User> 반환

String name = activeUser
        .map(User::getName)
        .orElse("활성 사용자 없음");

// 나쁜 코드 — null 체크와 다를 게 없다
Optional<User> opt = findById(id);
if (opt.isPresent()) {
    return opt.get();
}
return defaultUser;

// 좋은 코드
return findById(id).orElse(defaultUser);

// 하지 마세요
public class User {
    private Optional<String> nickname; // 안티패턴!
}

public class User {
    private String nickname; // 필드는 그냥 String

    public Optional<String> getNickname() {
        return Optional.ofNullable(nickname); // getter에서 Optional 반환
    }
}

// 하지 마세요
public void updateUser(Optional<String> nickname) {
    // Optional 자체가 null로 넘어올 수도 있다!
    // 호출자에게 불필요한 래핑 비용을 전가한다
}

// 대신 메서드 오버로딩이나 @Nullable 사용
public void updateUser(String nickname) { ... }
public void updateUser() { ... } // nickname 없는 버전

// 하지 마세요
public Optional<List<User>> findUsers() { ... }

// 빈 컬렉션을 반환하세요
public List<User> findUsers() {
    // 결과가 없으면 빈 리스트 반환
    return Collections.emptyList();
}

public User getUser(Long id) {
    return userRepository.findById(id)
            .orElseThrow(() -> new BusinessException(ErrorCode.USER_NOT_FOUND));
}

public UserResponse toResponse(User user) {
    return UserResponse.builder()
            .name(user.getName())
            .city(Optional.ofNullable(user.getAddress())
                    .map(Address::getCity)
                    .orElse("미등록"))
            .build();
}

public String resolveConfig(String key) {
    return findInSystemProperty(key)        // Optional<String>
            .or(() -> findInEnvVariable(key))
            .or(() -> findInConfigFile(key))
            .orElse("기본값");
}