﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>语源科技BlogJava-myjava</title><link>http://www.blogjava.net/zhqh/</link><description>myjavablog</description><language>zh-cn</language><lastBuildDate>Sat, 02 May 2026 10:21:58 GMT</lastBuildDate><pubDate>Sat, 02 May 2026 10:21:58 GMT</pubDate><ttl>60</ttl><item><title>设计模式之进化论(1)</title><link>http://www.blogjava.net/zhqh/archive/2008/08/14/221966.html</link><dc:creator>zhqh</dc:creator><author>zhqh</author><pubDate>Thu, 14 Aug 2008 04:54:00 GMT</pubDate><guid>http://www.blogjava.net/zhqh/archive/2008/08/14/221966.html</guid><wfw:comment>http://www.blogjava.net/zhqh/comments/221966.html</wfw:comment><comments>http://www.blogjava.net/zhqh/archive/2008/08/14/221966.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.blogjava.net/zhqh/comments/commentRss/221966.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/zhqh/services/trackbacks/221966.html</trackback:ping><description><![CDATA[这次这个主题还是关于设计模式的，在早期的一篇已经写了，一直到现在还没继续完成他。而为什么又写这主题呢？因为，这跟前面的主题确有不同之处，这回主要阐述了设计模式的进化问题。 <br />
到了今天，终于有点时间完成这主题了... <br />
目录结构： <br />
1.基本概念 <br />
2.基础结构 <br />
3.基于基础结构的模式演化过程 <br />
其实这样的层次是很简单了，在基础结构诞生之后，基于委托的模式已经算是很明了的了。然后，大概介绍几个基于委托的模式的演化过程 <br />
1.基本概念 <br />
这里列出了几个相关概念。 <br />
委托 <br />
临时委托 <br />
DIP原则 <br />
客户 <br />
中介者（我叫它为管理器和调度器，当然，在不同模式中，取名有所差别） <br />
目标对象 <br />
2.基本结构 <br />
编程中，当你需要某种服务，你当然会去调用具有该服务的目标对象（有可能是更高层次的组件），很显然，结果，就是这样一个的结构。client调用ClassA来实现某种服务。<br />
<wbr><wbr><a href="http://sz.photo.store.qq.com/rurl2=1c386acd6b8b8b95eb9631675fac9d7ab134c672fd787da69c59f3fd8fa0f21aa8052b30fd6efc8ec22f25ad6751acd481cbb04687cf96837b01a2cbb62ad815379395e63c3dbe3485445fd8900d32a3a9cfd4b2" target="_blank"></a><img height="62" alt="" src="http://www.blogjava.net/images/blogjava_net/zhqh/1.jpg" width="256" border="0" /><br />
比如，为了处理字符串，你会new String，然后进行一些处理。甚至，你的代码里到处都充砌着String的足迹，这样确实能很好的解决问题。这样的结构背后的理由呢？首先，我想说的是，这样的结构违反了DIP原则，细节应该依赖于抽象，而不是依赖于另一个细节。这样的依赖关系会使代码缺乏弹性，很难复用，迁一发动全身。应该改进的是，把ClassA的抽象提取出来，然后让client去依赖于IClassA,变成如下图：&nbsp;<br />
<wbr><a href="http://sz.photo.store.qq.com/rurl2=f4dc3151d2c6309947e225b2c9fe40c3680499cac8c36c6596c8e7a3e19a652dadc005dcf8ac015fa7f754d92f075d4be279ca88c1f7c37445d5f831e31f8f66fdcce9e3443abb469841531b6f70240fdf8efd17" target="_blank"></a><wbr><a href="http://sz.photo.store.qq.com/rurl2=f4dc3151d2c6309947e225b2c9fe40c3680499cac8c36c6596c8e7a3e19a652dadc005dcf8ac015fa7f754d92f075d4be279ca88c1f7c37445d5f831e31f8f66fdcce9e3443abb469841531b6f70240fdf8efd17" target="_blank"></a><img height="165" alt="" src="http://www.blogjava.net/images/blogjava_net/zhqh/2.jpg" width="253" border="0" />&nbsp;<br />
<br />
但是，事实上，我们没有这么做。这是因为String这样的类实例具有很强的稳定性，这样的稳定性保证了它不会经常变化，这就是行为的稳定性因素。这样具有强稳定性的类没必要复杂化。所以，我们让接受了client依赖于细节的结果。这样的细节是单一的。 <br />
然而，需求是变化的，解决方案是不稳定的，在我们的项目中，会有大量不具稳定性的因素存在。在项目中，你会发现存在着多个同性质而实现细节有异的行为类存在。 <br />
比如存在着这样的三个类ClassA,ClassB, ClassC, <br />
client在不同地方调用它。结构图如下：&nbsp;<br />
<wbr><a href="http://sz.photo.store.qq.com/rurl2=9663c78610aaf97914f50c4168fdd548b5ab14ac11829f806599e0ed1a017ad1359f99c4aefde511a63dcec5d158c185ac77cafb0757122f9de4a366b0a09b421a9ae71e627a6e89510d86e23fe253b3381463b2" target="_blank"></a><wbr><a href="http://sz.photo.store.qq.com/rurl2=9663c78610aaf97914f50c4168fdd548b5ab14ac11829f806599e0ed1a017ad1359f99c4aefde511a63dcec5d158c185ac77cafb0757122f9de4a366b0a09b421a9ae71e627a6e89510d86e23fe253b3381463b2" target="_blank"></a><img height="257" alt="" src="http://www.blogjava.net/images/blogjava_net/zhqh/3.jpg" width="290" border="0" />&nbsp;<br />
<br />
我假设client是个main函数，OK，调用的代码应该是这样， <br />
void main(){ <br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;... <br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ClassA a = new ClassA(); <br />
<br />
(1)&nbsp;&nbsp;&nbsp;&nbsp;a.MethodOne(); <br />
(2)&nbsp;&nbsp;&nbsp;&nbsp;for(int i=0;i&lt;3;i++){ <br />
(3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; a.MethodTwo(); <br />
(4)&nbsp;&nbsp;&nbsp;&nbsp;} <br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ..... <br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ClassB b = new ClassB(); <br />
(5)&nbsp;&nbsp;&nbsp;&nbsp;b.MethodOne(); <br />
(6)&nbsp;&nbsp;&nbsp;&nbsp;for(int i=0;i&lt;3;i++){ <br />
(7)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; b.MethodTwo(); <br />
(8)&nbsp;&nbsp;&nbsp;&nbsp;} <br />
<br />
} <br />
这样的代码，给你的感觉怎么样，也许还蛮过得去，他确实是跑得起来。但这样的代码存在潜在的危险性。应该被归入糟糕设计的范畴里。首先，客户面对不具稳定性的因素，根据DIP原则，它没有提取抽象，违反了DIP原则。其次，client（main）必须负责策略的组织(我把类似(1)(2)(3)(4)的目标对象的这样一组调用过程称为策略组织),也就是说，client面对的不是一个完全的黑盒子，他面对的是一些半黑的盒子，同时，他必须知道怎么把这些半黑的盒子组装起来。例如(5)(6)(7)(8)这些对客户来说，是一组半黑的盒子。客户本身的任务太重了，同时，这样的任务弥漫在客户的头和脚之间，及其零乱。很快，又有类似的另一种不具稳定性的因素参与这样的弥漫活动，最终的客户将被淹没在不稳定性因素组成的大海里。如果，刚好是你在负责这样的客户编码，我，很同情你。重构吧，老兄。 <br />
不满意，好，我们做第一次修改，根据DIP原则，我们提取这三个类的抽象。比如IClass, 然后，大家都实现他。然后，把ClassA a = new ClassA(); 改为IClass a = new ClassA();OK，很好的遵循了DIP原则。然后，我们需要有一个参与者，我称该类为Context或(Manager,mediator)，它的职责很简单，仅仅负责半黑盒子的组装。我们没有给予他过多的职责。SRP的违反同样让人觉得可怕。并把IClass作为一个委托对象属性传递给它。结构图如下：&nbsp;<br />
<wbr><a href="http://sz.photo.store.qq.com/rurl2=c98e25fb201de91bd82e3d65ef13df99ea9fc9ec6c88fa158709cb72852b779e2a450a7cc9e093cac5999b13ecf8ac412ba9d9bb8a554b0209603d83ab8ce6f4a4a00bd2c5c2668702e4161e3e757f6e68a67293" target="_blank"></a><wbr><a href="http://sz.photo.store.qq.com/rurl2=c98e25fb201de91bd82e3d65ef13df99ea9fc9ec6c88fa158709cb72852b779e2a450a7cc9e093cac5999b13ecf8ac412ba9d9bb8a554b0209603d83ab8ce6f4a4a00bd2c5c2668702e4161e3e757f6e68a67293" target="_blank"></a><img height="303" alt="" src="http://www.blogjava.net/images/blogjava_net/zhqh/4.jpg" width="473" border="0" />&nbsp;<br />
<br />
这样，客户很轻松的从半黑盒子的策略组织中脱离出来，它只管在Context与这三个类之间进行装配，而装配的方式，你可以自由选择任何一种注入方式。例如： <br />
你给Context装配一个ClassB。 <br />
Context context = new Context(new ClassB()); <br />
OK，针对于不稳定性因素的解决方案的基础结构出来了。这也是基于委托的设计模式的基础。这样的模型具有潜在的进化与退化问题。 <br />
1.Context是个具体类，具有不稳定性，有着往抽象方向的进化。 <br />
2.A线上是个委托属性。有着往临时委托方向的退化。 <br />
3.B线上create过程有从客户向Context转移的变化性。 <br />
4.Context的组织权有着向IClass转移的可能性。 <br />
在下面的继续中，我们会从基本型中根据这四个进化与退化以及委托的意义，演变出不同的模式。 同时，我会把各个模式自身的进化与退化做个简介（自身的演化可能演变成别的模式） <br />
等待继续..... 
<img src ="http://www.blogjava.net/zhqh/aggbug/221966.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/zhqh/" target="_blank">zhqh</a> 2008-08-14 12:54 <a href="http://www.blogjava.net/zhqh/archive/2008/08/14/221966.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>