设计模式之桥接 Bridge Pattern

桥接模式分离Interface class与 Implement class。另外如果有多个维度的功能，将这多个维度的功能分别拆分成独立的Implement class，在Interface class里面将他们组合起来。这其中，可能Interface class就是其中一个Implement class，依据实际的设计的抽象划分及实现。

场景举例

现需要提供大中小3种型号的画笔，能够绘制5种不同颜色，如果使用蜡笔，我们需要准备3*5=15支蜡笔，也就是说必须准备15个具体的蜡笔类。而如果使用毛笔的话，只需要3种型号的毛笔，外加5个颜料盒，用3+5=8个类就可以实现15支蜡笔的功能。本实例使用桥接模式来模拟毛笔的使用过程。

上图中，我们将整个功能拆分两个独立的Implement class：Pen 以及 Color，两个维度的Implement class可以独立的继承及组合。
在这个例子中，省略了Interface class，由Pen充当Interface class，即对外部模块提供调用接口。

//抽象类
public abstract class Pen
{
    protected Color color;
    public void setColor(Color color)
    {
        this.color=color;
    }
    public abstract void draw(String name);
} 

//扩充抽象类
public class SmallPen extends Pen
{
    public void draw(String name)
    {
        String penType="小号毛笔绘制";
        this.color.bepaint(penType,name);            
    }    
}

//扩充抽象类
public class MiddlePen extends Pen
{
    public void draw(String name)
    {
        String penType="中号毛笔绘制";
        this.color.bepaint(penType,name);            
    }    
}

//扩充抽象类
public class BigPen extends Pen
{
    public void draw(String name)
    {
        String penType="大号毛笔绘制";
        this.color.bepaint(penType,name);            
    }    
}

//实现类接口
public interface Color
{
    void bepaint(String penType,String name);
}

//扩充实现类
public class Red implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "红色的"+ name + ".");
    }
}

//扩充实现类
public class Green implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "绿色的"+ name + ".");
    }
}

//扩充实现类
public class Blue implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "蓝色的"+ name + ".");
    }
}

//扩充实现类
public class White implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "白色的"+ name + ".");
    }
}

//扩充实现类
public class Black implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "黑色的"+ name + ".");
    }
}

//配置文件configPen.xml
<?xml version="1.0"?>
<config>
    <className>Blue</className>
    <className>SmallPen</className>
</config>

//使用java反射创建具体的颜色和画笔
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtilPen
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getBean(String args)
    {
        try
        {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;                            
            doc = builder.parse(new File("configPen.xml")); 
            NodeList nl=null;
            Node classNode=null;
            String cName=null;
            nl = doc.getElementsByTagName("className");
            
            if(args.equals("color"))
            {
                //获取包含类名的文本节点
                classNode=nl.item(0).getFirstChild();
                
            }
            else if(args.equals("pen"))
            {
               //获取包含类名的文本节点
                classNode=nl.item(1).getFirstChild();
            }
            
             cName=classNode.getNodeValue();
             //通过类名生成实例对象并将其返回
             Class c=Class.forName(cName);
               Object obj=c.newInstance();
             return obj;        
           }   
               catch(Exception e)
               {
                   e.printStackTrace();
                   return null;
               }
        }
}

//客户端
public class Client
{
    public static void main(String a[])
    {
        Color color;
        Pen pen;
        
        color=(Color)XMLUtilPen.getBean("color");
        pen=(Pen)XMLUtilPen.getBean("pen");
        
        pen.setColor(color);
        pen.draw("鲜花");
    }
}

C++使用PIMPL实现桥接模式

C++中使用PIMPL(Pointer to Implmentation)隐藏Implement class的实现。举例如下：

person.h

#pragma once

#include <string>
#include <memory>

struct Person {
  class PersonImpl;
  unique_ptr<PersonImpl>  m_impl; // bridge - not necessarily inner class, can vary

  string m_name;

  Person();
  ~Person();
  void greet();

private:
  // secret data members or methods are in `PersonImpl` not here
  // as we are going to expose this class to client
};

person.cc

#include "person.h"

struct Person::PersonImpl {
  void greet(Person *p) {
    cout << "hello "<< p->name.c_str() << endl;
  }
};

Person::Person() : m_impl(new PersonImpl) {}
Person::~Person() { delete m_impl; }
void Person::greet() { m_impl->greet(this); }

引用

• 桥接模式
• Bridge Design Pattern in Modern C++
• 写给大家看的设计模式