private 생성자나 열거 타입으로 싱글턴임을 보증하라 - [2장 객체 생성과 파괴(아이템3)]

  해당 장에서는 싱글턴을 만드는 방식을 소개하고 있다. private 생성자를 이용하는 2가지 방식과 열거 타입을 이용하는 1가지 방식, 총 3가지 방식을 소개하고 있다. 각각의 장점과 단점에 대해서 알아보자.

 

1. 'private 생성자 + public static final 필드'를 이용하는 방법

public class Elvis{

    /**
     * 싱글톤 오브젝트
     */
    public static final Elvis INSTANCE = new Elvis();
    
    private Elvis(){}
    
    public void leaveTheBuilding(){
        System.out.println("Whoa baby, I'm outta here!");
    }
    
    public void sing(){
        System.out.println("I'll hava a blue~ Christmas without you~");
    }
}

------------------------------
// 아래는 다른 클래스에 작성된 것이라고 생각하자.
public static void main(String[] args){
    Elvis elvis = Elvis.INSTANCE;
    elvis.leaveTheBuilding();
}

  위와 같이 만들고 사용할 수 있다. 이것의 '간결하고 싱글턴임을 API에 들어낼 수 있다.'라는 장점이 있다. 생성자가 private인 것을 보고 인스턴스를 직접 생성하지 못하게 막았다는 것을 바로 알 수 있다. 그리고 static final로 선언된 부분이 자바독 생성 시 별도의 필드로 보여주기 때문에 주석과 함께 싱글턴임을 API에 드러낼 수 있다는 것이다. (자바독에서 description에 주석이 들어감)

  첫 번째 단점은 싱글톤을 사용하는 클라이언트가 테스트를 하기 어렵다는 것이다. 아래와 같이 콘서트 클래스를 테스트하는 경우 계속해서 elvis를 호출해야 한다는 문제가 있다. (테스트를 실행할 때마다 이렇게 동작하는 것은 매우 비효율적)

public class Concert{

    private boolean lightsOn;
    
    private boolean mainStateOpen;
    
    private Elvis elvis;
    
    public Concert(Elvis elvis){
        this.elvis = elvis;
    }
    
    public void perform(){
        mainStateOpen = true;
        lightsOn = true;
        elvis.sing();
    }
    
    public boolean isLightOn(){
        return LightsOn;
    }
    
    public boolean isMainStateOpen(){
        return mainStateOpen;
    }
}

class ConcertTest{
    @Test
    void perform(){
        Concert concert = new Concert(Elvis.INSTANCE); // 해결 방법 : new Concert(new MockElvis());
        concert.perform();
        
        assertTrue(concert.isLightsOn());
        assertTrue(concert.isMainStateOpen());
    }
}

  해결 방법은 인터페이스를 이용해서 가짜(mock)를 주는 것이다. 

  두 번째 단점은 리플렉션으로 private 생성자를 호출할 수 있다는 것이다. 아래처럼 같은 타입의 인스턴스를 여러 개 만들 수 있다는 것이다. 이에 대한 해결책은 flag 값을 이용하여 이미 인스턴스가 생성된 경우 다시 생성하는 과정에서 예외를 발생시키는 것이다.

public static void main(String[] args){
    try{
        Constructor<Elvis> defaultConstructor = Elvis.class.getDeclaredConstructor();
        defaultConstructor.setAccessible(true);
        Elvis elvis1 = defaultConstructor.newInstance();
        Elvis elvis2 = defaultConstructor.newInstance();
        System.out.println(elvis1 == elvis2); // false
    } catch(Exception exception){
    }
}

 

  세 번째 단점은 역직렬화 할 때 새로운 인스턴스가 생길 수 있다는 것이다. 만약 readResolve()를 사용한다면 싱글턴이 보장된다.(아래는 readResolve()를 정의하지 않은 상태이다.)

public class ElvisSerialization{
    public static void main(String[] args){
        // 직렬화
        // 직렬화를 통해 객체 정보를 어딘가에 저장 가능
        try(ObjectOutput out = new ObjectOutputStream(new FileOutputStream("elvis.obj"))){
            out.writeObject(Elvis.INSTANCE);
        } catch (IOException e){
            e.printStackTrace();
        }
        
        // 역직렬화
        // 역직렬화를 통해 어딘가에 저장된 객체 정보를 읽어올 수 있다.
        try(ObjectOutput in = new ObjectInputStream(new FileInputStream("elvis.obj"))){
            Elvis elvis3 = (Elvis) in.readObject();
            System.out.prinln(elvis3 == Elvis.INSTANCE); // false;
        } catch (IOException | ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}

[정리]

장점

1. 간결하고 싱글턴임을 API에 들어낼 수 있다.

단점

1. 싱글턴을 사용하는 클라이언트를 테스트하기 어려워진다.
2. 리플렉션으로 private 생성자를 호출할 수 있다.
3. 역직렬화 할 때 새로운 인스턴스가 생길 수 있다.

 

2. 'private 생성자 + 정적 팩터리 메서드'를 이용하는 방법

public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    
    private Elvis() { }
    
    public static Elvis getInstance(){
        return INSTANCE;
    }
    
    public void leaveTheBuilding(){
        System.out.println("Whoa baby, I'm outta here!");
    }
}

---------------------------
// 아래는 다른 클래스에 작성된 것이라고 생각하자.
public static void main(String[] args){
    Elvis elvis = Elvis.getInstance();
    elvis.leaveTheBuilding();
}

    첫 번째 방법과의 차이점은 메서드를 통해 인스턴스를 가져간다는 점이다. 단점의 첫 번째 방식과 동일하다. 장점 3가지에 대해서 알아보자.

 

public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    
    private Elvis() { }
    
    public static Elvis getInstance(){
        return new Elvis(); // 바뀐 부분
    }
    
    public void leaveTheBuilding(){
        System.out.println("Whoa baby, I'm outta here!");
    }
}

  첫 번째, 메서드를 위와 같이 바꾸게 된다면 클라이언트 코드를 바꾸지 않고도 싱글턴이 아니게 바꿀 수 있다.

 

public class MetaElvis<T> {
    private static final MetaElvis<Object> INSTANCE = new MetaElvis<>();
    
    private MetaElvis(){}
    
    @SuppressWarnings("unchecked")
    public static <T> MetatElvis<T> getInstance(){
        return (MetaElvis<T>) INSTANCE;
    }
    
    public void say(T t){
        System.out.println(t);
    }
    
    public void leaveTheBuilding(){
        System.out.println("Whoa baby, I'm outta here!");
    }
}

--------

public static void main(String[] args){
    MetaElvis<String> elvis1 = MetaElvis.getInstance();
    MetaElvis<Integer> elvis2 = MetaElvis.getInstance();
}

  두 번째, 제네릭 타입으로 동일한 싱글턴 인스턴스를 사용하고 싶을 때 위와 같이 제네릭 싱글턴 팩터리를 만들어서 사용할 수 있다. (인스턴스는 동일하지만 원하는 타입으로 바꿔서 사용할 수 있음)

 

public Class Concert{
    public void start(Supplier<Singer> singerSupplier){
        Singer singer = singerSupplier.get();
        singer.sing();
    }
    
    public static void main(String[] args){
        Concert concert = new Concert();
        concert.start(Elvis::getInstance);
    }
}

  마지막으로 위와 같이 메서드 자체를 supplier의 구현체 파라미터에 넘길 수 있다.

 

[정리]

장점

1. API를 바꾸지 않고도 싱글턴이 아니게 변경할 수 있다.
2. 정적 팩터리를 제너릭 싱글턴 팩터리로 만들 수 있다.
3. 정적 팩터리의 메서드 참조를 공급자(Supplier)로 사용할 수 있다.

단점

1. 'private 생성자 + public static final 필드'의 3가지 단점과 동일

 

3. '열거 타입'을 이용하는 방법

public enum Elvis{
    INSTANCE;
    
    public void leaveTheBuilding(){
        System.out.println("Whoa baby, I'm outta here!");
    }
}

----------

public static void main(String[] args){
    Elvis elvis = Elvis.INSTANCE;
    elvis.leaveTheBuilding();
}

  enum으로 설정하고 INSTANCE를 하나 만들면 끝이다. 이 방법은 앞에서 단점으로 나온 리플렉션과 직렬화&역직렬화 문제에 대해서 매우 안전하다는 것이다. 단점 1로 나온 테스트를 하기 어려운 문제는 인터페이스를 이용해서 해결하도록 하자.(인터페이스 구현이 가능하기 때문에 해결 가능하다는 의미)

  대부분 상황에서는 원소가 하나뿐인 열거 타입으로 싱글턴을 만드는 것이 가장 좋은 방법이다.

 

 

  이상으로 1) private 생성자 + public static final 필드 2) private 생성자 + 정적 팩터리 메서드 3) 열거 타입으로 싱글턴을 만드는 방식을 알아보았다. 

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 수강하고 작성한 것입니다.