设计模式——桥梁模式

桥梁模式

桥梁模式（Bridge Pattern）也叫做桥接模式：将抽象和实现解耦，使得两者可以独立地变化。

桥梁模式中的角色：

• Abstraction抽象化角色：定义出角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。
• Implementor实现化角色：接口或者抽象类，定义角色必需的行为和属性。
• RefinedAbstraction修正抽象化角色：引用了实现化角色对抽象化角色进行修正。
• ConcreteImplementor具体实现化角色：实现了接口或抽象类定义的方法和属性。

实现化角色Implementor：

public interface Implementor { 
    //基本方法 
    public void doSomething(); 
    public void doAnything(); 
}

具体实现化角色ConcreteImplementor1~2：代表两个不同的业务逻辑

public class ConcreteImplementor1 implements Implementor{ 
    public void doSomething(){ 
        //业务逻辑处理 
    }
    public void doAnything(){ 
        //业务逻辑处理 
    } 
}

public class ConcreteImplementor2 implements Implementor{ 
    public void doSomething(){ 
        //业务逻辑处理
    }
    public void doAnything(){ 
        //业务逻辑处理 
    } 
}

抽象化角色Abstraction：

public abstract class Abstraction { 
    //定义对实现化角色的引用 
    private Implementor imp; 
    //约束子类必须实现该构造函数 
    public Abstraction(Implementor _imp){ 
        this.imp = _imp; 
    }
    //自身的行为和属性 
    public void request(){ 
        this.imp.doSomething(); 
    }
    //获得实现化角色 
    public Implementor getImp(){ 
        return imp; 
    } 
}

具体抽象化角色RefinedAbstraction：

public class RefinedAbstraction extends Abstraction { 
    //覆写构造函数 
    public RefinedAbstraction(Implementor _imp){ 
        super(_imp); 
    }
    //修正父类的行为 
    @Override 
    public void request(){ 
        /*
        * 业务处理... 
        */ 
        super.request(); 
        super.getImp().doAnything(); 
    }
}

场景类Client：

public class Client { 
    public static void main(String[] args) { 
        //定义一个实现化角色 
        Implementor imp = new ConcreteImplementor1(); 
        //定义一个抽象化角色 
        Abstraction abs = new RefinedAbstraction(imp); 
        //执行行文 
        abs.request(); 
    } 
}

桥梁模式是一个非常简单的模式，它只是使用了类间的聚合关系、继承、覆写等常用功能，但是它却提供了一个非常清晰、稳定的架构。

---

桥梁模式的优点

• 抽象和实现分离：桥梁模式的主要特点，它完全是为了解决继承的缺点而提出的设计模式。在该模式下，实现可以不受抽象的约束，不用再绑定在一个固定的抽象层次上。
• 优秀的扩充能力。
• 实现细节对客户透明：客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。

桥梁模式的使用场景

• 不希望或不适用使用继承的场景：例如继承层次过渡、无法更细化设计颗粒等场景，需要考虑使用桥梁模式。
• 接口或抽象类不稳定的场景。
• 重用性要求较高的场景：设计的颗粒度越细，则被重用的可能性就越大，而采用继承则受父类的限制，不可能出现太细的颗粒度。

桥梁模式的注意事项

桥梁模式主要考虑如何拆分抽象和实现，并不是一涉及继承就要考虑使用该模式。桥梁模式的意图是对变化的封装，尽量把可能变化的因素封装到最细、最小的逻辑单元中，避免风险扩散。因此读者在进行系统设计时，发现类的继承有N层时，可以考虑使用桥梁模式。

---

桥梁模式的实例

一个老总有两家公司，一家房地产，一家山寨公司，山寨公司生产ipod或其他产品。

（1）定义产品 接口，包含产品的生产和销售两个方法

public abstract class Product {
	//生产
	public abstract void beProducted();
	//销售
	public abstract void beSelled();
}

（2）定义产品的实现类，分别对应各自的生产和销售

import com.sfq.impl.Product;
public class House extends Product {
	@Override
	public void beProducted() {
		System.out.println("生产出房子...");
	}
	@Override
	public void beSelled() {
		System.out.println("卖掉房子...");
	}
}

import com.sfq.impl.Product;
public class IPod extends Product {
	@Override
	public void beProducted() {
		System.out.println("生产出IPod...");
	}
	@Override
	public void beSelled() {
		System.out.println("卖掉IPod...");
	}
}

（3）定义公司接口，接收产品和挣钱

public abstract class Corp {
	private Product product;
	public Corp(Product product) {
		this.product = product;
	}
	public void makeMoney() {
		this.product.beProducted();
		this.product.beSelled();
	}
}

（4）在公司接口下，分别实现两个生产流水线

import com.sfq.impl.Corp;
import com.sfq.impl.Product;
public class HouseCorp extends Corp {
	public HouseCorp(Product product) {
		super(product);
	}
	public void makeMoney() {
		super.makeMoney();
		System.out.println("房地产大赚...");
	}
}

import com.sfq.impl.Corp;
import com.sfq.impl.Product;
//生产什么产品不知道，在被调用时才知道
public class ShanZhaiCorp extends Corp {
	public ShanZhaiCorp(Product product) {
		super(product);
	}
	public void makeMoney() {
		super.makeMoney();
		System.out.println("大赚...");
	}
}

（5）场景类，公司生产产品

import com.sfq.action.House;
import com.sfq.action.HouseCorp;
import com.sfq.action.IPod;
import com.sfq.action.ShanZhaiCorp;
public class Client {
	public static void main(String[] args) {
		House house = new House();
		System.out.println("-----房地产公司运行-----");
		HouseCorp houseCorp = new HouseCorp(house);
		houseCorp.makeMoney();
		System.out.println("\n");
		System.out.println("-----山寨公司运行-----");
		ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());
		shanZhaiCorp.makeMoney();
	}
}