二十三种设计模式-桥梁模式

主要的作用

将抽象与实现解耦，可以让抽象和实现独立的变化。

---

关键角色

（1）Abstraction：抽象角色，这个角色提供的接口是面向调用方的，其中会保持一个对实现化对象的引用，其中的真正实现就是由Implementor的实现类来提供的，Implementor就相当于一个桥梁，将抽象角色和具体的实现关联了起来，使用组合的方式，而不是继承的方式。

（2）RefinedAbstraction：修正抽象化角色，主要是Abstraction这个抽象角色可能没有提供过多的接口，可以通过RefinedAbstraction来扩展功能。

（3）Implementor：实现化角色，这个角色就是相当于一个桥梁，只给出接口而不给出具体的实现。

（4）具体实现化角色：就是Implementor这个接口的实现类，实现类才是真正提供功能的地方。

---

案例

• 案例一：自定义demo

public class BridgeBase {

    private static Abstractor abstractor;

    /**
     * 抽象化角色
     */
    static abstract class Abstractor {

        // 通过聚合模式保持对实现化角色的引用
        private Implementer implementer;

        public Abstractor(Implementer implementer) {
            this.implementer = implementer;
        }

        abstract void print();

        public Implementer getImplementer() {
            return implementer;
        }
    }


    /**
     * 实现化角色
     */
    static abstract class Implementer {
        abstract String say(String s);
    }

    static class HiAbstractor extends Abstractor {

        public HiAbstractor(Implementer implementer) {
            super(implementer);
        }

        @Override
        void print() {
            System.out.println("hi" + getImplementer().say("zzz"));
        }
    }

    static class HelloAbstractor extends Abstractor {

        public HelloAbstractor(Implementer implementer) {
            super(implementer);
        }

        @Override
        void print() {
            System.out.println("hello" + getImplementer().say(" what?"));
        }
    }

    static class LowImplementer extends Implementer {
        @Override
        String say(String s) {
            return s + " GG";
        }
    }

    static class HighImplementer extends Implementer {
        @Override
        String say(String s) {
            return s  + "MM";
        }
    }

    public static void main(String[] args) {
        Abstractor abstractor = new HelloAbstractor(new LowImplementer());
        abstractor.print();
    }
}

• 案例二：JDBC的连接的设计
  

Driver是相当于一个桥梁，对于mysql、oracle等数据库实现肯定是不一样的，只需要基于Driver提供不同的实现类即可。将抽象和实现解耦。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

上面就是mysql提供的基于Driver桥梁的一个实现类。

其实好好想想，感觉面向接口编程都有着一丝丝桥梁模式的影子。比如依赖于spring的依赖注入功能，就是根据需要提供不同的实现，能够将抽闲和实现解耦了。

这里先简单介绍下桥梁模式，等后面我把每种设计模式都理解清楚了，再一起总结下。

再次说明一下，这个模式的关键在于能够将抽象和实现解耦。就像是一个公司，中台负责搭架子，不同的业务提供具体的实现，这样就不需要把过重的业务完全放到中台了，中台就可以提供一些通用性的功能。