여러 디자인 패턴과 특징

0. 디자인 패턴이란?

프로그램 설계 시 발생하는 문제들을 객체 간의 상호 관계 들을 이용하여 해결할 수 있도록 하나의 규약 형태로 만들어 놓은 것

 

 

 

1. 싱글톤 패턴 Singleton Pattern

하나의 클래스에 오직 하나의 인스턴스만 가지는 패턴.

 

보통 데이터베이스 연결 모듈에 많이 사용된다.

 

하나의 인스턴스를 만들어두고, 다른 모듈들이 공유하며 사용하기 때문에 인스턴스를 생성하는 비용이 줄어드는 장점이 있다.

 

하지만 의존성이 낮아진다는 단점이 있다.

 

class Singleton {
    private static class singleInstanceHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return singleInstanceHolder.INSTANCE;
    }
}

public class HelloWorld{ 
     public static void main(String []args){ 
        Singleton a = Singleton.getInstance(); 
        Singleton b = Singleton.getInstance(); 
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());  
        if (a == b){
         System.out.println(true); 
        } 
     }
}

 

싱글톤 패턴의 단점

 

TDD

싱글톤 패턴은 TDD(Test Driven Development)에 걸림돌이 된다.

 

TDD의 단위 테스트는 테스트가 서로 독립적이여야 하는데, 싱글톤 패턴은 테스트마다 독립적인 인스턴스를 만들기 어렵다.

 

 

의존성

또한 싱글톤 패턴은 모듈 간의 결합을 강하게 만든다는 단점이 있다.

 

이를 의존성 주입(DI)를 통해 모듈 간의 결합을 느슨하게 만들어 해결할 수 있다.

 

 

 

 

 

2. 팩토리 패턴 Factory Pattern

객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴이다.

 

상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고, 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴이다.

 

팩토리 패턴의 장점

 

낮은 결합성

상위 클래스와 하위 클래스가 분리되기 때문에 느슨한 결합을 가지고, 상위 클래스에서는 인스턴스 생성 방식에 대해 알 필요가 없기 때문에 더 많은 유연성을 가지게 된다.

 

유지 보수성 증가

객체 생성 로직이 추상화되어 있기 때문에 리팩토링 과정에서 객체 생성 로직을 수정할 필요가 없어진다.

따라서 유지보수성이 증가된다.

 

abstract class Coffee { 
    public abstract int getPrice(); 
    
    @Override
    public String toString(){
        return "Hi this coffee is "+ this.getPrice();
    }
}

class CoffeeFactory { 
    public static Coffee getCoffee(String type, int price){
        if("Latte".equalsIgnoreCase(type)) return new Latte(price);
        else if("Americano".equalsIgnoreCase(type)) return new Americano(price);
        else{
            return new DefaultCoffee();
        } 
    }
}
class DefaultCoffee extends Coffee {
    private int price;

    public DefaultCoffee() {
        this.price = -1;
    }

    @Override
    public int getPrice() {
        return this.price;
    }
}
class Latte extends Coffee { 
    private int price; 
    
    public Latte(int price){
        this.price=price; 
    }
    @Override
    public int getPrice() {
        return this.price;
    } 
}
class Americano extends Coffee { 
    private int price; 
    
    public Americano(int price){
        this.price=price; 
    }
    @Override
    public int getPrice() {
        return this.price;
    } 
} 
public class HelloWorld{ 
     public static void main(String []args){ 
        Coffee latte = CoffeeFactory.getCoffee("Latte", 4000);
        Coffee ame = CoffeeFactory.getCoffee("Americano",3000); 
        System.out.println("Factory latte ::"+latte);
        System.out.println("Factory ame ::"+ame); 
     }
}

 

 

 

 

 

3. 전략 패턴 Strategy Pattern

객체의 행위를 바꾸고 싶은 경우 직접 수정하지 않고, 전략이라고 부르는 '캡슐화한 알고리즘'을 컨텍스트 내에서 바꿔주면서 상호 교체가 가능하게 만드는 패턴이다.

 

예를 들어 한 서비스에서 결제를 할 때, 요청한 결제 방법에 따라 '전략'을 바꿔서 결제하는 것을 구현한다.

 

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
interface PaymentStrategy { 
    public void pay(int amount);
} 

class KAKAOCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;
    
    public KAKAOCardStrategy(String nm, String ccNum, String cvv, String expiryDate){
        this.name=nm;
        this.cardNumber=ccNum;
        this.cvv=cvv;
        this.dateOfExpiry=expiryDate;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount +" paid using KAKAOCard.");
    }
} 

class LUNACardStrategy implements PaymentStrategy {
    private String emailId;
    private String password;
    
    public LUNACardStrategy(String email, String pwd){
        this.emailId=email;
        this.password=pwd;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid using LUNACard.");
    }
} 

class Item { 
    private String name;
    private int price; 
    public Item(String name, int cost){
        this.name=name;
        this.price=cost;
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }
} 

class ShoppingCart { 
    List<Item> items;
    
    public ShoppingCart(){
        this.items=new ArrayList<Item>();
    }
    
    public void addItem(Item item){
        this.items.add(item);
    }
    
    public void removeItem(Item item){
        this.items.remove(item);
    }
    
    public int calculateTotal(){
        int sum = 0;
        for(Item item : items){
            sum += item.getPrice();
        }
        return sum;
    }
    
    public void pay(PaymentStrategy paymentMethod){
        int amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}  

public class HelloWorld{
    public static void main(String []args){
        ShoppingCart cart = new ShoppingCart();
        
        Item A = new Item("kundolA",100);
        Item B = new Item("kundolB",300);
        
        cart.addItem(A);
        cart.addItem(B);
        
        // pay by LUNACard
        cart.pay(new LUNACardStrategy("kundol@example.com", "pukubababo"));
        // pay by KAKAOBank
        cart.pay(new KAKAOCardStrategy("Ju hongchul", "123456789", "123", "12/01"));
    }
}

 

PaymentStrategy를 상속한 KAKAOCardStrategy, LUNACardStrategy를 필요에 따라 전략을 바꾸어서 전달하게 된다.

 

 

 

 

4. 옵저버 패턴 Observer Pattern

주체가 어떤 객체의 상태 변화를 관찰하다가, 상태 변화가 있을 때마다 메서드 등을 통해 옵저버 목록에 있는 옵저버들에게 변화를 알려주는 디자인 패턴.

 

여기서 주체란, 객체의 상태 변화를 보고 있는 '관찰자'이다.

 

옵저버 패턴의 예시로, 트위터가 있다.

 

주체인 사람이 어떤 게시물을 게시하면, 팔로우하고 있는 사람들(옵저버)에게 알려준다.

 

 

또한, 옵저버 패턴은 주로 이벤트 기반 시스템에 사용되며 MVC패턴에서도 사용된다.

 

import java.util.ArrayList;
import java.util.List;

interface Subject {
    public void register(Observer obj);
    public void unregister(Observer obj);
    public void notifyObservers();
    public Object getUpdate(Observer obj);
}

interface Observer {
    public void update(); 
}

class Topic implements Subject {
    private List<Observer> observers;
    private String message; 

    public Topic() {
        this.observers = new ArrayList<>();
        this.message = "";
    }

    @Override
    public void register(Observer obj) {
        if (!observers.contains(obj)) observers.add(obj); 
    }

    @Override
    public void unregister(Observer obj) {
        observers.remove(obj); 
    }

    @Override
    public void notifyObservers() {   
        this.observers.forEach(Observer::update); 
    }

    @Override
    public Object getUpdate(Observer obj) {
        return this.message;
    } 
    
    public void postMessage(String msg) {
        System.out.println("Message sended to Topic: " + msg);
        this.message = msg; 
        notifyObservers();
    }
}

class TopicSubscriber implements Observer {
    private String name;
    private Subject topic;

    public TopicSubscriber(String name, Subject topic) {
        this.name = name;
        this.topic = topic;
    }

    @Override
    public void update() {
        String msg = (String) topic.getUpdate(this); 
        System.out.println(name + ":: got message >> " + msg); 
    } 
}

public class HelloWorld { 
    public static void main(String[] args) {
        Topic topic = new Topic(); 
        Observer a = new TopicSubscriber("a", topic);
        Observer b = new TopicSubscriber("b", topic);
        Observer c = new TopicSubscriber("c", topic);
        topic.register(a);
        topic.register(b);
        topic.register(c); 
   
        topic.postMessage("amumu is op champion!!"); 
    }
}

 

Topic에서는 Observer객체들을 가지고있고,

topic에서 메세지를 발행하면 옵저버들에게 알려주게 된다.

 

이벤트 기반(Event-Driven)구조와 같다.

 

 

 

 

5. 프록시 패턴 Proxy Patten

 

대상 객체에 접근하기 전 그 접근에 대한 흐름을 가로채 해당 접근을 필터링하거나 수정하는 등의 역할을 하는 계층이 있는 디자인 패턴.

 

객체의 속성, 변환 등을 보완하여 보안, 데이터 검증, 캐싱, 로깅에 사용하게 되거나, 프록시 서버로도 활용된다.

 

프록시 서버

서버와 클라이언트 사이에 클라이언트가 자신을 통해 다른 네트워크 서비스에 간접적으로 접근할 수 있게 해주는 시스템이나 프로그램.

 

프록시 서버를 통해 DDoS 공격, HTTPS구축 등을 할 수 있다.

 

 

 

 

 

6. 이터레이터 패턴 Iterator Pattern

이터레이터(Iterator)를 사용하여 컬렉션(Collection) 요소들에 접근하는 디자인 패턴

 

순회할 수 있는 여러 자료형의 구조에 상관없이 하나의 인터페이스로 순회가 가능.

 

import java.util.Iterator;

class SimpleCollection implements Iterable<String> {
    private String[] items = {"A", "B", "C"};

    @Override
    public Iterator<String> iterator() {
        return new SimpleIterator();
    }

    private class SimpleIterator implements Iterator<String> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < items.length;
        }

        @Override
        public String next() {
            return items[index++];
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SimpleCollection collection = new SimpleCollection();
        for (String item : collection) {
            System.out.println(item);
        }
    }
}

 

 

 

 

 

7. MVC 패턴

 

모델(Model), 뷰(View), 컨트롤러(Controller)로 이루어진 디자인 패턴

 

애플리케이션의 구성 요소를 세 가지 역할로 구분하여 개발 프로세스에서 각각의 구성 요소에 집중하여 개발할 수 있다.

 

장점

재사용성과 확장성에 용이함.

 

단점

애플리케이션이 복잡해질수록 모델과 뷰의 관계가 복잡해진다.

 

모델

애플리케이션의 데이터를 뜻한다. 데이터베이스, 상수, 변수 등.

 

뷰에서 데이터를 생성하거나 수정하면 컨트롤러를 통해 모델을 생성하거나 갱신한다.

 

뷰

사용자 인터페이스 요소를 나타낸다. inputbox, checkbox, texarea 등.

 

모델이 가지고 있는 정보를 따로 저장하지 않아야 한다.

 

컨트롤러

하나 이상의 모델과 하나 이상의 뷰를 잇는 다리 역할.

 

이벤트 등 메인 로직을 담당한다.

 

또한, 모델과 뷰의 생명주기를 관리한다.

 

스프링에서의 MVC 패턴

스프링 프레임워크는 대표적인 MVC패턴의 예이다.

 

특히, Spring Web에서는 여러 어노테이션을 통해 편리하게 요청의 상호작용이 가능하다.

 

 

 

 

8. MVP 패턴

MVP패턴으로 파생된 패턴으로, 컨트롤러가 프레젠터로 교체된 패턴

View와 Presenter는 1:1 관계이기 때문에 MVC패턴보다 더 강한 결합을 지닌 디자인 패턴이다.

 

 

 

9. MVVM 패턴

컨트롤러가 뷰 모델 (View Model)로 바뀐 패턴이다.

 

여기서 뷰 모델은 뷰를 더 추상화한 계층이며, MVMM 패턴은 커맨드와 데이터 바인딩을 가진다는게 특징이다.

 

뷰와 뷰 모델 사이의 양방향 데이터 바인딩을 지원하며, UI를 별도의 코드 수정 없이 재사용할 수 있고 단위 테스팅이 쉽다는 장점이 있다.