🐹 chap11. null 대신 Optional 클래스

11.1 값이 없는 상황을 어떻게 처리할까?

다음처럼 자동차와 자동차 보험을 갖고 있는 사람 객체를 중첩 구조로 구현했다고 하자.

// Person/Car/Insurance 데이터 모델
public class Person {
    private Car car;
    public Car getCar() { return car; }
}

public class Car {
    private Insurance insurance;
    public Insurance getInsurance() { return insurance; }
}

public class Insurance {
    private String name;
    public String getName() { return name; }
}

public String getCarInsuranceName(Person person) {
    return person.getCar().getInsurance().getName();
}

위 코드는 아무 문제가 없는 것처럼 보이지만 차를 소유하지 않은 사람도 많다. 이때 getCar을 호출하면 null 참조를 반환하는 방식으로 자동차를 소유하고 있지 않음을 표현할 것이다. 그러면 getInsurance는 null 참조의 보험 정보를 반환하려 할 것이므로 런타임에 NullPointerException이 발생하면서 프로그래밍 중단된다.

person이 null이거나 getInsurance가 null을 반환할 수도 있다.

11.1.1 보수적인 자세로 NullPointerException 줄이기

보수적인 방법으로 다양한 null 확인 코드를 추가하여 null 예외 문제를 해결할 수 있다.

// null 안전 시도 1: 깊은 의심
public String getCarInsuranceName(Person person) {
    if (person != null) {
        Car car = person.getCar();
        if (car != null) {
            Insurance insurance = car.getInsurancee();
            if (insurance != null) {
                // null 확인 코드 때문에 나머지 호출 체인의 들여쓰기 수준이 증가한다. 
                return insurance.getName();
            }
        }
    }
    return "Unknown";
}

위 코드에서는 변수를 참조할 때마다 null을 확인하며 중간 과정에 하나라도 null 참조가 있으면 “Unknown”이라는 문자열을 반환한다.

메서드에서는 모든 변수가 null인지 의심하므로 변수를 접근할 때마다 중첩된 if가 추가되면서 코드 들여쓰기 수준이 증가한다. 이를 반복하다보면 코드의 구조가 엉망이 되고 가독성도 떨어진다.

// null 안전 시도 2: 너무 많은 출구
public String getCarInsuranceName(Person person) {
    if (person == null) {
        return "Unknown";
    }
    Car car = person.getCar();
    if (car == null) {
        return "Unknown";
    }
    Insurance insurance = car.getInsurance();
    if (insurance == null) {
        return "Unknown";
    }
    return insurance.getName();
}

위 코드는 null 변수가 있으면 즉시 “Unknown”을 반환한다. 하지만 메서드에 네 개의 출구가 생겼기 때문에 유지보수가 어려워진다.

게다가 “Unknown”이 세 곳에서 반복되고 있는데 같은 문자열을 반복하면서 오타 등의 실수가 생길 수 있다.

11.1.2 null 때문에 발생하는 문제

null 참조를 사용하면서 발생할 수 있는 이론적, 실용적 문제는 다음과 같다.

• 에러의 근원이다

  : NullPointerException은 자바에서 가장 흔히 발생하는 에러다.

• 코드를 어지럽힌다

  : 때로는 중첩된 null 확인 코드를 추가해야 하므로 null 때문에 코드 가독성이 떨어진다.

• 아무 의미가 없다

  : null은 아무 의미도 표현하지 않는다. 특히 정적 형식 언어에서 값이 없음을 표현하는 방법으로는 적절하지 않다.

• 자바 철학에 위배된다

  : 자바는 개발자로부터 모든 포인터를 숨겼다. 하지만 예외가 있는데 그것이 바로 null 포인터다.

• 형식 시스템에 구멍을 만든다

  : null은 무형식이며 정보를 포함하고 있지 않으므로 모든 참조 형식에 null을 할당할 수 있다. 이런 식으로 null이 할당되기 시작하면서 시스템의 다른 부분으로 null이 퍼졌을 때 애초에 null이 어떤 의미로 사용되었는지 알 수 없다.

11.1.3 다른 언어는 null 대신 무얼 사용하나?

그루비

최근 그루비 같은 언어에서는 안전 내비게이션 연산자 (?.)를 도입해서 null 문제를 해결했다. 다음은 사람들이 그들의 자동차에 적용한 보험회사의 이름을 가져오는 그루비 코드 예제다.

def carInsuranceName = person?.car?.insurance?.name

어떤 사람은 자동차를 가지고 있지 않을 수 있으며 따라서 Person 객체의 car 참조는 null이 할당되어 있을 수 있다. 그루비 안전 내비게이션 연산자를 이용하면 null 참조 예외 걱정 없이 객체에 접근할 수 있다. 이때 호출 체인에 null인 참조가 있으면 결과로 null이 반환된다.

하스켈, 스칼라

하스켈, 스칼라 등의 함수형 언어는 아예 다른 관점에서 null 문제를 접근한다.

• Maybe(하스켈)
  • 선택형 값을 저장
  • 주어진 형식의 값을 갖거나 아니면 아무 값도 갖지 않을 수 있다. 따라서 null 참조 개념은 자연스럽게 사라진다.
• Option[T](스칼라)
  • T형식의 값을 갖거나 아무 값도 갖지 않을 수 있는 구조
  • Option 형식에서 제공하는 연산을 사용하여 값이 있는지 여부를 명시적으로 확인해야 한다. → 형식 시스템에서 이를 강제하므로 null과 관련한 문제가 일어날 가능성이 줄어든다.

11.2 Optional 클래스 소개

자바 8은 하스켈과 스칼라의 영향을 받아 **java.util.Optional**라는 새로운 클래스를 제공한다. Optional은 선택형값을 캡슐화하는 클래스다.

예를 들어 어떤 사람이 차를 소유하고있지 않다면 Person 클래스의 car 변수는 null을 가져야 할 것이다. 하지만 새로운 Optional을 이용할 수 있으므로 null을 할당하는 것이 아니라 **변수형을 Optional로 설정**할 수 있다.

값이 있으면 Oprional 클래스는 값을 감싼다. 반면 값이 없으면 Optional.empty 메서드로 Optional을 반환한다. Optional.empty는 Optional의 특별한 싱글턴 인스턴스를 반환하는 정적 팩토리 메서드다.

• null과 Optional.empty()의 차이
  • null → NullPointerException이 발생
  • Optional.empty() → Optional 객체이므로 다양한 방식으로 활용 가능

// Optional로 Person/Car/Insurance 데이터 모델 재정의
public class Person {
    // 사람이 차를 소유했을 수도 소유하지 않았을 수도 있으므로 Optional로 정의
    private Optional<Car> car;
    public Optional<Car> getCar() { return car; }
}

public class Car {
    // 자동차가 보험에 가입되어 있을 수도 가입되어 있지 않을수도 있으므로 Optional로 정의
    private Optional<Insurance> insurance;
    public Optional<Insurance> getInsurance() {
        return insurance;
    }
}

public class Insurance {
    // 보험회사에는 반드시 이름이 있다.
    private String name;
    public String getName() {
        return name;
    }
}

Optional 클래스를 사용하면서 모델의 의미가 더 명확해졌다.

Optional을 이용하면 값이 없는 상황이 우리 데이터에 문제가 있는 것인지 아니면 알고리즘의 버그인지 명확하게 구분할 수 있다. 모든 null 참조를 Optional로 대치하는 것은 바람직하지 않다. Optional의 역할은 더 이해하기 쉬운 API를 설계하도록 돕는 것이다.

즉, 메서드의 시그니처만 보고도 선택형값인지 여부를 구별할 수 있다. Optional이 등장하면 이를 언랩해서 값이 없을 수 있는 상황에 적절하게 대응하도록 강제하는 효과가 있다.

11.3 Optional 적용 패턴

11.3.1 Optional 객체 만들기

Optional을 사용하려면 Optional 객체를 만들어야 한다. 다양한 방법으로 Optional 객체를 만들 수 있다.

빈 Optional

정적 팩토리 메서드 Optional.empty로 빈 Optional 객체를 얻을 수 있다.

Optional<Car> optCar = Optional.empty();

null이 아닌 값으로 Optional 만들기

정적 팩토리 메서드 Optional.of로 null이 아닌 값을 포함하는 Optional을 만들 수 있다.

Optional<Car> optCar = Optional.of(car);

이제 car의 null이라면 즉시 NullPointerException이 발생한다(Optional을 사용하지 않았다면 car의 프로퍼티에 접근하려 할 때 에러가 발생했을 것이다).

null값으로 Optional 만들기

정적 팩토리 메서드 Optional.ofNullable로 null값을 저장할 수 있는 Optional을 만들 수 있다.

Optional<Car> optCar = Optional.ofNullable(car);

car가 null이면 빈 Optional 객체가 반환된다.

11.3.2 맵으로 Optional의 값을 추출하고 변환하기

보통 객체의 정보를 추출할 때는 Optional을 사용할 때가 많다.

예를 들어 보험회사의 이름을 추출할 때, 이름 정보에 접근하기 전에 insurance가 null인지 확인해야 한다.

String name = null;
if (insurance != null) {
    name = insurance.getName();
}

이런 유형의 패턴에 사용할 수 있도록 Optional은 map 메서드를 지원한다.

Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);

Optional의 map 메서드는 스트림의 map 메서드와 개념적으로 비슷하다. 스트림의 map은 스트림의 각 요소에 제공된 함수를 적용하는 연산이다. 여기서 Optional 객체를 최대 요소의 개수가 한 개 이하인 데이터 컬렉션으로 생각할 수 있다. Optional이 값을 포함하면 map의 인수로 제공되는 함수가 값을 바꾼다.

public String getCarInsuranceName(Person person) {
    return person.getCar().getInsurance().getName();
}

11.3.3 flatMap으로 Optional 객체 연결

다음처럼 map을 이용해서 코드를 재구현할 수 있다.

Optional<Person> optPerson = Optional.of(person);
Optional<String> name =
    optPerson.map(Person::getCar)
             .map(Car::getInsurance)
             .map(Insurance::getName);

위 코드는 컴파일되지 않는다. 변수 optPeople의 형식은 Optional이므로 map 메서드를 호출할 수 있다. 하지만 getCar는 Optional 형식의 객체를 반환한다. 즉, map 연산의 결과는 Optional<Oprional> 형식의 객체다. getInsurance는 또 다른 Optional 객체를 반환하므로 getInsurance 메서드를 지원하지 않는다. 아래 그림같은 중첩 Optional 객체 구조를 보여준다.

이 문제를 해결하기 위해 이차원 Optional을 일차원 Optional로 평준화해야 한다.

map의 메서드처럼 스트림의 flatMap 메서드와 Optional의 flatMap 메서드의 유사성을 보여준다.

• 스트림

  flatMap 메서드로 전달된 함수는 각각의 정사각형을 두 개의 삼각형을 포함하는 스트림으로 변환한다. 즉, map을 적용한 결과로 세 개의 스트림을 포함하는 하나의 스트림이 생성된다. 하지만 flatMap 메서드 덕분에 이차원 스트림이 여섯 개의 삼각형을 포함하는 일차원 스트림으로 바뀐다.

• Optional

  Optional에 저장된 정사각형을 Optional에 저장된 삼각형으로 바꾼다. map 메서드였다면 Optional 내부에 다른 Optional 그리고 그 내부에 삼각형이 저장되었겠지만 flatMap 메서드 덕분에 이차원 Optional이 하나의 삼각형을 포함하는 하나의 Optional로 바뀐다.

Optional로 자동차의 보험회사 이름 찾기

// Optional로 자동차의 보험회사 이름 찾기
public String getCarInsuranceName(Optional<Person> person) {
    return person.flatMap(Person::getCar)
                 .flatMap(Car::getInsurance)
                 .map(Insurance::getName)
                 .orElse("Unknown"); //결과 Optional이 비어있으면 기본값 사용
}

null을 확인하느라 조건 분기문을 추가해서 코드를 복잡하게 만들지 않으면서도 쉽게 이해할 수 있는 코드를 완성했다.

우선 getCarInsurance 메서드의 시그니처를 고쳤다. 주어진 조건에 해당하는 사람이 없을 수 있기 때문이다.

또한 Optional을 사용하므로 도메인 모델과 관련한 암묵적인 지식에 의존하지 않고 형식 시스템을 정의할 수 있다. 정확한 정보 전달은 언어의 가장 큰 목표 중 하나다. Optional을 인수로 받거나 Optional을 반환하는 메서드를 정의한다면 결과적으로 이 메서드를 사용하는 모든 사람에게 이 메서드가 빈 값을 받거나 빈 결과를 반환할 수 있음을 잘 문서화해서 제공하는 것과 같다.

Optional을 이용한 Person/Car/Insurance 참조 체인

• Person, Car, Insurance의 이름 문자열 참조(파이프라인 연산)

• 1단계: Person을 Optional로 감싼 후 flatMap(Person::getCar) 호출
  • Optional 내부의 Person에 Function(getCar 메서드)을 적용
  • getCar 메서드는 Optional를 반환하므로 Optional 내부의 Person이 Optional로 변환되면서 **중첩 Optional**이 생성
  • flatMap 연산으로 Optional을 평준화
• 2단계: Optional를 Optional로 변환
• 3단계: Insurance.getName()은 String으로 반환
  • flatMap을 사용할 필요가 없다.
• 4단계: 기본값을 제공하는 orElse 메서드 사용
  • 비어있을지도 모르는 Optional 결과에 Optional이 비었을 때 기본값을 제공하는 orElse 메서드를 사용

11.3.4 Optional 스트림 조작

자바 9에서는 Optional을 포함하는 스트림을 쉽게 처리할 수 있도록 Optional에 stream() 메서드를 추가했다. Optional 스트림을 값을 가진 스트림으로 변환할 때 이 기능을 유용하게 활용할 수 있다.

아래 코드는 List을 인수로 받아 자동차를 소유한 사람들이 가입한 보험 회사의 이름을 포함하는 Set을 반환하도록 메서드를 구현해야 한다.

public Set<String> getCarInsuranceNames(List<Person> persons) {
    return persons.stream()
                  // 사람 목록을 각 사람이 보유한 자동차의 Optional<Car> 스트림으로 변환
                  .map(Person::getCar)
                  // flatMap 연산을 이용해 Optional<Car>을 해당 Optional<Insurance>로 변환
                  .map(optCar -> optCar.flatMap(Car::getInsurance))
                  // Optional<Insurance>를 해당 이름의 Optional<String>으로 매핑
                  .map(optIns -> optIns.map(Insurance::getName))
                  // Stream<Optional<String>>을 현재 이름을 포함하는 Stream<String>으로 변환
                  .flatMap(Optional::stream)
                  // 결과 문자열을 중복되지 않은 값을 갖도록 집합으로 수집
                  .collect(toSet());

위 코드에서 getCar 메서드가 단순히 Car가 아니라 Optional를 반환하므로 사람이 자동차를 가지지 않을 수도 있는 상황이다.

1. map 변환을 수행하고 Stream<Optoinal>를 얻는다.
2. 이어지는 두 개의 map 연산을 이용해 Oprional를 Optional로 변환한 다음 스트림이 아니라 각각의 요소에 했던 것처럼 각각을 Optional으로 변환한다.

위 변환 과정 결과 Stream<Optional>을 얻는데 사람이 차를 갖고 있지 않거나 또는 차가 보험에 가입되어 있지 않아 결과가 비어있을 수 있다. 마지막 결과를 얻으려면 빈 Optional을 제거하고 값을 언랩해야 한다는 것이 문제다.

다음처럼 filter, map을 순차적으로 이용해 결과를 얻을 수 있다.

Stream<Optional<String>> stream =
Set<String> result = stream.filter(Optional::isPresent)
                           .map(Optional::get)
                           .collect(toSet());

하지만 Optional 클래스의 stream() 메서드를 이용하면 한 번의 연산으로 같은 결과를 얻을 수 있다.

1. Optional의 stream() 메서드를 통해 Optional을 제거하고 값을 언랩한다.

이 메서드는 flatMap 메서드로 전달할 수 있다.

11.3.5 디폴트 액션과 Optional 언랩

Optional 인스턴스에 포함된 값을 읽는 다양한 방법

• get()
  • 값을 읽는 가장 간단한 메서드이면서 동시에 가장 안전하지 않은 메서드이다.
  • 래핑된 값이 있으면 해당 값을 반환, 없으면 NoSuchElementException 발생
  • Optional에 값이 반드시 있다고 가정할 수 있는 상황이 아니면 get 메서드를 사용하지 않는 것이 바람직하다. (결국 이 상황은 중첩된 null 확인 코드를 넣는 상황과 크게 다르지 않다.)
• orElse(T other)
  • Optional이 값을 포함하지 않을 때 기본값을 제공할 수 있다.
• orElseGet(Supplier<? extends T> other)
  • orElse 메서드에 대응하는 게으른 버전의 메서드
  • Optional에 값이 없을 때만 Supplier 실행
  • 디폴트 메서드를 만드는 데 시간이 걸리거나(효율성 때문에) Optional이 비어있을 때만 기본값을 생성하고 싶다면 orElseGet(Supplier<? extends T> other)를 사용해야 한다.
• orElseThrow(Supplier<? extends X> exceptionSupplier)
  • Optional이 비어있을 때 예외를 발생시킨다는 점에서 get 메서드와 비슷
  • 하지만 이 메서드는 발생시킬 예외의 종류 선택 가능
• ifPresent(Consumer<? super T> consumer)
  • 값이 존재할 때 인수로 넘겨준 동작을 실행할 수 있다.
  • 값이 없으면 아무 일도 일어나지 않는다.

자바 9에서는 다음의 인스턴스 메서드가 추가되었다.

• ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)
  • Optional이 비었을 때 실행할 수 있는 Runnable을 인수로 받는다는 점만 ifPresent와 다름

11.3.6 두 Optional 합치기

Person과 Car 정보를 이용해 가장 저렴한 보험료를 제공하는 보험회사를 찾는 몇몇 복잡한 비즈니스 로직을 구현한 외부 서비스가 있다 가정하자.

public Insurance findCheapestInsurance(Person person, Car car) {
    // 다양한 보험회사가 제공하는 서비스 조회
    // 모든 결과 데이터 비교
    return cheapestCompany;
}

두 Optional을 인수로 받아서 Optional를 반환하는 null 안전 버전의 메서드를 구현해야한다 가정한다. 인수로 전달한 값 중 하나라도 비어있으면 빈 Optional를 반환한다. Optional 클래스는 Optional이 값을 포함하는지 여부를 알려주는 ifPresent라는 메서드도 제공한다.

public Optional<Insurance> nullSafeFindCheapestInsurance(
            Optional<Person> person, Optional<Car> car) {
    if (person.isPresent() && car.isPresent()) {
        return Optional.of(findCheapestInsurance(person.get(), car.get()));
    } else {
        return Optional.empty();
    }
}

이 메서드의 장점은 person과 car의 시그니처만으로 둘 다 아무 값도 반환하지 않을 수 있다는 정보를 명시적으로 보여주는 것이다.

• Quiz. Optional 언랩하지 않고 두 Optional 합치기

  map과 flatMap 메서드를 이용해서 기존의 nullSafeFindCheapestInsurance() 메서드를 한 줄의 코드로 재구현하시오.

  • 정답

      public Optional<Insurance> nullSafeFindCheapestInsurance(
                  Optional<Person> person, Optional<Car> car) {
          return person.flatMap(p -> car.map(c -> findCheapestInsurance(p, c));
      }
    

    첫 번째 Optional에 flatMap을 호출했으므로 첫 번째 Optional이 비어있다면 인수로 전달한 람다 표현식이 실행되지 않고 그대로 빈 Optional을 반환한다. 반면 person값이 있으면 flatMap 메서드에 필요한 Optional를 반환하는 Function의 입력으로 person을 사용한다.

    이 함수의 바디에서는 두 번째 Optional에 map을 호출하므로 Optional이 car값을 포함하지 않으면 Function은 빈 Optional을 반환하므로 결국 nullSafeFindCheapestInsurance는 빈 Optional을 반환한다. 마지막으로 person과 car가 모두 존재하면 map 메서드로 전달한 람다 표현식이 findCheapestInsurance 메서드를 안전하게 호출할 수 있다.

11.3.7 필터로 특정값 거르기

ex) 보험회사의 이름이 ‘CambridgeInsurance’인지 확인

Insurance insurance = ...;
if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
    System.out.println("ok");
}

Optional 객체에 filter 메서드를 이용해서 다음과 같이 코드를 재구현할 수 있다.

Optional<Insurance> optInsurance = ...;
optInsurance.filter(insurance -> 
                    "CambridgeInsurance".equals(insurance.getName())
            .ifPresent(x -> System.out.println("ok"));

filter 메서드는 프레디케이트를 인수로 받는다. Optional 객체가 값을 가지며 프레디케이트와 일치하면 filter 메서드는 그 값을 반환하고 그렇지 않으면 빈 Optional 객체를 반환한다.

Optional이 비어있다면 filter 연산은 아무 동작도 하지 않는다. Optional에 값이 있으면 그 값에 프레디케이트를 적용한다. 프레디케이트 결과가 true면 Optional에는 아무 변화도 일어나지 않는다. 하지만 결과가 false면 값은 사라지고 Optional은 빈 상태가 된다.

• Quiz. Optional 필터링

  우리의 Person/Car/Insurance 모델을 구현하는 Person 클래스에는 사람의 나이 정보를 가져오는 getAge 메서드도 있었다. 다음 시그니처를 이용해 getCarInsuranceName 메서드를 고치시오.

    public String getCarInsuranceName(Optional<Person> person, int minAge)
  

  즉, 인수 person이 minAge 이상의 나이일 때만 보험회사 이름을 반환한다.

  • 정답

      public String getCarInsuranceName(Optional<Person> person, int minAge) {
          return person.filter(p -> p.getAge() >= minAge)
                       .flatMap(Person::getCar)
                       .flatMap(Car::getInsurance)
                       .map(Insurance::getName)
                       .orElse("Unknown"); //결과 Optional이 비어있으면 기본값 사용
      }
    

11.4 Optional 을 사용한 실용 예제

11.4.1 잠재적으로 null이 될 수 있는 대상을 Optional로 감싸기

Map<String, Object> 형식의 맵이 있는데, 다음처럼 key로 값에 접근한다고 가정하자.

Object value = map.get("key");

문자열 ‘key’에 해당하는 값이 없으면 null이 반환될 것이다. map에서 반환하는 값을 Optional로 감싸서 이를 해결할 수 있다.

Optional<Object> value = Optional.ofNullable(map.get("key"));

위 코드로 null일 수 있는 값을 Optional로 안전하게 변환할 수 있다.

11.4.2 예외와 Optional 클래스

자바 API는 어떤 이유에서 값을 제공할 수 없을 때 null을 반환하는 대신 예외를 발생시킬 때도 있다. 전형적인 예가 문자열을 정수로 변환하는 정적 메서드 Integer.parseInt(String)이다. 이 메서드는 문자열을 정수로 바꾸지 못할 때 NumberFormatException을 발생시킨다. 즉, 문자열이 숫자가 아니라는 사실을 예외로 알리는 것이다.

기존에 값이 null일 수 있을때는 if문으로 null 여부를 확인했지만 예외를 발생시키는 메서드에서는 try/catch 블록을 사용해야 한다는 점이 다르다.

// 문자열을 정수 Optional로 변환
public static Optional<Integer> stringToInt(String s) {
    try {
        return Optional.of(Integer.parseInt(s));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

위와 같은 메서드를 포함하는 유틸리티 클래스 OptionalUtility를 만들어라. 그러면 필요할 때 OptionalUtility.stringToInt를 이용해 문자열 Optional로 변환할 수 있다.

11.4.3 기본형 특화 Optional을 사용하지 말아야 하는 이유

스트림처럼 Optional도 기본형으로 특화된 OptionalInt, OptionalLong, OptionalDouble 등의 클래스를 제공한다. 이전 코드에서 Optional 대신 OptionalInt를 반환할 수 있다.

스트림이 많은 요소를 가질 때는 기본형 특화 스트림을 이용해서 성능을 향상시킬 수 있었지만, Optional의 최대 요소 수는 한 개이므로 Optional에서는 기본형 특화 클래스로 성능을 개션할 수 없다.

기본형 특화 Optional은 Optional 클래스의 유용한 메서드 map, flatMap, filter 등을 지원하지 않으므로 기본형 특화 Optional을 사용할 것을 권장하지 않는다.

11.4.4 응용

ex) 프로그램의 설정 인수로 Properties를 전달

Properties props = new Properties();
props.setProperty("a", "5");
props.setProperty("b", "true");
props.setProperty("c", "-3");

이제 프로그램에서는 Properties를 읽어서 값을 초 단위의 지속 시간으로 해석한다. 다음과 같은 메서드 시그니처로 지속 시간을 읽을 것이다.

public int readDuration(Properties props, String name)

지속 시간은 양수여야 하므로 문자열이 양의 정수를 가리키면 해당 정수를 반환하지만 그 외에는 0을 반환한다.

assertEquals(5, readDuration(param, "a"));
assertEquals(0, readDuration(param, "b"));
assertEquals(0, readDuration(param, "c"));
assertEquals(0, readDuration(param, "d"));

• 프로퍼티 a: 양수로 변환할 수 있는 문자열을 포함하므로 readDuration 메서드는 5를 반환
• 프로퍼티 b: 숫자로 변환할 수 없는 문자열을 포함하므로 0 반환
• 프로퍼티 c: 음수 문자열을 포함하므로 0 반환
• 프로퍼티 d: ‘d’라는 이름의 프로퍼티는 없으므로 0 반환

//프로퍼티에서 지속 시간을 읽는 명령형 코드
public int readDuration(Properties props, String name) {
    String value = props.getProperty(name);
    if (value != null) { //요청한 이름에 해당하는 프로퍼티가 존재하는지 확인
        try {
            int i = Integer.parseInt(value); //문자열 프로퍼티를 숫자로 변환하기 위해 시도
            if (i > 0) { //결과 숫자가 양수인지 확인
                return i;
            }
        } catch (NumberFormatException nfe) { }
    }
    return 0; // 하나의 조건이라도 실패하면 0 반환
}

if문과 try/catch 블록이 중첩되면서 구현 코드가 복잡해졌고 가독성도 나빠졌다.

• Quiz. Optional로 프로퍼티에서 지속 시간 읽기

  위 명령형 코드를 하나의 유연한 코드로 재구현하라.

    public int readDuration(Properties props, String name) {
        return Optional.ofNullable(props.getProperty(name))
                       .flatMap(OptionalUtility::stringToInt)
                       .filter(i -> i > 0)
                       .orElse(0);
    }
  

  • ofNullable : 요청한 프로퍼티가 존재하지 않을 때
  • flatMap : OptionalUtility.stringToInt 메서드 참조를 전달해 Optional을 Optional로 바꿀 수 있다.
  • filter: 음수 필터링

  이들 중 하나라도 빈 Optional을 반환하면 orElse 메서드에 의해 기본값 0이 반환된다. 그렇지 않다면 Optional에 들어있는 양수를 반환한다.

Optional과 스트림에서 사용한 방식은 여러 연산이 서로 연결되는 데이터베이스 질의문과 비슷한 형식을 갖는다.