模式十四（桥梁模式）

桥梁模式是一个非常有用的模式，也是比较复杂的一个模式，熟悉这个模式对于理解面向对象的设计原则，包括"开--闭"原则以及组合/聚集复用原则都很有帮助，理解好这两个原则，有助于形成正确的设计思想和培养良好的设计风格。

 

桥梁模式的用意

在提出桥梁模式的时候指出，桥梁模式的用意是“将抽象化与实现化脱耦，使得二者可以独立地变化”，这句话有三个关键词，也就是抽象化，实现化和脱耦。

 

抽象化

存在于多个实现中的共同的概念性联系，就是抽象化，作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待。

 

实现化

抽象化给出的具体实现，就是实现化。

 

脱耦

所谓耦合，就是两个实体的行为的某种强关联，而将他们的强关联去掉，就是耦合的解脱，或称脱耦，在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是他们之间的强关联改换成弱关联。

 

将两个角色之间的继承关系改为聚合关系，就是将他们之间的强关联改换成弱关联，因此，桥梁模式中的所谓脱耦，就是指在一个软件系统的抽象化合实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以相对独立地变化，这就是桥梁模式的用意。

 

二，桥梁模式的结构

桥梁模式是对象的结构模式，又称为柄体模式或接口模式。

这个系统含有两个等级结构，也就是：

由抽象化角色和修正抽象化角色组成的抽象化等级结构。

由实现化角色和两个具体实现化角色所组成的实现化等级结构。

桥梁模式所涉及的角色有：

抽象化角色：抽象化给出的定义，并保存一个对实现化对象的引用。

修正抽象化角色：扩展抽象化角色，改变和修正父类对抽象化的定义。

实现化角色：这个角色给出实现化角色的接口，但不给出具体的实现，必须指出的是，这个接口不一定和抽象化角色的接口定义相同，实际上，这两个接口可以非常不一样，实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层的操作。

具体实现化角色：这个角色给出实现化角色接口的具体实现。

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple_Factory
{
    /// <summary>
    /// 实现化角色
    /// </summary>
    abstract class Implementor
    {
        abstract public void Operation();
    }

    /// <summary>
    /// 抽象化给出的定义
    /// 并保存一个对实现化对象的引用
    /// </summary>
    class Abstraction
    {
        protected Implementor implementor;

        public Implementor implementor
        {
            set
            {
                implementor = value;
            }
        }

        virtual public void Operation()
        {
            implementor.Operation();
        }
    }

    /// <summary>
    /// 修正抽象化角色
    /// </summary>
    class RefinedAbstraction : Abstraction
    {
        public override void Operation()
        {
            implementor.Operation();
        }
    }

    /// <summary>
    /// 具体实现化角色
    /// </summary>
    class ConcreateImplementorA:Implementor
    {
        public override void Operation()
        {
            Console.WriteLine("ConcreateImplementorA Operation");
        }
    }

    class ConcrateImplementorB:Implementor
    {
        public override void Operation()
        {
            Console.WriteLine("ConcreateImplementorB Operation");
        }
    }

    class Bridge_Pattern
    {
        public static void Main(string[] args)
        {
            Abstraction abstraction = new RefinedAbstraction();
            abstraction.implementor = new ConcreateImplementorA();
            abstraction.Operation();

            abstraction.implementor = new ConcrateImplementorB();
            abstraction.Operation();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace Simple_Factory
{
    /// <summary>
    /// 业务对象通过Bridge模式与数据对象解耦
    /// </summary>

    abstract class DataObject
    {
        abstract public void NextRecord();
        abstract public void PriorRecord();
        abstract public void NewRecord(string name);
        abstract public void DeleteRecord(string name);
        abstract public void ShowRecord();
        abstract public void ShowAllRecords();
    }

    class BusinessObject
    {
        private DataObject dataObject;

        internal DataObject DataObject
        {
            get { return dataObject; }
            set { dataObject = value; }
        }
        protected string group;

        public BusinessObject(string group)
        {
            this.group = group;
        }

        virtual public void Next()
        {
            dataObject.NextRecord();
        }

        virtual public void Prior()
        {
            dataObject.PriorRecord();
        }

        virtual public void New(string name)
        {
            dataObject.NewRecord(name);
        }

        virtual public void Delete(string name)
        {
            dataObject.DeleteRecord(name);
        }

        virtual public void Show()
        {
            dataObject.ShowRecord();
        }

        virtual public void ShowAll()
        {
            Console.WriteLine("Customer Group:{0}",group);
            dataObject.ShowAllRecords();
        }
    }

    class CustomersBusinessObject : BusinessObject
    {
        public CustomersBusinessObject(string group) : base(group) { }

        public override void ShowAll()
        {
            base.ShowAll();
        }
    }

    class CustomersDataObject:DataObject
    {
        private ArrayList customers = new ArrayList();
        private int current = 0;

        public CustomersDataObject()
        {
            customers.Add("Jim Jones");
            customers.Add("Samual Jackson");
            customers.Add("Allen Good");
            customers.Add("Ann Stills");
            customers.Add("Lisa Giolani");
        }

        public override void NextRecord()
        {
            if (current <= customers.Count - 1)
                current++;
        }

        public override void PriorRecord()
        {
            if (current > 0)
                current--;
        }

        public override void NewRecord(string name)
        {
            customers.Add(name);
        }

        public override void DeleteRecord(string name)
        {
            customers.Remove(name);
        }

        public override void ShowRecord()
        {
            Console.WriteLine(customers[current]);
        }

        public override void ShowAllRecords()
        {
            foreach (string name in customers)
                Console.WriteLine(" "+name);
        }
    }

    class Bridge_PatternTwo
    {
        public static void Main()
        {
            CustomersBusinessObject customers = new CustomersBusinessObject("Chicago");

            customers.DataObject = new CustomersDataObject();
            customers.Show();
            customers.Next();
            customers.Show();
            customers.Next();
            customers.New("Henry Velasquez");

            customers.ShowAll();
        }
    }
}

如果一个系统需要再构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系；

设计要求实现化角色的热河改变不应当影响客户端，或者说实现实现化角色的改变对客户端是完全透明的；

一个构件有多于一个的抽象化角色和实现化角色，系统需要他们之间进行动态耦合；

虽然在系统中使用继承是没问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者