когда гибкость важнее всего?

Перечень паттернов можно найти здесь.

Что такое паттерн проектирования Bridge?

Привет! Вы когда-нибудь задумывались о том, как сделать свой код по-настоящему универсальным и легко адаптируемым к изменениям? Ну, знаете, чтобы не переписывать полпрограммы каждый раз, когда нужно добавить новую функцию или поддержку нового оборудования. Вот тут-то и приходят на помощь паттерны проектирования! И сегодня мы поговорим об одном из самых интересных – Bridge (Мост).

Bridge – это как… ну, представьте себе пульт дистанционного управления от телевизора. Пульт управляет разными устройствами: телевизором, DVD-плеером, звуковой системой. Сам пульт не знает, что именно он контролирует, ему важно лишь то, какие команды он отправляет. Вот и Bridge – это способ разделить абстракцию (пульт) и реализацию (устройства), чтобы они могли развиваться независимо друг от друга. Звучит сложно? Сейчас разберемся!


Зачем вообще нужен этот Bridge?

По правде говоря, в простых проектах без него можно обойтись. Но когда у вас сложная система с множеством классов, которые зависят друг от друга, Bridge становится настоящим спасением. Он помогает избежать жесткой связи между классами, что делает код более гибким, расширяемым и удобным для тестирования.

Представьте себе ситуацию: вы разрабатываете графический редактор. У вас есть разные фигуры – круги, квадраты, треугольники. И у вас есть разные способы рендеринга этих фигур – OpenGL, DirectX, Vulkan. Если бы все эти классы были жестко связаны друг с другом, то добавление нового способа рендеринга потребовало бы изменения всех классов фигур. А это… ну, не очень приятно, скажем честно.

Bridge позволяет решить эту проблему, разделив абстракцию фигуры и реализацию рендеринга. Теперь вы можете добавлять новые способы рендеринга без изменения классов фигур, и наоборот. Круто, да?


Как же он работает?

В основе Bridge лежит идея разделения интерфейса (абстракции) от реализации. У нас есть два основных типа классов:

  • Abstraction: Определяет высокоуровневый интерфейс для работы с объектами.
  • Implementor: Реализует конкретные способы выполнения операций, которые использует Abstraction.

Abstraction содержит ссылку на Implementor и делегирует ему выполнение реальной работы. Это позволяет менять реализацию “на лету”, не затрагивая абстракцию.

А знаете что? Bridge – это один из поведенческих паттернов проектирования. Он относится к группе паттернов, которые определяют взаимодействие между объектами. Другие популярные поведенческие паттерны включают Observer, Strategy и Template Method. Но об этом в другой раз!


Примеры кода: посмотрим на практике

Давайте посмотрим, как Bridge выглядит в коде на разных языках программирования.

Swift

protocol Renderer {
    func render(shape: Shape)
}

class OpenGLRenderer: Renderer {
    func render(shape: Shape) {
        print("Rendering shape using OpenGL")
    }
}

class DirectXRenderer: Renderer {
    func render(shape: Shape) {
        print("Rendering shape using DirectX")
    }
}

protocol Shape {
    var renderer: Renderer { get set }
    func draw()
}

class Circle: Shape {
    var renderer: Renderer = OpenGLRenderer() // По умолчанию используем OpenGL
    func draw() {
        renderer.render(shape: self)
    }
}

let circle = Circle()
circle.draw() // Rendering shape using OpenGL

circle.renderer = DirectXRenderer() // Меняем способ рендеринга
circle.draw() // Rendering shape using DirectX

В этом примере Shape – это абстракция, а OpenGLRenderer и DirectXRenderer – реализации. Мы можем менять реализацию рендеринга для каждого объекта фигуры без изменения его кода.

Java

interface Renderer {
    void render(Shape shape);
}

class OpenGLRenderer implements Renderer {
    @Override
    public void render(Shape shape) {
        System.out.println("Rendering shape using OpenGL");
    }
}

class DirectXRenderer implements Renderer {
    @Override
    public void render(Shape shape) {
        System.out.println("Rendering shape using DirectX");
    }
}

interface Shape {
    void draw();
    void setRenderer(Renderer renderer);
}

class Circle implements Shape {
    private Renderer renderer = new OpenGLRenderer();

    @Override
    public void draw() {
        renderer.render(this);
    }

    @Override
    public void setRenderer(Renderer renderer) {
        this.renderer = renderer;
    }
}

Circle circle = new Circle();
circle.draw(); // Rendering shape using OpenGL

circle.setRenderer(new DirectXRenderer());
circle.draw(); // Rendering shape using DirectX

Здесь логика аналогична Swift: Shape – абстракция, а OpenGLRenderer и DirectXRenderer – реализации.

JavaScript

class Renderer {
  render(shape) {
    throw new Error("Method 'render()' must be implemented.");
  }
}

class OpenGLRenderer extends Renderer {
  render(shape) {
    console.log("Rendering shape using OpenGL");
  }
}

class DirectXRenderer extends Renderer {
  render(shape) {
    console.log("Rendering shape using DirectX");
  }
}

class Shape {
  constructor() {
    this.renderer = new OpenGLRenderer(); // По умолчанию используем OpenGL
  }

  draw() {
    this.renderer.render(this);
  }

  setRenderer(renderer) {
    this.renderer = renderer;
  }
}

const circle = new Shape();
circle.draw(); // Rendering shape using OpenGL

circle.setRenderer(new DirectXRenderer());
circle.draw(); // Rendering shape using DirectX

В JavaScript тоже все понятно: Shape – абстракция, а OpenGLRenderer и DirectXRenderer – реализации.

Python

from abc import ABC, abstractmethod

class Renderer(ABC):
    @abstractmethod
    def render(self, shape):
        pass

class OpenGLRenderer(Renderer):
    def render(self, shape):
        print("Rendering shape using OpenGL")

class DirectXRenderer(Renderer):
    def render(self, shape):
        print("Rendering shape using DirectX")

class Shape:
    def __init__(self):
        self.renderer = OpenGLRenderer() # По умолчанию используем OpenGL

    def draw(self):
        self.renderer.render(self)

    def set_renderer(self, renderer):
        self.renderer = renderer

circle = Shape()
circle.draw() # Rendering shape using OpenGL

circle.set_renderer(DirectXRenderer())
circle.draw() # Rendering shape using DirectX

В Python мы используем абстрактные классы (ABC) для определения интерфейса Renderer.


Подведём итоги?

Bridge – это мощный паттерн проектирования, который позволяет разделить абстракцию и реализацию, делая код более гибким, расширяемым и удобным для тестирования. Он особенно полезен в сложных системах с множеством классов, которые зависят друг от друга.

Конечно, как и любой паттерн, Bridge не является серебряной пулей. Его использование может усложнить код, если он применяется без необходимости. Но если вы столкнулись с проблемой жесткой связи между классами, то стоит обратить внимание на этот паттерн. В чём же дело? Попробуйте применить его в своем следующем проекте! Уверен, вам понравится результат.


Будет интересно

Nikulux в Telegram

Статьи, архивы материалов, скоро ещё и мемы

(= Подписаться =)