디자인 패턴에 대해서 ...

접을 위한 CS 전공 지식 노트라는 책을 보면서 공부한 내용들을 기입하려고 한다.

1.1 디자인 패턴

디자인 패턴이란?
우리가 프로그램들을 설계할 때에 발생했던 문제점들을
객체간의 상호 관계등을 통해서 해결 할 수 있도록
하나의 '규약' 형태로 만들어 놓은 것을 말한다.

우리가 흔히 프로그래밍을 할 때 쓰는 React, Vue, Spring 등의
프레임워크나 라이브러리의 기본이 되는 것이 디자인 패턴이다.

여기서 라이브러리와 프레임워크의 정의에대해 먼저 알아본다.

• 라이브러리: 공통으로 사용될 수 있는 기능등을 모듈화 한것
  폴더명이나 파일명에 규칙이 없고 프레임워크에 비해 자유롭다.
  
  이 말은 라이브러리 같은 경우에는 내가 직접 이 라이브러리를
  통해서 컨트롤하고 서비스하는 경우를 말한다.
  
  예를 들어 내가 무엇을 자르려고 할 때 가위가 필요해서
  내가 직접 가위를 들고 자르는 것과 같은 이치
  
  
• 프레임워크 : 공통으로 사용될 수 있는 기능등을 모듈화 한것
  라이브러리에 비해 엄격하고 파일명, 폴더명에 대한 규칙이 있다.
  
  라이브러리와 비교를 하자면 예를들어 내가 해외를 여행을간다
  하였을 때 비행기라는 물체를 타고 이동을 하지만 내가 직접 비행기를 운전을 해서 가는 것이아니다 도움을 받지만 내가 직접 컨트롤 하지 않는다 이런 느낌인 것이다.

1.1.1 싱글톤 패턴

싱글톤 패턴이란?

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

하나의 클래스를 기반으로 여러개의 개별적인 인스턴스를
만들 수 있지만, 그렇게 하지 않고 하나의 클래스를 기반으로
단 하나의 인스턴스를 만들어 쓰는 것을 말한다.

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

장점과 단점

• 장점
  • 하나의 인스턴스를 만들어놓고 해당 인스턴스를
    다른 모듈들이 공유하며 사용하기 때문에 인스턴스를
    생성할 때 드는 비용이 줄어드는 장점이 있다.
• 단점
  • 이게 중요합니다 객체지향에서 가장 조심해야하는
    의존성이 높아진다는 단점이 있습니다.

싱글톤 패턴의 단점
이 의존성이 높아진다는 것은 TDD(Test Driven Development)를
할 때 걸림돌이 된다는 것이다.
단위 테스트를 주로 하게 되는데, 단위 테스트는 각각의 테스트가
서로 독립적이어야 하고 테스트를 어떤 순서로든
실행할 수 있어야 합니다.

이렇기 때문에 싱글톤의 단점을 의존성 주입이라는 것으로
해결 할 수가 있는데,

참고로 의존성이란 종속성이라고도 하고 A가 B에 의존성이 있다는 것은 B의 변경 사항에 따라 A또한 변경이 되어야 한다는 것을 의미한다.

이 점을 DI 의존성 주입을 통해 해결 할 수가 있는데
메인 모듈이 직접 다른 하위 모듈에 대한 의존성을 주입하기
보다는 중간에 의존성 주입자가 이 부분들을 가로채서
메인 모듈이 간접적으로 의존성을 주입하는 것을
의존성 주입 dependency injection이라고 합니다.
이렇게 되면 당연히 메인모듈과 하위모듈간의 의존성은
떨어지게 됩니다.

의존성 주입의 장점과 단점

• 장점
  • 모듈들을 쉽게 교체 할수 있는 구조가 된다.
  • 테스팅 하기 쉽고 마이그레이션 하기 수월해진다.
  • 어플리케이션 의존성 방향이 일관되고
    쉽게 추론가능하게 해준다.
  • 모듈 간의 관계들이 조금 더 명확해진다.
• 단점
  • 모듈들이 더욱더 분리되기에 클래스 수가 늘어나 복잡성 증가
  • 약간의 런타임 패널티가 생기기도 한다.

※ 의존성 주입 원칙
의존성 주입은 " 상위 모듈은 하위 모듈에서 어떠한 것도 가져오지
않아야 한다 또한, 둘 다 추상화에 의존해야 하고, 이 때 세부사항에 의존하지 말아야한다."

싱글톤 코드

class Singletone {
    private static class singleInstanceHolder {
        private static final Singletone INSTANCE = new Singletone();
    }
    public static Singletone getInstance(){
        return singleInstanceHolder.INSTANCE;
    }
}
public class HelloWorld {
    public static void main(String[] args) {
        Singletone a = Singletone.getInstance();
        Singletone b = Singletone.getInstance();

        System.out.println(a.hashCode());
        System.out.println(b.hashCode());
        if (a==b){
            System.out.println(true);
        }
    }
}

 

 

1.1.2 팩토리 패턴

팩토리 패턴은 객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴
상속 관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고
하위 클래스에서는 객체 생성에 관한 구체적인 내용을 결정하는 패턴이다.

• 특징
  • 상위 클래스와 하위클래스가 분리 되기에 느슨한 결합을 가진다.
  • 인스턴스 생성 방식에 대해 전혀 알 필요가 없기 때문에 더 많은 유연성을 가진다.
  • 객체 생성 로직이 따로 떼어져 있기 때문에 유지 보수성이 증가된다.

예를 들어 커피 공장이 있다고 생각하게 되면
구체적인 레시피 들이 들어 있는 하위 클래스가 전달이 되고 이 레시피들을
토대로 제품들이 생산되는 것을 생각하면 된다.

밑의 코드를 통해 자세히 알아보자.

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 DefaulCoffee();
        }
    }
}

class DefaulCoffee extends Coffee{
    private int price;

    public DefaulCoffee(){
        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;
    }
}

/*
커피 팩토리라는 커피를 생성하는 클래스가 있고
그 클래스에는 라떼와 아메리카노 defalutCoffee를 받고 있다
커피 종류와 가격을 적으면 그에 맞게 출력되는 시스템

 */
public class HelloWorld {

    public static void main(String[] args) {
        Coffee latte = CoffeeFactory.getCoffee("Latte", 5500);
        Coffee americano = CoffeeFactory.getCoffee("americano", 5500);

        System.out.println("Factory latte:: " + latte);
        System.out.println("Factory americano:: " + americano);

    }
}

1.1.3 전략 패턴

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

※ 컨텍스트란?
프로그래밍에서는 컨텍스트는 상황, 맥락, 문맥을 의미하며 개발자가
어떤 작업을 완료하는데 필요한 모든 관련 정보를 말한다.

다음예제는 우리가 어떤 상품을 구매할 때 네이버페이나 카카오페이등
다양한 결제 시스템이 있듯이 LUNACard로 사는 것과 KAKAOCard로
사는 것을 구현한 예제입니다.

interface PaymentStrategy {
    public void pay(int amount);
}
class KAKAOCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String date0fExpiry;

    public KAKAOCardStrategy(String name, String cardNumber, String cvv, String date0fExpiry){
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.date0fExpiry = date0fExpiry;
    }
    @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 emailId, String password) {
        this.emailId = emailId;
        this.password = password;
    }

    @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 KAKAOCard
        cart.pay(new KAKAOCardStrategy("Ju hongchul", "123456789","123","12/01"));

// 위의 코드는 쇼핑카트에 아이템을 담고 LUNACard와 KAKAOCard라는 두개의
// 전략으로 결제하는 코드이다.

    }
}

 

 

1.1.4 옵저버 패턴

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

옵저버 패턴에는 객체와 주체가 분리되어 있는 옵저버 패턴과
객체와 주체가 합쳐져 있는 옵저버 패턴으로 나뉜다.

※ 여기서 주체라는 것은
객체의 상태 변화를 보고 있는 관찰자 이고,
옵저버 들이란 객체의 상태 변화에 따라 전달되는 메서드등을
기반으로 추가 변화 사항이 생기는 객체를 의미한다.

옵저버 패턴을 활용한 서비스로는 트위터가 있습니다.

예를 들어 나 자신 user가 어떤 다른사람인 주체를 팔로우 했다면
그 주체가 포스팅을 올리게 되면 알림이 팔로워에게 가게 됩니다.

그리고 이 옵저버 패턴은 주로 이벤트 기반 시스템에 사용되며
MVC(Model - View - Controller) 패턴에도 사용된다.

여기서 주체라고 볼 수 있는 모델에서 변경 사항이 생기면 update()라는
메서드를 통해서 옵저버인 view객체에 전달을 하고 이를 기반으로
controller가 작동하게 되는 원리이다.

옵저버 패턴을 사용한 자바 코드를 보겠습니다

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이라는 객체를 기반으로 옵저버 패턴을 구성
하였습니다. 여기서 topic은 주체이자 객체입니다.
Topic에 Subject인터페이스를 구현을 했고 메인 클래스에서
옵저버를 선언할 때에 해당 이름과 어떠한 토픽의 옵저버가 될 것인지
정의했습니다.

여기서 알아보는 자바의 상속과 구현

상속: 자식클래스가 부모 클래스의 메서드등을 상속받아 사용하게되고
자식 클래스에서 추가 및 확장을 할 수 있는 것을 말하고
이로 인해 재사용성, 중복성의 최소화가 이루어진다.

구현(Implements): 부모 인터페이스를 자식 클래스에서 재정의하여
구현하는 것을 말하며, 상속과는 달리 반드시 부모 클래스의 메서드를
재정의 해서 구현해야 한다.

상속은 abstract를 통해 상속을 하고 인터페이스는 implements를 통해 구현합니다.