[Design pattern] 2-3. 브릿지 패턴(Bridge pattern)

안녕하세요. 명월입니다.

이 글은 디자인 패턴의 브릿지 패턴(Bridge pattern)에 대한 글입니다.

브릿지 패턴이라는 것은 개념적으로 추상층의 처리와 구현부의 처리를 독립적으로 사용할 수 있게 하는 방법입니다. 쉽게 말해서 추상층, 즉 인터페이스에서 함수에 대한 처리에 대한 정의를 하면, 상속을 받은 구현부, 즉 클래스에서는 입력받은 인스턴스에 따라 다른 결과를 만들어 내는 구조입니다.

출처 - https://en.wikipedia.org/wiki/Bridge_pattern

#pragma once
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
// INode 인터페이스
class INode {
public:
  // 추상 함수
  virtual void print() = 0;
  virtual ~INode() { }
};
// IBridge 인터페이스
class IBridge {
public:
  // 추상 함수
  virtual void exec() = 0;
  virtual ~IBridge() { }
};
// INode 인터페이스를 상속받은 Node1 클래스
class Node1 : public INode {
public:
  // 함수 재정의
  virtual void print() {
    // 콘솔 출력
    cout << "Node1 - print" << endl;
  }
};
// INode 인터페이스를 상속받은 Node2 클래스
class Node2 : public INode {
public:
  // 함수 재정의
  virtual void print() {
    // 콘솔 출력
    cout << "Node2 - print" << endl;
  }
};
// IBridge 인터페이스를 상속받은 Bridge 클래스
class Bridge : public IBridge {
private:
  // 브릿지 패턴에 사용될 맴버 변수
  INode* node;
public:
  // 생성자, INode의 인스턴스를 받는다.
  Bridge(INode* node) {
    this->node = node;
  }
  // 실행
  virtual void exec() {
    // INode 인스턴스의 print 함수 실행
    this->node->print();
  }
  // 소멸자
  ~Bridge() {
    // 메모리 해제
    delete node;
  }
};
// 실행 함수
int main() {
  // Bridge 인스턴스 생성 (Node1 클래스의 인스턴스를 넣는다.)
  Bridge bridge1(new Node1());
  // 함수 실행
  bridge1.exec();
  // Bridge 인스턴스 생성 (Node2 클래스의 인스턴스를 넣는다.)
  Bridge bridge2(new Node2());
  // 함수 실행
  bridge2.exec();

  return 0;
}

위 결과를 보면 Bridge의 클래스에 어떤 인스턴스를 넣느냐에 결과가 달라집니다. 즉, Node1 인스턴스를 넣으면 Node1이 콘솔에 출력이 되고 Node2 인스턴스를 넣으면 Node2가 콘솔에 출력이 됩니다.

Bridge 클래스는 INode 클래스의 실행에 대한 정의를 구현하는 것이고 그 데이터 값에 따라 결과는 다르게 나오는 것입니다.

// INode 인터페이스
interface INode {
  // 추상 함수
  String output();
}
// IBridge 인터페이스
interface IBridge {
  // 추상 함수
  void print();
}
// INode 인터페이스를 상속받은 Node 클래스
class Node1 implements INode {
  // 함수 재정의
  public String output() {
    // 값 리턴
    return "Node1";
  }
}
// INode 인터페이스를 상속받은 Node 클래스
class Node2 implements INode {
  // 함수 재정의
  public String output() {
    // 값 리턴
    return "Node2";
  }
}
// IBridge 인터페이스를 상속받은 Bridge 클래스
class Bridge implements IBridge {
  // 브릿지 패턴에 사용될 맴버 변수
  private INode node;

  // 생성자, INode의 인스턴스를 받는다.
  public Bridge(INode node) {
    this.node = node;
  }

  // 함수 재정의
  public void print() {
    // 브릿지 패턴의 맴버 변수의 output 함수의 결과 값을 콘솔 출력
    System.out.println(this.node.output());
  }
}
public class Program {
  // 실행 함수
  public static void main(String[] args) {
    // Bridge 인스턴스 생성, Node1의 인스턴스를 넣는다.
    var bridge1 = new Bridge(new Node1());
    // print 함수 실행
    bridge1.print();
    // Bridge 인스턴스 생성, Node2의 인스턴스를 넣는다.
    var bridge2 = new Bridge(new Node2());
    // print 함수 실행
    bridge2.print();
  }
}

자바의 형태도 C++과 비슷한 구조입니다. 브릿지 패턴은 거의 규격화된 패턴이랄까? 다른 형식으로 응용할 만한 구조는 없네요..

제가 모르는 것일 수도 있습니다.

using System;
// Controller 인터페이스
public interface Controller
{
  // 추상 함수
  void Execute(Model model);
}
// Model 인터페이스
public interface Model
{
  // 추상 함수
  String GetData();
}
// MVC 형태의 프레임워크에서 Model 클래스(파라미터)
public class ParameterModel : Model
{
  // 맴버 변수
  private string data;
  // 생성자
  public ParameterModel(string data)
  {
    // 맴버 변수 데이터에 넣는다.
    this.data = data;
  }
  // 함수 재정의, 데이터 취득 함수
  public String GetData()
  {
    // data 리턴
    return this.data;
  }
}
// MVC 형태의 프레임워크에서 Controller 클래스
public class MainController : Controller
{
  // 함수 재정의, model를 받는다.
  public void Execute(Model model)
  {
    // 콘솔 출력, model의 데이터를 취득
    Console.WriteLine("Execute - " + model.GetData());
  }
}

class Program
{
  // 실행 함수
  static void Main(string[] args)
  {
    // Controller 인스턴스
    var controller = new MainController();
    // 웹 요청시의 파라미터 model 인스턴스
    var model = new ParameterModel("Hello world");
    // Controller 실행
    controller.Execute(model);
    // 아무 키나 누르시면 종료합니다.
    Console.WriteLine("Press any key...");
    Console.ReadKey();
  }
}

이 브릿지 패턴은 우리가 자주 사용하는 MVC 형태의 프레임워크에서 자주 보이는 패턴입니다.

Client(브라우져)로부터 요청이 오면 요청 파라미터로 Model 클래스로 인스턴스를 생성하고 Controller를 호출하여 실제 우리가 작성하는 구현부는 Controller의 Execute 함수입니다.

추상 부분은 다 프레임워크에 구현이 되어 있죠.

여기까지 디자인 패턴의 브릿지 패턴(Bridge pattern)에 대한 글이었습니다.

궁금한 점이나 잘못된 점이 있으면 댓글 부탁드립니다.