item 41

정의하려는 것이 타입이라면 마커 인터페이스를 사용하라

아무 메서드도 담고 있지 않고, 단지 자신을 구현하는 클래스가 특정 속성을 가짐을 표시해주는 인터페이스를 마커인터페이스 라고 한다. Serializable 인터페이스가 좋은 예다. Serializable은 자신을 구현할 클래스의 인터페이스는 ObjectOutputStream을 통해 쓸 수 있다고 (직렬화 할 수 있다고) 알려준다.

* @author  unascribed
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @see java.io.ObjectOutput
 * @see java.io.ObjectInput
 * @see java.io.Externalizable
 * @since   JDK1.1
 */
public interface Serializable {
}

마커 애너테이션이 등장하면서 마커 인터페이스는 구식이 되었다고 하지만 이는 사실이 아니다. 마커 인터페이스는 아래와 같은 상황에서 마커 애너테이션보다 낫다.

• 마커 인터페이스는 이를 구현한 클래스의 인스턴스들을 구분하는 타입으로 쓸 수 있으나, 마커 애너테이션은 그렇지 않다.
• 적용 대상을 더 정밀하게 지정할 수 있다.

마커 애너테이션 @Test

@Retention(value=RUNTIME)
@Target(value=METHOD)
public @interface Test

아무 매개변수 없이 단순히 대상에 마킹한다 (item 39)

마커 인터페이스는 이를 구현한 클래스의 인스턴스들을 구분하는 타입으로 쓸 수 있으나 마커 애너테이션은 그렇지 않다.

마커 인터페이스는 어엿한 타입이기 때문에, 마커 애너테이션을 사용했다면 런타임에 발견될 오류를 컴파일 타임에 잡을 수 있다.

/**
     * Underlying writeObject/writeUnshared implementation.
     */
    private void writeObject0(Object obj, boolean unshared)
        throws IOException
    {
        boolean oldMode = bout.setBlockDataMode(false);
        depth++;
        try {
            // handle previously written and non-replaceable objects
            int h;
            if ((obj = subs.lookup(obj)) == null) {
                writeNull();
                return;
            } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                writeHandle(h);
                return;
            } else if (obj instanceof Class) {
                writeClass((Class) obj, unshared);
                return;
            } else if (obj instanceof ObjectStreamClass) {
                writeClassDesc((ObjectStreamClass) obj, unshared);
                return;
            }

            // check for replacement object
            Object orig = obj;
            Class<?> cl = obj.getClass();
            ObjectStreamClass desc;
            for (;;) {
                // REMIND: skip this check for strings/arrays?
                Class<?> repCl;
                desc = ObjectStreamClass.lookup(cl, true);
                if (!desc.hasWriteReplaceMethod() ||
                    (obj = desc.invokeWriteReplace(obj)) == null ||
                    (repCl = obj.getClass()) == cl)
                {
                    break;
                }
                cl = repCl;
            }
            if (enableReplace) {
                Object rep = replaceObject(obj);
                if (rep != obj && rep != null) {
                    cl = rep.getClass();
                    desc = ObjectStreamClass.lookup(cl, true);
                }
                obj = rep;
            }

            // if object replaced, run through original checks a second time
            if (obj != orig) {
                subs.assign(orig, obj);
                if (obj == null) {
                    writeNull();
                    return;
                } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                    writeHandle(h);
                    return;
                } else if (obj instanceof Class) {
                    writeClass((Class) obj, unshared);
                    return;
                } else if (obj instanceof ObjectStreamClass) {
                    writeClassDesc((ObjectStreamClass) obj, unshared);
                    return;
                }
            }

            // remaining cases
            if (obj instanceof String) {
                writeString((String) obj, unshared);
            } else if (cl.isArray()) {
                writeArray(obj, desc, unshared);
            } else if (obj instanceof Enum) {
                writeEnum((Enum<?>) obj, desc, unshared);
            } else if (obj instanceof Serializable) {
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                if (extendedDebugInfo) {
                    throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
                }
            }
        } finally {
            depth--;
            bout.setBlockDataMode(oldMode);
        }
    }

Serializable 인터페이스를 사용하면 ObjectOutputStream.writeObject 매서드에서 Seralizable 을 구현하지 않은 객체를 받으면 컴파일 타임에 오류가 난다. 이처럼 마커 인터페이스는 오류를 컴파일 타임에 잡을 수 있지만 마커 애너테이션을 쓸 경우 발생된 오류를 런타임에 가서야 잡을 수 있다.

마커 인터페이스가 나은 점 두 번째는 적용 대상을 더 정밀하게 지정할 수 있다.

적용 대상(@Target)을 Element.TYPE 으로 선언한 에너테이션은 모든 타입(클래스, 인터페이스, 열거타입, 애너테이션)에 달 수 있다. 부착할 수 있는 타입을 더 세밀하게 재한하지는 못한다는 뜻이다.

package java.lang.annotation;

public enum ElementType {
    TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ANNOTATION_TYPE,
    PACKAGE,
    TYPE_PARAMETER,
    TYPE_USE,
    MODULE;

    private ElementType() {
    }
}

특정 인터페이스를 구현한 클래스에만 적용하고 싶은 마커가 있다고 해보자. 이 마커를 인터페이스로 정의했다면 그냥 마킹하고 싶은 클래스에서만 그 인터페이스를 구현하면 된다. 그러면 마킹된 타입은 자동으로 그 인터페이스의 하위 타입임이 보장되는 것이다.

Set 인터페이스도 일종의 마커 인터페이스로 볼 수 있다.

• Collection 하위 타입에만 적용할 수 있다.
• Collection이 정의한 add, equals, hashCode 등의 메서드 외에는 새로 추가한 것이 없다.
• 이런 마커 인터페이스는 객체의 특정 부분을 불변식으로 규정하거나 그 타입의 인스턴스는 다른 클래스의 특정 메서드가 처리할 수 있다는 사실을 명시하는 용도로 사용할 수 있다. (ex: Serializable 인터페이스는 ObjectOutPutStream이 처리할 수 있는 인스턴스)

반대로 마커 애너테이션이 마커 인터페이스보다 나은 점으로는 거대한 애너테이션 시스템의 지원을 받는다는 점을 들 수 있다. 따라서 애너테이션을 적극 활용하는 프레임워크에서는 마커 애너테이션을 쓰는 쪽이 일관성을 지키는데 유리할 것이다.

그렇다면 어떤 때에 마커 애너테이션을, 또 어떤 때에 마커 인터페이스를 써야할까?

• 클래스와 인터페이스 외의 프로그램 요소들(모듈, 패키지, 필드, 지역변수 등)에 마킹을 해야 할 때 애너테이션을 쓸 수밖에 없다. 마커 인터페이스를 사용하면 인터페이스를 구현할 수 있는 클래스와 인터페이스만 사용이 가능하기 때문이다.

• 애너테이션을 활발히 활용하는 프레임워크에서 사용하는 마커라면 마커 애너테이션을 사용하는 편이 좋을 것이다.

• 마커를 인터페이스나 클래스에 적용해야 한다면?

  "이 마킹이 된 객체를 매개변수로 받는 메서드를 작성할 일이 있을까?" 라고 자문해보자.

  '그렇다' → 마커 인터페이스를 써야한다. 그 마커 인터페이스를 해당 메서드의 매개변수 타입으로 사용하여 컴파일 타임에 오류를 잡아낼 수 있다.

  '그런 일은 절대 없다' → 아마도 마커 애너테이션이 나은 선택이다.

sum up

마커 인터페이스와 마커 애너테이션은 각자의 쓰임이 있다. 새로 추가하는 메서드 없이 단지 타입 정의가 목적이라면 마커 인터페이스를 사용하자. 적용 대상이 ElementType.TYPE인 마커 애너테이션을 작성하고 있다면, 잠시 여유를 가지고 정말 애너테이션으로 구현하는게 옳은지, 혹은 마커 인터페이스가 낫지는 않을지 곰곰이 생각해보자.