转自http://www.cnblogs.com/cbf4life/archive/2009/12/29/1634773.html
观察者模式 VS 责任链模式
为什么要把观察者模式和责任链模式放在一起对比呢？这两个模式没有太多的相似性呀，真没有嘛？有相似性，我们在观察者模式中也提到了触发链（也叫做观察者链）的问题，一个具体的角色既可以是观察者，也可以是被观察者，如此则形成了一个观察者链，这与责任模式非常类似，都实现了事务的链条化处理，比如说在上课的时候你睡着了，打鼾声音太大，盖过了老师讲课声音，老师火了，捅到了校长这里，校长也处理不了，然后告状到你父母，于是你的魔鬼日子来临了，这是责任链模式，老师、校长、父母都是链中的一个具体角色，事件（你睡觉）在链中传递，最终由一个具体的节点来处理，并反馈结果给调用者（你挨揍了）。那什么是触发链？你还是在课堂上睡觉，还是打鼾声音太大，老师火了，但是老师贼机灵了，掏出个扩音器来讲课，于是你睡不找了，同时其他同学的耳朵遭殃了，这就是触发链，其中老师既是观察者（相对你）也是被观察者（相对其他同学），事件从“你睡觉”到老师这里转化为“扩音器放大声音”，这也是一个链条结构，但是链结构中传递的事件改变了。
我们还是以一个具体的例子来说明两者的区别，DNS协议相信大家都听说过了，我们只要在“网络设置”中设置一个DNS服务器地址就可以把我们需要的域名翻译成IP地址，DNS协议还是比较简单的，传递过去一个域名以及记录标志（比如是要A记录还是要MX记录），然后DNS就开始查找自己的记录树，找到后把IP地址反馈给请求者。我们可以在Windows操作系统可以按照如下步骤了解一下DNS解析过程，在DOS窗口下输入nslookup命令后，如图32-6所示。
图32-1 DNS服务器解析域名
我们的意图就是要DNS服务器192.168.10.1解析出www.xxx.com.cn的IP地址，那DNS服务器是如何工作的呢？也就是我们图中的182.168.10.1这个DNS Server，它存储着全球的域名和IP之间的对应关系吗？不可能，目前全球的域名数量是1.7亿个，如此庞大的数字，每个DNS服务都存储一份，还怎么快速响应？DNS解析响应时间一般都是毫秒级别的，如此高的性能要求还怎么让DNS Server遍地开花呢？而且域名变更也非常频繁，数据读写的量也非常大，不可能这1.7亿数据每个DNS服务器都保留一条，那是怎么设计的呢？DNS协议还是很聪明的，它规定了每个区域的DNS服务器(Local DNS)只保留自己区域的域名解析，对于不能解析的域名，则提交上级域名解析器解析，最终由一台位于美国洛杉矶的*域名服务器进行解析，返回结果，这非常明显是一个事物的链结构处理，我们使用两种模式来实现该解析过程。
32.3.1 责任链实现DNS解析过程
猜想大家看到这里，肯定非责任链模式莫属，好，我们就用责任链模式来实现，首先我们定义一下业务场景，这里有三个DNS服务器：上海DNS服务器（区域服务器）、中国*DNS服务器（父服务器）、全球*DNS服务器，其示意图如图32-7所示。
图32-2 DNS解析示意图
有请求者发出请求，然后由上海DNS进行解析，如果能够解析，则返回结果，若不能解析，则提交给父服务器中国*DNS进行解析，若还不能解析，则提交到全球*DNS进行解析，若还不能解析呢？那就返回该域名无法解析，那可能就是外星球的域名了。确实，这与责任链模式非常相似，那我们把这一过程抽象一下，类图如图32-8所示。
图32-3 责任链模式实现域名解析
我们来解释一下类图，Recorder是一个BO对象，它是记录DNS服务器解析后的结果记录，包括域名、IP地址、属主（即由谁解析的），然后分别有getter/setter方法；DnsServer抽象类中的resolve方法是一个基本方法，每个DNS服务器都必须拥有该方法，它是对DNS进行解析，如何解析呢？具体是由echo方法来实现，每个DNS服务器独自实现。类图还是比较简单的，我们首先看一下解析记录Recorder类，如代码清单32-31所示。
代码清单32-1 解析记录
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
public class Recorder
{
//域名
private String
domain;
//IP地址
private String
ip;
//属主
private String
owner;
public String
getDomain() {
return domain;
}
public void setDomain(String
domain) {
this.domain
= domain;
}
public String
getIp() {
return ip;
}
public void setIp(String
ip) {
this.ip
= ip;
}
public String
getOwner() {
return owner;
}
public void setOwner(String
owner) {
this.owner
= owner;
}
//输出记录信息
@Override
public String
toString(){
String
str= "域名：" +
this.domain;
str
= str + "\nIP地址：" +
this.ip;
str
= str + "\n解析者：" +
this.owner;
return str;
}
}
|
为什么要覆写toString方法呢？是为了我们打印展示的需要，可以直接把Recorder的信息打印出来。我们再来看抽象域名服务器，如代码清单32-32所示。
代码清单32-2 抽象域名服务器
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
public abstract class DnsServer
{
//上级DNS是谁
private DnsServer
upperServer;
//解析域名
public final Recorder
resolve(String domain){
Recorder
recorder=null;
if(isLocal(domain)){//是本服能解析的域名
recorder
= echo(domain);
}else{//本服不能解析
//提交上级DNS进行解析
recorder
= upperServer.resolve(domain);
}
return recorder;
}
//指向上级DNS
public void setUpperServer(DnsServer
_upperServer){
this.upperServer
= _upperServer;
}
//每个DNS都有一个DNS的数据处理区（ZONE）,检查域名是否在本zone中
protected abstract boolean isLocal(String
domain);
//每个DNS服务器都必须实现解析任务
protected Recorder
echo(String domain){
Recorder
recorder = new Recorder();
//获得IP地址
recorder.setIp(genIpAddress());
recorder.setDomain(domain);
return recorder;
}
//随机产生一个IP地址，工具类
private String
genIpAddress(){
Random
rand = new Random();
String
address = rand.nextInt(255)
+ "." +
rand.nextInt(255)
+ "."+
rand.nextInt(255)
+ "."+
rand.nextInt(255);
return address;
}
}
|
在该类中有一个方法——genIpAddress方法——没有在类图中展现出来，它实现随机生成IP地址，这是我们为模拟DNS解析场景而建立的一个虚拟方法，在实际的应用中是不可能出现的。抽象DNS服务器编写完成，我们再来看具体的DNS服务器，先看上海的DNS服务器，如代码清单32-33所示。
代码清单32-3 上海DNS服务器
|
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
|
public class SHDnsServer
extends DnsServer
{
@Override
protected Recorder
echo(String domain) {
Recorder
recorder= super.echo(domain);
recorder.setOwner("上海DNS服务器");
return recorder;
}
//定义上海的DNS服务器能处理的级别
@Override
protected boolean isLocal(String
domain) {
return domain.endsWith(".sh.cn");
}
}
|
为什么要覆写echo方法？各具体的DNS服务器实现自己的解析过程，个性化处理，它代表的是每个DNS服务器的不同处理逻辑。还要注意一下，我们在这里做了一个简化处理，所有以“.sh.cn”结尾的域名都由上海DNS服务器解析。其他的中国*DNS和全球*DNS实现过程类似，如代码清单32-34、32-35所示。
代码清单32-4 中国*DNS服务器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public class ChinaTopDnsServer
extends DnsServer
{
@Override
protected Recorder
echo(String domain) {
Recorder
recorder = super.echo(domain);
recorder.setOwner("中国*DNS服务器");
return recorder;
}
@Override
protected boolean isLocal(String
domain) {
return domain.endsWith(".cn");
}
}
|
代码清单32-5 全球*DNS服务器
|
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
|
public class TopDnsServer
extends DnsServer
{
@Override
protected Recorder
echo(String domain) {
Recorder
recorder = super.echo(domain);
recorder.setOwner("全球*DNS服务器");
return recorder;
}
@Override
protected boolean isLocal(String
domain) {
//所有的域名最终的解析地点
return true;
}
}
|
所有的DNS服务器都准备了，那我们就写一个客户端来模拟一下IP地址是怎么解析的，如代码清单32-36所示。
代码清单32-6 场景类
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
public class Client
{
public static void main(String[]
args) throws Exception
{
//上海域名服务器
DnsServer
sh = new SHDnsServer();
//中国*域名服务器
DnsServer
china = new ChinaTopDnsServer();
//*域名服务器
DnsServer
top = new TopDnsServer();
//定义查询路径
china.setUpperServer(top);
sh.setUpperServer(china);
//解析域名
System.out.println("=====域名解析模拟器=====");
while(true){
System.out.print("\n请输入域名(输入N退出):");
String
domain = (new BufferedReader(new InputStreamReader(System.in))).readLine();
if(domain.equalsIgnoreCase("n")){
return;
}
Recorder
recorder = sh.resolve(domain);
System.out.println("----DNS服务器解析结果----");
System.out.println(recorder);
}
}
}
|
我们来模拟一下，运行结果如下所示：
=====域名解析模拟器=====
请输入域名(输入N退出):www.xxx.sh.cn
----DNS服务器解析结果----
域名：www. xxx.sh.cn
IP地址：69.224.162.154
解析者：上海DNS服务器
请输入域名(输入N退出):www. xxx.com.cn
----DNS服务器解析结果----
域名：www. xxx.com.cn
IP地址：51.28.66.140
解析者：中国*DNS服务器
请输入域名(输入N退出):www. xxx.com
----DNS服务器解析结果----
域名：www. xxx.com
IP地址：73.247.80.117
解析者：全球*DNS服务器
请输入域名(输入N退出):n
请注意看运行结果，“.sh.cn”结尾的域名确实由上海的DNS服务器解析了，“.cn”结尾的域名由中国*DNS解析了，其他域名都由全球*DNS解析，这个模拟过程很完整嘛，它完全就是责任链模式的一个具体应用，把一个请求放置到链中的首节点，然后由链中的某个节点进行解析并反馈调用者，很完善是吗？
但是，我可以负责任的告诉你：这个解析过程是有缺陷的，什么缺陷？欲知后事，去看下回分解。
32.3.2 触发链实现DNS解析过程
承上一章节，我们说到使用责任链模式模拟DNS解析过程是有缺陷的，有什么缺陷？大家是不是觉得这个解析过程很完美了，没什么问题了？那说明你对DNS协议了解得还不太深入，这样，我们做一个实验，在dos窗口下输入nslookup命令，然后你输入多个域名，注意观察返回值有哪些数据是相同的？对了，就是解析者都是相同，都是由同一个DNS服务器解析的，准确地说都是由你本机配置的DNS服务器做的解析，这与我们上面的模拟过程是不相同的，看看我们模拟的过程，对请求者来说，“.sh.cn”是由区域DNS解析了，“.com”却是由全球*DNS解析了，这可与真实的过程不相同呀，这是怎么回事呢？
肯定地说，采用责任链模式模拟DNS解析过程是不完美的，或者说是有缺陷的，那我们怎么来修复这个缺陷呢？我们先来看看真实的DNS解析过程，如图32-9所示。
图32-4 真实的DNS解析示意图
一个域名解析的完整路径如图中的标号①②③④⑤⑥所示，首先由请求者发送一个请求，然后由上海DNS服务进行尝试解析，若不能解析再通过路径②转发给中国*DNS进行解析，解析后结果通过路径⑤返回给上海DNS服务器，然后由上海DNS服务器通过路径⑥返回给请求者。同样，若中国*DNS不能解析，则通过路径③转由全球*DNS进行解析，通过路径④把结果返回给中国*DNS，然后再通过路径⑤返回给上海DNS。注意看标号⑥，不管一个域名最终由谁解析，但是最终反馈到请求者的还是第一个节点，也就是说首节点负责对请求者应答，其他节点都不与请求者交互，只与自己左右节点交互。实际上我们的DNS服务器确实是如此处理的，例如本机请求查询一个www.abcdefg.com的域名，上海DNS服务器解析不到这个域名，于是提交到中国*DNS服务器，如果中国*DNS服务器有该域名的记录，则找到该记录，反馈到上海DNS服务器，上海DNS服务器做两件事务处理：一是响应请求者，二是存储该记录，以备其他请求者再次查询，类似数据缓存。
整个场景我们已经清晰，想想看，我们把请求者看做是被观察者，它的行为或属性变更通知了被观察者上海DNS，上海DNS又作为被观察者出现了自己不能处理的行为（行为改变），通知了中国*DNS，依次类推，是不是一个非常标准的触发链？而且还必须是同步的触发，异步触发已经在该场景中失去了意义，读者可以想想为什么。
分析了这么多，我们用触发链来模拟DNS的解析过程，如图32-10所示。
图32-5 触发链实现DNS解析过程
与责任链模式很相似，仅仅多了一个Observable父类和Observer接口，但是两者的实现有非常大的差异，我们先类解释一下抽象DnsServer的作用，它有两个作用。
- 标示声明
表示所有的DNS服务器都具备双重身份：既是观察者也是被观察者，这很重要，它声明所有的服务器都具有相同的身份标志，具有该标志后就可以在链中随意移动，而无需固定在链中的某个位置（这也是链的一个重要特性）。
- 业务抽象
方法setUpperServer的作用是设置父DNS，也就是设置自己的观察者，update方法不仅仅是一个事件的处理者，也同时是事件的触发者。
我们来看代码，首先说最简单的，Recorder类与责任链中的记录没有任何改变，不再赘述。那我们就先看看我们的核心抽象DnsServer，如代码清单32-37所示。
代码清单32-7 抽象DNS服务器
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
public abstract class DnsServer
extends Observable
implements Observer
{
//处理请求，也就是接收到事件后的处理
public void update(Observable
arg0, Object arg1) {
Recorder
recorder = (Recorder)arg1;
//如果本机能解析
if(isLocal(recorder)){
recorder.setIp(genIpAddress());
}else{//本机不能解析，则提交到上级DNS
responsFromUpperServer(recorder);
}
//签名
sign(recorder);
}
//作为被观察者，允许增加观察者,DNS解析的上级DNS一般是一个
public void setUpperServer(DnsServer
dnsServer){
//先清空，然后再增加
super.deleteObservers();
super.addObserver(dnsServer);
}
//向父DNS请求解析，也就是通知观察者
private void responsFromUpperServer(Recorder
recorder){
super.setChanged();
super.notifyObservers(recorder);
}
//每个DNS服务器签上自己的名字
protected abstract void sign(Recorder
recorder);
//每个DNS服务器都必须定义自己的处理级别
protected abstract boolean isLocal(Recorder
recorder);
//随机产生一个IP地址，工具类
private String
genIpAddress(){
Random
rand = new Random();
String
address = rand.nextInt(255)
+ "." +
rand.nextInt(255)
+ "."+
rand.nextInt(255)
+ "."+
rand.nextInt(255);
return address;
}
}
|
注意看一下responseFromUpperServer方法，它只允许设置一个观察者，因为一般的DNS服务都只有一个上级DNS服务器，主备DNS？想清楚什么是主DNS、什么是备用DNS，然后再提问！还有sign方法是什么意思呢？就是签名，这个记录是由谁解析出来的，由各个实现类独自来实现。三个DnsServer的实现类都比较简单，如代码清单32-38、32-39、32-40所示。
代码清单32-8 上海DNS服务器
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
public class SHDnsServer
extends DnsServer
{
@Override
protected void sign(Recorder
recorder) {
recorder.setOwner("上海DNS服务器");
}
//定义上海的DNS服务器能处理的级别
@Override
protected boolean isLocal(Recorder
recorder) {
return recorder.getDomain().endsWith(".sh.cn");
}
}
代码清单32-9 中国*DNS服务器
public class ChinaTopDnsServer
extends DnsServer
{
@Override
protected void sign(Recorder
recorder) {
recorder.setOwner("中国*DNS服务器");
}
@Override
protected boolean isLocal(Recorder
recorder) {
return recorder.getDomain().endsWith(".cn");
}
}
代码清单32-10 全球*DNS服务器
public class TopDnsServer
extends DnsServer
{
@Override
protected void sign(Recorder
recorder) {
recorder.setOwner("全球*DNS服务器");
}
@Override
protected boolean isLocal(Recorder
recorder) {
//所有的域名最终的解析地点
return true;
}
}
|
我们再建立一个场景类模拟一下DNS解析过程，如代码清单32-31所示。
代码清单32-11 场景类
|
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
public class Client
{
public static void main(String[]
args) throws Exception
{
//上海域名服务器
DnsServer
sh = new SHDnsServer();
//中国*域名服务器
DnsServer
china = new ChinaTopDnsServer();
//*域名服务器
DnsServer
top = new TopDnsServer();
//定义查询路径
china.setUpperServer(top);
sh.setUpperServer(china);
//解析域名
System.out.println("=====域名解析模拟器=====");
while(true){
System.out.print("\n请输入域名(输入N退出):");
String
domain = (new BufferedReader(new InputStreamReader(System.in))).readLine();
if(domain.equalsIgnoreCase("n")){
return;
}
Recorder
recorder = new Recorder();
recorder.setDomain(domain);
sh.update(null,recorder);
System.out.println("----DNS服务器解析结果----");
System.out.println(recorder);
}
}
}
|
与责任链模式中的场景类很相似，读者请注意sh.update(null,recorder)这句话，这是我们虚拟了观察者触发动作，完整的做法是把场景类作为一个被观察，然后设置观察者为上海DNS服务器，再进行测试，其结果完全相同，我们这里为减少代码量采用了简化处理，有兴趣的读者可以扩充实现。
我们来看看运行结果如何，结果如下所示：
=====域名解析模拟器=====
请输入域名(输入N退出):www.xxx.sh.cn
----DNS服务器解析结果----
域名：www.xxx.sh.cn
IP地址：197.15.34.227
解析者：上海DNS服务器
请输入域名(输入N退出):www.xxx.com.cn
----DNS服务器解析结果----
域名：www.xxx.com.cn
IP地址：201.177.148.99
解析者：上海DNS服务器
请输入域名(输入N退出):www.xxx.com
----DNS服务器解析结果----
域名：www.xxx.com
IP地址：251.41.14.230
解析者：上海DNS服务器
请输入域名(输入N退出):n
看看，所有的解析结果都是由上海DNS服务器返回的，这才是真正的DNS解析过程。各位看官可能要说了，我怎么知道它是由上海DNS服务器解析的还是由别的DNS服务器解析的呢？好办，代码拷贝过去，然后调试跟踪一下就可以了，很简单。或者读者仔细看看代码，理解一下代码逻辑就非常清楚它是如何解析的了。
再仔细看一下我们的代码逻辑，上下两个节点直接的关系很微妙，很有意思。
- 下级节点对上级节点顶礼膜拜
比如我们输入的这个域名www.xxx.com，上海域名服务器只是知道它是由父节点（中国*DNS服务器）解析的，而不知道父节点把该请求转发给了更上层节点（*域名服务器），也就是说下级节点关注的是上级阶段的响应，只要是上级反馈的结果就认为是上级的。www.xxx.com这个域名最终是由最高节点（全球*DNS服务器）解析的，它把解析结果传递给第二个节点（中国*DNS服务器）时的签名为“全球*DNS服务器”，而第二个节点把请求传递给首节点（上海DNS服务器）时的签名被修改为“中国*DNS服务器”，为什么呢？所有从上级节点反馈的响应都认为是上级节点处理的结果，而不追究到底是不是真的是上级节点处理的。
- 上级节点对下级节点极度信任
上级节点只对下级节点负责，它不关心下级节点的请求是从何而来，只要是下级发送的请求，就认为是下级的，还是www.xxx.com域名，当最高节点（全球*DNS服务器）获得解析请求时，它认为这个请求是谁？当然是第二个节点（中国*DNS服务器）的，否则它也不会把结果反馈给它，但是这个请求的源头却是首节点（上海DNS服务器）的，信任，绝对是信任，上级节点对下级节点太信任了。
32.3.3 小结
通过对DNS解析过程的实现，我们发现触发链和责任链虽然都是链结构，但是还是有区别的：
- 链中的消息对象不同
从首节点开始，到最终的尾节点，两个链中传递的消息对象是不同的，责任链模式基本上是不改变消息对象的结构，虽然每个节点都可以参与消费（一般是不参与消费），类似与“雁过拔毛”性质，但是它的结构不会改变，比如从首节点传递进来是一个String对象或者是Person对象，不会出现到链尾的时候成了int或者Human对象，这在责任链模式中是不可能的，但是在触发链中就允许，链中传递的对象可以*变化，只要上下级节点对传递对象了解即可，它不要求链中的消息对象不变化，它只要求链中相邻两个节点的消息对象固定即可。
- 上下节点的关系不同
在责任链模式中，上下节点没有关系，都是接受同样的对象，所有传递的对象都是从链首传递过来，上一节点是阿猫阿狗和我没有关系，我只要按照自己的逻辑处理就成。而触发链就不同了，它的上下级关系很亲密，下级对上级顶礼膜拜，上级对下级绝对信任，链中的任意两个相邻节点都是一个牢固的独立团体。
- 消息的分销渠道不同
在责任链模式中，一个消息从链首传递进来后，就开始沿着链条向链尾运动，方向是单一的、固定的；而触发链则不同，由于它采用的是观察者模式，它可以有非常大的灵活性，一个消息传递到链首后，具体怎么传递则是不固定的，可以广播方式传递，也可以跳跃传递，取决于处理消息的逻辑。