#12. Optional API (Null값 처리)

자바는 컴파일 시점에 확인가능한 null safe 연산을 따로 제공해주지 않는다. 그래서 기존에는 조건문으로 확인하거나 예외를 던져 책임을 코드 사용자에게 넘기는 방법을 사용했었다.

* 참고로 Optional은 Stream 전용 메서드가 아니다. Optional.Stream() 통해 스트림을 생성하여(Java9부터 추가됨) 사용하는 것이다.

# NPE (NullPointerException)

위에도 언급했지만, 의도했던 의도하지않았던 객체에 값을 할당해주지않아 null이 들어가서 생기는 NPE 문제는 흔히 일어나는 예외이면서 깔끔하게 해결하기는 어려운 주제였다. (* 이를 조금이나마 해결하려고 2020년 Java14부터는 instanceof 키워드와 NPE에 대한 오류를 더 자세하게 보여주는 기능이 추가되었다.)

// 핸드폰 제조사의 이름을 반환한다.
public String getPhoneManufacturerName(Person person) {
    // `person` 이 null 이면?
    // 아니면 `getPhone()` 메서드의 결과가 null 이면?
    return person.getPhone().getManufacturer().getName();
}
 
// 만약.. 내가 만든 메서드가 아니라 라이브러리처럼 호출하는 입장이라면?
String manufacturerName = getPhoneManufacturerName(person);
 
// manufacturer 가 null 을 참조하고 있는 경우 NPE가 발생할 수 있다.
String lowerCaseName = manufacturerName.toLowerCase();

# NPE를 예방하는 고전적인 방법

Java8 이전에는 다음과 같은 방식으로 NPE를 예방했었다.

// 징그러운 예외처리 코드
public String getPhoneManufacturerName(Person person) {
	if (person != null) {
	    Phone phone = person.getPhone();
        if (phone != null) {
        	Manufacturer manufacturer = phone.getManufacturer();
	        if (manufacturer != null) {
	            return manufacturer.getName();
	        }
	    }
	}
	return "Samsung";
}

그러면서 개발자들이 아이디어를 낸 것이, 널 객체 패턴(Null Object Pattern)이 었다. 이 패턴의 핵심은 null 키워드를 사용하는 대신 이를 대체할 수 있는 null 담당 객체를 만들어 사용하는 것이었다.

/* 널 객체(Null Object) 클래스를 따로 구현. */
class NullMessenger implements Messenger {
	@Override
	public void send(String msg) {
        // 그냥 빈 메서드를 사용한다. 아무 동작도 하지 않는다.
	}
}
 
 
/* null 객체가 아닌 클래스들. */
interface Messenger {
	void send(String msg);
}
 
class Kakao implements Messenger {
	@Override
	public void send(String msg) {...} 
}
 
class Line implements Messenger {
	@Override
	public void send(String msg) {...}
}

class MessengerFactory {
    public static Messenger getMessenger(String name) {
        if ( ... ){
            return ... // 특정 조건에 맞는 Messenger 구현체 클래스의 객체를 반환한다. 
        }
        // 결과가 없는 경우 `null`을 반환하지 않고 `NullMessenger`를 반환한다.
        return new NullMessenger();
    }
}
 
// 실제 사용하는 예시
Messenger messenger = MessengerFactory.getMessenger("KakaoTalk");
messenger.send("Hello");

이렇게 함으로서 NPE 에러는 피할 수 있었지만, 모든 개발자가 해당 객체의 'Null 전용 클래스'를 알고 있어야 사용할 수 있다는 단점이 있었다. 만약 인터페이스에 내용이 추가되거나 정확한 클래스 구현을 잘 모른다면 기존의 if(..null) 중복처리보다 훨씬 더 복잡한 검사 코드를 작성해야 할지도 모른다.

# Optional Class의 등장

이러한 문제점들을 해결하기위해 Java8 부터 공식적으로 제공하는 Null 전용 객체가 Optional Class이다. 위에서 말한 null-object pattern을 자바에서 공식적으로 구현하고 표준화 한 것이다.

다른 해결책은 없었나요?

// Java7의 Project Coin - 엘비스 연산자가 적용되었다면 이런 코드가 가능하지 않았을까?
public String getPhoneManufacturerName(Person person) {
    // 체이닝 중에서 null이 있다면, "Samsung"을 반환한다.
    return person?.getPhone()?.getManufacturer()?.getName() : "Samsung";
}

# Optional 생성

제너릭 타입으로 선언하고, 전용 Static Factory Method를 이용하여 객체를 생성한다.

Optional<Person> person; // Person 타입의 `Optional` 변수
Optional<Phone> phone; // phone 타입의 `Optional` 변수
 
// 사용예시
phone1 = Optional.empty();
phone2 = Optional.ofNullable(phone);

# Optional.empty()

비어있는 Optional 객체를 생성한다. 내부적으로는 싱글턴 인스턴스를 반환하게 된다.

// 메서드 시그니처
// `Optional` 클래스의 정적 멤버로 선언되어 싱글톤을 구현함.
private static final Optional<?> EMPTY = new Optional<>();
public static<T> Optional<T> empty() {
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}
 
// 예제
Optional<String> emptyOpt = Optional.empty();

# Optional.of ( T value )

값이 null 이라면 NPE 예외를 던진다. 만약 해당 객체에 값이 반드시 있어야 하는 경우 사용하면 된다.

// 메서드 시그니처
public static <T> Optional<T> of(T value);
// 예제
Optional<String> opt = Optional.of("result");

# Optional.ofNullable( T value )

값이 null일 수도 있는 T 객체를 생성한다. 만약 값이 null이라면 비어있는 Optional 객체를 반환한다.

// 메서드 시그니처
public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}
 
// 예제
Optional<String> opt = Optional.ofNullable(null);

# Optional 중간 연산

# Filter

// 메서드 시그니처
public Optional<T> filter(Predicate<? super T> predicate);
 
// 값이 비어있다면(null이라면) NPE 예외를 발생시킨다.
Optional.of("True").filter((val) -> "True".eqauls(val)).orElse("NO DATA"); // "True"
Optional.of("False").filter((val) -> "True".eqauls(val)).orElse("NO DATA"); // "NO DATA"
 
// 조건에 맞는 Optional(=person) 객체를 받는다. 비어있다면 empty Optional을 반환한다.
Optional.ofNullable(person).filter(p -> p.getName().equals("Kimtaeng"));

# map

mapper 함수를 통해 입력 값을 수정한다.

// 메서드 시그니처
public<U> Optional<U> map(Function<? super T, ? extends U> mapper);
// 예제
Integer test = Optional.of("1").map(Integer::valueOf).orElseThrow(NoSuchElementException::new); // string to integer
 
// Optional 객체(=person)가 값이 있다면 map을 실행하고, 비어있다면 아무런 연산을 하지 않는다.
Optional.ofNullable(person).map(p -> p.getName());

# flatMap

중첩된 Optional 구조를 한 단계 없애고 단일 요소로 만들어준다. 이해가 되지않는다면 이 링크를 참조하자.

// 메서드 시그니처
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper);
 
// 예제
String result = Optional.of("result")
        .flatMap((val) -> Optional.of("good"))
        .get();
System.out.println(result); // print 'good'

class Person {
	private Optional<Phone> phone;
	// getter, setter 생략
}
 
/* person 객체를 주면 해당 객체가 가지고있는 phone을 반환함.*/
 
// 작동하지 않는 코드. Optional 으로 Optional<phone>를 감싸고 있다.
public Optional<Phone> testMap(Person person) {
	// Optional<Optional<Phone>> 타입이기 때문에 컴파일 오류 발생
	return Optional.ofNullable(person)
	    .map(Person::getPhone);
}
 
// 작동하는 코드. flatMap을 이용하여 Optional<> 중첩을 한 단계 제거해준다.
// Optional<Optional<phone>>을 Optional<Phone>으로 접근한다. Stream flatmap과 동작방식이 유사하다.
public Optional<Phone> testFlatMap(Person person) {
    return Optional.ofNullable(person)
        .flatMap(Person::getPhone);
}

# or (null 대체값 지정)

값이 존재하는 경우 Optional 객체를, 없는 경우 비어있는 Optional이 아니라 or(~)에 등록한 Optional 객체를 반환한다.

Optional.ofNullable("Hi")
    .filter(value -> value.length() > 3) // `filter` 조건에 걸러짐. 빈 Optional 반환
    .or(() -> Optional.of("Hello")) // 값이 없으므로 대체 Optional[Hello] 반환

# Stream으로 변환

중간에 비어있는 Optional 객체가 반환되는 경우, Stream.empty()가 반환되며 함수 체이닝이 더 이상 진행되지 않는점을 유의하자. 스트림 연산이 멈춘다.

public void testOptionalWithStream() {
    // 참고로 List.of는 자바 9에서 추가된 팩터리 메서드. 튜플을 만든다.
    // Unmodifiable list(수정 불가능한 리스트)를 반환하므로 주의
    List.of(4, 3, 2, 5)
        .stream() // stream으로 복사해서 사용가능하다.
        .map(value -> value > 2 ? Optional.of(value) : Optional.empty())
        .flatMap(Optional::stream)
        .forEach(System.out::println);
}

물론 람다식과 메서드 레퍼런스는 선택사항이다. 꼭 필요하다면 익명클래스를 사용해도 상관없다. 

// 위와 완전히 같은 코드이다. 이해를 돕기위해 중간중간 println을 추가하였다.
public void testOptionalWithStream() {
    List.of(4, 3, 2, 5)
        .stream()
        .map(value -> {
            return value > 2 ? Optional.of(value) : Optional.empty();
        })
        .peek(v -> {
            // 넘어오는 값을 출력하기 위함
            System.out.println("peek: " + v);
        })
        .flatMap(new Function<Optional<? extends Object>, Stream<?>>() {
            @Override
            public Stream<?> apply(Optional<?> o) {
                System.out.println("flatMap: " + o);
                return o.stream();
            }
        })
        .forEach(v -> {
            System.out.println("forEach: " + v);
        });
}

# Optional 값 꺼내오기 (종단 처리)