8.桥接模式

1.什么是桥接模式？

将两个独立变化的维度设计为两个独立的继承等级结构，而不是将二者耦合在一起形成多层继承结构。

桥接模式在抽象层建立起一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，所以叫桥接模式。

 

2.桥接模式结构

（1）Abstraction（抽象类）：它用于定义抽象类的接口，通常是抽象类而不是接口。其中定义了一个实现类接口类型的对象，并可以维护这个对象。

（2）RefinedAbstraction（扩充抽象类）：它扩充抽象类定义的接口，通常情况下，它不再是抽象类而是具体类。它可以调用在实现类接口中定义的业务方法。

（3）Implementor（实现类接口）：这个接口不一定要与抽象类的接口完全一致。实现类接口只提供基本操作，而抽象类可以有更多的操作。实现类对这些基本操作进行声明，而具体实现交给其子类。

（4）ConcreteImplementor（具体实现类）：实现了实现类的接口，不同的具体实现类提供基本操作的不同实现。

 

3.桥接模式实现

桥接模式会将两个维护分别抽抽成两部分：抽象部分、实现部分。

为了降低两者之间的耦合度，首先需要针对不同的维度抽取抽象类和实现类接口，并建立一个抽象关联关系。

（1）对于实现部分，典型实现类接口代码：

package controller.bridgeModule;

/**
 * 实现类
 */
public interface Implementor {
    public void operationImpl();
}

（2）具体实现类

package controller.bridgeModule;

/**
 * 具体实现类
 */
public class ConcreteImplementor implements Implementor {
    @Override
    public void operationImpl() {
        //具体业务方法的实现
    }
}

（3）抽象类

package controller.bridgeModule;

/**
 * 抽象类
 */
public abstract class Abstraction {
    protected Implementor impl;//定义实现类接口对象

    public void setImpl(Implementor impl) {
        this.impl = impl;
    }

    public abstract void operation();//声明抽象业务方法
}

（4）扩充抽象类

package controller.bridgeModule;

/**
 * 扩充抽象类
 */
public class RefinedAbstraction extends Abstraction {
    @Override
    public void operation() {
        //业务代码
        impl.operationImpl();//调用实现类的方法
        //业务代码
    }
}

 

4.桥接模式实例——可支持多平台多格式的跨平台图像浏览系统

（1）像素矩阵类

/**
 * 像素矩阵类，各个格式的图像文件都会转化为像素矩阵，不同的操作系统提供不同的方式显示像素矩阵
 */
public class Matrix {
    //代码省略
}

（2）抽象操作系统实现类，充当实现类接口

package controller.bridgeImageModule;

/**
 * 抽象操作系统实现类，充当实现类接口
 */
public interface ImageImp {
    public void doPaint(Matrix m);//显示像素矩阵m
}

（3）windows操作系统实现类，充当具体实现类

package controller.bridgeImageModule;

/**
 * windows操作系统实现类，充当具体实现类
 */
public class WindowsImp implements ImageImp {
    @Override
    public void doPaint(Matrix m) {
        //调用windows系统的绘制函数绘制像素矩阵
        System.out.println("在windows操作系统中显示像素：");
    }
}

（4）linux操作系统实现类，充当具体实现类

package controller.bridgeImageModule;
/**
 * linux操作系统实现类，充当具体实现类
 */
public class LinuxImp implements ImageImp {
    @Override
    public void doPaint(Matrix m) {
        //调用linux系统的绘制函数绘制像素矩阵
        System.out.println("在linux操作系统中显示像素：");
    }
}

（5）unux操作系统实现类，充当具体实现类

package controller.bridgeImageModule;

/**
 * unux操作系统实现类，充当具体实现类
 */
public class UnixImp implements ImageImp {
    @Override
    public void doPaint(Matrix m) {
        //调用unux系统的绘制函数绘制像素矩阵
        System.out.println("在unux操作系统中显示像素：");
    }
}

（6）抽象图像类，充当抽象类

package controller.bridgeImageModule;

/**
 * 抽象图像类，充当抽象类
 */
public abstract class Image {
    protected ImageImp imp;

    //注入实现类接口对象
    public void setImageImp(ImageImp imp) {
        this.imp = imp;
    }

    public abstract void parseFile(String fileName);
}

（7）JPG格式图像类，充当扩充抽象类

package controller.bridgeImageModule;

/**
 *JPG格式图像类，充当扩充抽象类
 */
public class JPGImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析JPG文件并获取一个像素矩阵对象m
        Matrix m = new Matrix();
        imp.doPaint(m);
        System.out.println(fileName + ",格式为JPG");
    }
}

（8）PNG格式图像类，充当扩充抽象类

package controller.bridgeImageModule;

/**
 *PNG格式图像类，充当扩充抽象类
 */
public class PNGImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析PNG文件并获取一个像素矩阵对象m
        Matrix m = new Matrix();
        imp.doPaint(m);
        System.out.println(fileName + ",格式为PNG");
    }
}

（9）GIF格式图像类，充当扩充抽象类

package controller.bridgeImageModule;

/**
 *GIF格式图像类，充当扩充抽象类
 */
public class GIFImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析BMP文件并获取一个像素矩阵对象m
        Matrix m = new Matrix();
        imp.doPaint(m);
        System.out.println(fileName + ",格式为GIF");
    }
}

（10）BMP格式图像类，充当扩充抽象类

package controller.bridgeImageModule;

/**
 *BMP格式图像类，充当扩充抽象类
 */
public class BMPImage extends Image {
    @Override
    public void parseFile(String fileName) {
        //模拟解析BMP文件并获取一个像素矩阵对象m
        Matrix m = new Matrix();
        imp.doPaint(m);
        System.out.println(fileName + ",格式为BMP");
    }
}

（11）config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <className>controller.bridgeImageModule.JPGImage</className>
    <className>controller.bridgeImageModule.WindowsImp</className>
</config>

（12）工具类

package controller.bridgeImageModule;


import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class XMLUtil {
    /**
     * 从xml配置文件中提取具体类的类名，并返回一个实例对象
     */
    public static Object getBean(String args){
        try {
            //创建DOM文档对象
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
            Document document = builder.parse(new File("src//controller//bridgeImageModule//config.xml"));

            //获取包含类名的文本节点
            NodeList nl = document.getElementsByTagName("className");
            Node classNode = null;

            //获取第一个包含类名的节点，即扩充抽象类
            if(args.equals("image")){
                classNode = nl.item(0).getFirstChild();
            }else if(args.equals("os")){//获取第二个包含类名的节点，即具体实现类
                classNode = nl.item(1).getFirstChild();
            }

            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回
            Class c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;

        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }

    }
}

（13）客户端

package controller.bridgeImageModule;

public class Client {
    public static void main(String[] args) {
        Image image;
        ImageImp imp;
        image = (Image)XMLUtil.getBean("image");
        imp = (ImageImp)XMLUtil.getBean("os");
        image.setImageImp(imp);
        image.parseFile("小龙女");
    }
}

 

5.桥接模式的优缺点

优：

（1）分离抽象接口及实现部分

（2）可以取代多层继承方案

（3）提高系统的可拓展性

缺：

（1）增加系统难度

（2）辨识两个维度比较难