2. 디자인 패턴공부

[bumdream]

자기가 원하는 거 공부 (1개 또는 2개)

[hongsukchoi]

프록시 패턴(Proxy Pattern)

프록시 = 대리자

어떤 작업을 할 때, 구체적으로 인터페이스를 사용하고 실행시킬 클래스에 대한 객체가 들어갈 자리에 대리자 객체를 대신 투입해 작업을 대신 시키는 패턴.

왜 쓸까?

일단 프록시 패턴의 특징은 다음 4가지와 같다

• 대리자는 실제 서비스와 같은 이름의 메서드를 구현한다. 이때 인퍼페이스를 사용한다.
• 대리자는 실제 서비스에 대한 참조 변수를 갖는다(합성)
• 대리자는 실제 서비스의 같은 이름을 가진 메서드를 호출하고 그 값을 클라이언트에게 돌려준다.
• 대리자는 실제 서비스의 메서드 호출 전후에도 별도의 로직을 수행할 수도 있다.

쓰는 이유는 4번째가 핵심이라고 생각하는데, 데이터가 크거나 해서 로딩작업이 느릴 때 등 작업시간이 긴 경우,

일단 완료된 상태까지만 유저에게 제공하거나 그 시간 동안 다른 작업을 하려는 경우에 쓸모 있을 것 같다.

주의할 점: 프록시는 흐름제어만 할 뿐 결과값을 조작하거나 변경시키면 안됩니다.

예시

프록시가 실제 작업 객체를 필드로 가지고 있으면서 해당 함수를 호출한다. 그렇기 때문에 작업 딜레이 동안 프록시는 다른 일을 할 수 있다.

출처: 림키

[bumdream]

전략패턴 (Strategy Pattern)

전략패턴을 구성하는 3가지 요소

• 전략 메서드를 가진 전략 객체
• 전략 객체를 사용하는 컨텍스트(전략객체의 소비자)
• 전략 객체를 생성해 컨텍스트에 주입하는 공급자.
• 현재 상황에 적합한 전략을 생성해 컨텍스트에게 전략 객체를 주입

전략패턴 적용사례 (SubtitleParser)

public interface SubtitleParser {
    List<SubtitleObject> parse(String subtitlePath) throws IOException;
}

• 위 메소드는 자막을 파싱하는 인터페이스다.
• 나는 이 인터페이스를 가지고 SamiParser, VttParser 을 만들었고 실제 사용하는 부분에서는 아래와 같이 사용하였다.

  SubtitleParser parser = ParseFactory.INSTANCE.createParser(subtitlePath);
  List<SubtitleObject> subtitleList = parser.parse(subtitlePath);

• 팩토리 패턴으로 자막경로에 맞는 파서기를 가져오고, 그 다음 parse 가 실행되면 전략패턴으로 구현한 parse 메소드가 호출되는 방식이다.

[bumdream]

싱글톤패턴 (Singleton)

Eaeeger initialization (이른 초기화 방식)

package SingleTonExample;

public class EagerInitialization {

    //private static으로 선언
    private static EagerInitialization instance = new EagerInitialization();

    //생성자
    private EagerInitialization() {}

    //인스턴스 리턴
    public static EagerInitialization getInstance() {
        return instance;
    }

}

• 위와 같이 클래스를 선언할 때 private static 으로 선언해놓고, 생성자는 private 으로 만들어서 클래스 밖에서 클래스를 인스턴스화 못하게 하는 방식.
• 클래스 로더에 의해서 싱클톤 객체가 생성되므로 thread-safe 하다.
• 하지만 사용시점에 관계없이 처음부터 메모리를 저렇게 잡고 있는 모습은 비효율적일 수 있다.

lazy initialization

• 클래스 인스턴스가 사용되는 시점에 인스턴스를 만드는 패턴

  public class LazyInitialization {
  
  private static LazyInitialization instance;
  private LazyInitialization () {}
  
  public static LazyInitialization getInstance () {
      if ( instance == null )
          instance = new LazyInitialization();
      return instance;
  }
  
  public void print () {
      System.out.println("It's print() method in LazyInitialization instance.");
      System.out.println("instance hashCode > " + instance.hashCode());
  }
  }

• new LayzaInitializatoin() 은 getInstance() 메소드 안에서 사용되었다.
• 최초 사용시점에만 인스턴스화 시키기 떄문에 프로그램 메모리에 적재되는 시점에 부담이 많이 줄게 된다.
• 그러나 multi-thread 환경에서는 위 방식은 안전하지 않다. 동일 시점에 getInstance를 호출하면 인스턴스가 두번 생길 위험이 있기 때문.

thread safe initialization

• 자바에서 synchronized(동기화) 를 이용하여 여러 스레드들이 동시에 접근하는 것을 막을 수 있다.

public class ThreadSafeInitalization {

    private static ThreadSafeInitalization instance;
    private ThreadSafeInitalization () {}

    public static synchronized ThreadSafeInitalization getInstance () {
        if (instance == null)
            instance = new ThreadSafeInitalization();
        return instance;
    }

    public void print () {
        System.out.println("It's print() method in ThreadSafeInitalization instance.");
        System.out.println("instance hashCode > " + instance.hashCode());
    }

}

• getInstance() 메소드에 synchronized 를 붙임으로써 저 메소드는 서로 다른 스레드가 동시에 실행할 수 없다.
• 그러나 synchronized 를 사용하게 되면 프로그램이 굉장히 느려지기 때문에 좋지 않다.

initialization on demand holder idiom

• jvm의 클래스로더 메카니즘과 class의 load 시점을 이용한 방식

  public class InitializationOnDemandHolderIdiom {
  
  private InitializationOnDemandHolderIdiom () {}
  private static class Singleton {
      private static final InitializationOnDemandHolderIdiom instance = new InitializationOnDemandHolderIdiom();
  }
  
  public static InitializationOnDemandHolderIdiom getInstance () {
      System.out.println("create instance");
      return Singleton.instance;
  }
  }

• inner 클래스는 메소드나 멤버변수가 참조되기 전까진 클래스로더에의해 로드되지 않는 원리를 이용.
• 최근에 가장 많이 사용한다고 한다.
• 추가 참조 문서 : initialization-on-demand-holder

enum initialization

public enum EnumInitialization {
    INSTANCE;
    static String test = "";
    public static EnumInitialization getInstance() {
        test = "test";
        return INSTANCE;
    }
}

• 단 한번의 인스턴스 생성을 보장
• 사용 간편.

java reflection

• 자바 리플렉션을 이용해서 싱글톤을 깨뜨릴 수도 있다는데, 리플렉션의 개념에 대해선 내일 공부해봐야겠다

[hongsukchoi]

탬플릿 콜백 패턴(Template Callback Pattern)

전략 패턴에 익명 내부 클래스를 가미한 패턴

하나의 컨텍스트에서만 사용하는 전략일 때, 불필요한 클래스 생성을 방지할 수 있다.

다음은 자주 쓰는 탬플릿 콜백 패턴 형태

Strategy.java (전략 인터페이스 정의)

public interface Strategy {
void runStrategy();
}

SoliderWithRefactoring.java (전략을 사용할 컨텍스트 + 내부 익명 클래스 이관 당함)

public class SoliderWithRefactoring {
    void runContext(String StrategySound) {

        execute(StrategySound).runStrategy();
    }

    private Strategy execute(final String StrategySound) {
        return new Strategy() {

            @Override
            public void runStrategy() {
                System.out.println(StrategySound);       
            }
        };

    }
}

Client.java (클라이언트 Solider안에 내부 익명 클래스를 이관했다. -> 코드가 깔끔해짐)

public class Client {

    public static void main(String[] args) {
        SoliderWithRefactoring rambo = new SoliderWithRefactoring();

        rambo.runContext("탕! 탕탕탕!");

        rambo.runContext("수류탄 투척~! 쾅!!!");
    }
}

Strategy 인터페이스를 통해 OCP와 DIP를 지켰다.

[hongsukchoi]

싱글톤 패턴 리뷰

"해당 클래스의 인스턴스가 하나만 만들어지고,

어디서든지 그 인스턴스에 접근할 수 있도록 하기 위한 패턴"

출처: http://hjjungdev.tistory.com/4 [우아한 프로그래밍]

Synchronized

(thread safe initialization 읽다가 헷갈려서 다시 찾아봄)

Synchronized 메소드를 사용하는 동안에 다른 스레드에서 해당 메소드를 가진 객체를 사용할 수 없음

출처: 해시코드

[bumdream]

Adapter Pattern(어댑터 패턴)

• 이미 잘 구축되어 있는 것을 새로운 어떤 것이 사용할 때 양쪽 간의 호환성을 유지해주기 위함.

예시

Volt class

public class Volt {
    private int volts;

    public Volt(int v) {
        this.volts = v;
    }

    public int getVolts() {
        return this.volts;
    }

    public void setVolts(int volts) {
        this.volts = volts;
    }
}

socket class

public class Socket {
    public Volt getVolt() {
        return new Volt(120);
    }
}

설명

• volt 와 socket 클래스를 만들었다. socket에서는 현재 120v 만 얻을 수 있다. 실생활에선 12v,3v 를 얻기 위해 어댑터를 끼워서 원하는 볼트를 얻는다.
• volt 와 socket 을 내부적으로 수정해서 원하는 값을 얻을 수도 있겠지만, 원본 클래스를 수정하고 싶지 않거나, 수정이 불가능한 경우 어댑터 클래스를 만들어 사용한다고 보면된다.

adapter class

public interface SocketAdapter {
    public Volt get120Volt();
    public Volt get12Volt();
    public Volt get3Volt();
}

• 다음과 같이 원하는 값을 얻을 수 있게 인터페이스를 짜고 내용을 구성하면 된다.

adapter클래스 구현방법

• 두 가지 방법이 있다.
  • extends Socket implements SocketAdapter
  • implements SocketAdapter(Socket 은 내부변수로 가지고 있기)

예시

• extends Socket implements SocketAdapter

  public class SocketClassAdapterImpl extends Socket implements SocketAdapter {
  public Volt get120Volt() {
      return getVolt();
  }
  
  public Volt get12Volt() {
      Volt v = getVolt();
      return convertVolt(v, 10);
  }
  
  public Volt get3Volt() {
      Volt v = getVolt();
      return convertVolt(v, 40);
  }
  
  public Volt convertVolt(Volt v, int i) {
      return new Volt(v.getVolts()/i);
  }
  }

• implements SocketAdapter(Socket 은 내부변수로 가지고 있기)

  
  public class SocketObjectAdapterImpl implements SocketAdapter {
  
  private Socket sock = new Socket();
  
  public Volt get120Volt() {
      return sock.getVolt();
  }
  
  public Volt get12Volt() {
      Volt v = sock.getVolt();
      return convertVolt(v, 10);
  }
  
  public Volt get3Volt() {
      Volt v = sock.getVolt();
      return convertVolt(v, 40);
  }
  
  private Volt convertVolt(Volt v, int i) {
      return new Volt(v.getVolts()/i);
  }

}

[hongsukchoi]

팩토리 메서드 패턴(Factory Method Pattern)

팩토리에서 객체를 생성해 반환하는 패턴.

Concrete Creator(팩토리)에서 Concrete Product(객체)를 생성, 반환함.

public class ConcreteFactory extends Factory{

    @Override
    public Product createProduct(String name) {

        switch (name) {
            case "AAA": return new ProductA(); 
            case "BBB": return new ProductB();
        }      
        return null;
    }
}

public class Main {

    public static void main(String[] args) {

        ConcreteFactory factory = new ConcreteFactory();
        List<Product> products = new ArrayList<>();
        products.add(factory.createProduct("AAA"));
        products.add(factory.createProduct("BBB"));

        for(Product product : products){
              System.out.println(productA.getName()+"\n");
        }
    }

}

기본적으로 DIP를 지키는 패턴 (상위와 하위 객체는 구상 클래스에 의존하지 않고, 모두 동일한 추상화에 의존)

장점

• 객체생성을 한 곳에서 관리해 응집도를 높임
• 객체 추가, 삭제 용이
• 인터페이스를 활용해 결합도를 낮춤 ( = 객체의 추상화 단계가 높아진다)
• 객체 생성의 캡슐화
• 사용자는 생성하는 객체에 대해 알 필요가 없음