大牛分享的几种设计模式及知识要点（三）

一、责任链模式

定义：Avoid coupling the sender of a request to its receiver by giving more than

one object a chance to handle the request.Chain the receiving objects and pass

the request along the chain until an object handles it.（使多个对象都有机会处理请

求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，

并沿着这条链传递该请求，直到有对象处理它为止。）

抽象处理者的代码：

public abstract class Handler {

private Handler nextHandler;

//每个处理者都必须对请求做出处理

public final Response handleMessage(Request request){

Response response = null;

//判断是否是自己的处理级别

if(this.getHandlerLevel().equals(request.getRequestLevel())){

response = this.echo(request);

}else{ //不属于自己的处理级别

//判断是否有下一个处理者

if(this.nextHandler != null){

response =

this.nextHandler.handleMessage(request);

}else{

//没有适当的处理者，业务自行处理

}

}

return response;

}

//设置下一个处理者是谁

public void setNext(Handler _handler){

this.nextHandler = _handler;

}

//每个处理者都有一个处理级别

protected abstract Level getHandlerLevel();

//每个处理者都必须实现处理任务

protected abstract Response echo(Request request);

}

抽象的处理者实现三个职责：

一是定义一个请求的处理方法 handleMessage，唯一对外开放的方法；

二是定义一个链的编排方法 setNext，设置下一个处理者；

三是定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别

getHandlerLevel 和具体的处理任务 echo。

注意事项：

链中节点数量需要控制，避免出现超长链的情况，一般的做法是在 Handler 中设置

一个最大节点数量，在 setNext 方法中判断是否已经是超过其阈值，超过则不允许

该链建立，避免无意识地破坏系统性能。

二、装饰模式（Decorator Pattern ）

定义：Attach additional responsibilities to an object dynamically keeping the

same interface.Decorators provide a flexible alternative to subclassing for

extending functionality.（动态地给一个对象添加一些额外的职责。就增加功能来

说，装饰模式相比生成子类更为灵活。）

● Component 抽象构件

Component 是一个接口或者是抽象类，就是定义我们最核心的对象，也就是最原

始的对象，如上面的成绩单。

注意：在装饰模式中，必然有一个最基本、最核心、最原始的接口或抽象类充当

Component 抽象构件。

● ConcreteComponent 具体构件

ConcreteComponent 是最核心、最原始、最基本的接口或抽象类的实现，你要装

饰的就是它。

● Decorator 装饰角色

一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象

的方法呀，在它的属性里必然有一个 private 变量指向 Component 抽象构件。

● 具体装饰角色

ConcreteDecoratorA 和 ConcreteDecoratorB 是两个具体的装饰类，你要把你最核

心的、最原始的、最基本的东西装饰成其他东西，上面的例子就是把一个比较平庸

的成绩单装饰成家长认可的成绩单。

使用场景：

● 需要扩展一个类的功能，或给一个类增加附加功能。

● 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

● 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。

kx33389,加她就能免费领取分布式、微服务、源码分析、性能优化、高并发高可用等技术的资料

三、策略模式（Strategy Pattern ）

定义：Define a family of algorithms,encapsulate each one,and make them

interchangeable.（定义一组算法，将每个算法都封装起来，并且使它们之间可以

互换。）

● Context 封装角色

它也叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访

问，封装可能存在的变化。

● Strategy 抽象策略角色

策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属

性。各位看官可能要问了，类图中的 AlgorithmInterface 是什么意思，嘿嘿，

algorithm 是“运算法则”的意思，结合起来意思就明白了吧。

● ConcreteStrategy 具体策略角色（多个）

实现抽象策略中的操作，该类含有具体的算法。

使用场景：

● 多个类只有在算法或行为上稍有不同的场景。

● 算法需要自由切换的场景。

● 需要屏蔽算法规则的场景。

注意事项：具体策略数量超过 4 个，则需要考虑使用混合模式

策略模式扩展：策略枚举

public enum Calculator {

//加法运算

ADD("+"){

public int exec(int a,int b){

return a+b;

}

},

//减法运算

SUB("-"){

public int exec(int a,int b){

return a - b;

}

};

String value = "";

//定义成员值类型

private Calculator(String _value){

this.value = _value;

}

//获得枚举成员的值

public String getValue(){

return this.value;

}

//声明一个抽象函数

public abstract int exec(int a,int b);

}

定义：

● 它是一个枚举。

● 它是一个浓缩了的策略模式的枚举。

注意：

受枚举类型的限制，每个枚举项都是 public、final、static 的，扩展性受到了一定

的约束，因此在系统开发中，策略枚举一般担当不经常发生变化的角色。

致命缺陷：

所有的策略都需要暴露出去，由客户端决定使用哪一个策略。

四、适配器模式（Adapter Pattern ）

定义：Convert the interface of a class into another interface clients

expect.Adapter lets classes work together that couldn't otherwise because of

incompatible interfaces.（将一个类的接口变换成客户端所期待的另一种接口，从

而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。）

类适配器：

● Target 目标角色

该角色定义把其他类转换为何种接口，也就是我们的期望接口，例子中的

IUserInfo 接口就是目标角色。

● Adaptee 源角色

你想把谁转换成目标角色，这个“谁”就是源角色，它是已经存在的、运行良好的类

或对象，经过适配器角色的包装，它会成为一个崭新、靓丽的角色。

● Adapter 适配器角色

适配器模式的核心角色，其他两个角色都是已经存在的角色，而适配器角色是需要

新建立的，它的职责非常简单：把源角色转换为目标角色，怎么转换？通过继承或

是类关联的方式。

使用场景：

你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的模式。比如

系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口，怎

么办？使用适配器模式，这也是我们例子中提到的。

注意事项：

详细设计阶段不要考虑使用适配器模式，使用主要场景为扩展应用中。

对象适配器：

对象适配器和类适配器的区别：

类适配器是类间继承，对象适配器是对象的合成关系，也可以说是类的关联关系，

这是两者的根本区别。（实际项目中对象适配器使用到的场景相对比较多）。

五、迭代器模式（Iterator Pattern ）

定义：Provide a way to access the elements of an aggregate object sequentially

without exposing its underlying representation.（它提供一种方法访问一个容器对

象中各个元素，而又不需暴露该对象的内部细节。）

● Iterator 抽象迭代器

抽象迭代器负责定义访问和遍历元素的接口，而且基本上是有固定的 3 个方法：

first()获得第一个元素，next()访问下一个元素，isDone()是否已经访问到底部

（Java 叫做 hasNext()方法）。

● ConcreteIterator 具体迭代器

具体迭代器角色要实现迭代器接口，完成容器元素的遍历。

● Aggregate 抽象容器

容器角色负责提供创建具体迭代器角色的接口，必然提供一个类似 createIterator()

这样的方法，在 Java 中一般是 iterator()方法。

● Concrete Aggregate 具体容器

具体容器实现容器接口定义的方法，创建出容纳迭代器的对象。

ps ：迭代器模式已经被淘汰，java 中已经把迭代器运用到各个聚集类

（collection ）中了，使用 java 自带的迭代器就已经满足我们的需求了。