Iron之观察者
引言
上一篇说的职责链模式,很有意思的一个模式,今天这个模式也是很有意思的一个模式,还是不啰嗦了直接进入主题吧。
场景介绍:在上一遍中说到用到部件检测,很巧妙的让调用者和处理者解耦了(没有看过上篇的文章也没关系,只是剧情是要接着发展的),要把部件拿去检测是要让个人来盯着看呢?还是部件生产好了自动就被拿去检测了呢?毋庸置疑必须是自动化的。
看一下部件的结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
1
/// <summary>
2
/// 部件
3
/// </summary>
4
public
class
ComponentModel
5 {
6
public
string
Name {
get
;
set
; }
7
public
int
Value
8 {
9
get
10 {
11
return
5;
12 }
13 }
14
15 }
|
这个部件还是上一篇的部件,没有做任何改动。只是示例,为了让没看过上一篇的朋友知道。
按照场景里所要求的,定义了下面的两个类型,ComponentModelFactory类型,ComponentModel类型工厂负责生产ComponentModel部件,并且在完成时通知要另外处理部件的对象。
ExecutionCheck类型,就是要要被通知到的对象,它等待着别人告诉它 “有部件生产好了,需要被你送去检测”,不会它会很无聊。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
1
/// <summary>
2
/// 示例ComponentModel类型工厂 生产了ComponentModel 通知ExecutionCheck对象去检测
3
/// </summary>
4
public
class
ComponentModelFactory
5 {
6
public
static
ComponentModel ComModelFactory()
7 {
8
return
new
ComponentModel();
9 }
10 }
11
/// <summary>
12
/// 送ComponentModel对象去检测
13
/// </summary>
14
public
class
ExecutionCheck
15 {
16
public
void
ComponentModelCheck(ComponentModel comModel)
17 {
18
//送去执行检测
19
//或者是一些其他操作
20 }
21 }
|
来看看调用代码:
1
2
3
4
|
1 ExecutionCheck executionCheck =
new
ExecutionCheck();
2 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());
3 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());
4 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());
|
似乎是解决了问题,但是结果糟透了,虽然executionCheck很高兴,因为它有活干了,我只能以这样的方式去通知executionCheck,或许有人说修改下ComponentModelFactory类型会好一点,我知道是这样的:
1
2
3
4
5
6
7
8
9
10
11
|
1
public
class
ComponentModelFactory
2 {
3
public
static
ComponentModel ComModelFactory()
4 {
5
return
new
ComponentModel();
6 }
7
public
void
PastMessage(ComponentModel componentModel,ExecutionCheck executionCheck)
8 {
9 executionCheck.ComponentModelCheck(componentModel);
10 }
11 }
|
调用代码则调整为:
1
2
3
|
1 ComponentModelFactory componentModelFactory =
new
ComponentModelFactory();
2 ExecutionCheck executionCheck=
new
ExecutionCheck();
3 componentModelFactory.PastMessage(ComponentModelFactory.ComModelFactory(), executionCheck);
|
这样的结果,调用方式没问题了,可是ComponentModelFactory类型的内部居然有着这样高的耦合,无法忍受,必须得找出一种方式或者模式来解决这样的难题,不然寝食难安!!!!
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
——Gof
按照模式的定义重新来过(会有点不一样的地方中心思想不变),先对ExecutionCheck 类型进行抽象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
1
/// <summary>
2
/// 抽象的ExecutionCheck(抽象观察者)
3
/// </summary>
4
public
abstract
class
ABSExecutionCheck
5 {
6
public
abstract
void
ComponentModelCheck(ComponentModel comModel);
7 }
8
9
/// <summary>
10
/// 送ComponentModel对象去检测(观察者)
11
/// </summary>
12
public
class
ExecutionCheck:ABSExecutionCheck
13 {
14
public
override
void
ComponentModelCheck(ComponentModel comModel)
15 {
16
//送去执行检测
17
//或者是一些其他操作
18 }
19 }
|
然后再对ComponentModelFactory进行改造,并且抽象它。
1
2
3
4
5
6
7
8
9
10
|
1
/// <summary>
2
/// 抽象目标
3
/// </summary>
4
public
abstract
class
ABSComponentModelFactory
5 {
6
protected
ABSExecutionCheck absExecutionCheck;
7
public
abstract
void
RegisterABSExecutionCheck(ABSExecutionCheck executionCheck);
8
public
abstract
void
ClearABSExecutionCheck();
9
public
abstract
void
PastMessage(ComponentModel componentModel);
10 }
|
ABSComponentModelFactory类型是要让ComponentModelFactory类型实现的,从这里可以看出是遵循设计原则的面对抽象编程的,当然了最后一个PastMessage函数忽略掉,现在来看一下实现了抽象目标ABSComponentModelFactory的ComponentModelFactory(具体目标)的实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
1
/// <summary>
2
/// 示例ComponentModel类型工厂 生产了ComponentModel 通知ExecutionCheck对象去检测 (具体目标)
3
/// </summary>
4
public
class
ComponentModelFactory:ABSComponentModelFactory
5 {
6
public
static
ComponentModel ComModelFactory()
7 {
8
return
new
ComponentModel();
9 }
10
11
public
override
void
RegisterABSExecutionCheck(ABSExecutionCheck executionCheck)
12 {
13 absExecutionCheck = executionCheck;
14 }
15
16
public
override
void
ClearABSExecutionCheck()
17 {
18 absExecutionCheck =
null
;
19 }
20
public
override
void
PastMessage(ComponentModel componentModel)
21 {
22 absExecutionCheck.ComponentModelCheck(componentModel);
23 }
24 }
|
现在再来看一下调用的代码:
1
2
3
4
|
1 ABSExecutionCheck executionCheck =
new
ExecutionCheck();
2 ABSComponentModelFactory componentModelFactory =
new
ComponentModelFactory();
3 componentModelFactory.RegisterABSExecutionCheck(executionCheck);
4 componentModelFactory.PastMessage(ComponentModelFactory.ComModelFactory());
|
这样就比较稳固了,在第一行new ExecutionCheck()的地方可以动态注入,和最后行的工厂生产对象一样。因为这里只是示例就不会很严谨。 还有要说的就是定义中是一对多,这样可以修改ABSComponentModelFactory类型中的字段,修改为集合类型就可以了。 把对应的实现类也适当的修改一下就可以了。
观察者就讲到这里。下一篇是外观,敬请期待。
本文转自jinyuan0829 51CTO博客,原文链接:http://blog.51cto.com/jinyuan/1409132,如需转载请自行联系原作者