桥梁模式(Bridge Patter)也叫做桥接模式,是一个比较简单的模式。
定义:
将抽象和实现解耦,使得两者可以独立地变化。
通用类图:
● Abstraction——抽象化角色
它主要的职责是定义出该角色的行为,同时保存一个对实现化角色的引用,该角色一般是抽象类。
● Implementro——实现化角色
它是接口或者抽象类,定义角色必须的行为和属性。
● RefinedAbstraction——修正抽象化角色
它引用实现化角色对抽象化角色进行修正。
● ConcreteImplementor——具体实现化角色
它实现接口或抽象类定义的方法和属性。
其中imp的地方就是一个组合。Abstraction就是饮料这个例子里的杯子。,它的子类RefinedAbstraction就是杯子的大小等型号。Implementor是加的物品类类,ConcreteImplementorA和ConcreteImplementorB分别是加糖和柠檬。
整个设计模式的关键就是组合的使用。
通用代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/**
* 实现化角色
*
* @author Administrator
*
*/
public
interface
Implementor {
// 基本方法
public
void
doSomething();
public
void
doAnything();
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/**
* 具体实现化角色
*
* @author Administrator
*
*/
public
class
ConcreteImplementor1
implements
Implementor {
public
void
doAnything() {
// 业务处理逻辑
}
public
void
doSomething() {
// 业务处理逻辑
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/**
* 具体实现化角色
*
* @author Administrator
*
*/
public
class
ConcreteImplementor2
implements
Implementor {
public
void
doAnything() {
// 业务处理逻辑
}
public
void
doSomething() {
// 业务处理逻辑
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
/**
* 抽象化角色
*
* @author Administrator
*
*/
public
abstract
class
Abstraction {
// 定义对实现化角色的引用
private
Implementor imp;
// 约束子类必须实现该构造函数
public
Abstraction(Implementor _imp) {
this
.imp = _imp;
}
// 自身的行为和属性
public
void
request() {
this
.imp.doSomething();
}
// 获得实现化角色
public
Implementor getImp() {
return
this
.imp;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
/**
* 具体抽象化角色
*
* @author Administrator
*
*/
public
class
RefinedAbstraction
extends
Abstraction {
// 覆写构造函数
public
RefinedAbstraction(Implementor _imp) {
super
(_imp);
}
// 修正父类的行为
@Override
public
void
request() {
/*
* 业务处理
*/
super
.request();
super
.getImp().doAnything();
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* 场景类
*
* @author Administrator
*
*/
public
class
Client {
/**
* @param args
*/
public
static
void
main(String[] args) {
// 定义一个实现化角色
Implementor imp =
new
ConcreteImplementor1();
// 定义一个抽象化角色
Abstraction abs =
new
RefinedAbstraction(imp);
// 执行行文
abs.request();
}
}
|
桥梁模式是一个非常简单的模式,它只是使用了类间的聚合关系、继承、覆写等常用功能,但是它却提供了一个非常清晰、稳定的架构。
理解桥接模式,重点需要理解如何将抽象化(Abstraction)与实现化(Implementation)脱耦,使得二者可以独立地变化。
•抽象化:抽象化就是忽略一些信息,把不同的实体当作同样的实体对待。在面向对象中,将对象的共同性质抽取出来形成类的过程即为抽象化的过程。
•实现化:针对抽象化给出的具体实现,就是实现化,抽象化与实现化是一对互逆的概念,实现化产生的对象比抽象化更具体,是对抽象化事物的进一步具体化的产物。
•脱耦:脱耦就是将抽象化和实现化之间的耦合解脱开,或者说是将它们之间的强关联改换成弱关联,将两个角色之间的继承关系改为关联关系。
桥梁模式的优点:
● 抽象和实现分离
这是桥梁模式的主要特点,它完全是为了解决继承的缺点而提出的设计模式。在该模式下,实现可以不受抽象的约束,不用再绑定在一个固定的抽象层次上。
● 优秀的扩展能力
● 实现细节对客户透明
客户不用关心细节的实现,它已经由抽象层通过聚合关系完成了封装。
桥梁模式的使用场景:
● 不希望或不适用使用继承的场景
例如继承层次过渡、无法更细化设计颗粒等场景,需要考虑使用桥梁模式。
● 接口或抽象类不稳定的场景
明知道接口不稳定还想通过实现或继承来实现业务需求,那是得不偿失的,也是比较失败的做法。
● 重用性要求较高的场景
设计的颗粒度越细,则被重用的可能性就越大,而采用继承则受父类的限制,不可能出现太细的颗粒度。
桥梁模式的注意事项:
使用桥梁模式时主要考虑如何拆分抽象和实现,并不是一涉及继承就要考虑使用该模式,那还要继承干什么。
桥梁模式的意图还是对变化的封装,尽量把可能变化的因素封装到最细、最小的逻辑单元中,避免风险扩散。
系统设计时,发现类的继承有N层时,可以考虑使用桥梁模式。