타입 안전 이종 컨테이너를 고려하라 - [5장. 제네릭(아이템33)]

1. 타입 안전 이종 컨테이너 🍙

  타입 안전 이종(Heterogeneous) 컨테이너란 한 타입의 객체만 담을 수 있는 컨테이너가 아닌, 여러 다른 타입(이종)을 담을 수 있는 타입 안전한 컨테이너를 말한다.

  지금까지 우리가 흔히 알고 있는 컨테이너는 한 가지 타입만 사용할 수 있는 컨테이너다.

public static void main(String[] args) {
    Set<String> names = new HashSet<>();
    names.add("amenable");
    // names.add(1); // 불가능

    Set<Integer> numbers = new HashSet<>();
    numbers.add(1);
    // numbers.add("amenable"); // 불가능
}

  하지만, 경우에 따라서는 이종 컨테이너(= 같은 종이 아닌 타입을 넣을 수 있는 컨테이너)가 필요하다. 이번 아이템의 주제인 타입 안전 이종 컨테이너를 만드는 방식을 알아보자.

 

 

2. 구현 🍘

  타입 안전 이종 컨테이너의 예시로 타입별로 즐겨 찾는 인스턴스를 저장하고(= putFavorite 메서드) 검색할 수 있는(= getFavorite 메서드) Favorites 클래스를 생각할 수 있다.

  구현 방법은 '컨테이너가 아니라 "키"를 매개변수화 하여 구현하는 것'이다.

public class Favorites {

    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance) {
        favorites.put(Objects.requireNonNull(type), instance);
    }

    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }
}

  그러면 아래와 각 타입별로 인스턴스를 저장하고 검색할 수 있다.

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite(String.class, "amenable");
    favorites.putFavorite(Integer.class, 1);

    String name = favorites.getFavorite(String.class); // amenable
    Integer number = favorites.getFavorite(Integer.class); // 1
}

  즉, Favorites 인스턴스는 타입 안전하고, 일반적인 맵과 달리 여러 가지 타입의 원소를 담을 수 있기 때문에 Favorites는 '타입 안전 이종 컨테이너'라고 할 수 있다.

 

  용어 하나를 짚고 넘어가자면 컴파일타임 타입 정보와 런타임 타입 정보를 알아내기 위해 메서드들이 주고받는 class 리터럴을 타입 토큰(Type Token)이라 한다.

  class 리터럴의 타입은 Class가 아닌 Class<T>이고, String.class의 타입은 Class<String>, Integer.class의 타입은 Class<Integer>인 것이다.

 

 

3. 제약 사항 🍚

  지금까지 타입 이종 컨테이너인 Favorites 클래스를 살펴보았다. 하지만 여기서 알아두어야 할 제약이 2가지 있다.

📒 제약 1. 악의적인 클라이언트가 Class 객체를 (제네릭이 아닌) 로 타입으로 넘기면 Favorites 인스턴스의 타입 안전성이 쉽게 깨진다.

public class Favorites {

    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance) {
        favorites.put(Objects.requireNonNull(type), instance);
    }

    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }
}

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite((Class) String.class, 1);
}

  putFavorite 메서드를 사용할 때 클래스의 타입(String, Integer, ...)를 설정하지 않고 그냥 Class로만 넘기게 되면 코드에서 확인할 수 있는 것처럼 instance에 아무 값이나 넣을 수 있다.

  예상할 수 있듯이 putFavorite 메서드를 사용할 때 문제가 발생한다.

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite((Class) String.class, 1);

    String str = favorites.getFavorite(String.class); // ClassCastException
}

  Integer 값을 넣었지만 그것을 String으로 변환하려고 했기 때문에 ClassCastException이 발생한다.

 

  해당 문제를 해결하기 위한 방법으로는 putFavorite 메서드에서 인수로 주어진 instance의 타입이 type으로 명시한 타입과 같은지 확인하면 된다.

public class Favorites {

    ...

    public <T> void putFavorite(Class<T> type, T instance) {
        favorites.put(Objects.requireNonNull(type), type.cast(instance));
    }

    ...
}

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite((Class) String.class, 1); // ClassCastException

    String str = favorites.getFavorite(String.class);
}

  그러면 getFavorite를 사용할 때 런타임 에러가 나는 것이 아니라 putFavorites에서 런타임 에러가 발생한다. 조금 더 나은 방법이기는 하지만 근본적으로 컴파일 타임에는 막을 수 없다는 한계가 있다.

 

📒 제약 2. 실체화 불가 타입에는 사용할 수 없다.

  List.class는 기본적으로 아래와 같이 사용할 있다.

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite(List.class, List.of(1, 2, 3));

    List list = favorites.getFavorite(List.class);
    list.forEach(System.out::print); // 123
}

  만약 List.of(1, 2, 3)과 List.of("a", "b", "c")를 따로 저장하고 싶어서 아래와 같이 쓴다면 뒤에 나온 것이 앞에 나온 것을 덮어쓰게 된다.

public static void main(String[] args) {
    Favorites favorites = new Favorites();
    favorites.putFavorite(List.class, List.of(1, 2, 3));
    favorites.putFavorite(List.class, List.of("a", "b", "c")); // 덮어씀

    List list = favorites.getFavorite(List.class);
    list.forEach(System.out::print); // abc
}

  그래서 아래와 같은 방법을 쓰면 되지 않을까라고 생각할 수 있다.

public static void main(String[] args) {
    Favorites favorites = new Favorites();

    // 사용불가
    favorites.putFavorite(List<Integer>.class, List.of(1, 2, 3));
    favorites.putFavorite(List<String>.class, List.of("a", "b", "c"));

    List list = favorites.getFavorite(List.class);
    list.forEach(System.out::print); // abc
}

하지만 이 방법은 불가능하다. List.class만 존재하는 것이지 List<Integer>.class, List<String>.class와 같은 것은 존재하지 않기 때문이다.

 

  이 제약사항에 대해서는 완벽히 만족스러운 우회로는 없다. 닐 개프터(Neal Gafter)가 제안한 슈퍼 타입 토큰(Super Type Token)으로 어느 정도 문제는 해결할 수 있다. 하지만, 슈퍼 타입 토큰도 완벽하지는 않으니 주의해서 사용하도록 해야 한다.

 

 

4. 한정적 타입 토큰 🍛

  지금까지 살펴본 타입 토큰은 비한정적이다. 즉, getFavorite와 putFavorite는 어떤 Class 객체든 받아들일 수 있다.

  때로는 이 메서드들이 허용하는 타입을 제한하고 싶을 수 있는데, 이때 한정적 타입 토큰을 활용할 수 있다. 한정적 타입 토큰이란 단순히 한정적 타입 매개변수나 한정적 와일드카드를 사용하여 표현 가능한 타입을 제한하는 타입 토큰이다.

// FindMe
@Retention(RetentionPolicy.RUNTIME)
public @interface FindMe { }

// MyService
@FindMe
public class MyService { }

// PrintAnnotation
public class PrintAnnotation {

    static Annotation getAnnotation(AnnotatedElement element, String annotationTypeName) {
        Class<?> annotationType = null;
        try {
            annotationType = Class.forName(annotationTypeName);
        } catch (Exception ex) {
            throw new IllegalArgumentException(ex);
        }

        return element.getAnnotation(annotationType.asSubclass(Annotation.class));
    }
}

// 명시한 클래스의 명시한 애너테이션을 출력하는 테스트 프로그램
public static void main(String[] args) {
    System.out.println(getAnnotation(MyService.class, FindMe.class.getName()));
}

  asSubclass 메서드는 호출된 인스턴스 자신의 Class 객체를 인수가 명시한 클래스로 형변환한다. 그래서 asSubclass를 사용해서 한정적 타입 토큰을 안전하게 형변환할 수 있다.

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 참고하였습니다.