Java의 Optional이란 무엇이며 올바른 사용법은?

// 기존 null 처리 방식 - 잊어버리기 쉬움
public String getUserEmail(Long userId) {
    User user = userRepository.findById(userId);
    if (user == null) {
        return null; // 호출자가 null 체크를 해야 하는데 강제되지 않음
    }
    return user.getEmail();
}

// 호출 코드에서 NPE 위험
String email = getUserEmail(1L);
System.out.println(email.toUpperCase()); // user가 없으면 NPE!

// Optional 사용 - null 가능성을 타입으로 명시
public Optional<String> getUserEmail(Long userId) {
    // 반환 타입이 Optional이므로 호출자는 반드시 처리를 고려하게 됨
    return userRepository.findById(userId)
        .map(User::getEmail);
}

// 1. Optional.of(value): 값이 반드시 null이 아닐 때
Optional<String> opt1 = Optional.of("Hello");
Optional<String> opt2 = Optional.of(null); // NullPointerException 발생!

// 2. Optional.ofNullable(value): 값이 null일 수 있을 때
Optional<String> opt3 = Optional.ofNullable("Hello"); // Optional["Hello"]
Optional<String> opt4 = Optional.ofNullable(null);    // Optional.empty

// 3. Optional.empty(): 명시적으로 빈 Optional 생성
Optional<String> opt5 = Optional.empty();

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

// isPresent(): 값이 있으면 true
System.out.println(opt.isPresent());   // true
System.out.println(empty.isPresent()); // false

// isEmpty(): Java 11+ 값이 없으면 true
System.out.println(opt.isEmpty());   // false
System.out.println(empty.isEmpty()); // true

// get(): 값 반환, 없으면 NoSuchElementException
System.out.println(opt.get()); // "Hello"
// empty.get(); // NoSuchElementException!

Optional<String> opt = Optional.empty();

// orElse: 값이 없으면 기본값 반환 (항상 평가됨)
String result1 = opt.orElse("default");
System.out.println(result1); // "default"

// orElseGet: 값이 없을 때만 Supplier 실행 (지연 평가)
String result2 = opt.orElseGet(() -> generateDefault());
// opt가 비어있을 때만 generateDefault() 호출

// orElseThrow: 값이 없으면 예외 던짐 (Java 10+: 기본 NoSuchElementException)
String result3 = opt.orElseThrow(() -> new IllegalStateException("값이 없습니다."));

// orElse vs orElseGet 성능 차이
Optional<String> hasValue = Optional.of("value");
// orElse: "default"가 항상 생성됨
String r1 = hasValue.orElse(expensiveOperation()); // expensiveOperation 항상 실행
// orElseGet: 값이 있으면 람다 미실행
String r2 = hasValue.orElseGet(() -> expensiveOperation()); // 실행 안 됨

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

// map: 값을 변환 (변환 결과가 null이면 Optional.empty 반환)
Optional<String> upper = opt.map(String::trim).map(String::toUpperCase);
System.out.println(upper.get()); // "HELLO WORLD"

// flatMap: Optional을 반환하는 함수를 적용 (중첩 Optional 방지)
Optional<Optional<String>> nested = opt.map(s -> Optional.of(s.trim())); // Optional<Optional<String>>
Optional<String> flat = opt.flatMap(s -> Optional.of(s.trim()));         // Optional<String>

// filter: 조건을 만족하지 않으면 Optional.empty 반환
Optional<String> filtered = opt.map(String::trim)
    .filter(s -> s.length() > 5);
System.out.println(filtered.isPresent()); // true ("hello world" 길이 11)

Optional<String> shortOpt = Optional.of("hi");
Optional<String> filtered2 = shortOpt.filter(s -> s.length() > 5);
System.out.println(filtered2.isPresent()); // false

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

// ifPresent: 값이 있을 때만 Consumer 실행
opt.ifPresent(System.out::println); // "Hello"

// ifPresentOrElse: Java 9+ 값이 있을 때와 없을 때 각각 처리
opt.ifPresentOrElse(
    s -> System.out.println("값: " + s),
    () -> System.out.println("값 없음")
);

// or: Java 9+ 값이 없을 때 대체 Optional 반환
Optional<String> result = Optional.<String>empty()
    .or(() -> Optional.of("대체값"));
System.out.println(result.get()); // "대체값"

// stream: Java 9+ Optional을 Stream으로 변환
opt.stream()
   .map(String::toUpperCase)
   .forEach(System.out::println); // "HELLO"

// 좋은 예: 조회 결과가 없을 수 있는 메서드의 반환 타입
public Optional<User> findUserById(Long id) {
    return userRepository.findById(id);
}

public Optional<String> findConfigValue(String key) {
    return Optional.ofNullable(configMap.get(key));
}

// 호출 코드
findUserById(1L)
    .map(User::getName)
    .ifPresent(name -> System.out.println("사용자: " + name));

// 나쁜 예: 파라미터에 Optional 사용
public void process(Optional<String> name) { // 안티패턴
    // 호출자가 null을 Optional 대신 직접 전달 가능
}

// 좋은 예: 오버로딩 또는 @Nullable 사용
public void process(String name) { ... }
public void process() { ... } // 이름 없는 경우 별도 메서드

// 나쁜 예: 필드에 Optional 사용 (직렬화 불가, 메모리 낭비)
public class User {
    private Optional<String> middleName; // 안티패턴
}

// 좋은 예: null 허용 필드로 선언하고 getter에서 Optional 반환
public class User {
    private String middleName; // null 허용

    public Optional<String> getMiddleName() {
        return Optional.ofNullable(middleName);
    }
}

// 나쁜 예: isPresent/get 조합은 기존 null 체크와 동일
Optional<User> userOpt = findUserById(1L);
if (userOpt.isPresent()) {
    User user = userOpt.get();
    System.out.println(user.getName());
}

// 좋은 예: ifPresent 또는 map 사용
findUserById(1L).ifPresent(user -> System.out.println(user.getName()));

// 또는
String name = findUserById(1L)
    .map(User::getName)
    .orElse("알 수 없음");

// 중첩 null 체크를 Optional 체이닝으로 단순화
// 기존 방식
String city = null;
if (user != null && user.getAddress() != null) {
    city = user.getAddress().getCity();
}

// Optional 방식
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("서울");

List<Optional<String>> list = Arrays.asList(
    Optional.of("A"),
    Optional.empty(),
    Optional.of("B"),
    Optional.empty(),
    Optional.of("C")
);

// flatMap으로 빈 Optional 제거 후 값만 추출
List<String> values = list.stream()
    .flatMap(Optional::stream) // Java 9+
    .collect(Collectors.toList());
System.out.println(values); // [A, B, C]

// Spring Data JPA는 Optional을 자연스럽게 지원
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    Optional<User> findByUsername(String username);
}

// 서비스 계층에서 활용
@Service
public class UserService {
    private final UserRepository userRepository;

    public UserDto getUser(Long id) {
        return userRepository.findById(id)
            .map(UserDto::from)
            .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다: " + id));
    }

    public void updateEmail(Long id, String newEmail) {
        userRepository.findById(id)
            .ifPresentOrElse(
                user -> {
                    user.setEmail(newEmail);
                    userRepository.save(user);
                },
                () -> { throw new UserNotFoundException("사용자 없음: " + id); }
            );
    }
}