Bridge (ontwerppatroon)

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken
Klassediagram van het patroon

Het bridge patroon is een ontwerppatroon gebruikt in de software engineering.

De bedoeling van het bridge patroon is om de abstractie en de implementatie los te koppelen van elkaar zodanig dat de twee onafhankelijk van elkaar kunnen variëren.

"decouple an abstraction from its implementation so that the two can vary independently" [1]

De bridge maakt gebruik van inkapseling, aggregatie, en kan gebruik maken van overerving om de afzonderlijke taken in verschillende klassen onder te brengen. Het patroon is bruikbaar wanneer beide klassen veel veranderen. De klasse zelf kan gezien worden als een implementatie en wat de klasse kan doen als een abstractie.

Een variant hierop is dat de implementatie nog meer ontkoppeld wordt door aanwezigheid van de implementatie uit te stellen tot het punt waar de abstractie wordt gebruikt.

Code voorbeelden[bewerken]

Ruby[bewerken]

class Abstraction
  def initialize(implementor)
    @implementor = implementor
  end
 
  def operation
    raise 'Implementor object does not respond to the operation method' unless @implementor.respond_to?(:operation)
    @implementor.operation
  end
end
 
class RefinedAbstraction < Abstraction
  def operation
    puts 'Starting operation... '
    super
  end
end
 
class Implementor
  def operation
    puts 'Doing neccessary stuff'
  end
end
 
class ConcreteImplementorA < Implementor
  def operation
    super
    puts 'Doing additional stuff'
  end
end
 
class ConcreteImplementorB < Implementor
  def operation
    super
    puts 'Doing other additional stuff' 
  end
end
 
normal_with_a = Abstraction.new(ConcreteImplementorA.new)
normal_with_a.operation
# Doing neccessary stuff
# Doing additional stuff
 
normal_with_b = Abstraction.new(ConcreteImplementorB.new)
normal_with_b.operation
# Doing neccessary stuff
# Doing other additional stuff
 
refined_with_a = RefinedAbstraction.new(ConcreteImplementorA.new)
refined_with_a.operation
# Starting operation...
# Doing neccessary stuff
# Doing additional stuff
 
refined_with_b = RefinedAbstraction.new(ConcreteImplementorB.new)
refined_with_b.operation
# Starting operation...
# Doing neccessary stuff
# Doing other additional stuff

Java[bewerken]

The following Java (SE 6) program illustrates the 'shape' example given above and will output:

API1.circle at 1.000000:2.000000 radius 7.500000
API2.circle at 5.000000:7.000000 radius 27.500000
/** "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();
       }
   }
}

Scala[bewerken]

Een Scala implementatie van de Java uitbeeldingsvoorbeeld met dezelfde gegevens.

  /** "Implementor" */
  trait DrawingAPI {
    def drawCircle(x:Double, y:Double, radius:Double)
  }
 
  /** "ConcreteImplementor" 1/2 */
  class DrawingAPI1 extends DrawingAPI {
    def drawCircle(x:Double, y:Double, radius:Double) {
      printf("API1.circle at %f:%f radius %f\n", x, y, radius)
    }
  }
 
  /** "ConcreteImplementor" 2/2 */
  class DrawingAPI2 extends DrawingAPI {
    def drawCircle(x:Double, y:Double, radius:Double) {
      printf("API2.circle at %f:%f radius %f\n", x, y, radius)
    }
  }
 
  /** "Abstraction" */
  trait Shape {
     def draw()                             // low-level
     def resizeByPercentage(pct:Double)     // high-level
  }
 
  /** "Refined Abstraction" */
  class CircleShape(var x:Double, var y:Double,
    var radius:Double, val drawingAPI:DrawingAPI) extends Shape {
 
    // low-level i.e. Implementation specific
    def draw() = drawingAPI.drawCircle(x, y, radius)
 
    // high-level i.e. Abstraction specific
    def resizeByPercentage(pct:Double) = radius *= pct
  }
 
  /** "Client" */
  val shapes = List(
    new CircleShape(1, 2, 3, new DrawingAPI1),
    new CircleShape(5, 7, 11, new DrawingAPI2)
  )
 
  shapes foreach { shape =>
    shape.resizeByPercentage(2.5)
    shape.draw()
  }

C++[bewerken]

Here, the DrawingAPI Implementor follows the Class Adapter Pattern.

#include <iostream>
 
/** "Implementor" */
class DrawingAPI {
public:
    virtual void drawCircle(double x, double y, double radius) = 0;
 
    virtual ~DrawingAPI() {
    }
};
 
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1: public DrawingAPI {
public:
    DrawingAPI1() {
    }
 
    virtual ~DrawingAPI1() {
    }
 
    void drawCircle(double x, double y, double radius) {
        printf("\nAPI1.circle at %f:%f radius %f\n", x, y, radius);
    }
};
 
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2: public DrawingAPI {
public:
    DrawingAPI2() {
    }
 
    virtual ~DrawingAPI2() {
    }
 
    void drawCircle(double x, double y, double radius) {
        printf("\nAPI2.circle at %f:%f radius %f\n", x, y, radius);
    }
};
 
// Note: this example does not follow the "structure" specified above.
// In particular, that this class "maintains the Implementor reference"
/** "Abstraction" */
class Shape {
public:
    virtual void draw()= 0; // low-level
    virtual void resizeByPercentage(double pct) = 0; // high-level
    virtual ~Shape() {
    }
};
 
/** "Refined Abstraction" */
class CircleShape: public Shape {
public:
    CircleShape(double x, double y, double radius, DrawingAPI& drawingAPI) :
        x(x), y(y), radius(radius), drawingAPI(drawingAPI) {
    }
 
    virtual ~CircleShape() {
    }
 
    // low-level i.e. Implementation specific
    void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
    // high-level i.e. Abstraction specific
    void resizeByPercentage(double pct) {
        radius *= pct;
    }
private:
    double x, y, radius;
    DrawingAPI& drawingAPI;
};
 
int main(int argc, char* argv[]) {
    DrawingAPI1 api1;
    DrawingAPI2 api2;
 
    CircleShape c1(1, 2, 3, api1);
    CircleShape c2(5, 7, 11, api2);
 
    Shape* shapes[2];
    shapes[0] = &c1;
    shapes[1] = &c2;
 
    shapes[0]->resizeByPercentage(2.5);
    shapes[0]->draw();
    shapes[1]->resizeByPercentage(2.5);
    shapes[1]->draw();
 
    return 0;
}

C#[bewerken]

using System;
 
namespace Bridge
{
    class Program
    {
        interface IDrawingApi
        {
            void DrawCircle(double x, double y, double radius);
        }
 
        class DrawingApi1 : IDrawingApi
        {
            public void DrawCircle(double x, double y, double radius)
            {
                Console.WriteLine("API1 circle {0} {1}, r: {2}", x, y, radius);
            }
        }
 
        class DrawingApi2 : IDrawingApi
        {
            public void DrawCircle(double x, double y, double radius)
            {
                Console.WriteLine("API2 circle {0} {1}, r: {2}", x, y, radius);
            }
        }
 
        interface Shape
        {
            void Draw();
            void ResizeByPercentage(double p);
        }
 
        class CircleShape : Shape
        {
            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;
            }
 
            public void Draw()
            {
                drawingApi.DrawCircle(x, y, radius);
            }
 
            public void ResizeByPercentage(double p)
            {
                radius *= p;
            }
        }
 
        static void Main(string[] args)
        {
            Shape[] shapes = new Shape[]{
                new CircleShape(1,2,3, new DrawingApi1()),
                new CircleShape(5,7,11, new DrawingApi2())
            };
            foreach (var s in shapes)
            {
                s.ResizeByPercentage(2.5);
                s.Draw();
            }
        }
    }
}

D[bewerken]

import std.stdio;
 
/** "Implementor" */
interface DrawingAPI {
    void drawCircle(double x, double y, double radius);
}
 
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1: DrawingAPI {
    void drawCircle(double x, double y, double radius) {
        writefln("\nAPI1.circle at %f:%f radius %f", x, y, radius);
    }
}
 
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2: DrawingAPI {
    void drawCircle(double x, double y, double radius) {
        writefln("\nAPI2.circle at %f:%f radius %f", x, y, radius);
    }
}
 
/** "Abstraction" */
interface Shape {
    void draw(); // low-level
    void resizeByPercentage(double pct); // high-level
}
 
/** "Refined Abstraction" */
class CircleShape: Shape {
    this(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
    void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
    // high-level i.e. Abstraction specific
    void resizeByPercentage(double pct) {
        radius *= pct;
    }
private:
    double x, y, radius;
    DrawingAPI drawingAPI;
}
 
int main(string[] argv) {
    auto api1 = new DrawingAPI1();
    auto api2 = new DrawingAPI2();
 
    auto c1 = new CircleShape(1, 2, 3, api1);
    auto c2 = new CircleShape(5, 7, 11, api2);
 
    Shape[4] shapes;
    shapes[0] = c1;
    shapes[1] = c2;
 
    shapes[0].resizeByPercentage(2.5);
    shapes[0].draw();
    shapes[1].resizeByPercentage(2.5);
    shapes[1].draw();
 
    return 0;
}

Python[bewerken]

# Implementor
class drawing_api:
    def draw_circle(self, x, y, radius):
        raise NotImplementedError('draw_circle')
 
# ConcreteImplementor 1/2
class drawing_api1(drawing_api):
    def draw_circle(self, x, y, radius):
        print 'API1.circle at %f:%f radius %f' % (x, y, radius)
 
# ConcreteImplementor 2/2
class drawing_api2(drawing_api):
    def draw_circle(self, x, y, radius):
        print 'API2.circle at %f:%f radius %f' % (x, y, radius)
 
# Abstraction
class Shape:
    def draw(self):
        raise NotImplementedError('draw')
 
    def resize_by_percentage(self, pct):
        raise NotImplementedError('resize_by_percentage')
 
# Refined Abstraction
class CircleShape(Shape):
    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
 
# Client
if __name__ == '__main__':
    shapes = [
        CircleShape(1, 2, 3, drawing_api1()),
        CircleShape(5, 7, 11, drawing_api2())
    ]
 
    for shape in shapes:
        shape.resize_by_percentage(2.5)
        shape.draw()

Perl[bewerken]

Note: This example uses the MooseX::Declare module.

# Implementor
role Drawing::API {
    requires 'draw_circle';
}
 
# Concrete Implementor 1
class Drawing::API::1 with Drawing::API {
    method draw_circle(Num $x, Num $y, Num $r) {
        printf "API1.circle at %f:%f radius %f\n", $x, $y, $r;
    }
}
 
# Concrete Implementor 2
class Drawing::API::2 with Drawing::API {
    method draw_circle(Num $x, Num $y, Num $r) {
        printf "API2.circle at %f:%f radius %f\n", $x, $y, $r;
    }
}
 
# Abstraction
role Shape {
    requires qw( draw resize );
}
 
# Refined Abstraction
class Shape::Circle with Shape {
    has $_  => ( is => 'rw', isa  => 'Any' ) for qw( x y r );
    has api => ( is => 'ro', does => 'Drawing::API' );
 
    method draw() {
        $self->api->draw_circle( $self->x, $self->y, $self->r );
    }
 
    method resize(Num $percentage) {
        $self->{r} *= $percentage;
    }
}
 
my @shapes = (
    Shape::Circle->new( x=>1, y=>2, r=>3,  api => Drawing::API::1->new ),
    Shape::Circle->new( x=>5, y=>7, r=>11, api => Drawing::API::2->new ),
)
 
$_->resize( 2.5 ) and $_->draw for @shapes;

Zie ook[bewerken]

Referenties[bewerken]

  1. Gamma, E, Helm, R, Johnson, R, Vlissides, J: Design Patterns, page 151. Addison-Wesley, 1995

Externe links[bewerken]