[모던 자바] 디자인 패턴 소개 및 람다를 이용해 리팩터링 하기

디자인 패턴(design pattern)이란?

소프트웨어를 설계할 때 특정 맥락에서 발생하는 문제들을 해결할 수 있는 해결책을 유형별로 정리한 것이 디자인 패턴(design pattern)이다.

디자인 패턴은 공통적인 소프트웨어 문제를 설계할 때 재 사용할 수 있는, 검증된 청사진을 제공해주고, 공통의 언어를 만들어주며 팀원 사이의 의사 소통을 원활하게 해주는 아주 중요한 역할을 한다.

 

람다를 이용하면 이전에 디자인 패턴으로 해결하던 문제를 더 쉽고 간단하게 해결할 수 있다.

또한 람다 표현식으로 기존의 많은 객체지향 디자인 패턴을 제거하거나 간결하게 재구현할 수 있다.

하지만 모든 코드에서 람다 표현식을 사용하는건 적절하지 않다.

클래스에 상태가 있거나 여러 메서드를 정의하는 등 복잡하다면 기존 패턴을 사용하는 것이 유리할 수 있다.

 

아래 다섯 가지 패턴을 살펴보자.

• 전략(strategy)
• 템플릿 메서드(template method)
• 옵저버(observer)
• 의무 체인(chain of responsibility)
• 팩토리(factory)

---

전략(strategy) 패턴

전략 패턴은 한 유형의 알고리즘을 보유한 상태에서 런타임에 적절한 알고리즘을 선택하는 기법이다.

다양한 기준을 갖는 입력값을 검증하거나 다양한 파싱 방법을 사용하거나, 입력 형식을 설정하는 등 다양한 시나리오에 전략 패턴을 활용할 수 있다.

 

예를 들어 결제 로직(알고리즘)을 구현한다고 했을때 여러가지 전략(카드, 현금 결제)으로 나눠서 같은 알고리즘을 구현할 수 있다. 

public class BankAccount { // 은행 통장
    private int balance;
    public BankAccount(int balance) {
        this.balance = balance;
    }

    // 잔액 차감
    public void deductBalance(int amount) {
        System.out.println(amount + "원 차감!");
        this.balance -= amount;
    }
}

public interface Payment { // 결제
    void pay(BankAccount account, int amount);
}

public class CreditCardPay implements Payment { // 카드 결제
    @Override
    public void pay(BankAccount account, int amount) {
        account.deductBalance(amount);
        System.out.println(amount + "원 카드 결재 완료");
    }
}

public class AccountTransfer implements Payment { // 계좌 이체
    @Override
    public void pay(BankAccount account, int amount) {
        account.deductBalance(amount);
        System.out.println(amount + "원 계좌 이체 완료");
    }
}

public class PaymentSystem { // 결제 시스템
    private final Payment payment;
    public PaymentSystem(Payment payment) {
        this.payment = payment;
    }

    public void pay(BankAccount account, int amount) {
        this.payment.pay(account, amount);
    }
}

BankAccount myBankAccount = new BankAccount(1_000_000);
PaymentSystem paymentSystem = new PaymentSystem(new CreditCardPay());
paymentSystem.pay(myBankAccount, 100_000); 
// 100000원 차감!
// 100000원 카드 결재 완료

이런 경우 람다 표현식을 이용하면 전략 디자인 패턴에서 발생하는 자잘한 코드를 제거할 수 있다.

public interface Payment {
    void pay(int amount);
}

public class PaymentSystem {
    private final Payment payment;

    public PaymentSystem(Payment payment) {
        this.payment = payment;
    }

    public void pay(int amount) {
        this.payment.pay(amount);
    }
}
    
BankAccount myBankAccount = new BankAccount(1_000_000);
PaymentSystem paymentSystem = new PaymentSystem((account, amount) -> {
    account.deductBalance(amount);
    System.out.println(amount + "원 카드 결재 완료");
});
paymentSystem.pay(myBankAccount, 100_000);
// 100000원 차감!
// 100000원 카드 결재 완료

---

템플릿 메서드(template method) 패턴

알고리즘의 개요를 제시한 다음에 알고리즘의 일부를 고칠 수 있는 유연함을 제공해야 할 때 템플릿 메서드 디자인 패턴을 사용한다. 

간단히 말해, 템플릿 메서드는 "이 알고리즘을 사용하고 싶은데 그대로는 안 되고 조금 고쳐야 하는"상황에 적합하다.

 

먼저 추상화 크래스를 만들어 공통적인 부분을 구현 후 조금 다른 부분만 추상화 메서드를 생성해 상속받은 클래스에서 구현하도록 한다.

public abstract class PaymentSystem {
    public void pay(BankAccount account, int amount) {
        account.deductBalance(amount);
    }
    abstract void payProcess(int amount);
}

public class CreditCardPaymentSystem extends PaymentSystem {
    @Override
    void payProcess(int amount) {
        System.out.println(amount + "원 카드 결재 완료");
    }
}

BankAccount myBankAccount = new BankAccount(1_000_000);
PaymentSystem paymentSystem = new CreditCardPaymentSystem();
paymentSystem.pay(myBankAccount, 100_000);
// 100000원 차감!
// 100000원 카드 결재 완료

마찬가지로 람다를 이용하면 더욱 간단하게 구현할 수 있다.

위 예제에서 payProcess의 시그니처와 일치하도록 Consumer<Integer> 형식을 갖는 두 번째 인수를 추가한 후 

추상화 클래스를 직접 상속받지 않고 직접 람다 표현식을 전달해서 다양한 동작을 실행할 수 있다.

public class PaymentSystem {
    public void pay(BankAccount account, int amount, Consumer<Integer> payProcess) {
        account.deductBalance(amount);
        payProcess.accept(amount);
    }
}


BankAccount myBankAccount = new BankAccount(1_000_000);
new PaymentSystem().pay(
    myBankAccount, 
    100_000, 
    (amount) -> System.out.println(amount + "원 카드 결재 완료")
);
// 100000원 차감!
// 100000원 카드 결재 완료

전략 패턴과 마찬가지로 패턴에서 발생하는 자잘한 코드를 제거할 수 있다.

---

옵저버(observer) 패턴

어떤 이벤트가 발생했을 때 한 객체(주제)가 다른 객체 리스트(옵저버)에 자동으로 알림을 보내야 하는 상황에서 옵저버 디자인 패턴을 사용한다.

 

예를 들어 여러 친구들에게 한번에 편지를 보낸다고 가정해보자.

우선 다양한 옵저버를 그룹화할 인터페이스가 필요하다.

interface LetterObserver {
    void send(String contents);
}

class Friend_A implements LetterObserver {
    @Override
    public void send(String contents) {
        System.out.println("To. Friend_A : " + contents);
    }
}

class Friend_B implements LetterObserver {
    @Override
    public void send(String contents) {
        System.out.println("To. Friend_B : " + contents);
    }
}

그리고 주제도 구현해야 한다.

주제는 옵저버를 등록하는 메서드(registerObserver)와 편지를 보내는 메서드(sendObservers)를 구현해야 한다.

interface Subject {
    void registerObserver(Observer observer);
    void sendObservers(String content);
}

class Sender implements Subject {
    private final List<Observer> observerList = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void sendObservers(String content) {
        observerList.forEach(observer -> observer.send(content));
    }
}

주제(Sender)는 옵저버를 등록한 후 편지를 보내는 메서드를 통해 한번에 여러 친구에게 편지를 보낼 수 있다.

Sender sender = new Sender();
sender.registerObserver(new Friend_A());
sender.registerObserver(new Friend_B());
sender.sendObservers("이 편지는 영국으로 부터...");
// To. Friend_A : 이 편지는 영국으로 부터...
// To. Friend_B : 이 편지는 영국으로 부터...

 

자 그럼 이번엔 람다 표현식을 사용해 옵저버 패턴을 구현해보자.

옵저버는 함수형 인테페이스이기 때문에 람다 표현식을 사용할 수 있다.

Sender sender = new Sender();
sender.registerObserver((String content) -> {
    System.out.println("To. Friend_A : " + content);
});
sender.registerObserver((String content) -> {
    System.out.println("To. Friend_B : " + content);
});
sender.sendObservers("이 편지는 영국으로 부터...");

각각의 옵저버를 구현하는 클래스를 만들 필요가 없어졌다. 즉, 이번에도 역시 자잘한 코드를 제거했다.

---

의무 체인(chain of responsibility) 패턴

작업 처리 객체의 체인(동작 체인 등)을 만들 떄는 의무 체인 패턴을 사용한다.

한 객체가 어떤 작업을 처리한 다음에 다른 객체로 결과를 전달하고, 다른 객체도 해야 할 작업을 처리한 다음에 또 다른 객체로 전달하는 식이다.

public abstract class ProcessingObject<T> {
    protected ProcessingObject<T> successor;
    public void setSuccessor(ProcessingObject<T> successor) {
        this.successor = successor;
    }

    public T handler(T input) {
        T output = work(input);
        if (successor != null) return successor.handler(output);
        return output;
    }

    abstract protected T work(T input);
}

handler 메서드를 보면 해야할 작업을 처리(work)를 한 후 설정된 successor이 있으면 객체를 넘겨 successor에 handler메서드를 실행시킨다.   

 

그럼 자동차 공장에서 타이어 공장, 문(door) 공장을 거쳐 자동차가 만들어 진다고 가정하고 의무 채인 패턴을 적용해보자.

@Setter
public class Car {
    public boolean hasTire; // 타이어 조립 여부
    public boolean hasDoor; // 문 조립 여부
    public Car() {
    	this.hasTire = false;
        this.hasDoor = false;
    }
}

public class TireFactory extends ProcessingObject<Car> { // 타이어 조립 공장
    @Override
    protected Car work(Car car) {
        car.setHasTire(true);
        return car;
    }
}

public class DoorFactory extends ProcessingObject<Car> { // 문 조립 공장
    @Override
    protected Car work(Car car) {
        car.setHasDoor(true);
        return car;
    }
}


ProcessingObject<Car> factory1 = new TireFactory();
ProcessingObject<Car> factory2 = new DoorFactory();
factory1.setSuccessor(factory2);
Car car = factory1.handler(new Car());
// Car{hasTire=true, hasDoor=true}

이렇게 factory1과 factory2를 연결해서 작업 체인을 만들 수 있다.

이 방식은 함수 체인(함수 조합) 방식으로 람다 표현식을 조합하면 의무 체인 페턴과 같은 방식으로 사용할 수 있다.

Function<Car, Car> factory1 = (Car car) -> { car.setHasTire(true); return car; };
Function<Car, Car> factory2 = (Car car) -> { car.setHasDoor(true); return car; };
Function<Car, Car> pipeline = factory1.andThen(factory2);
Car car = pipeline.apply(new Car());
// Car{hasTire=true, hasDoor=true}

---

팩토리(factory) 패턴

인스턴스화 로직을 클라이언트에 노출하지 않고 객체를 만들 때 팩토리 디자인 패턴을 사용한다.

예를 들어 자동차를 만드는 공장이 있는데 그 공장에서 여러가지 유형 별로 자동차를 만들 수 있다고 생각해보자.

public class Car {
    private String name;
    private CarType type;
    public Car(String name, CarType type) {
        this.name = name;
        this.type = type;
    }
}

public class SmallCar extends Car {
    public SmallCar(String name) {
        super(name, CarType.SMALL);
    }
}

public class SedanCar extends Car {
    public SedanCar(String name) {
        super(name, CarType.SEDAN);
    }
}

public class SuvCar extends Car {
    public SuvCar(String name) {
        super(name, CarType.SUV);
    }
}

경차, 세단, SUV 종류의 클래스가 Car 클래스를 상속받고 있다.

이제 자동자를 만드는 팩토리를 생성해서 사용해보자.

public class CarFactory {
    public Car createCar(CarType carType) {
        switch (carType) {
            case SMALL:
                return new SmallCar("모닝");
            case SEDAN:
                return new SedanCar("아반테");
            case SUV:
                return new SuvCar("투싼");
            default:
                return null;
        }
    }
}

CarFactory carFactory = new CarFactory();
Car car = carFactory.createCar(CarType.SUV);
// Car{name='투싼', type=SUV}

생성자와 설정을 외부로 노출하지 않음으로써 클라이언트가 단순하게 인스턴스를 생산할 수 있다.

그럼 이 코드를 람다 표현식을 사용해서 구현해보자.

public class CarFactory {
    private final Map<CarType, Supplier<Car>> map = Map.ofEntries(
        Map.entry(CarType.SMALL, () -> new SmallCar("모닝")),
        Map.entry(CarType.SEDAN, () -> new SedanCar("아반테")),
        Map.entry(CarType.SUV, () -> new SuvCar("투싼"))
    );

    public Car createCar(CarType carType) {
        Supplier<Car> supplier = map.get(carType);
        if (supplier != null) return supplier.get();
        throw new IllegalArgumentException("No Such Car type");
    }
}

CarFactory carFactory = new CarFactory();
Car car = carFactory.createCar(CarType.SUV);
// Car{name='투싼', type=SUV}

 Switch문을 사용해 분기를 태웟던 것과 달리 Map에 Supplier 함수형 인터페이스로 구현하였다.