**브리지 패턴**(Bridge pattern)이란 구현부에서 추상층을 분리하여 각자 독립적으로 변형할 수 있게 하는 패턴이다.

구조
--

구조

코드 예
----

### 자바

```
/\*\* "Implementor" \*/
interface DrawingAPI
{
 public void drawCircle(double x, double y, double radius);
}

/\*\* "ConcreteImplementor" 1/2 \*/
class DrawingAPI1 implements DrawingAPI
{
 public void drawCircle(double x, double y, double radius)
 {
 System.out.printf("API1.circle at %f:%f radius %f\n", x, y, radius);
 }
}

/\*\* "ConcreteImplementor" 2/2 \*/
class DrawingAPI2 implements DrawingAPI
{
 public void drawCircle(double x, double y, double radius)
 {
 System.out.printf("API2.circle at %f:%f radius %f\n", x, y, radius);
 }
}

/\*\* "Abstraction" \*/
interface Shape
{
 public void draw(); // low-level
 public void resizeByPercentage(double pct); // high-level
}

/\*\* "Refined Abstraction" \*/
class CircleShape implements Shape
{
 private double x, y, radius;
 private DrawingAPI drawingAPI;
 public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI)
 {
 this.x = x; this.y = y; this.radius = radius;
 this.drawingAPI = drawingAPI;
 }

 // low-level i.e. Implementation specific
 public void draw()
 {
 drawingAPI.drawCircle(x, y, radius);
 }
 // high-level i.e. Abstraction specific
 public void resizeByPercentage(double pct)
 {
 radius \*= pct;
 }
}

/\*\* "Client" \*/
class BridgePattern {
 public static void main(String[] args)
 {
 Shape[] shapes = new Shape[2];
 shapes[0] = new CircleShape(1, 2, 3, new DrawingAPI1());
 shapes[1] = new CircleShape(5, 7, 11, new DrawingAPI2());

 for (Shape shape : shapes)
 {
 shape.resizeByPercentage(2.5);
 shape.draw();
 }
 }
}

```

###  C#

```
 using System;

 /\*\* "Implementor" \*/
 interface IDrawingAPI {
 void DrawCircle(double x, double y, double radius);
 }

 /\*\* "ConcreteImplementor" 1/2 \*/
 class DrawingAPI1 : IDrawingAPI {
 public void DrawCircle(double x, double y, double radius)
 {
 System.Console.WriteLine("API1.circle at {0}:{1} radius {2}", x, y, radius);
 }
 }

 /\*\* "ConcreteImplementor" 2/2 \*/
 class DrawingAPI2 : IDrawingAPI
 {
 public void DrawCircle(double x, double y, double radius)
 {
 System.Console.WriteLine("API2.circle at {0}:{1} radius {2}", x, y, radius);
 }
 }

 /\*\* "Abstraction" \*/
 interface IShape {
 void Draw(); // low-level (i.e. Implementation-specific)
 void ResizeByPercentage(double pct); // high-level (i.e. Abstraction-specific)
 }

 /\*\* "Refined Abstraction" \*/
 class CircleShape : IShape {
 private double x, y, radius;
 private IDrawingAPI drawingAPI;
 public CircleShape(double x, double y, double radius, IDrawingAPI drawingAPI)
 {
 this.x = x; this.y = y; this.radius = radius;
 this.drawingAPI = drawingAPI;
 }
 // low-level (i.e. Implementation-specific)
 public void Draw() { drawingAPI.DrawCircle(x, y, radius); }
 // high-level (i.e. Abstraction-specific)
 public void ResizeByPercentage(double pct) { radius \*= pct; }
 }

 /\*\* "Client" \*/
 class BridgePattern {
 public static void Main(string[] args) {
 IShape[] shapes = new IShape[2];
 shapes[0] = new CircleShape(1, 2, 3, new DrawingAPI1());
 shapes[1] = new CircleShape(5, 7, 11, new DrawingAPI2());

 foreach (IShape shape in shapes) {
 shape.ResizeByPercentage(2.5);
 shape.Draw();
 }
 }
 }

```

### C++

  
**출력 결과**| 
```
API1.circle at 1:2 7.5
API2.circle at 5:7 27.5

```
 |

```
#include <iostream>

using namespace std;

/\* Implementor\*/
class DrawingAPI {
 public:
 virtual void drawCircle(double x, double y, double radius) = 0;
 virtual ~DrawingAPI(){};
};

/\* Concrete ImplementorA\*/
class DrawingAPI1 : public DrawingAPI {
 public:
 void drawCircle(double x, double y, double radius) {
 cout << "API1.circle at "<< x << ":" << y << "" << radius << endl;
 }
};

/\* Concrete ImplementorB\*/
class DrawingAPI2 : public DrawingAPI {
public:
 void drawCircle(double x, double y, double radius) {
 cout << "API2.circle at "<< x << ":" << y << "" << radius << endl;
 }
};

/\* Abstraction\*/
class Shape {
 public:
 virtual ~Shape() {};
 virtual void draw() = 0;
 virtual void resizeByPercentage(double pct) = 0;
};

/\* Refined Abstraction\*/
class CircleShape : public Shape {
 public:
 CircleShape(double x, double y,double radius, DrawingAPI \*drawingAPI){
 m\_x = x;
 m\_y = y;
 m\_radius = radius;
 m\_drawingAPI = drawingAPI;
 }
 void draw() {
 m\_drawingAPI->drawCircle(m\_x,m\_y,m\_radius);
 }
 void resizeByPercentage(double pct) {
 m\_radius \*= pct;
 }
 private:
 double m\_x,m\_y,m\_radius;
 DrawingAPI \*m\_drawingAPI;
};

int main(void) {
 DrawingAPI1 dap1;
 DrawingAPI2 dap2;
 CircleShape circle1(1,2,3,&dap1);
 CircleShape circle2(5,7,11,&dap2);
 circle1.resizeByPercentage(2.5);
 circle2.resizeByPercentage(2.5);
 circle1.draw();
 circle2.draw();
 return 0;
}

```

### GO

```
package main

import (
 "fmt"
)

// Implementor
type DrawingAPI interface {
 drawCircle(float32, float32, float32)
}

// ConcreteImplementor 1/2
type DrawingAPI1 struct{}

func (d \*DrawingAPI1) drawCircle(x float32, y float32, radius float32) {
 fmt.Printf("API1.circle at %f:%f radius %f\n", x, y, radius)
}

// ConcreteImplementor 2/2
type DrawingAPI2 struct{}

func (d \*DrawingAPI2) drawCircle(x float32, y float32, radius float32) {
 fmt.Printf("API2.circle at %f:%f radius %f\n", x, y, radius)
}

// Abstraction
type Shape interface {
 draw()
 resizeByPercentage(float32)
}

// Refined Abstraction
type CircleShape struct {
 x, y, radius float32
 drawingAPI DrawingAPI
}

// Implementation specific
func (c \*CircleShape) draw() {
 c.drawingAPI.drawCircle(c.x, c.y, c.radius)
}

// Abstraction specific
func (c \*CircleShape) resizeByPercentage(pct float32) {
 c.radius \*= pct
}

// Client
func main() {
 shape1 := &CircleShape{1, 2, 3, &DrawingAPI1{}}
 shape1.resizeByPercentage(2.5)
 shape1.draw()

 shape2 := &CircleShape{5, 7, 11, &DrawingAPI2{}}
 shape2.resizeByPercentage(2)
 shape2.draw()
}

```

### Python3

```
# Implementor
class DrawingAPI:
    def draw\_circle(self, x, y, radius):
        pass

# ConcreteImplementor 1/2
class DrawingAPI1(DrawingAPI):
    def draw\_circle(self, x, y, radius):
        print(f"API1.circle at {x}:{y} {radius}")

# ConcreteImplementor 2/2
class DrawingAPI2(DrawingAPI):
    def draw\_circle(self, x, y, radius):
        print(f"API2.circle at {x}:{y} {radius}")

# Abstraction
class Shape:
    def draw(self):
        pass
    def resize\_by\_percentage(pct):
        pass

# Refined Abstraction
class CircleShape(Shape):
    x = 0
    y = 0
    radius = 0
    drawing\_api = None

    def \_\_init\_\_(self, x, y, radius, drawing\_api):
        self.x = x
        self.y = y
        self.radius = radius
        self.drawing\_api = drawing\_api

    def draw(self):
        self.drawing\_api.draw\_circle(self.x, self.y, self.radius)

    def resize\_by\_percentage(self, pct):
        self.radius \*= pct

def main():
    dap1 = DrawingAPI1()
    dap2 = DrawingAPI2()
    circle1 = CircleShape(1, 2, 3, dap1)
    circle2 = CircleShape(5, 7, 11, dap2)
    circle1.resize\_by\_percentage(2.5)
    circle2.resize\_by\_percentage(2.5)
    circle1.draw()
    circle2.draw()

if \_\_name\_\_ == "\_\_main\_\_":
    main()

```

| * v
* t
* e
소프트웨어 디자인 패턴 |
| --- |
| 4인방(Gang of four) 패턴 | 

|  |  |
| --- | --- |
| 생성 패턴 | 
* 추상 팩토리
* 빌더
* 팩토리 메소드
* 프로토타입
* 싱글턴

 |
| 구조 패턴 | 
* 어댑터
* 브리지
* 컴포지트
* 데코레이터
* 퍼사드
* 플라이웨이트
* 프록시

 |
| 동작 패턴 | 
* 책임 연쇄
* 커맨드
* 인터프리터
* 반복자
* 중재자
* 메멘토
* 옵서버
* 상태
* 전략
* 템플릿 메소드
* 비지터

 |

 |
| 동시성 패턴 | 
* 액티브 오브젝트
* Balking
* 바인딩 속성
* 더블 체크 라킹
* 이벤트 기반 비동기
* 가디드 서스펜션
* 조인
* 락
* 모니터 (동기화)
* 프로액터
* 반응자 패턴
* 읽기 쓰기 락
* 스케줄링 (컴퓨팅)
* 스레드 풀
* 스레드 로컬 스토리지

 |
| 아키텍처 패턴 | 
* 프론트 컨트롤러
* 인터셉터
* 모델-뷰-컨트롤러
* 모델-뷰-프리젠터
* 모델-뷰-뷰모델
* 다층 구조
* 사양
* 발행-구독 모델
* 네이키드 오브젝트
* 서비스 로케이터
* 액티브 레코드
* 아이덴티티 맵
* 데이터 접근 객체
* 데이터 전송 객체
* ADR
* 제어 반전

 |
| 기타 패턴 | 
* 블랙보드
* 비즈니스 델리게이트
* 컴포지트 엔티티
* 의존성 주입
* 인터셉터 필터
* 지연된 로딩
* 모의 객체
* 널 객체
* 객체 풀
* 서번트
* 트윈
* 타입 터널
* 메서드 체이닝

 |
| 관련 도서 | 
* 《디자인 패턴》
* 《Enterprise Integration Patterns》

 |
| 인물 | 
* 크리스토퍼 알렉산더
* 에릭 감마
* 랄프 존슨
* John Vlissides
* 그래디 부치
* 켄트 벡
* 워드 커닝햄
* 마틴 파울러
* 로버트 마틴
* Jim Coplien
* 더글라스 슈미트
* 린다 라이징

 |
| 커뮤니티 | 
* 힐사이드 그룹
* 포틀랜드 패턴 리포지토리

 |