Roy_Sashulin

设计模式(Patterns in Java)

设计模式(Patterns in Java) -- http://www.jdon.com
1
设计模式(Patterns in Java)
Java 提供了丰富的API，同时又有强大的数据库系统作底层支持，那么我们的编程似乎
变成了类似积木的简单"拼凑"和调用，甚至有人提倡"蓝领程序员",这些都是对现代编
程技术的不了解所至.
在真正可复用的面向对象编程中,GoF 的《设计模式》为我们提供了一套可复用的面向对
象技术,再配合Refactoring(重构方法),所以很少存在简单重复的工作,加上Java 代码
的精炼性和面向对象纯洁性(设计模式是java 的灵魂),编程工作将变成一个让你时刻体
验创造快感的激动人心的过程.
为能和大家能共同探讨"设计模式",我将自己在学习中的心得写下来,只是想帮助更多
人更容易理解GoF 的《设计模式》。由于原著都是以C++为例, 以Java 为例的设计模式
基本又都以图形应用为例,而我们更关心Java 在中间件等服务器方面的应用,因此,本站
所有实例都是非图形应用,并且顺带剖析Jive 论坛系统.同时为降低理解难度，尽量避
免使用UML 图.
如果你有一定的面向对象编程经验,你会发现其中某些设计模式你已经无意识的使用过
了;如果你是一个新手,那么从开始就培养自己良好的编程习惯(让你的的程序使用通用
的模式,便于他人理解;让你自己减少重复性的编程工作),这无疑是成为一个优秀程序
员的必备条件.
整个设计模式贯穿一个原理:面对接口编程，而不是面对实现.目标原则是:降低耦合,增
强灵活性.
1:前言
学习GoF 设计模式的重要性
建筑和软件中模式之异同
2:GoF 设计模式
A.创建模式
设计模式之Factory(工厂方法和抽象工厂)
使用工厂模式就象使用new 一样频繁.
设计模式之Prototype(原型)
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的
对象。
设计模式(Patterns in Java) -- http://www.jdon.com
2
设计模式之Builder
汽车由车轮方向盘发动机很多部件组成，同时，将这些部件组装
成汽车也是一件复杂的工作，Builder 模式就是将这两种情况分开
进行。
设计模式之Singleton(单态)
保证一个类只有一个实例,并提供一个访问它的全局访问点
B.结构模式
设计模式之Facade
可扩展的使用JDBC 针对不同的数据库编程,Facade 提供了一种灵
活的实现.
设计模式之Proxy
以Jive 为例,剖析代理模式在用户级别授权机制上的应用
设计模式之Adapter
使用类再生的两个方式:组合(new)和继承(extends),这个已经在
"thinking in java"中提到过.
设计模式之Composite
就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，
你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。
文章中还对Jive 再进行了剖析。
设计模式之Decorator
Decorator 是个油漆工,给你的东东的外表刷上美丽的颜色.
设计模式之Bridge
将"牛郎织女"分开(本应在一起,分开他们,形成两个接口),在他们之
间搭建一个桥(动态的结合)
设计模式之Flyweight
提供Java 运行性能,降低小而大量重复的类的开销.
C.行为模式
设计模式之Template
实际上向你介绍了为什么要使用Java 抽象类,该模式原理简单,使
用很普遍.
设计模式之Memento
很简单一个模式,就是在内存中保留原来数据的拷贝.
设计模式之Observer
介绍如何使用Java API 提供的现成Observer
设计模式(Patterns in Java) -- http://www.jdon.com
3
设计模式之Chain of Responsibility
各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不
要推委给下一个.
设计模式之Command
什么是将行为封装,Command 是最好的说明.
设计模式之State
状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便
可在状态中轻松切换.
设计模式之Strategy
不同算法各自封装,用户端可随意挑选需要的算法.
设计模式之Mediator
Mediator 很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可
以.
设计模式之Interpreter
主要用来对语言的分析,应用机会不多.
设计模式之Visitor
访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.
设计模式之Iterator
这个模式已经被整合入Java 的Collection.在大多数场合下无需自
己制造一个Iterator,只要将对象装入Collection中，直接使用Iterator
进行对象遍历。
3:英文资料
Thinking in Patterns with Java Thinking in Java 的作者Eckel 又一
著作!
CMSC491D Design Patterns In Java
Overview of Design Patterns 精确定义各个模式以及他们的关系
Design Patterns Java Companion
EJB 设计模式(英文) 从设计模式去理解EJB 或J2EE我认为是个非常有效
的办法.
设计模式(Patterns in Java) -- http://www.jdon.com
4
学习GoF 设计模式的重要性
GoF 的《设计模式》也许你没有听说过,但是《Thingking in Java》(Java 编程思想)你应该
知道甚至读过吧！
在浏览《Thingking in Java》(第一版)时，你是不是觉得好象这还是一本Java 基础语言书
籍？但又不纯粹是，因为这本书的作者将面向对象的思想巧妙的融合在Java 的具体技术上，
潜移默化的让你感觉到了一种新的语言和新的思想方式的诞生。
但是读完这本书，你对书中这些蕴含的思想也许需要一种更明晰更系统更透彻的了解和掌
握，那么你就需要研读GoF 的《设计模式》了。
《Thingking in Java》(第一版中文)是这样描述设计模式的：他在由Gamma, Helm 和Johnson
Vlissides 简称Gang of Four(四人帮),缩写GoF 编著的《Design Patterns》一书中被定义
成一个“里程碑”。事实上，那本书现在已成为几乎所有OOP(面向对象程序设计)程序员都
必备的参考书。(在国外是如此)。
GoF 的《设计模式》是所有面向对象语言(C++ Java C#)的基础，只不过不同的语言将之实
现得更方便地使用。
GOF 的设计模式是一座"桥"
就Java 语言体系来说，GOF 的设计模式是Java 基础知识和J2EE 框架知识之间一座隐性的"
桥"。
会Java 的人越来越多，但是一直徘徊在语言层次的程序员不在少数，真正掌握Java 中接口
或抽象类的应用不是很多，大家经常以那些技术只适合大型项目为由，避开或忽略它们，实
际中，Java 的接口或抽象类是真正体现Java 思想的核心所在，这些你都将在GoF 的设计模
式里领略到它们变幻无穷的魔力。
GoF 的设计模式表面上好象也是一种具体的"技术"，而且新的设计模式不断在出现，设计模
式自有其自己的发展轨道，而这些好象和J2EE .Net 等技术也无关！
实际上，GoF 的设计模式并不是一种具体"技术",它讲述的是思想，它不仅仅展示了接口或
抽象类在实际案例中的灵活应用和智慧，让你能够真正掌握接口或抽象类的应用，从而在原
来的Java 语言基础上跃进一步，更重要的是，GoF 的设计模式反复向你强调一个宗旨：要
让你的程序尽可能的可重用。
这其实在向一个极限挑战：软件需求变幻无穷，计划没有变化快，但是我们还是要寻找出不
变的东西，并将它和变化的东西分离开来，这需要非常的智慧和经验。
而GoF 的设计模式是在这方面开始探索的一块里程碑。
设计模式(Patterns in Java) -- http://www.jdon.com
5
J2EE 等属于一种框架软件，什么是框架软件？它不同于我们以前接触的Java API 等，那些
属于Toolkist(工具箱)，它不再被动的被使用，被调用，而是深刻的介入到一个领域中去，
J2EE 等框架软件设计的目的是将一个领域中不变的东西先定义好，比如整体结构和一些主
要职责(如数据库操作事务跟踪安全等)，剩余的就是变化的东西，针对这个领域中具体应
用产生的具体不同的变化需求，而这些变化东西就是J2EE 程序员所要做的。
由此可见，设计模式和J2EE 在思想和动机上是一脉相承，只不过
1.设计模式更抽象，J2EE 是具体的产品代码，我们可以接触到，而设计模式在对每个应用
时才会产生具体代码。
2.设计模式是比J2EE 等框架软件更小的体系结构，J2EE 中许多具体程序都是应用设计模式
来完成的，当你深入到J2EE 的内部代码研究时，这点尤其明显，因此，如果你不具备设计
模式的基础知识(GoF 的设计模式)，你很难快速的理解J2EE。不能理解J2EE,如何能灵活应
用？
3.J2EE 只是适合企业计算应用的框架软件，但是GoF 的设计模式几乎可以用于任何应用！
因此GoF 的设计模式应该是J2EE 的重要理论基础之一。
所以说，GoF 的设计模式是Java 基础知识和J2EE 框架知识之间一座隐性的"桥"。为什么说
隐性的？
GOF 的设计模式是一座隐性的"桥"
因为很多人没有注意到这点，学完Java 基础语言就直接去学J2EE,有的甚至鸭子赶架，直
接使用起Weblogic 等具体J2EE 软件，一段时间下来，发现不过如此，挺简单好用，但是你
真正理解J2EE 了吗？你在具体案例中的应用是否也是在延伸J2EE 的思想？
如果你不能很好的延伸J2EE 的思想，那你岂非是大炮轰蚊子，认识到J2EE 不是适合所有场
合的人至少是明智的，但我们更需要将J2EE 用对地方，那么只有理解J2EE 此类框架软件的
精髓，那么你才能真正灵活应用Java 解决你的问题，甚至构架出你自己企业的框架来。(我
们不能总是使用别人设定好的框架，为什么不能有我们自己的框架？)
因此，首先你必须掌握GoF 的设计模式。虽然它是隐性，但不是可以越过的。
在著名的EJB 领域顶尖的专家Richard Monson-Haefel 的个人网站:www.EJBNow.com 中
Richard 极力推荐的几本书中就有GoF 的《设计模式》,原文如下:
Design Patterns
Most developers claim to experience an epiphany reading this book. If you've never
read the Design Patterns book then you have suffered a very serious gap in your
programming education that should be remedied immediately.
翻译: 很多程序员在读完这本书,宣布自己相当于经历了一次"主显节"(纪念那稣降生和受
洗的双重节日),如果你从来没有读过这本书,你会在你的程序教育生涯里存在一个严重裂沟,
所以你应该立即挽救弥补!
设计模式(Patterns in Java) -- http://www.jdon.com
6
设计模式(Patterns in Java) -- http://www.jdon.com
7
建筑和软件中模式之异同
CSDN 的透明特别推崇《建筑的永恒之道》,认为从中探寻到软件的永恒之道,并就"设计模式
"写了专门文章《探寻软件的永恒之道》,其中很多观点我看了很受启发,以前我也将"设计
模式" 看成一个简单的解决方案,没有从一种高度来看待"设计模式"在软件中地位,下面是
我自己的一些想法:
建筑和软件某些地方是可以来比喻的
特别是中国传统建筑,那是很讲模式的,这些都是传统文化使然,比如京剧一招一式都有套
路;中国画,也有套路,树应该怎么画法?有几种画法?艺术大家通常是创造出自己的套路,比
如明末清初,水墨画法开始成熟,这时画树就不用勾勒这个模式了,而是一笔下去,浓淡几个
叶子,待毛笔的水墨要干枯时,画一下树干,这样,一个活生写意的树就画出来.
我上面这些描述其实都是一种模式,创建模式的人是大师,但是拘泥于模式的人永远是工匠.
再回到传统建筑中,中国的传统建筑是过分注重模式了,所以建筑风格发展不大,基本分南北
两派,大家有个感觉,旅游时,到南方,你发现古代名居建筑都差不多;北方由于受满人等少数
民族的影响,在建筑色彩上有些与南方迥异,但是很多细节地方都差不多.这些都是模式的体
现.
由于建筑受材料和功用以及费用的影响,所用模式种类不多,这点是和软件很大的不同.
正因为这点不同,导致建筑的管理模式和软件的管理模式就有很多不同, 有些人认识不到这
点,就产生了可以大量使用"软件蓝领"的想法,因为他羡慕建筑中"民工"的低成本.
要知道软件还有一个与建筑截然相反的责任和用途,那就是:现代社会中,计划感不上变化,
竞争激烈,所有一切变幻莫测,要应付所有这些变化,首推信息技术中的软件,只有软件能够
帮助人类去应付各种变化.而这点正好与建筑想反,建筑是不能帮助人类去应付变化的,(它
自己反而要求稳固,老老实实帮助人遮风避雨,总不能叫人类在露天或树叶下打开电脑编软
件吧).
软件要帮助人类去应付变化,这是软件的首要责任,所以,软件中模式产生的目的就和建筑不
一样了,建筑中的模式产生可以因为很多原因:建筑大师的创意;材料的革新等;建筑中这些
模式一旦产生,容易发生另外一个缺点,就是有时会阻碍建筑本身的发展,因为很多人会不思
创造,反复使用老的模式进行设计,阻碍建筑的发展.
但是在软件中,这点正好相反,软件模式的产生是因为变化的东西太多,为减轻人类的负担,
将一些不变的东西先用模式固化,这样让人类可以更加集中精力对付变化的东西,所以在软
件中大量反复使用模式(我个人认为这样的软件就叫框架软件了,比如J2EE),不但没阻碍软
件的发展,反而是推动了软件的发展.因为其他使用这套软件的人就可以将更多精力集中在
对付那些无法用模式的应用上来.
设计模式(Patterns in Java) -- http://www.jdon.com
8
可以关于建筑和软件中的模式作用可以总结如下:
在软件中,模式是帮助人类向"变化"战斗,但是在软件中还需要和'变化'直接面对面战斗的
武器:人的思维,特别是创造分析思维等等，这些是软件真正的灵魂，这种思维可以说只要
有实践需求(如有新项目)就要求发生，发生频度高，人类的创造或分析思维决定了软件的质
量和特点。
而在建筑中,模式可以构成建筑全部知识，当有新的需求(如有新项目)，一般使用旧的模式
都可以完成，因此对人类的创造以及分析思维不是每个项目都必须的，也不是非常重要的，
对创造性的思维的需求只是属于锦上添花（除非人类以后离开地球居住了）。
设计模式(Patterns in Java) -- http://www.jdon.com
9
设计模式之Factory
定义:提供创建对象的接口.
为何使用?
工厂模式是我们最常用的模式了,著名的Jive 论坛系统,就大量使用了工厂模式.
为什么说工厂模式是最常用,因为工厂模式就相当于创建对象的new. 工厂模式就是用来创
建对象的.
比如我们有一个类Sample 我们要创建Sample 的对象:
Sample sample=new Sample();
如果我们要在创建sample 之前做点事情,比如,赋值等,可以使用Sample 的构造函数:
Sample sample=new Sample(参数);
如果创建sample 时做的事情不是如赋值这样简单的事,可能是很长一段代码,如果也写入构
造函数中,那明显的就违背了面向对象的原则.封装(Encapsulation)和分派(Delegation);
我们需要将创建实例的责任与使用实例的责任分开, 使得语句
Sample sample=new Sample(参数);
就是简单的责任:使用Sample 这个实例;至于创建Sample 的任务就交给了Factory 工厂模
式.
还有,如果Sample 有个继承如MySample, 按照面向接口编程,我们需要将Sample 抽象成一
个接口.
现在Sample 是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着项目的深入,Sample 可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实
例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程
序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
你会建立一个专门生产Sample 实例的工厂:
设计模式(Patterns in Java) -- http://www.jdon.com
10
public class Factory{
public static Sample creator(){
....
if (which==1)
return new MySample();
else if (which==2)
return new HisSample();
}
}
那么在你的程序中,如果要实例化MySample 时.就使用
Sample sample=Factory.creator();
这样,在整个就不涉及到Sample 的具体子类,达到封装效果,也就减少错误修改的机会,这个
原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作
的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们
从编程序中也能悟出人生道理?呵呵.
好了,言归正传,既然不可避免使用factory,那我们就认识一下工厂模式.
如何使用?
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
上例中,我们使用的是简单的工厂方法. 这两个模式没有很明显的区别,区别在于需要创建
对象的复杂程度上。如果我们创建对象的方法变得复杂了,我们就可能要将上例中Factory
变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator();
}
public class SimpleFactory extends Factory{
public Sample creator(){
设计模式(Patterns in Java) -- http://www.jdon.com
11
......
}
public Sample2 creator(){
......
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
}
public Sample2 creator(){
......
}
}
上例中我们只有一类产品接口Sample , 工厂方法和抽象工厂可以创建多个产品接口的实
例,比如Sample2 Sample3
FactoryMethod 往往只是创建单个的实例。Abstract Factory 创建一系列的实例组，这些实
例彼此相关。
举例1
下图是来自天极网" 阎宏"的爪哇语言抽象工厂创立性模式介绍中的抽象工厂图:
设计模式(Patterns in Java) -- http://www.jdon.com
12
在这张图中, 有两类产品接口interface RAM 和interface CPU; 同时有两个创建方
法:MacProducer 和PCProducer,这两个创建方法中都有createCPU()和createRAM(),返回的
实例对象组是CPU 和RAM, 这是分别来自两类产品接口,表面彼此是相关的.因此它是抽象工
厂.
举例2
我们以Jive 的ForumFactory 为例:
public abstract class ForumFactory {
private static Object initLock = new Object();
private static String className =
"com.jivesoftware.forum.database.DbForumFactory";
private static ForumFactory factory = null;
public static ForumFactory getInstance(Authorization authorization) {
//If no valid authorization passed in, return null.
if (authorization == null) {
return null;
}
//以下使用了Singleton 单态模式
if (factory == null) {
synchronized(initLock) {
if (factory == null) {
设计模式(Patterns in Java) -- http://www.jdon.com
13
......
try {
//动态转载类
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
}
catch (Exception e) {
return null;
}
}
}
}
//Now, 返回proxy.用来限制授权对forum 的访问
return new ForumFactoryProxy(authorization, factory,
factory.getPermissions(authorization));
}
//真正创建forum 的方法由继承forumfactory 的子类去完成.
public abstract Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException;
....
}
因为现在的Jive 是通过数据库系统存放论坛帖子等内容数据,如果有人要扩展为纯粹的文
件系统存放的论坛帖子,这个工厂方法ForumFactory 就提供了提供动态接口:
private static String className =
"com.jivesoftware.forum.database.DbForumFactory";
你可以使用自己开发的创建forum 的方法代替
com.jivesoftware.forum.database.DbForumFactory 就可以.
在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton 单态模式,以及
proxy 模式,proxy 模式主要用来授权用户对forum 的访问,因为访问forum有两种人:一个是
注册用户一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统
的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果.
设计模式(Patterns in Java) -- http://www.jdon.com
14
好了.经过上述简单描述,你对工厂模式应该有个简单的印象,如果你要钻研工厂模式,网络
上有很多英文资料,不过我觉得过分钻研也没有必要,主要是使用实践,实际使用中工厂模式
的变种很多,只要你知道这样一个大概思路,相信在实践中你会是工厂模式的设计创建高手!
设计模式(Patterns in Java) -- http://www.jdon.com
15
设计模式之Prototype(原型)
定义:
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
Prototype 模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的
细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象
通过请求原型对象拷贝它们自己来实施创建。
如何使用?
因为Java 中的提供clone()方法来实现对象的克隆(具体了解clone()按这里),所以
Prototype 模式实现一下子变得很简单.
以勺子为例：
public abstract class AbstractSpoon implements Cloneable
{
String spoonName;
public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
public String getSpoonName() {return this.spoonName;}
public Object clone()
{
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println("AbstractSpoon is not Cloneable");
}
return object;
}
}
有两个具体实现(ConcretePrototype):
public class SoupSpoon extends AbstractSpoon
{
public SoupSpoon()
{
setSpoonName("Soup Spoon");
设计模式(Patterns in Java) -- http://www.jdon.com
16
}
}
public class SaladSpoon extends AbstractSpoon
{
public SaladSpoon()
{
setSpoonName("Salad Spoon");
}
}
调用Prototype 模式很简单:
AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon = new SaladSpoon();
当然也可以结合工厂模式来创建AbstractSpoon 实例。
在Java 中Prototype 模式变成clone()方法的使用，由于Java 的纯洁的面向对象特性，使
得在Java 中使用设计模式变得很自然，两者已经几乎是浑然一体了。这反映在很多模式上，
如Interator 遍历模式。
设计模式(Patterns in Java) -- http://www.jdon.com
17
设计模式之Builder
Builder 模式定义:
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.
Builder 模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型
和内容就可以构建它们.用户不知道内部的具体构建细节.Builder 模式是非常类似抽象工
厂模式,细微的区别大概只有在反复使用中才能体会到.
为何使用?
是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件.
因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮方向盘发动机
还有各种小零件等等,部件很多,但远不止这些,如何将这些部件装配成一辆汽车,这个装配
过程也很复杂(需要很好的组装技术),Builder 模式就是为了将部件和组装过程分开.
如何使用?
首先假设一个复杂对象是由多个部件组成的,Builder 模式是把复杂对象的创建和部件的创
建分别开来,分别用Builder 类和Director 类来表示.
首先,需要一个接口,它定义如何创建复杂对象的各个部件:
public interface Builder {
//创建部件A 比如创建汽车车轮
void buildPartA();
//创建部件B 比如创建汽车方向盘
void buildPartB();
//创建部件C 比如创建汽车发动机
void buildPartC();
//返回最后组装成品结果(返回最后装配好的汽车)
//成品的组装过程不在这里进行,而是转移到下面的Director 类中
进行.
//从而实现了解耦过程和部件
Product getResult();
}
用Director 构建最后的复杂对象,而在上面Builder 接口中封装的是如何创建一个个部件
(复杂对象是由这些部件组成的),也就是说Director 的内容是如何将部件最后组装成成品:
设计模式(Patterns in Java) -- http://www.jdon.com
18
public class Director {
private Builder builder;
public Director( Builder builder ) {
this.builder = builder;
}
// 将部件partA partB partC 最后组成复杂对象
//这里是将车轮方向盘和发动机组装成汽车的过程
public void construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
Builder 的具体实现ConcreteBuilder:
通过具体完成接口Builder 来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西;
提供一个可以重新获取产品的接口:
public class ConcreteBuilder implements Builder {
Part partA, partB, partC;
public void buildPartA() {
//这里是具体如何构建partA 的代码
};
public void buildPartB() {
//这里是具体如何构建partB 的代码
};
public void buildPartC() {
//这里是具体如何构建partB 的代码
};
public Product getResult() {
//返回最后组装成品结果
};
}
复杂对象:产品Product:
设计模式(Patterns in Java) -- http://www.jdon.com
19
public interface Product { }
复杂对象的部件:
public interface Part { }
我们看看如何调用Builder 模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );
director.construct();
Product product = builder.getResult();
Builder 模式的应用
在Java 实际使用中,我们经常用到"池"(Pool)的概念,当资源提供者无法提供足够的资源,
并且这些资源需要被很多用户反复共享时,就需要使用池.
"池"实际是一段内存,当池中有一些复杂的资源的"断肢"(比如数据库的连接池,也许有时一
个连接会中断),如果循环再利用这些"断肢",将提高内存使用效率,提高池的性能.修改
Builder 模式中Director 类使之能诊断"断肢"断在哪个部件上,再修复这个部件.
具体英文文章见:Recycle broken objects in resource pools
设计模式(Patterns in Java) -- http://www.jdon.com
20
设计模式之Singleton(单态)
定义:
Singleton 模式主要作用是保证在Java 应用程序中，一个Class 只有一个实例存在。
一个实例表示是单线程，在很多操作中，比如建立目录数据库连接都需要单线程操作，
Singleton 模式经常用于控制对系统资源的控制,我们常常看到工厂模式中工厂方法也用
Singleton 模式实现的.
如何使用?
一般Singleton 模式通常有几种形式:
public class Singleton {
private static Singleton _instance = new Singleton();
public static Singleton getInstance() {
return _instance;
}
}
调用方法：
Singleton.getInstance()
第二种形式:
public class Singleton {
private static Singleton _instance = null;
public static Singleton getInstance() {
if (_instance==null)
_instancenew Singleton()
return _instance;
}
}
调用方法：
Singleton.getInstance()
设计模式(Patterns in Java) -- http://www.jdon.com
21
Singleton 模式在创建对象时使用较多，使用它也比较简单。
设计模式(Patterns in Java) -- http://www.jdon.com
22
设计模式之Facade(外观)
Facade 的定义: 为子系统中的一组接口提供一个一致的界面.
Facade 一个典型应用就是数据库JDBC 的应用,如下例对数据库的操作:
public class DBCompare {
Connection conn = null;
PreparedStatement prep = null;
ResultSet rset = null;
try {
Class.forName( "" ).newInstance();
conn = DriverManager.getConnection( "" );
String sql = "SELECT * FROM

WHERE = ?";
prep = conn.prepareStatement( sql );
prep.setString( 1, "" );
rset = prep.executeQuery();
if( rset.next() ) {
System.out.println( rset.getString( "}
} catch( SException e ) {
e.printStackTrace();
} finally {
rset.close();
prep.close();
conn.close();
}
}
上例是Jsp 中最通常的对数据库操作办法.
在应用中,经常需要对数据库操作,每次都写上述一段代码肯定比较麻烦,需要将其中不变的
部分提炼出来,做成一个接口,这就引入了facade 外观对象.如果以后我们更换
Class.forName 中的也非常方便,比如从Mysql 数据库换到Oracle 数据库,只要更
换facade 接口中的driver 就可以.
我们做成了一个Facade 接口,使用该接口,上例中的程序就可以更改如下:
public class DBCompare {
设计模式(Patterns in Java) -- http://www.jdon.com
23
String sql = "SELECT * FROM

WHERE = ?";
try {
Mysql msql=new mysql(sql);
prep.setString( 1, "" );
rset = prep.executeQuery();
if( rset.next() ) {
System.out.println( rset.getString( "}
} catch( SException e ) {
e.printStackTrace();
} finally {
mysql.close();
mysql=null;
}
}
可见非常简单,所有程序对数据库访问都是使用改接口,降低系统的复杂性,增加了灵活性.
如果我们要使用连接池,也只要针对facade 接口修改就可以.
由上图可以看出, facade 实际上是个理顺系统间关系,降低系统间耦合度的一个常用的办法,
也许你已经不知不觉在使用,尽管不知道它就是facade.
设计模式(Patterns in Java) -- http://www.jdon.com
24
设计模式之Proxy(代理)
理解并使用设计模式,能够培养我们良好的面向对象编程习惯,同时在实际应用中,可以如鱼
得水,享受游刃有余的乐趣.
Proxy 是比较有用途的一种模式,而且变种较多,应用场合覆盖从小结构到整个系统的大结
构,Proxy 是代理的意思,我们也许有代理服务器等概念,代理概念可以解释为:在出发点到
目的地之间有一道中间层,意为代理.
设计模式中定义: 为其他对象提供一种代理以控制对这个对象的访问.
为什么要使用Proxy?
1.授权机制不同级别的用户对同一对象拥有不同的访问权利,如Jive 论坛系统中,就使用
Proxy 进行授权机制控制,访问论坛有两种人:注册用户和游客(未注册用户),Jive 中就通过
类似ForumProxy 这样的代理来控制这两种用户对论坛的访问权限.
2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
举例两个具体情况:
(1)如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包
含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处
理完成,这时需要做个图片Proxy 来代替真正的图片.
(2)如果那个对象在Internet 的某个远端服务器上,直接操作这个对象因为网络速度原因可
能比较慢,那我们可以先用Proxy 来代替那个对象.
总之原则是,对于开销很大的对象,只有在使用它时才创建,这个原则可以为我们节省很多宝
贵的Java 内存. 所以,有些人认为Java 耗费资源内存,我以为这和程序编制思路也有一定的
关系.
如何使用Proxy?
以Jive 论坛系统为例,访问论坛系统的用户有多种类型:注册普通用户论坛管理者系统管
理者游客,注册普通用户才能发言;论坛管理者可以管理他被授权的论坛;系统管理者可以
管理所有事务等,这些权限划分和管理是使用Proxy 完成的.
Forum 是Jive 的核心接口,在Forum 中陈列了有关论坛操作的主要行为,如论坛名称论坛描
述的获取和修改,帖子发表删除编辑等.
在ForumPermissions 中定义了各种级别权限的用户:
public class ForumPermissions implements Cacheable {
/**
设计模式(Patterns in Java) -- http://www.jdon.com
25
* Permission to read object.
*/
public static final int READ = 0;
/**
* Permission to administer the entire sytem.
*/
public static final int SYSTEM_ADMIN = 1;
/**
* Permission to administer a particular forum.
*/
public static final int FORUM_ADMIN = 2;
/**
* Permission to administer a particular user.
*/
public static final int USER_ADMIN = 3;
/**
* Permission to administer a particular group.
*/
public static final int GROUP_ADMIN = 4;
/**
* Permission to moderate threads.
*/
public static final int MODERATE_THREADS = 5;
/**
* Permission to create a new thread.
*/
public static final int CREATE_THREAD = 6;
/**
* Permission to create a new message.
*/
public static final int CREATE_MESSAGE = 7;
/**
* Permission to moderate messages.
*/
public static final int MODERATE_MESSAGES = 8;
设计模式(Patterns in Java) -- http://www.jdon.com
26
.....
public boolean isSystemOrForumAdmin() {
return (values[FORUM_ADMIN] || values[SYSTEM_ADMIN]);
}
.....
}
因此,Forum 中各种操作权限是和ForumPermissions 定义的用户级别有关系的,作为接口
Forum 的实现:ForumProxy 正是将这种对应关系联系起来.比如,修改Forum 的名称,只有论坛
管理者或系统管理者可以修改,代码如下:
public class ForumProxy implements Forum {
private ForumPermissions permissions;
private Forum forum;
this.authorization = authorization;
public ForumProxy(Forum forum, Authorization authorization,
ForumPermissions permissions)
{
this.forum = forum;
this.authorization = authorization;
this.permissions = permissions;
}
.....
public void setName(String name) throws UnauthorizedException,
ForumAlreadyExistsException
{
//只有是系统或论坛管理者才可以修改名称
if (permissions.isSystemOrForumAdmin()) {
forum.setName(name);
}
else {
throw new UnauthorizedException();
}
}
...
设计模式(Patterns in Java) -- http://www.jdon.com
27
}
而DbForum 才是接口Forum 的真正实现,以修改论坛名称为例:
public class DbForum implements Forum, Cacheable {
...
public void setName(String name) throws
ForumAlreadyExistsException {
....
this.name = name;
//这里真正将新名称保存到数据库中
saveToDb();
....
}
...
}
凡是涉及到对论坛名称修改这一事件,其他程序都首先得和ForumProxy 打交道,由
ForumProxy 决定是否有权限做某一样事情,ForumProxy 是个名副其实的"网关","安全代理
系统".
在平时应用中,无可避免总要涉及到系统的授权或安全体系,不管你有无意识的使用Proxy,
实际你已经在使用Proxy 了.
我们继续结合Jive 谈入深一点,下面要涉及到工厂模式了,如果你不了解工厂模式,请看我
的另外一篇文章:设计模式之Factory
我们已经知道,使用Forum 需要通过ForumProxy,Jive 中创建一个Forum 是使用Factory 模
式,有一个总的抽象类ForumFactory,在这个抽象类中,调用ForumFactory 是通过
getInstance()方法实现,这里使用了Singleton(也是设计模式之一,由于介绍文章很多,我
就不写了,看这里),getInstance()返回的是ForumFactoryProxy.
为什么不返回ForumFactory,而返回ForumFactory 的实现ForumFactoryProxy?
原因是明显的,需要通过代理确定是否有权限创建forum.
在ForumFactoryProxy 中我们看到代码如下:
设计模式(Patterns in Java) -- http://www.jdon.com
28
public class ForumFactoryProxy extends ForumFactory {
protected ForumFactory factory;
protected Authorization authorization;
protected ForumPermissions permissions;
public ForumFactoryProxy(Authorization authorization, ForumFactory factory,
ForumPermissions permissions)
{
this.factory = factory;
this.authorization = authorization;
this.permissions = permissions;
}
public Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException
{
//只有系统管理者才可以创建forum
if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
Forum newForum = factory.createForum(name, description);
return new ForumProxy(newForum, authorization, permissions);
}
else {
throw new UnauthorizedException();
}
}
方法createForum 返回的也是ForumProxy, Proxy 就象一道墙,其他程序只能和Proxy 交互
操作.
注意到这里有两个Proxy:ForumProxy 和ForumFactoryProxy. 代表两个不同的职责:使用
Forum 和创建Forum;
至于为什么将使用对象和创建对象分开,这也是为什么使用Factory 模式的原因所在:是为
了"封装" "分派";换句话说,尽可能功能单一化,方便维护修改.
Jive 论坛系统中其他如帖子的创建和使用,都是按照Forum 这个思路而来的.
以上我们讨论了如何使用Proxy 进行授权机制的访问,Proxy 还可以对用户隐藏另外一种称
为copy-on-write 的优化方式.拷贝一个庞大而复杂的对象是一个开销很大的操作,如果拷
贝过程中,没有对原来的对象有所修改,那么这样的拷贝开销就没有必要.用代理延迟这一拷
贝过程.
设计模式(Patterns in Java) -- http://www.jdon.com
29
比如:我们有一个很大的Collection,具体如hashtable,有很多客户端会并发同时访问它.
其中一个特别的客户端要进行连续的数据获取,此时要求其他客户端不能再向hashtable 中
增加或删除东东.
最直接的解决方案是:使用collection 的lock,让这特别的客户端获得这个lock,进行连续
的数据获取,然后再释放lock.
public void foFetches(Hashtable ht){
synchronized(ht){
//具体的连续数据获取动作..
}
}
但是这一办法可能锁住Collection 会很长时间,这段时间,其他客户端就不能访问该
Collection 了.
第二个解决方案是clone 这个Collection,然后让连续的数据获取针对clone 出来的那个
Collection 操作.这个方案前提是,这个Collection 是可clone 的,而且必须有提供深度
clone 的方法.Hashtable 就提供了对自己的clone 方法,但不是Key 和value 对象的clone,
关于Clone 含义可以参考专门文章.
public void foFetches(Hashtable ht){
Hashttable newht=(Hashtable)ht.clone();
}
问题又来了,由于是针对clone 出来的对象操作,如果原来的母体被其他客户端操作修改了,
那么对clone 出来的对象操作就没有意义了.
最后解决方案:我们可以等其他客户端修改完成后再进行clone,也就是说,这个特别的客户
端先通过调用一个叫clone 的方法来进行一系列数据获取操作.但实际上没有真正的进行对
象拷贝,直至有其他客户端修改了这个对象Collection.
使用Proxy 实现这个方案.这就是copy-on-write 操作.
Proxy 应用范围很广,现在流行的分布计算方式RMI 和Corba 等都是Proxy 模式的应用.
更多Proxy 应用,见http://www.research.umbc.edu/~tarr/cs491/lectures/Proxy.pdf
Sun 公司的Explore the Dynamic Proxy API Dynamic Proxy Classes
设计模式(Patterns in Java) -- http://www.jdon.com
30
设计模式之Adapter(适配器)
定义:
将两个不兼容的类纠合在一起使用，属于结构型模式,需要有Adaptee(被适配者)和
Adaptor(适配器)两个身份.
为何使用?
我们经常碰到要将两个没有关系的类组合在一起使用,第一解决方案是：修改各自类的接口，
但是如果我们没有源代码，或者，我们不愿意为了一个应用而修改各自的接口。怎么办?
使用Adapter，在这两种接口之间创建一个混合接口(混血儿).
如何使用?
实现Adapter 方式,其实"think in Java"的"类再生"一节中已经提到,有两种方式：组合
(composition)和继承(inheritance).
假设我们要打桩，有两种类：方形桩圆形桩.
public class SquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
public class RoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
} }
现在有一个应用,需要既打方形桩,又打圆形桩.那么我们需要将这两个没有关系的类综合应
用.假设RoundPeg 我们没有源代码,或源代码我们不想修改,那么我们使用Adapter 来实现这
个应用:
public class PegAdapter extends SquarePeg{
private RoundPeg roundPeg;
public PegAdapter(RoundPeg peg)(this.roundPeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);}
设计模式(Patterns in Java) -- http://www.jdon.com
31
}
在上面代码中,RoundPeg 属于Adaptee,是被适配者.PegAdapter 是Adapter,将Adaptee(被
适配者RoundPeg)和Target(目标SquarePeg)进行适配.实际上这是将组合方法
(composition)和继承(inheritance)方法综合运用.
PegAdapter 首先继承SquarePeg，然后使用new 的组合生成对象方式，生成RoundPeg 的对
象roundPeg，再重载父类insert()方法。从这里,你也了解使用new 生成对象和使用extends
继承生成对象的不同,前者无需对原来的类修改,甚至无需要知道其内部结构和源代码.
如果你有些Java 使用的经验，已经发现，这种模式经常使用。
进一步使用
上面的PegAdapter 是继承了SquarePeg,如果我们需要两边继承，即继承SquarePeg 又继承
RoundPeg,因为Java 中不允许多继承，但是我们可以实现(implements)两个接口
(interface)
public interface IRoundPeg{
public void insertIntoHole(String msg);
}
public interface ISquarePeg{
public void insert(String str);
}
下面是新的RoundPeg 和SquarePeg, 除了实现接口这一区别，和上面的没什么区别。
public class SquarePeg implements ISquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
public class RoundPeg implements IRoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
}
}
下面是新的PegAdapter,叫做two-way adapter:
public class PegAdapter implements IRoundPeg,ISquarePeg{
private RoundPeg roundPeg;
设计模式(Patterns in Java) -- http://www.jdon.com
32
private SquarePeg squarePeg;
// 构造方法
public PegAdapter(RoundPeg peg){this.roundPeg=peg;}
// 构造方法
public PegAdapter(SquarePeg peg)(this.squarePeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);}
}
还有一种叫Pluggable Adapters,可以动态的获取几个adapters 中一个。使用Reflection
技术，可以动态的发现类中的Public 方法。
设计模式(Patterns in Java) -- http://www.jdon.com
33
设计模式之Composite(组合)
Composite 定义:
将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和
组合对象的使用具有一致性.
Composite 比较容易理解，想到Composite 就应该想到树形结构图。组合体内这些对象都有
共同接口,当组合体一个对象的方法被调用执行时，Composite 将遍历(Iterator)整个树形
结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。
所以Composite 模式使用到Iterator 模式，和Chain of Responsibility 模式类似。
Composite 好处:
1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自
己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。
如何使用Composite?
首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制
不多，Composite 却有个规定，那就是要在接口内部定义一个用于访问和管理Composite 组
合体的对象们（或称部件Component）.
下面的代码是以抽象类定义，一般尽量用接口interface,
public abstract class Equipment
{
private String name;
//网络价格
public abstract double netPrice();
//折扣价格
public abstract double discountPrice();
//增加部件方法
public boolean add(Equipment equipment) { return false; }
//删除部件方法
public boolean remove(Equipment equipment) { return false; }
//注意这里，这里就提供一种用于访问组合体类的部件方法。
public Iterator iter() { return null; }
public Equipment(final String name) { this.name=name; }
}
设计模式(Patterns in Java) -- http://www.jdon.com
34
抽象类Equipment 就是Component 定义，代表着组合体类的对象们,Equipment 中定义几个
共同的方法。
public class Disk extends Equipment
{
public Disk(String name) { super(name); }
//定义Disk 网络价格为1
public double netPrice() { return 1.; }
//定义了disk 折扣价格是0.5 对折。
public double discountPrice() { return .5; }
}
Disk 是组合体内的一个对象，或称一个部件，这个部件是个单独元素( Primitive)。
还有一种可能是，一个部件也是一个组合体，就是说这个部件下面还有'儿子'，这是树形结
构中通常的情况，应该比较容易理解。现在我们先要定义这个组合体：
abstract class CompositeEquipment extends Equipment
{
private int i=0;
//定义一个Vector 用来存放'儿子'
private Lsit equipment=new ArrayList();
public CompositeEquipment(String name) { super(name); }
public boolean add(Equipment equipment) {
this.equipment.add(equipment);
return true;
}
public double netPrice()
{
double netPrice=0.;
Iterator iter=equipment.iterator();
for(iter.hasNext())
netPrice+=((Equipment)iter.next()).netPrice();
return netPrice;
}
public double discountPrice()
{
double discountPrice=0.;
Iterator iter=equipment.iterator();
for(iter.hasNext())
设计模式(Patterns in Java) -- http://www.jdon.com
35
discountPrice+=((Equipment)iter.next()).discountPrice();
return discountPrice;
}
//注意这里，这里就提供用于访问自己组合体内的部件方法。
//上面dIsk 之所以没有，是因为Disk 是个单独(Primitive)的元素.
public Iterator iter()
{
return equipment.iterator() ;
{
//重载Iterator 方法
public boolean hasNext() { return i//重载Iterator 方法
public Object next()
{
if(hasNext())
return equipment.elementAt(i++);
else
throw new NoSuchElementException();
}
}
上面CompositeEquipment 继承了Equipment,同时为自己里面的对象们提供了外部访问的方
法,重载了Iterator,Iterator 是Java 的Collection 的一个接口，是Iterator 模式的实现.
我们再看看CompositeEquipment 的两个具体类:盘盒Chassis 和箱子Cabinet，箱子里面可
以放很多东西，如底板，电源盒，硬盘盒等；盘盒里面可以放一些小设备，如硬盘软驱等。
无疑这两个都是属于组合体性质的。
public class Chassis extends CompositeEquipment
{
public Chassis(String name) { super(name); }
public double netPrice() { return 1.+super.netPrice(); }
public double discountPrice()
{ return .5+super.discountPrice(); }
}
public class Cabinet extends CompositeEquipment
{
设计模式(Patterns in Java) -- http://www.jdon.com
36
public Cabinet(String name) { super(name); }
public double netPrice() { return 1.+super.netPrice(); }
public double discountPrice()
{ return .5+super.discountPrice(); }
}
至此我们完成了整个Composite 模式的架构。
我们可以看看客户端调用Composote 代码:
Cabinet cabinet=new Cabinet("Tower");
Chassis chassis=new Chassis("PC Chassis");
//将PC Chassis 装到Tower 中(将盘盒装到箱子里)
cabinet.add(chassis);
//将一个10GB 的硬盘装到PC Chassis (将硬盘装到盘盒里)
chassis.add(new Disk("10 GB"));
//调用netPrice()方法;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());
上面调用的方法netPrice()或discountPrice()，实际上Composite 使用Iterator 遍历了
整个树形结构,寻找同样包含这个方法的对象并实现调用执行.
Composite 是个很巧妙体现智慧的模式，在实际应用中，如果碰到树形结构，我们就可以尝
试是否可以使用这个模式。
以论坛为例，一个版(forum)中有很多帖子(message),这些帖子有原始贴，有对原始贴的回
应贴，是个典型的树形结构，那么当然可以使用Composite 模式，那么我们进入Jive 中看
看，是如何实现的.
Jive 解剖
在Jive 中ForumThread 是ForumMessages 的容器container(组合体).也就是说，
ForumThread 类似我们上例中的CompositeEquipment.它和messages 的关系如图：
[thread]
|- [message]
|- [message]
|- [message]
|- [message]
|- [message]
我们在ForumThread 看到如下代码：
设计模式(Patterns in Java) -- http://www.jdon.com
37
public interface ForumThread {
....
public void addMessage(ForumMessage parentMessage,
ForumMessage newMessage)
throws UnauthorizedException;
public void deleteMessage(ForumMessage message)
throws UnauthorizedException;
public Iterator messages();
....
}
类似CompositeEquipment, 提供用于访问自己组合体内的部件方法: 增加删除遍历.
结合我的其他模式中对Jive 的分析，我们已经基本大体理解了Jive 论坛体系的框架，如果
你之前不理解设计模式，而直接去看Jive 源代码，你肯定无法看懂。
设计模式(Patterns in Java) -- http://www.jdon.com
38
设计模式之Decorator(油漆工)
Decorator 常被翻译成"装饰",我觉得翻译成"油漆工"更形象点,油漆工(decorator)是用来
刷油漆的,那么被刷油漆的对象我们称decoratee.这两种实体在Decorator 模式中是必须
的.
Decorator 定义:
动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator 模式相比用生成
子类方式达到功能的扩充显得更为灵活.
为什么使用Decorator?
我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势
必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓
展功能,这些功能是编译时就确定了,是静态的.
使用Decorator 的理由是:这些功能需要由用户动态决定加入的方式和时机.Decorator 提供
了"即插即用"的方法,在运行期间决定何时增加何种功能.
如何使用?
举Adapter 中的打桩示例,在Adapter 中有两种类:方形桩圆形桩,Adapter 模式展示如何综
合使用这两个类,在Decorator 模式中,我们是要在打桩时增加一些额外功能,比如,挖坑在
桩上钉木板等,不关心如何使用两个不相关的类.
我们先建立一个接口:
public interface Work
{
public void insert();
}
接口Work 有一个具体实现:插入方形桩或圆形桩,这两个区别对Decorator 是无所谓.我们以
插入方形桩为例:
public class SquarePeg implements Work{
public void insert(){
System.out.println("方形桩插入");
}
}
设计模式(Patterns in Java) -- http://www.jdon.com
39
现在有一个应用:需要在桩打入前,挖坑,在打入后,在桩上钉木板,这些额外的功能是动态,
可能随意增加调整修改,比如,可能又需要在打桩之后钉架子(只是比喻).
那么我们使用Decorator 模式,这里方形桩SquarePeg 是decoratee(被刷油漆者),我们需要
在decoratee 上刷些"油漆",这些油漆就是那些额外的功能.
public class Decorator implements Work{
private Work work;
//额外增加的功能被打包在这个List 中
private ArrayList others = new ArrayList();
//在构造器中使用组合new 方式,引入Work 对象;
public Decorator(Work work)
{
this.work=work;
others.add("挖坑");
others.add("钉木板");
}
public void insert(){
newMethod();
}
//在新方法中,我们在insert 之前增加其他方法,这里次序先后是用
户灵活指定的
public void newMethod()
{
otherMethod();
work.insert();
}
public void otherMethod()
{
ListIterator listIterator = others.listIterator();
while (listIterator.hasNext())
{
设计模式(Patterns in Java) -- http://www.jdon.com
40
System.out.println(((String)(listIterator.next()))
+ " 正在进行");
}
}
}
在上例中,我们把挖坑和钉木板都排在了打桩insert 前面,这里只是举例说明额外功能次序
可以任意安排.
好了,Decorator 模式出来了,我们看如何调用:
Work squarePeg = new SquarePeg();
Work decorator = new Decorator(squarePeg);
decorator.insert();
Decorator 模式至此完成.
如果你细心,会发现,上面调用类似我们读取文件时的调用:
FileReader fr = new FileReader(filename);
BufferedReader br = new BufferedReader(fr);
实际上Java 的I/O API 就是使用Decorator 实现的,I/O 变种很多,如果都采取继承方法,
将会产生很多子类,显然相当繁琐.
Jive 中的Decorator 实现
在论坛系统中,有些特别的字是不能出现在论坛中如"打倒XXX",我们需要过滤这些"反动"
的字体.不让他们出现或者高亮度显示.
在IBM Java 专栏中专门谈Jive 的文章中,有谈及Jive 中ForumMessageFilter.java 使用了
Decorator 模式,其实,该程序并没有真正使用Decorator,而是提示说:针对特别论坛可以设
计额外增加的过滤功能,那么就可以重组ForumMessageFilter 作为Decorator 模式了.
所以,我们在分辨是否真正是Decorator 模式,以及会真正使用Decorator 模式,一定要把握
好Decorator 模式的定义,以及其中参与的角色(Decoratee 和Decorator).
设计模式(Patterns in Java) -- http://www.jdon.com
41
设计模式之Bridge
Bridge 定义:
将抽象和行为划分开来,各自独立,但能动态的结合.
为什么使用?
通常,当一个抽象类或接口有多个具体实现(concrete subclass),这些concrete 之间关系可
能有以下两种:
1. 这多个具体实现之间恰好是并列的,如前面举例,打桩,有两个concrete class:方形桩和
圆形桩;这两个形状上的桩是并列的,没有概念上的重复,那么我们只要使用继承就可以了.
2.实际应用上,常常有可能在这多个concrete class 之间有概念上重叠.那么需要我们把抽
象共同部分和行为共同部分各自独立开来,原来是准备放在一个接口里,现在需要设计两个
接口,分别放置抽象和行为.
例如,一杯咖啡为例,有中杯和大杯之分,同时还有加奶不加奶之分. 如果用单纯的继承,这
四个具体实现(中杯大杯加奶不加奶)之间有概念重叠,因为有中杯加奶,也有中杯不加奶,
如果再在中杯这一层再实现两个继承,很显然混乱,扩展性极差.那我们使用Bridge 模式来
实现它.
如何实现?
以上面提到的咖啡为例. 我们原来打算只设计一个接口(抽象类),使用Bridge 模式后,我
们需要将抽象和行为分开,加奶和不加奶属于行为,我们将它们抽象成一个专门的行为接口.
先看看抽象部分的接口代码:
public abstract class Coffee
{
CoffeeImp coffeeImp;
public void setCoffeeImp() {
this.CoffeeImp = CoffeeImpSingleton.getTheCoffeImp();
}
public CoffeeImp getCoffeeImp() {return this.CoffeeImp;}
public abstract void pourCoffee();
}
其中CoffeeImp 是加不加奶的行为接口,看其代码如下:
设计模式(Patterns in Java) -- http://www.jdon.com
42
public abstract class CoffeeImp
{
public abstract void pourCoffeeImp();
}
现在我们有了两个抽象类,下面我们分别对其进行继承,实现concrete class:
//中杯
public class MediumCoffee extends Coffee
{
public MediumCoffee() {setCoffeeImp();}
public void pourCoffee()
{
CoffeeImp coffeeImp = this.getCoffeeImp();
//我们以重复次数来说明是冲中杯还是大杯,重复2 次是中杯
for (int i = 0; i < 2; i++)
{
coffeeImp.pourCoffeeImp();
}
}
}
//大杯
public class SuperSizeCoffee extends Coffee
{
public SuperSizeCoffee() {setCoffeeImp();}
public void pourCoffee()
{
CoffeeImp coffeeImp = this.getCoffeeImp();
//我们以重复次数来说明是冲中杯还是大杯,重复5 次是大杯
for (int i = 0; i < 5; i++)
{
coffeeImp.pourCoffeeImp();
}
}
}
设计模式(Patterns in Java) -- http://www.jdon.com
43
上面分别是中杯和大杯的具体实现.下面再对行为CoffeeImp 进行继承:
//加奶
public class MilkCoffeeImp extends CoffeeImp
{
MilkCoffeeImp() {}
public void pourCoffeeImp()
{
System.out.println("加了美味的牛奶");
}
}
//不加奶
public class FragrantCoffeeImp extends CoffeeImp
{
FragrantCoffeeImp() {}
public void pourCoffeeImp()
{
System.out.println("什么也没加,清香");
}
}
Bridge 模式的基本框架我们已经搭好了,别忘记定义中还有一句:动态结合,我们现在可以
喝到至少四种咖啡:
1.中杯加奶
2.中杯不加奶
3.大杯加奶
4.大杯不加奶
看看是如何动态结合的,在使用之前,我们做个准备工作,设计一个单态类(Singleton)用来
hold 当前的CoffeeImp:
public class CoffeeImpSingleton
{
private static CoffeeImp coffeeImp;
public CoffeeImpSingleton(CoffeeImp coffeeImpIn)
{this.coffeeImp = coffeeImpIn;}
public static CoffeeImp getTheCoffeeImp()
{
设计模式(Patterns in Java) -- http://www.jdon.com
44
return coffeeImp;
}
}
看看中杯加奶和大杯加奶是怎么出来的:
//拿出牛奶
CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new
MilkCoffeeImp());
//中杯加奶
MediumCoffee mediumCoffee = new MediumCoffee();
mediumCoffee.pourCoffee();
//大杯加奶
SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee();
superSizeCoffee.pourCoffee();
注意: Bridge 模式的执行类如CoffeeImp 和Coffee 是一对一的关系, 正确创建CoffeeImp
是该模式的关键,
Bridge 模式在EJB 中的应用
EJB 中有一个Data Access Object (DAO)模式,这是将商业逻辑和具体数据资源分开的,因为
不同的数据库有不同的数据库操作.将操作不同数据库的行为独立抽象成一个行为接口DAO.
如下:
1.Business Object (类似Coffee)
实现一些抽象的商业操作:如寻找一个用户下所有的订单
涉及数据库操作都使用DAOImplementor.
2.Data Access Object (类似CoffeeImp)
一些抽象的对数据库资源操作
3.DAOImplementor 如OrderDAOCS, OrderDAOOracle, OrderDAOSybase(类似MilkCoffeeImp
FragrantCoffeeImp)
具体的数据库操作,如"INSERT INTO "等语句,OrderDAOOracle 是Oracle OrderDAOSybase
是Sybase 数据库.
4.数据库(Cloudscape, Oracle, or Sybase database via JDBC API)
设计模式(Patterns in Java) -- http://www.jdon.com
45
设计模式之Flyweight(享元)
板桥里人http://www.jdon.com 2002/05/02
Flyweight 定义:
避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).
为什么使用?
面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞
大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,无疑耗
费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被
共享的类,另外,还有一些特性是取决于应用(context),是不可共享的,这也Flyweight 中两
个重要概念内部状态intrinsic 和外部状态extrinsic 之分.
说白点,就是先捏一个的原始模型,然后随着不同场合和环境,再产生各具特征的具体模型,
很显然,在这里需要产生不同的新对象,所以Flyweight 模式中常出现Factory 模
式.Flyweight 的内部状态是用来共享的,Flyweight factory 负责维护一个Flyweight
pool(模式池)来存放内部状态的对象.
Flyweight 模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合
很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们
可以将这些字符串储存在Flyweight 池(pool)中.
如何使用?
我们先从Flyweight 抽象接口开始:
public interface Flyweight
{
public void operation( ExtrinsicState state );
}
//用于本模式的抽象数据类型(自行设计)
public interface ExtrinsicState { }
下面是接口的具体实现(ConcreteFlyweight) ,并为内部状态增加内存空间,
ConcreteFlyweight 必须是可共享的,它保存的任何状态都必须是内部(intrinsic),也就是
说,ConcreteFlyweight 必须和它的应用环境场合无关.
public class ConcreteFlyweight implements Flyweight {
private IntrinsicState state;
public void operation( ExtrinsicState state )
设计模式(Patterns in Java) -- http://www.jdon.com
46
{
//具体操作
}
}
当然,并不是所有的Flyweight 具体实现子类都需要被共享的,所以还有另外一种不共享的
ConcreteFlyweight:
public class UnsharedConcreteFlyweight implements Flyweight {
public void operation( ExtrinsicState state ) { }
}
Flyweight factory 负责维护一个Flyweight 池(存放内部状态),当客户端请求一个共享
Flyweight 时,这个factory 首先搜索池中是否已经有可适用的,如果有,factory 只是简单返
回送出这个对象,否则,创建一个新的对象,加入到池中,再返回送出这个对象.池
public class FlyweightFactory {
//Flyweight pool
private Hashtable flyweights = new Hashtable();
public Flyweight getFlyweight( Object key ) {
Flyweight flyweight = (Flyweight) flyweights.get(key);
if( flyweight == null ) {
//产生新的ConcreteFlyweight
flyweight = new ConcreteFlyweight();
flyweights.put( key, flyweight );
}
return flyweight;
}
}
至此,Flyweight 模式的基本框架已经就绪,我们看看如何调用:
FlyweightFactory factory = new FlyweightFactory();
Flyweight fly1 = factory.getFlyweight( "Fred" );
Flyweight fly2 = factory.getFlyweight( "Wilma" );
......
设计模式(Patterns in Java) -- http://www.jdon.com
47
从调用上看,好象是个纯粹的Factory 使用,但奥妙就在于Factory 的内部设计上.
Flyweight 模式在XML 等数据源中应用
我们上面已经提到,当大量从数据源中读取字符串,其中肯定有重复的,那么我们使用
Flyweight 模式可以提高效率,以唱片CD 为例,在一个XML 文件中,存放了多个CD 的资料.
每个CD 有三个字段:
1.出片日期(year)
2.歌唱者姓名等信息(artist)
3.唱片曲目(title)
其中,歌唱者姓名有可能重复,也就是说,可能有同一个演唱者的多个不同时期不同曲目的
CD.我们将"歌唱者姓名"作为可共享的ConcreteFlyweight.其他两个字段作为
UnsharedConcreteFlyweight.
首先看看数据源XML 文件的内容:

Another Green World
1978
Eno, Brian

Greatest Hits
1950
Holiday, Billie

Taking Tiger Mountain (by strategy)
1977
Eno, Brian

.......

设计模式(Patterns in Java) -- http://www.jdon.com
48
虽然上面举例CD 只有3 张,CD 可看成是大量重复的小类,因为其中成分只有三个字段,而且
有重复的(歌唱者姓名).
CD 就是类似上面接口Flyweight:
public class CD {
private String title;
private int year;
private Artist artist;
public String getTitle() { return title; }
public int getYear() { return year; }
public Artist getArtist() { return artist; }
public void setTitle(String t){ title = t;}
public void setYear(int y){year = y;}
public void setArtist(Artist a){artist = a;}
}
将"歌唱者姓名"作为可共享的ConcreteFlyweight:
public class Artist {
//内部状态
private String name;
// note that Artist is immutable.
String getName(){return name;}
Artist(String n){
name = n;
}
}
再看看Flyweight factory,专门用来制造上面的可共享的ConcreteFlyweight:Artist
public class ArtistFactory {
设计模式(Patterns in Java) -- http://www.jdon.com
49
Hashtable pool = new Hashtable();
Artist getArtist(String key){
Artist result;
result = (Artist)pool.get(key);
产生新的Artist
if(result == null) {
result = new Artist(key);
pool.put(key,result);
}
return result;
}
}
当你有几千张甚至更多CD 时,Flyweight 模式将节省更多空间,共享的flyweight 越多,空间
节省也就越大.
设计模式(Patterns in Java) -- http://www.jdon.com
50
设计模式之Template
Template 定义:
定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中.
其实Java 的抽象类本来就是Template 模式,因此使用很普遍.而且很容易理解和使用,我们
直接以示例开始:
public abstract class Benchmark
{
/**
* 下面操作是我们希望在子类中完成
*/
public abstract void benchmark();
/**
* 重复执行benchmark 次数
*/
public final long repeat (int count) {
if (count <= 0)
return 0;
else {
long startTime = System.currentTimeMillis();
for (int i = 0; i < count; i++)
benchmark();
long stopTime = System.currentTimeMillis();
return stopTime - startTime;
}
}
}
在上例中,我们希望重复执行benchmark()操作,但是对benchmark()的具体内容没有说明,
而是延迟到其子类中描述:
public class MethodBenchmark extends Benchmark
{
/**
* 真正定义benchmark 内容
*/
设计模式(Patterns in Java) -- http://www.jdon.com
51
public void benchmark() {
for (int i = 0; i < Integer.MAX_VALUE; i++){
System.out.printtln("i="+i);
}
}
}
至此,Template 模式已经完成,是不是很简单?看看如何使用:
Benchmark operation = new MethodBenchmark();
long duration = operation.repeat(Integer.parseInt(args[0].trim()));
System.out.println("The operation took " + duration + " milliseconds");
也许你以前还疑惑抽象类有什么用,现在你应该彻底明白了吧? 至于这样做的好处,很显然
啊,扩展性强,以后Benchmark 内容变化,我只要再做一个继承子类就可以,不必修改其他应
用代码.
设计模式(Patterns in Java) -- http://www.jdon.com
52
设计模式之Memento(备忘机制)
Memento 定义:
memento 是一个保存另外一个对象内部状态拷贝的对象.这样以后就可以将该对象恢复到原
先保存的状态.
Memento 模式相对也比较好理解,我们看下列代码:
public class Originator {
private int number;
private File file = null;
public Originator(){}
// 创建一个Memento
public Memento getMemento(){
return new Memento(this);
}
// 恢复到原始值
public void setMemento(Memento m){
number = m.number;
file = m.file;
}
}
我们再看看Memento 类:
private class Memento implements java.io.Serializable{
private int number;
private File file = null;
public Memento( Originator o){
number = o.number;
设计模式(Patterns in Java) -- http://www.jdon.com
53
file = o.file;
}
}
可见Memento 中保存了Originator 中的number 和file 的值. 通过调用Originator 中
number 和file 值改变的话,通过调用setMemento()方法可以恢复.
Memento 模式的缺点是耗费大,如果内部状态很多,再保存一份,无意要浪费大量内存.
Memento 模式在Jsp+Javabean 中的应用
在Jsp 应用中,我们通常有很多表单要求用户输入,比如用户注册,需要输入姓名和Email 等,
如果一些表项用户没有填写或者填写错误,我们希望在用户按"提交Submit"后,通过Jsp 程
序检查,发现确实有未填写项目,则在该项目下红字显示警告或错误,同时,还要显示用户刚
才已经输入的表项.
如下图中First Name 是用户已经输入,Last Name 没有输入,我们则提示红字警告.:
设计模式(Patterns in Java) -- http://www.jdon.com
54
这种技术的实现,就是利用了Javabean 的scope="request"或scope="session"特性,也就是
Memento 模式.
具体示例和代码见JavaWorld 的英文原文, Javabean 表单输入特性参见我的另外一篇文
章.
设计模式(Patterns in Java) -- http://www.jdon.com
55
设计模式之Observer
Java 深入到一定程度,就不可避免的碰到设计模式(design pattern)这一概念,了解设计模
式,将使自己对java 中的接口或抽象类应用有更深的理解.设计模式在java 的中型系统中应
用广泛,遵循一定的编程模式,才能使自己的代码便于理解,易于交流,Observer(观察者)模
式是比较常用的一个模式,尤其在界面设计中应用广泛,而本站所关注的是Java 在电子商务
系统中应用,因此想从电子商务实例中分析Observer 的应用.
虽然网上商店形式多样,每个站点有自己的特色,但也有其一般的共性,单就"商品的变化,以
便及时通知订户"这一点,是很多网上商店共有的模式,这一模式类似Observer patern.
具体的说,如果网上商店中商品在名称价格等方面有变化,如果系统能自动通知会员,将是
网上商店区别传统商店的一大特色.这就需要在商品product 中加入Observer 这样角色,以
便product 细节发生变化时,Observer 能自动观察到这种变化,并能进行及时的update 或
notify 动作.
Java 的API 还为为我们提供现成的Observer 接口Java.util.Observer.我们只要直接使用
它就可以.
我们必须extends Java.util.Observer 才能真正使用它:
1.提供Add/Delete observer 的方法;
2.提供通知(notisfy) 所有observer 的方法;
//产品类可供Jsp 直接使用UseBean 调用该类主要执行产品数据库插
设计模式(Patterns in Java) -- http://www.jdon.com
56
入更新
public class product extends Observable{
private String name;
private float price;
public String getName(){ return name;}
public void setName(){
this.name=name;
//设置变化点
setChanged();
notifyObservers(name);
}
public float getPrice(){ return price;}
public void setPrice(){
this.price=price;
//设置变化点
setChanged();
notifyObservers(new Float(price));
}
//以下可以是数据库更新插入命令.
public void saveToDb(){
.....................
}
我们注意到,在product 类中的setXXX 方法中,我们设置了notify(通知)方法, 当Jsp 表
单调用setXXX(如何调用见我的另外一篇文章),实际上就触发了notisfyObservers 方法,这
将通知相应观察者应该采取行动了.
下面看看这些观察者的代码,他们究竟采取了什么行动:
//观察者NameObserver 主要用来对产品名称(name)进行观察的
public class NameObserver implements Observer{
private String name=null;
public void update(Observable obj,Object arg){
设计模式(Patterns in Java) -- http://www.jdon.com
57
if (arg instanceof String){
name=(String)arg;
//产品名称改变值在name 中
System.out.println("NameObserver :name changet to "+name);
}
}
}
//观察者PriceObserver 主要用来对产品价格(price)进行观察的
public class PriceObserver implements Observer{
private float price=0;
public void update(Observable obj,Object arg){
if (arg instanceof Float){
price=((Float)arg).floatValue();
System.out.println("PriceObserver :price changet to "+price);
}
}
}
Jsp 中我们可以来正式执行这段观察者程序:

<%
设计模式(Patterns in Java) -- http://www.jdon.com
58
if (request.getParameter("save")!=null)
{
product.saveToDb();
out.println("产品数据变动保存! 并已经自动通知客户");
}else{
//加入观察者
product.addObserver(nameobs);
product.addObserver(priceobs);
%>
//request.getRequestURI()是产生本jsp 的程序名,就是自己调用自己

产品名称:
产品价格:

<%
}
%>
执行改Jsp 程序,会出现一个表单录入界面, 需要输入产品名称产品价格, 点按Submit 后,
还是执行该jsp 的
if (request.getParameter("save")!=null)之间的代码.
由于这里使用了数据javabeans 的自动赋值概念,实际程序自动执行了setName setPrice
语句.你会在服务器控制台中发现下面信息::
设计模式(Patterns in Java) -- http://www.jdon.com
59
NameObserver :name changet to ?????(Jsp 表单中输入的产品名称)
PriceObserver :price changet to ???(Jsp 表单中输入的产品价格);
这说明观察者已经在行动了.!!
同时你会在执行jsp 的浏览器端得到信息:
产品数据变动保存! 并已经自动通知客户
上文由于使用jsp 概念,隐含很多自动动作,现将调用观察者的Java 代码写如下:
public class Test {
public static void main(String args[]){
Product product=new Product();
NameObserver nameobs=new NameObserver();
PriceObserver priceobs=new PriceObserver();
//加入观察者
product.addObserver(nameobs);
product.addObserver(priceobs);
product.setName("橘子红了");
product.setPrice(9.22f);
}
}
你会在发现下面信息::
NameObserver :name changet to 橘子红了
PriceObserver :price changet to 9.22
设计模式(Patterns in Java) -- http://www.jdon.com
60
这说明观察者在行动了.!!
设计模式(Patterns in Java) -- http://www.jdon.com
61
设计模式之Chain of Responsibility(职责链)
Chain of Responsibility 定义
Chain of Responsibility(CoR) 是用一系列类(classes)试图处理一个请求request,这些
类之间是一个松散的耦合,唯一共同点是在他们之间传递request. 也就是说，来了一个请
求，A 类先处理，如果没有处理，就传递到B 类处理，如果没有处理，就传递到C 类处理，
就这样象一个链条(chain)一样传递下去。
如何使用?
虽然这一段是如何使用CoR,但是也是演示什么是CoR.
有一个Handler 接口:
public interface Handler{
public void handleRequest();
}
这是一个处理request 的事例，如果有多种request,比如请求帮助请求打印或请求格
式化：
最先想到的解决方案是：在接口中增加多个请求：
public interface Handler{
public void handleHelp();
public void handlePrint();
public void handleFormat();
}
具体是一段实现接口Handler 代码：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleHelp(){
//具体处理请求Help 的代码
...
}
设计模式(Patterns in Java) -- http://www.jdon.com
62
public void handlePrint(){
//如果是print 转去处理Print
successor.handlePrint();
}
public void handleFormat(){
//如果是Format 转去处理format
successor.handleFormat();
}
}
一共有三个这样的具体实现类，上面是处理help,还有处理Print 处理Format 这大概是我
们最常用的编程思路。
虽然思路简单明了，但是有一个扩展问题，如果我们需要再增加一个请求request 种类,需
要修改接口及其每一个实现。
第二方案:将每种request 都变成一个接口，因此我们有以下代码：
public interface HelpHandler{
public void handleHelp();
}
public interface PrintHandler{
public void handlePrint();
}
public interface FormatHandler{
public void handleFormat();
}
public class ConcreteHandler
implements HelpHandler,PrintHandler,FormatHandlet{
private HelpHandler helpSuccessor;
private PrintHandler printSuccessor;
private FormatHandler formatSuccessor;
public ConcreteHandler(HelpHandler helpSuccessor,PrintHandler
printSuccessor,FormatHandler formatSuccessor)
{
this.helpSuccessor=helpSuccessor;
this.printSuccessor=printSuccessor;
this.formatSuccessor=formatSuccessor;
}
设计模式(Patterns in Java) -- http://www.jdon.com
63
public void handleHelp(){
.......
}
public void handlePrint(){this.printSuccessor=printSuccessor;}
public void handleFormat(){this.formatSuccessor=formatSuccessor;}
}
这个办法在增加新的请求request 情况下，只是节省了接口的修改量，接口实现
ConcreteHandler 还需要修改。而且代码显然不简单美丽。
解决方案3: 在Handler 接口中只使用一个参数化方法：
public interface Handler{
public void handleRequest(String request);
}
那么Handler 实现代码如下：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleRequest(String request){
if (request.equals("Help")){
//这里是处理Help 的具体代码
}else
//传递到下一个
successor.handle(request);
}
}
}
这里先假设request 是String 类型，如果不是怎么办？当然我们可以创建一个专门类
Request
最后解决方案:接口Handler 的代码如下：
public interface Handler{
public void handleRequest(Request request);
}
Request 类的定义:
设计模式(Patterns in Java) -- http://www.jdon.com
64
public class Request{
private String type;
public Request(String type){this.type=type;}
public String getType(){return type;}
public void execute(){
//request 真正具体行为代码
}
}
那么Handler 实现代码如下：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleRequest(Request request){
if (request instanceof HelpRequest){
//这里是处理Help 的具体代码
}else if (request instanceof PrintRequst){
request.execute();
}else
//传递到下一个
successor.handle(request);
}
}
}
这个解决方案就是CoR, 在一个链上,都有相应职责的类,因此叫Chain of Responsibility.
CoR 的优点：
因为无法预知来自外界的请求是属于哪种类型，每个类如果碰到它不能处理的请求只要放弃
就可以。无疑这降低了类之间的耦合性。
缺点是效率低，因为一个请求的完成可能要遍历到最后才可能完成，当然也可以用树的概念
优化。在Java AWT1.0 中，对于鼠标按键事情的处理就是使用CoR,到Java.1.1 以后，就
使用Observer 代替CoR
扩展性差，因为在CoR 中，一定要有一个统一的接口Handler.局限性就在这里。
设计模式(Patterns in Java) -- http://www.jdon.com
65
设计模式之Command
Command 模式是最让我疑惑的一个模式,我在阅读了很多代码后,才感觉隐约掌握其大概原
理,我认为理解设计模式最主要是掌握起原理构造,这样才对自己实际编程有指导作
用.Command 模式实际上不是个很具体,规定很多的模式,正是这个灵活性,让人有些
confuse.
Command 定义
不少Command 模式的代码都是针对图形界面的,它实际就是菜单命令,我们在一个下拉菜单
选择一个命令时,然后会执行一些动作.
将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,这就是Command 模
式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),就直
接指向打开文档的代码,使用Command 模式,就是在这两者之间增加一个中间者,将这种直接
关系拗断,同时两者之间都隔离,基本没有关系了.
显然这样做的好处是符合封装的特性,降低耦合度,Command 是将对行为进行封装的典型模
式,Factory 是将创建进行封装的模式,
从Command 模式,我也发现设计模式一个"通病":好象喜欢将简单的问题复杂化, 喜欢在不
同类中增加第三者,当然这样做有利于代码的健壮性可维护性还有复用性.
如何使用?
具体的Command 模式代码各式各样,因为如何封装命令,不同系统,有不同的做法.下面事例
是将命令封装在一个Collection 的List 中,任何对象一旦加入List 中,实际上装入了一个
封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出:
典型的Command 模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装
为对象":
public interface Command {
public abstract void execute ( );
}
具体不同命令/请求代码是实现接口Command,下面有三个具体命令
public class Engineer implements Command {
public void execute( ) {
//do Engineer's command
}
}
public class Programmer implements Command {
设计模式(Patterns in Java) -- http://www.jdon.com
66
public void execute( ) {
//do programmer's command
}
}
public class Politician implements Command {
public void execute( ) {
//do Politician's command
}
}
按照通常做法,我们就可以直接调用这三个Command,但是使用Command 模式,我们要将他们
封装起来,扔到黑盒子List 里去:
public class producer{
public static List produceRequests() {
List queue = new ArrayList();
queue.add( new DomesticEngineer() );
queue.add( new Politician() );
queue.add( new Programmer() );
return queue;
}
}
这三个命令进入List 中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是
Engineer 谁是Programmer 了,看下面如何调用Command 模式:
public class TestCommand {
public static void main(String[] args) {
List queue = Producer.produceRequests();
for (Iterator it = queue.iterator(); it.hasNext(); )
//取出List 中东东,其他特征都不能确定,只能保证一
个特征是100%正确,
// 他们至少是接口Command 的"儿子".所以强制转换
类型为接口Command
((Command)it.next()).execute();
设计模式(Patterns in Java) -- http://www.jdon.com
67
}
}
由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口
编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand 中的代码了.
理解了上面的代码的核心原理,在使用中,就应该各人有自己方法了,特别是在如何分离调用
者和具体命令上,有很多实现方法,上面的代码是使用"从List 过一遍"的做法.这种做法只
是为了演示.
使用Command 模式的一个好理由还因为它能实现Undo 功能.每个具体命令都可以记住它刚刚
执行的动作,并且在需要时恢复.
Command 模式在界面设计中应用广泛.Java 的Swing 中菜单命令都是使用Command 模式,由于
Java 在界面设计的性能上还有欠缺,因此界面设计具体代码我们就不讨论,网络上有很多这
样的示例.
参考:
http://www.patterndepot.com/put/8/command.pdf
设计模式(Patterns in Java) -- http://www.jdon.com
68
设计模式之State
State 的定义: 不同的状态,不同的行为;或者说,每个状态有着相应的行为.
何时使用?
State 模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else
进行状态切换, 如果针对状态的这样判断切换反复出现,我们就要联想到是否可以采取
State 模式了.
不只是根据状态,也有根据属性.如果某个对象的属性不同,对象的行为就不一样,这点在数
据库系统中出现频率比较高,我们经常会在一个数据表的尾部,加上property 属性含义的字
段,用以标识记录中一些特殊性质的记录,这种属性的改变(切换)又是随时可能发生的,就有
可能要使用State.
是否使用?
在实际使用,类似开关一样的状态切换是很多的,但有时并不是那么明显,取决于你的经验和
对系统的理解深度.
这里要阐述的是"开关切换状态" 和" 一般的状态判断"是有一些区别的, " 一般的状态判
断"也是有if..elseif 结构,例如:
if (which==1) state="hello";
else if (which==2) state="hi";
else if (which==3) state="bye";
这是一个" 一般的状态判断",state 值的不同是根据which 变量来决定的,which 和state
没有关系.如果改成:
if (state.euqals("bye")) state="hello";
else if (state.euqals("hello")) state="hi";
else if (state.euqals("hi")) state="bye";
这就是"开关切换状态",是将state 的状态从"hello"切换到"hi",再切换到""bye";在切换
到"hello",好象一个旋转开关,这种状态改变就可以使用State 模式了.
如果单纯有上面一种将"hello"-->"hi"-->"bye"-->"hello"这一个方向切换,也不一定需要
使用State 模式,因为State 模式会建立很多子类,复杂化,但是如果又发生另外一个行为:
将上面的切换方向反过来切换,或者需要任意切换,就需要State 了.
请看下例:
设计模式(Patterns in Java) -- http://www.jdon.com
69
public class Context{
private Color state=null;
public void push(){
//如果当前red 状态就切换到blue
if (state==Color.red) state=Color.blue;
//如果当前blue 状态就切换到green
else if (state==Color.blue) state=Color.green;
//如果当前black 状态就切换到red
else if (state==Color.black) state=Color.red;
//如果当前green 状态就切换到black
else if (state==Color.green) state=Color.black;
Sample sample=new Sample(state);
sample.operate();
}
public void pull(){
//与push 状态切换正好相反
if (state==Color.green) state=Color.blue;
else if (state==Color.black) state=Color.green;
else if (state==Color.blue) state=Color.red;
else if (state==Color.red) state=Color.black;
Sample2 sample2=new Sample2(state);
sample2.operate();
}
}
在上例中,我们有两个动作push 推和pull 拉,这两个开关动作,改变了Context 颜色,至此,
我们就需要使用State 模式优化它.
另外注意:但就上例,state 的变化,只是简单的颜色赋值,这个具体行为是很简单的,State
适合巨大的具体行为,因此在,就本例,实际使用中也不一定非要使用State 模式,这会增加
子类的数目,简单的变复杂.
例如: 银行帐户, 经常会在Open 状态和Close 状态间转换.
设计模式(Patterns in Java) -- http://www.jdon.com
70
例如: 经典的TcpConnection, Tcp 的状态有创建侦听关闭三个,并且反复转换,其创建侦
听关闭的具体行为不是简单一两句就能完成的,适合使用State
例如:信箱POP 帐号, 会有四种状态, start HaveUsername Authorized quit,每个状态对应
的行为应该是比较大的.适合使用State
例如:在工具箱挑选不同工具,可以看成在不同工具中切换,适合使用State.如具体绘图程
序,用户可以选择不同工具绘制方框直线曲线,这种状态切换可以使用State.
如何使用
State 需要两种类型实体参与:
1.state manager 状态管理器,就是开关,如上面例子的Context 实际就是一个state
manager, 在state manager 中有对状态的切换动作.
2.用抽象类或接口实现的父类,,不同状态就是继承这个父类的不同子类.
以上面的Context 为例.我们要修改它,建立两个类型的实体.
第一步: 首先建立一个父类:
public abstract class State{
public abstract void handlepush(Context c);
public abstract void handlepull(Context c);
public abstract void getcolor();
}
父类中的方法要对应state manager 中的开关行为,在state manager 中本例就是Context
中,有两个开关动作push 推和pull 拉.那么在状态父类中就要有具体处理这两个动
作:handlepush() handlepull(); 同时还需要一个获取push 或pull结果的方法getcolor()
下面是具体子类的实现:
public class BlueState extends State{
public void handlepush(Context c){
//根据push 方法"如果是blue 状态的切换到green" ;
c.setState(new GreenState());
}
public void handlepull(Context c){
//根据pull 方法"如果是blue 状态的切换到red" ;
设计模式(Patterns in Java) -- http://www.jdon.com
71
c.setState(new RedState());
}
public abstract void getcolor(){ return (Color.blue)}
}
同样其他状态的子类实现如blue 一样.
第二步: 要重新改写State manager 也就是本例的Context:
public class Context{
private Sate state=null; //我们将原来的Color state 改成了新建的State
state;
//setState 是用来改变state 的状态使用setState 实现状态的切换
pulic void setState(State state){
this.state=state;
}
public void push(){
//状态的切换的细节部分,在本例中是颜色的变化,已经封装在子类的
handlepush 中实现,这里无需关心
state.handlepush(this);
//因为sample 要使用state 中的一个切换结果,使用getColor()
Sample sample=new Sample(state.getColor());
sample.operate();
}
public void pull(){
state.handlepull(this);
Sample2 sample2=new Sample2(state.getColor());
设计模式(Patterns in Java) -- http://www.jdon.com
72
sample2.operate();
}
}
至此,我们也就实现了State 的refactorying 过程.
以上只是相当简单的一个实例,在实际应用中,handlepush 或handelpull 的处理是复杂的.
参考资源:
the State and Stategy
How to implement state-dependent behavior
The state patterns
设计模式(Patterns in Java) -- http://www.jdon.com
73
设计模式之Strategy(策略)
Strategy 是属于设计模式中对象行为型模式,主要是定义一系列的算法,把这些算法一个
个封装成单独的类.
Stratrgy 应用比较广泛,比如, 公司经营业务变化图, 可能有两种实现方式,一个是线条曲
线,一个是框图(bar),这是两种算法,可以使用Strategy 实现.
这里以字符串替代为例, 有一个文件,我们需要读取后,希望替代其中相应的变量,然后输出.
关于替代其中变量的方法可能有多种方法,这取决于用户的要求,所以我们要准备几套变量
字符替代方案.
首先,我们建立一个抽象类RepTempRule 定义一些公用变量和方法:
public abstract class RepTempRule{
protected String oldString="";
public void setOldString(String oldString){
this.oldString=oldString;
}
protected String newString="";
设计模式(Patterns in Java) -- http://www.jdon.com
74
public String getNewString(){
return newString;
}
public abstract void replace() throws Exception;
}
在RepTempRule 中有一个抽象方法abstract 需要继承明确,这个replace 里其实是替代的
具体方法.
我们现在有两个字符替代方案,
1.将文本中aaa 替代成bbb;
2.将文本中aaa 替代成ccc;
对应的类分别是RepTempRuleOne RepTempRuleTwo
public class RepTempRuleOne extends RepTempRule{
public void replace() throws Exception{
//replaceFirst 是jdk1.4 新特性
newString=oldString.replaceFirst("aaa", "bbbb")
System.out.println("this is replace one");
}
}
public class RepTempRuleTwo extends RepTempRule{
public void replace() throws Exception{
newString=oldString.replaceFirst("aaa", "ccc")
System.out.println("this is replace Two");
}
设计模式(Patterns in Java) -- http://www.jdon.com
75
}
第二步：我们要建立一个算法解决类，用来提供客户端可以自由选择算法。
public class RepTempRuleSolve {
private RepTempRule strategy;
public RepTempRuleSolve(RepTempRule rule){
this.strategy=rule;
}
public String getNewContext(Site site,String oldString) {
return strategy.replace(site,oldString);
}
public void changeAlgorithm(RepTempRule newAlgorithm) {
strategy = newAlgorithm;
}
}
调用如下:
public class test{
......
public void testReplace(){
//使用第一套替代方案
RepTempRuleSolve solver=new RepTempRuleSolve(new RepTempRuleSimple());
solver.getNewContext(site,context);
//使用第二套
solver=new RepTempRuleSolve(new RepTempRuleTwo());
solver.getNewContext(site,context);

设计模式(Patterns in Java) -- http://www.jdon.com
77
设计模式之Mediator(中介者)
Mediator 定义:
用一个中介对象来封装一系列关于对象交互行为.
为何使用Mediator?
各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此对方,修改一个对象的行
为,同时会涉及到修改很多其他对象的行为,如果使用Mediator 模式,可以使各个对象间的
耦合松散,只需关心和Mediator 的关系,使多对多的关系变成了一对多的关系,可以降低系
统的复杂性,提高可修改扩展性.
如何使用?
首先有一个接口,用来定义成员对象之间的交互联系方式:
public interface Mediator { }
Meiator 具体实现,真正实现交互操作的内容:
public class ConcreteMediator implements Mediator {
//假设当前有两个成员.
private ConcreteColleague1 colleague1 = new ConcreteColleague1();
private ConcreteColleague2 colleague2 = new ConcreteColleague2();
...
}
再看看另外一个参与者:成员,因为是交互行为,都需要双方提供一些共同接口,这种要求在
Visitor Observer 等模式中都是相同的.
public class Colleague {
private Mediator mediator;
public Mediator getMediator() {
return mediator;
}
public void setMediator( Mediator mediator ) {
this.mediator = mediator;
}
设计模式(Patterns in Java) -- http://www.jdon.com
78
}
public class ConcreteColleague1 { }
public class ConcreteColleague2 { }
每个成员都必须知道Mediator,并且和Mediator 联系,而不是和其他成员联系.
至此,Mediator 模式框架完成,可以发现Mediator 模式规定不是很多,大体框架也比较简单,
但实际使用起来就非常灵活.
Mediator 模式在事件驱动类应用中比较多,例如界面设计GUI.;聊天,消息传递等,在聊天应
用中,需要有一个MessageMediator,专门负责request/reponse 之间任务的调节.
MVC 是J2EE 的一个基本模式,View Controller 是一种Mediator,它是Jsp 和服务器上应用
程序间的Mediator.
设计模式(Patterns in Java) -- http://www.jdon.com
79
设计模式之Interpreter(解释器)
Interpreter 定义:
定义语言的文法,并且建立一个解释器来解释该语言中的句子.
Interpreter 似乎使用面不是很广,它描述了一个语言解释器是如何构成的,在实际应用中,
我们可能很少去构造一个语言的文法.我们还是来简单的了解一下:
首先要建立一个接口,用来描述共同的操作.
public interface AbstractExpression {
void interpret( Context context );
}
再看看包含解释器之外的一些全局信息
public interface Context { }
AbstractExpression 的具体实现分两种:终结符表达式和非终结符表达式:
public class TerminalExpression implements AbstractExpression {
public void interpret( Context context ) { }
}
对于文法中没一条规则,非终结符表达式都必须的:
public class NonterminalExpression implements AbstractExpression {
private AbstractExpression successor;
public void setSuccessor( AbstractExpression successor ) {
this.successor = successor;
}
public AbstractExpression getSuccessor() {
return successor;
}
public void interpret( Context context ) { }
}
设计模式(Patterns in Java) -- http://www.jdon.com
80
设计模式之Visitor
Visitor 定义
作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作
用于这些对象的新操作.
在Java 中,Visitor 模式实际上是分离了collection 结构中的元素和对这些元素进行操作
的行为.
为何使用Visitor?
Java 的Collection(包括Vector 和Hashtable)是我们最经常使用的技术,可是Collection
好象是个黑色大染缸,本来有各种鲜明类型特征的对象一旦放入后,再取出时,这些类型就消
失了.那么我们势必要用If 来判断,如:
Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof Collection)
messyPrintCollection((Collection)o);
else if (o instanceof String)
System.out.println("'"+o.toString()+"'");
else if (o instanceof Float)
System.out.println(o.toString()+"f");
else
System.out.println(o.toString());
}
在上例中,我们使用了instanceof 来判断o 的类型.
很显然,这样做的缺点代码If else if 很繁琐.我们就可以使用Visitor 模式解决它.
如何使用Visitor?
针对上例,我们设计一个接口visitor 访问者:
public interface Visitor
{
public void visitCollection(Collection collection);
public void visitString(String string);
public void visitFloat(Float float);
}
在这个接口中,将我们认为Collection 有可能的类的类型放入其中.
设计模式(Patterns in Java) -- http://www.jdon.com
81
有了访问者,我们需要被访问者,被访问者就是我们Collection 的每个元素Element,我们要
为这些Element 定义一个可以接受访问的接口(访问和被访问是互动的,只有访问者,被访问
者如果表示不欢迎,访问者就不能访问),
我们定义这个接口叫Visitable,用来定义一个Accept 操作,也就是说让Collection 每个元
素具备可访问性.
public interface Visitable
{
public void accept(Visitor visitor);
}
好了,有了两个接口,我们就要定义他们的具体实现(Concrete class):
public class ConcreteElement implements Visitable
{
private String value;
public ConcreteElement(String string) {
value = string;
}
//定义accept 的具体内容这里是很简单的一句调用
public void accept(Visitor visitor) {
visitor.visitString(this);
}
}
再看看访问者的Concrete 实现:
public class ConcreteVisitor implements Visitor
{
//在本方法中,我们实现了对Collection 的元素的成功访问
public void visitCollection(Collection collection) {
Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof Visitable)
((Visitable)o).accept(this);
}
public void visitString(String string) {
System.out.println("'"+string+"'");
}
设计模式(Patterns in Java) -- http://www.jdon.com
82
public void visitFloat(Float float) {
System.out.println(float.toString()+"f");
}
}
在上面的visitCollection 我们实现了对Collection 每个元素访问,只使用了一个判断语句,
只要判断其是否可以访问.
至此,我们完成了Visitor 模式基本架构.
使用Visitor 模式的前提
对象群结构中(Collection) 中的对象类型很少改变,也就是说访问者的身份类型很少改变,
如上面中Visitor 中的类型很少改变,如果需要增加新的操作,比如上例中我们在
ConcreteElement 具体实现外,还需要新的ConcreteElement2 ConcreteElement3.
可见使用Visitor 模式是有前提的,在两个接口Visitor 和Visitable 中,确保Visitor 很少
变化,变化的是Visitable,这样使用Visitor 最方便.
如果Visitor 也经常变化, 也就是说,对象群中的对象类型经常改变,一般建议是,不如在这
些对象类中逐个定义操作.但是Java 的Reflect 技术解决了这个问题.
Reflect 技术是在运行期间动态获取对象类型和方法的一种技术,具体实现参考Javaworld
的英文原文.

你可能感兴趣的:(Patterns)

深入理解单元测试元闰子单元测试 log4j
荐语本文要介绍的是2020年O’Reilly出版的书籍UnitTestingPrinciples,Practices,andPatterns，一本在豆瓣评分高达9.9的好书。作为一名软件开发工程师，你应该对单元测试（unittest）很熟悉，但单元测试的目的、Mock的正确用法、单元测试和集成测试的区别等等，你真的懂吗？书中对这些内容都做了深入的介绍，并通过实际案例教你如何写出好的单元测试。读完这
Shell_11_sed 热爱_生活
一、sed工作流程imagesed是一种在线的、非交互式的编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（patternspace），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写
二整合web开发 guideEmotion
一整合Servlet1通过注解扫描完成Servlet组件的注册1.编写servlet@WebServlet(name="FirstServlet",urlPatterns="/first")publicclassFirstServletextendsHttpServlet{@OverrideprotectedvoiddoGet(HttpServletRequestreq,HttpServletRe
23种设计模式详解 WineMonk #设计模式设计模式
23种设计模式详解文章目录23种设计模式详解1设计模式概述1.1创建型模式（CreationalPatterns）2.2结构型模式（StructuralPatterns）3.3行为型模式（BehavioralPatterns）2设计模式详解2.1简单工厂模式（SimpleFactoryPattern）2.1.1定义2.1.2结构2.1.3示例代码2.1.4特点2.1.5适用场景2.1.6工厂方法模
Linux shell sed 命令详解 BugBear1989
详细的sed命令详解，请参考https://my.oschina.net/u/3908182/blog/1921761一、sed命令工作机制：每次读取一行文本至“模式空间(patternspace)”中，在模式空间中完成处理；将处理结果输出至标准输出设备；语法：sed[OPTION]...{script}[input-file]...参数说明-r支持扩展正则表达式-n静默模式-escript1-e
3.创建型设计模式详解：生成器模式与原型模式的深度解析胡耀超设计模式原型模式设计模式生成器模式创建型设计模式 java 后端
设计模式（DesignPatterns）是软件开发中常用的解决方案，帮助开发者处理常见的设计问题。创建型设计模式专注于对象的实例化，旨在提高系统的灵活性和可维护性。在这篇文章中，我们将深入探讨创建型设计模式中的生成器模式（BuilderPattern）和原型模式（PrototypePattern），详细分析它们的应用场景、优缺点，并通过类图和综合案例加以对比。1.创建型设计模式概述创建型设计模式包
设计模式学习笔记（6）工厂方法摆码王子
本文实例代码：https://github.com/JamesZBL/java_design_patterns工厂方法（FactoryMethod)模式，又叫做虚拟构造（VirtualConstructor）模式或多态工厂(PolymorphicFactory）模式。工厂方法的特点是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。实例这次以顾客点餐为例，
shell编程----sed grep awk 醉卧考场君莫笑 linux系统课程学习 linux unix 正则表达式
其他编程前言Sed的介绍sed命令格式Sed程序示例Grepgrep示例Grep与Find示例awk程序示例：总结前言sedgrepawkSed的介绍Sed是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（patternspace），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。主
重构与模式(Refactoring to Patterns)-读书笔记 weixin_30693683
第一章☛过度设计：是指代码的灵活性和复杂性超出所需。第二章☛重构是一种保持行为的转换。第三章☛每一个模式都是由三部分组成的规则，他表达的是某一环境，一个问题以及解决问题的方案之间的关系。☛模式痴迷：对模式过于依赖。第四章☛代码坏味道●代码重复（DuplicatedCode）通常可以通过形成TemplateMethod重构。●方法过长（LongMethod）●条件逻辑太复杂（ConditionalC
开始写Refactoring to Patterns读书笔记 taoofyoung 读书笔记 refactoring 读书设计模式任务编程工作
工作一年多了，越来越感觉自己的编程思维有较大的缺陷：往往对设计任务的整体把握不够，造成效率低下。急需巩固自己对设计模式、体系构架方面的知识结构。就从阅读《从重构到模式》这本书开始吧。打算写这本书的读书笔记。由于手上的是英文版，所以读得会比较慢。但贵在坚持。坚持！
读<重构与模式>(Refactoring to Patterns) iteye_6952 技术设计模式企业应用读书网络应用 UML
,我几年前读过两遍,对里面提到的各类概念印象深刻,不断发出'哇,哇'.是我读到的关于设计的最早的书籍,当时只有一年多的开发经验,对设计模式的理解很肤浅.后来开始使用Java之后,又在网上找到J道([url]http://www.jdon.com[/url])关于设计模式的一些资料,算是对设计模式有了初步的认识.之后就是每几个月就会再看看其中的一些模式,努力加深对软件设计的理解.一次偶然的机会,我看
java 23种设计模式 Lambert_lin0 java 设计模式开发语言
作者备注：该文未全部完成，正在编辑完善中文字结构：第1章为类型第2章为概念第3章为概念和优缺点第4章为详细或demo第1章Java语言中常用的设计模式有23种，它们被分为三大类：1、创建型模式（CreationalPatterns）2、结构型模式（StructuralPatterns）3、行为型模式（BehavioralPatterns）第2章创建型模式（CreationalPatterns）:1
《设计模式沉思录》分享雾江流设计模式
书籍信息书名:设计模式沉思录原作名:PatternHatching:DesignPatternsApplied豆瓣评分:8.6分(78人评价)内容简介本书作者是设计模式的开山鼻祖之一。在本书中，他不仅通过一些通俗易懂的实例对如何运用设计模式进行了深入的讲解，而且还介绍了一些新的设计模式。同时还讲述了模式背后鲜为人知的一些故事，让读者领略其中的苦与乐。本书帮助读者在面向对象设计的基本原则下，将设计模
Django中 render() 函数的使用方法 Erudite_x Django django render函数
render()函数在讲render()函数之前，我们在Django项目index文件夹的urls.py和views.py中编写如下功能代码：（不难，望读者细心阅之）#index的urls.pyfromdjango.urlsimportpathform.importviewsurlpatterns=[#定义首页的路由path('',views.index,name='index'),]#index
探索Java设计模式：原理、应用与实践小码快撩 java 设计模式开发语言
导语Java设计模式作为软件开发领域的瑰宝，不仅体现了面向对象设计原则的应用，更是解决复杂编程问题、提升代码质量和可维护性的强大工具。本文将深入探讨Java设计模式的基本概念、分类、核心原理，并结合具体示例阐述几种重要设计模式的运用，旨在引导读者理解并掌握这一重要知识体系，将其应用于实际项目开发中。创建型模式（CreationalPatterns）创建型模式关注对象的创建过程，旨在提供灵活、高效、
Java的设计模式贾斯汀玛尔斯 Java java 设计模式开发语言
设计模式分类在Java中，设计模式是一套被反复使用的、被多数人知晓的、经过分类编目的、代码设计经验的总结。它们是软件开发过程中为了提升代码的可维护性、可扩展性和可重用性而采用的解决方案。Java设计模式主要分为三大类：创建型模式（CreationalPatterns）结构型模式（StructuralPatterns）行为型模式（BehavioralPatterns）下面详细介绍每一类模式及其子模式
设计模式反模式：UML图示常见误用案例分析 hai40587 设计模式 uml
设计模式反模式：UML图示常见误用案例分析在软件开发过程中，设计模式（DesignPatterns）作为解决常见设计问题的最佳实践，被广泛地应用于提升代码质量和系统可维护性。然而，当这些设计模式被误用或滥用时，它们可能会转变为反模式（Anti-Patterns），导致系统架构的复杂性增加，甚至引发一系列问题。特别是在使用UML（统一建模语言）图示时，这些误用表现得尤为明显。本文将通过几个具体的案例
设计模式反模式：UML图示常见误用案例分析 jun778895 设计模式 uml
设计模式反模式：UML图示常见误用案例分析在软件开发过程中，设计模式（DesignPatterns）作为解决常见设计问题的最佳实践，被广泛地应用于提升代码质量和系统可维护性。然而，当这些设计模式被误用或滥用时，它们可能会转变为反模式（Anti-Patterns），导致系统架构的复杂性增加，甚至引发一系列问题。特别是在使用UML（统一建模语言）图示时，这些误用表现得尤为明显。本文将通过几个具体的案例
设计模式反模式：UML图示常见误用案例分析天蓝蓝23528 设计模式 uml
设计模式反模式：UML图示常见误用案例分析在软件开发过程中，设计模式（DesignPatterns）作为解决常见设计问题的最佳实践，被广泛地应用于提高代码质量和可维护性。然而，当这些设计模式被误用或滥用时，它们可能会变成反模式（Anti-Patterns），导致系统架构的复杂性增加，甚至引发一系列问题。特别是在使用UML（统一建模语言）图示设计模式时，这些误用表现得尤为明显。本文将通过几个具体的案
springboot框架中filter过滤器的urlPatterns的匹配源码 Smileassissan springboot框架学习 spring boot 后端 java filter 匹配源码
如下图所示，我使用@WebFilter注解的方式定义了一个过滤器，同时定义了过滤器的过滤条件urlPatterns为/*,可能很多人都知道filter的/*代表所有URL都匹配，但是源码在哪里呢先打断点看一下调用链然后跟着调用链慢慢点，看看哪里开始出现了过滤器，这条链路已经出现了，那么说明肯定是在这个之前进行过滤器注册的往上翻就能看到创建过滤器链条的然后我们就找到了filter匹配的具体位置，里面
logback.xml自定义标签节点重生之我是一名程序员 springmvc logback
logback.xml自定义标签节点问题(\w+@\w+\.\w+)%d{HH:mm:ss.SSS}[%thread]%-5level%logger{36}-%msg%n自定义layoutpublicclassDataMaskingPatternLayoutextendsPatternLayout{privateListmaskPatterns=newArrayList标签*@parammaskP
.NET IoC 容器（二）Unity WineMonk IoC .NET .net unity ioc di c#
.NETIoC容器（二）UnityUnityUnityApplicationBlock（Unity）是Microsoft模式和实践团队（Patterns&Practicesteam）推出的一个开源依赖注入容器。它是.NETFramework的一个组件，旨在简化应用程序的构建过程，提高代码的可测试性和可维护性。UnityApplicationBlock提供了以下功能：依赖注入（DI）：Unity容器
设计模式概述 WineMonk 八股文设计模式设计模式程序设计
设计模式设计模式（DesignPatterns）是软件工程中的一种解决方案，它提供了一套经过验证的代码设计和架构方案，用于解决软件设计中反复出现的问题。设计模式不特定于某种编程语言，而是普遍适用于各种面向对象的编程语言。设计模式主要分为三大类：创建型模式、结构型模式和行为型模式。1.创建型模式（CreationalPatterns）创建型模式关注对象的创建过程，旨在使对象的创建与使用分离，避免系统
django 使用技巧造火箭后台开发 android windows django
教程django3.2教程django3.2queryset配置首页(根路由)#创建coolhomeapp#在project配置目录(settings.py所在目录)的urls.py导入coolhome/views的home()#fromcoolhome.viewsimporthomeurlpatterns=[path('',home),path('home',home),path('admin/
设计模式概述话唠扇贝软件架构设计设计模式 java
一设计模式简介定义：设计模式，即DesignPatterns，是指在软件设计中常见问题的典型解决方案。作用：使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。来源：上世纪90年代，ErichGamma、RichardHelm、RaplhJohnson和JonhnVlissides四位作者出版了《DesignPatterns:ElementsofReusableObject-Ori
what is web 2.0 iteye_20954 Web Google F#Yahoo Python
WhatIsWeb2.0DesignPatternsandBusinessModelsfortheNextGenerationofSoftwarebyTimO'Reilly09/30/2005Theburstingofthedot-combubbleinthefallof2001markedaturningpointfortheweb.Manypeopleconcludedthatthewebwa
Architecting Software Like a Pro: Exploring Key Design Patterns 卢延吉 New Developer 软件工程 &ME &GPT 软件工程技术架构 Arch
1.LayeredPattern:Imagineyourapplicationstackedlikeacake,witheachlayerhandlingspecifictasks(presentation,businesslogic,dataaccess).Thismodularapproachfostersmaintainabilityandindependenceacrosslayers.2
关于面向对象编程的一些摘录亲密数 oop OOP
[1]UnderstandingObjectOrientedProgramming--http://www.csis.pace.edu/~bergin/patterns/ppoop.html[2]PatternsforObjects--http://www.csis.pace.edu/~bergin/patterns/PatternObjects.html[3]OOPStory--http://w
架构师蓝图: 理解软件风格与模式俞凡 DeepNoMind 后端
本文介绍了10种软件架构风格及其对应设计模式，梳理了各个风格的优缺点和适用场景，帮助读者在架构选项过程中能有的放矢，做出更适合业务场景的架构设计。原文:TheArchitect’sBlueprint:UnderstandingSoftwareStylesandPatternswithCheatsheet在软件开发过程中，架构在塑造软件系统的结构和行为方面起着至关重要的作用。架构为系统设计提供蓝图，
django向视图发送参数，url中传递参数每天说够一万句废话 django
查看django版本：python-mdjango--versiondjango3.0版本及以上使用：fromdjango.urlsimportre_pathurlpatterns=[re_path('^article/(\d+)',demo.views.viewArticle,name='article')]django3.0版本以下使用：fromdjango.conf.urlsimportpa
windows下源码安装golang 616050468 golang安装 golang环境 windows
系统： 64位win7，开发环境：sublime text 2， go版本： 1.4.1 1. 安装前准备(gcc, gdb, git) golang在64位系
redis批量删除带空格的key bylijinnan redis
redis批量删除的通常做法： redis-cli keys "blacklist*" | xargs redis-cli del 上面的命令在key的前后没有空格时是可以的，但有空格就不行了： $redis-cli keys "blacklist*" 1) "blacklist:12: [email protected]
oracle正则表达式的用法 0624chenhong oracle 正则表达式
方括号表达示方括号表达式描述 [[:alnum:]] 字母和数字混合的字符 [[:alpha:]] 字母字符 [[:cntrl:]] 控制字符 [[:digit:]] 数字字符 [[:graph:]] 图像字符 [[:lower:]] 小写字母字符 [[:print:]] 打印字符 [[:punct：]] 标点符号字符 [[:space:]]
2048源码(核心算法有，缺少几个anctionbar，以后补上) 不懂事的小屁孩 2048
2048游戏基本上有四部分组成， 1：主activity，包含游戏块的16个方格，上面统计分数的模块 2：底下的gridview，监听上下左右的滑动，进行事件处理， 3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 写代码的流程 1：设计游戏的布局，基本是两块，上面是分
jquery内部链式调用机理换个号韩国红果果 JavaScript jquery
只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this 因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） function create(type){ var element=document.createElement(type); //this=element;
你订酒店时的每一次点击背后都是NoSQL和云计算蓝儿唯美 NoSQL
全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
java笔记1 a-john java
1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 3，面向对象程序设计方式的特性： 3.1 万物皆为对象。
C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题必备考点（一） aijuans C/C++求职面试必备考点
找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
程序员写代码时就不要管需求了吗？ asia007 程序员不能一味跟需求走
编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。我的技术不是很好，但是就不代
Activity的四种启动模式百合不是茶 android 栈模式启动 Activity的标准模式启动栈顶模式启动单例模式启动
android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 启动模式xml中配置 <activity android:name=".MainActivity" android:launchMode="standard&quo
Spring中@Autowired标签与@Resource标签的区别 bijian1013 java spring @Resource @Autowired @Qualifier
Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 1. @Autowired @Autowired是Spring 提供的，需导入 Package:org.springframewo
Changes Between SOAP 1.1 and SOAP 1.2 sunjing Changes Enable SOAP 1.1 SOAP 1.2
JAX-WS SOAP Version 1.2 Part 0: Primer (Second Edition) SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) SOAP Version 1.2 Part 2: Adjuncts (Second Edition) Which style of WSDL
【Hadoop二】Hadoop常用命令 bit1129 hadoop
以Hadoop运行Hadoop自带的wordcount为例， hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 Hadoop HDFS相关命令 hadoop fs -ls 列出HDFS文件系统的第一级文件和第一级
java异常处理（初级）白糖_ java DAO spring 虚拟机 Ajax
从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
记录整理-工作问题 braveCS 工作
1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
org.apache.tools.zip实现文件的压缩和解压，支持中文 bylijinnan apache
刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦）后改用org.apache.tools.zip org.apache.tools.zip的使用网上有更简单的例子下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 import java.io.BufferedReader; import java.io.BufferedWrit
读书笔记-4 chengxuyuancsdn 读书笔记
1、JSTL 核心标签库标签 2、避免SQL注入 3、字符串逆转方法 4、字符串比较compareTo 5、字符串替换replace 6、分拆字符串 1、JSTL 核心标签库标签共有13个，学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html 功能上分为4类： (1)表达式控制标签：out
[物理与电子]半导体教材的一个小问题 comsci 问题
各种模拟电子和数字电子教材中都有这个词汇-空穴书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴我现在回过头翻大学时候的教材,觉得这个
Flashback Database --闪回数据库 daizj oracle 闪回数据库
Flashback 技术是以Undo segment中的内容为基础的，因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
简单排序:插入排序 dieslrae 插入排序
public void insertSort(int[] array){ int temp; for(int i=1;i<array.length;i++){ temp = array[i]; for(int k=i-1;k>=0;k--)
C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容 dcj3sjt126com c
# include <stdio.h> int main(void) { int * p; //等价于 int *p 也等价于 int* p; int i = 5; char ch = 'A'; //p = 5; //error //p = &ch; //error //p = ch; //error p = &i; //
centos下php redis扩展的安装配置3种方法 dcj3sjt126com redis
方法一 1.下载php redis扩展包代码如下复制代码 #wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz 2 tar -zxvf 解压压缩包，cd /扩展包（进入扩展包然后运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
线程池(Executors) shuizhaosi888 线程池
在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 public interface Executor { void execute(Runnable command); } public class RunMain implements Executor{ @Override pub
openstack 快速安装笔记 haoningabc openstack
前提是要配置好yum源版本icehouse，操作系统redhat6.5 最简化安装，不要cinder和swift 三个节点 172 control节点keystone glance horizon 173 compute节点nova 173 network节点neutron control /etc/sysctl.conf net.ipv4.ip_forward =
从c面向对象的实现理解c++的对象（二） jimmee C++面向对象虚函数
1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 3. c++中类的析构函数，就时回收内存(free) 4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。专门在
如何让那个一个div可以拖动 lingfeng520240 html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml
第10章高级事件（中） onestopweb 事件
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
计算两个经纬度之间的距离 roadrunners 计算纬度 LBS 经度距离
要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 /** * * @param longitudeA * 经度A点 * @param latitudeA * 纬度A点 * @param longitudeB *
最具争议的10个Java话题 tomcat_oracle java
1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。　　2、Java 9 即将到来　　 Oracle早在8月份就发布
zoj 3826 Hierarchical Notation(模拟) 阿尔萨斯 rar
题目链接：zoj 3826 Hierarchical Notation 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。这题是最后10分钟出的，因为没有考虑value为{}的情

按字母分类： A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 其他