国内偷自视频区视频综合,亚洲一区二区三区色,久久99国产精品久久99果冻传媒

设计模式之Interpreter(解释�?

powerwind — Mon, 11 Dec 2006 11:54:00 GMT

设计模式之Interpreter(解释�?

板桥里�h http://www.jdon.com 2002/05/05

模式实战书籍《Java实用�pȝ��开发指南�?/font>

Interpreter解释器模式定�?
定义语言的文�?,�q�且建立一个解释器来解释该语言中的句子.

Interpreter��g��使用面不是很�q?它描�q�C��一个语�a�解释器是如何构成�?在实际应用中,我们可能很少��L��造一个语�a�的文�?我们�q�是来简单的了解一�?

首先要徏立一个接�?用来描述共同的操�?

public interface AbstractExpression {
　　 void interpret( Context context );
}

再看看包含解释器之外的一些全局信息

public interface Context { }

AbstractExpression的具体实现分两种:�l�结�W�表辑ּ�和非�l�结�W�表辑ּ�:

public class TerminalExpression implements AbstractExpression {
　　 public void interpret( Context context ) { }
}

对于文法中没一条规�?非终�l�符表达式都必须�?

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 ) { }
}

powerwind 2006-12-11 19:54 发表评论

设计模式之Visitor

powerwind — Mon, 11 Dec 2006 11:54:00 GMT

设计模式之Visitor

板桥里�h http://www.jdon.com 2002/05/05�Q��{载请保留�Q?/p>

模式实战书籍《Java实用�pȝ��开发指南�?/font>

Visitor讉K��者模式定�?/b>
作用于某个对象群中各个对象的操作. 它可以��你在不改变这些对象本�w�的情况�?定义作用于这些对象的新操�?

在Java�?Visitor模式实际上是分离了collection�l�构中的元素和对�q�些元素�q�行操作的行�?

��Z��使用Visitor?
Java的Collection(包括Vector和Hashtable)是我们最�l�常使用的技�?可是Collection好象是个黑色大染�~?本来有各�U�鲜明类型特征的对象一旦放入后,再取出时,�q�些�c�d��消�׃��.那么我们势必要用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的类�?

很显�?�q�样做的�~�点代码If else if 很繁�?我们��可以��用Visitor模式解决�?

如何使用Visitor?
针对上例,定义接口叫Visitable,用来定义一个Accept操作,也就是说让Collection每个元素具备可访问�?

被访问者是我们Collection的每个元素Element,我们要�ؓ�q�些Element定义一个可以接受访问的接口(讉K��和被讉K��是互动的,只有讉K��?被访问者如果表�C�Z��Ƣ迎,讉K��者就不能讉K��),取名为Visitable�Q�也可取名�ؓElement�?/p>

public interface Visitable
{
　　 public void accept(Visitor visitor);
}

被访问的具体元素�l�承�q�个新的接口Visitable�Q?/p>

public class StringElement implements Visitable
{
　　 private String value;
　　 public StringElement(String string) {
　　　　 value = string;
　　 }

　　 public String getValue(){
　　　　 return value;
　　 }

　　 //定义accept的具体内�?�q�里是很��单的一句调�?br />　　 public void accept(Visitor visitor) {
　　　　 visitor.visitString(this);
　　 }
}

上面是被讉K��者是字符串类型，下面再徏立一个Float�c�d��的：

public class FloatElement implements Visitable
{
　　 private Float value;
　　 public FloatElement(Float value) {
　　　　 this.value = value;
　　 }

　　 public Float getValue(){
　　　　 return value;
　　 }

　　 //定义accept的具体内�?�q�里是很��单的一句调�?br />　　 public void accept(Visitor visitor) {
　　　　 visitor.visitFloat(this);
　　 }
}

我们设计一个接口visitor讉K��者，在这个接口中,有一些访问操作，�q�些讉K��操作是专门访问对象集合Collection中有可能的所有类�Q�目前我们假定有三个行�ؓ�Q�访问对象集合中的字�W�串�c�d��Q�访问对象集合中的Float�c�d��Q�访问对象集合中的对象集合类型。注意最后一个类型是集合嵌套�Q�通过�q�个嵌套实现可以看出使用讉K��模式的一个优炏V�?/p>
接口visitor讉K��者如下：

public interface Visitor
{

　　 public void visitString(StringElement stringE);
　　 public void visitFloat(FloatElement floatE);
　　 public void visitCollection(Collection collection);

}

讉K��者的实现:

public class ConcreteVisitor implements Visitor
{
　　 //在本�Ҏ��?我们实现了对Collection的元素的成功讉K��
　　 public void visitCollection(Collection collection) {
　　　　 Iterator iterator = collection.iterator()
　　　　 while (iterator.hasNext()) {
　　　　　　 Object o = iterator.next();
　　　　　　 if (o instanceof Visitable)
　　　　　　　　 ((Visitable)o).accept(this);
　　　　 }
　　 �?/p>
　　 public void visitString(StringElement stringE) {
　　　　 System.out.println("'"+stringE.getValue()+"'");
　　 }
　　 public void visitFloat(FloatElement floatE){
　　　　 System.out.println(floatE.getValue().toString()+"f");
　　 }

}

在上面的visitCollection我们实现了对Collection每个元素讉K��,只��用了一个判断语�?只要判断其是否可以访�?

StringElement只是一个实玎ͼ�可以拓展为更多的实现�Q�整个核心奥妙在accept�Ҏ��中，在遍历Collection�Ӟ��通过相应的accept�Ҏ��调用具体�c�d��的被讉K��者。这一步确定了被访问者类型，

如果是StringElement�Q�而StringElement则回调访问者的visiteString�Ҏ��Q�这一步实��C��行�ؓ操作�Ҏ��?/p>
客户端代码：

Visitor visitor = new ConcreteVisitor();

StringElement stringE = new StringElement("I am a String");
visitor.visitString(stringE);

Collection list = new ArrayList();
list.add(new StringElement("I am a String1"));
list.add(new StringElement("I am a String2"));
list.add(new FloatElement(new Float(12)));
list.add(new StringElement("I am a String3"));
visitor.visitCollection(list);

客户端代码中的list对象集合中放�|�了多种数据�c�d��Q�对对象集合中的讉K��不必象一开始那��P��使用instance of逐个判断�Q�而是通过讉K��者模式��y妙实��C��?/p>
��x��,我们完成了Visitor模式基本�l�构.

使用Visitor模式的前�?/b>
使用讉K��者模式是对象��结构中(Collection) 中的对象�c�d��很少改变�?/p>
在两个接口Visitor和Visitable�?��保Visitable很少变化,也就是说�Q�确保不能老有新的Element元素�c�d��加进来，可以变化的是讉K��者行为或操作�Q�也��是Visitor的不同子�c�d��以有多种,�q�样使用讉K��者模式最方便.

如果对象集合中的对象集合�l�常有变�? 那么不但Visitor实现要变化，Visistable也要增加相应行�ؓ�Q�GOF��?不如在这些对象类中直接逐个定义操作�Q�无需使用讉K��者设计模式�?/p>
但是在Java中，Java的Reflect技术解决了�q�个问题�Q�因此结合reflect反射机制�Q�可以��得访问者模式适用范围更广了�?/p>
Reflect技术是在运行期间动态获取对象类型和�Ҏ��的一�U�技�?具体实现参考Javaworld�?a target="_blank">英文原文.

powerwind 2006-12-11 19:54 发表评论

设计模式之Strategy(�{�略)

powerwind — Mon, 11 Dec 2006 11:52:00 GMT

设计模式之Strategy(�{�略)

板桥里�h http://www.jdon.com 2002/03/30

模式实战书籍《Java实用�pȝ��开发指南�?/font>

Strategy�{�略模式是属于设计模式中对象行�ؓ型模�?主要是定义一�p�d��的算�?把这些算法一个个��装成单独的�c?

Stratrgy应用比较�q�泛,比如, 公司�l�营业务变化�? 可能有两�U�实现方�?一个是�U�条曲线,一个是框图(bar),�q�是两种��法,可以使用Strategy实现.

�q�里以字�W�串替代��Z��, 有一个文�?我们需要读取后,希望替代其中相应的变�?然后输出.关于替代其中变量的方法可能有多种�Ҏ��,�q�取决于用户的要�?所以我们要准备几套变量字符替代�Ҏ��.

首先,我们建立一个抽象类RepTempRule 定义一些公用变量和�Ҏ��:

public abstract class RepTempRule{

protected String oldString="";
public void setOldString(String oldString){
　　this.oldString=oldString;
}

protected String newString="";
public String getNewString(){
　　return newString;
}

public abstract void replace() throws Exception;

}

在RepTempRule�?有一个抽象方法abstract需要��承明��?�q�个replace里其实是替代的具体方�?
我们现在有两个字�W�替代方�?
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");
　　
}

}

�W�二步：我们要徏立一个算法解决类�Q�用来提供客��L��可以自由选择��法�?/p>

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(){

　　//使用�W�一套替代方�?br />　　RepTempRuleSolve solver=new RepTempRuleSolve(new RepTempRuleSimple());
　　solver.getNewContext(site,context);

　　//使用�W�二�?/p>
　　solver=new RepTempRuleSolve(new RepTempRuleTwo());
　　solver.getNewContext(site,context);

　　}

.....

}

我们辑ֈ�了在�q�行期间�Q�可以自由切换算法的目的�?/p>
实际整个Strategy的核心部分就是抽象类的��?使用Strategy模式可以在用户需要变化时,修改量很��?而且快�?

Strategy和Factory有一定的�c�M��,Strategy相对��单容易理�?�q�且可以在运行时刻自由切换。Factory重点是用来创建对象�?/p>
Strategy适合下列场合:

1.以不同的格式保存文�g;

2.以不同的��法压羃文�g;

3.以不同的��法截获图象;

powerwind 2006-12-11 19:52 发表评论

设计模式之Mediator(中介�?

powerwind — Mon, 11 Dec 2006 11:52:00 GMT

设计模式之Mediator(中介�?

板桥里�h http://www.jdon.com 2002/05/05

模式实战书籍《Java实用�pȝ��开发指南�?/font>

Mediator中介者模式定�?
用一个中介对象来��装一�p�d��关于对象交互行�ؓ.

��Z��使用Mediator?
各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此�Ҏ��,修改一个对象的行�ؓ,同时会涉及到修改很多其他对象的行�?如果使用Mediator模式,可以使各个对象间的耦合松散,只需兛_��?Mediator的关�p?使多对多的关�p�d��成了一对多的关�p?可以降低�pȝ��的复杂�?提高可修�Ҏ��展�?

如何使用?

首先有一个接�?用来定义成员对象之间的交互联�p�L��?

public interface Mediator { }

Meiator具体实现,真正实现交互操作的内�?

public class ConcreteMediator implements Mediator {

　　 //假设当前有两个成�?
　　 private ConcreteColleague1 colleague1 = new ConcreteColleague1();
　　 private ConcreteColleague2 colleague2 = new ConcreteColleague2();

　　 ...

}

再看看另外一个参与�?成员,因�ؓ是交互行�?都需要双�Ҏ��供一些共同接�?�q�种要求在Visitor Observer�{�模式中都是相同�?

public class Colleague {
　　 private Mediator mediator;
　　 public Mediator getMediator() {
　　　　 return mediator;
　　 }

　　 public void setMediator( Mediator mediator ) {
　　　　 this.mediator = mediator;
　　 }
}

public class ConcreteColleague1 { }

public class ConcreteColleague2 { }

每个成员都必��ȝ��道Mediator,�q�且�?Mediator联系,而不是和其他成员联系.

��x��,Mediator模式框架完成,可以发现Mediator模式规定不是很多,大体框架也比较简�?但实际��用�v来就非常灉|��.

Mediator模式在事仉��动类应用中比较多,例如界面设计GUI.;聊天,消息传递等,在聊天应用中,需要有一个MessageMediator,专门负责request/reponse之间��d��的调�?

MVC是J2EE的一个基本模�?View Controller是一�U�Mediator,它是Jsp和服务器上应用程序间的Mediator.

powerwind 2006-12-11 19:52 发表评论

设计模式之Chain of Responsibility(职责�?

powerwind — Mon, 11 Dec 2006 11:51:00 GMT

设计模式之Chain of Responsibility(职责�?

板桥里�h http://www.jdon.com 2002/04/21(转蝲请保�?

Chain of Responsibility定义
Chain of Responsibility(CoR) 是用一�p�d��c?classes)试图处理一个请求request,�q�些�c�M��间是一个松散的耦合,唯一共同�Ҏ��在他们之间传递request. 也就是说�Q�来了一个请求，A�c�d��处理�Q�如果没有处理，��׃��递到B�c�d��理，如果没有处理�Q�就传递到C�c�d��理，��p��栯��一个链�?chain)一样传递下厅R�?/p>
如何使用?
虽然�q�一�D�|��如何使用CoR,但是也是演示什么是CoR.

有一个Handler接口:

public interface Handler{
　　public void handleRequest();
}

�q�是一个处理request的事例，如果有多�U�request,比如 ��h��帮助 ��h��打印或请求格式化�Q?br />
最先想到的解决�Ҏ��是：在接口中增加多个��h��Q?br />public interface Handler{
　　public void handleHelp();
　　public void handlePrint();
　　public void handleFormat();

}

具体是一�D�实现接口Handler代码�Q?br />public class ConcreteHandler implements Handler{
　　private Handler successor;

　　public ConcreteHandler(Handler successor){
　　this.successor=successor;
}

　　public void handleHelp(){
　　　　//具体处理��h��Help的代�?br />　　　　...
　　}

　　public void handlePrint(){
　　　　//如果是print 转去处理Print
　　　　successor.handlePrint();
　　}
　　public void handleFormat(){
　　　　//如果是Format 转去处理format
　　　　successor.handleFormat();
　　}

}
一共有三个�q�样的具体实现类�Q�上面是处理help,�q�有处理Print 处理Format�q�大概是我们最常用的编�E�思�\�?/p>
虽然思�\��单明了，但是有一个扩展问题，如果我们需要再增加一个请求request�U�类,需要修�Ҏ��口及其每一个实现�?/p>
�W�二�Ҏ��:��每�U�request都变成一个接口，因此我们有以下代�?�Q?/p>
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;
　　}

　　public void handleHelp(){
　　　　.......
　　}

　　public void handlePrint(){this.printSuccessor=printSuccessor;}

　　public void handleFormat(){this.formatSuccessor=formatSuccessor;}

}

�q�个办法在增加新的请求request情况下，只是节省了接口的修改量，接口实现ConcreteHandler�q�需要修攏V��而且代码昄��不简单美丽�?/p>
解决�Ҏ��3: 在Handler接口中只使用一个参数化�Ҏ��Q?br />public interface Handler{
　　public void handleRequest(String request);
}
那么Handler实现代码如下�Q?br />public class ConcreteHandler implements Handler{
　　private Handler successor;

　　public ConcreteHandler(Handler successor){
　　　　this.successor=successor;
　　}

　　public void handleRequest(String request){
　　　　if (request.equals("Help")){
　　　　　　//�q�里是处理Help的具体代�?br />　　　　}else
　　　　　　//传递到下一�?br />　　　　　　successor.handle(request);

　　　　}
　　}

}

�q�里先假设request是String�c�d��Q�如果不是怎么办？当然我们可以创徏一个专门类Request

最后解��x��?接口Handler的代码如下：
public interface Handler{
　　public void handleRequest(Request request);
}
Request�cȝ��定义:
public class Request{
　　private String type;

　　public Request(String type){this.type=type;}

　　public String getType(){return type;}

　　public void execute(){
　　　　//request真正具体行�ؓ代码
　　}
}
那么Handler实现代码如下�Q?br />public class ConcreteHandler implements Handler{
　　private Handler successor;

　　public ConcreteHandler(Handler successor){
　　　　this.successor=successor;
　　}

　　public void handleRequest(Request request){
　　　　if (request instanceof HelpRequest){
　　　　　　//�q�里是处理Help的具体代�?br />　　　　}else if (request instanceof PrintRequst){
　　　　　　request.execute();
　　　　}else
　　　　　　//传递到下一�?br />　　　　　　successor.handle(request);

　　　　}
　　}

}

�q�个解决�Ҏ��是CoR, 在一个链�?都有相应职责的类,因此�?b>Chain of Responsibility.

CoR的优点：
因�ؓ无法预知来自外界�Q�客��L��Q�的��h��是属于哪�U�类型，每个�c�d��果碰到它不能处理的请求只要放弃就可以�?/p>
�~�点是效率低�Q�因��Z��个请求的完成可能要遍历到最后才可能完成�Q�当然也可以用树的概念优化�?在Java AWT1.0中，对于鼠标按键事情的处理就是��用CoR,到Java.1.1以后�Q�就使用Observer代替CoR

扩展性差�Q�因为在CoR中，一定要有一个统一的接口Handler.局限性就在这里�?/p>
与Command模式区别�Q?/strong>

Command 模式需要事先协商客��L��和服务器端的调用关系�Q�比�?1 代表 start 2 代表 move �{�，�q�些都是��装�?request 中，到达服务器端再分解�?/p>
CoR 模式��无需�q�种事先�U�定�Q�服务器端可以��?CoR 模式�q�行客户端请求的猜测�Q�一个个猜测试验�?

powerwind 2006-12-11 19:51 发表评论

设计模式之Command

powerwind — Mon, 11 Dec 2006 11:51:00 GMT

设计模式之Command

板桥里�h http://www.jdon.com 2002/4/23/�Q��{载请保留�Q?/p>
模式实战书籍《Java实用�pȝ��开发指南�?/font>

Command模式是最让我疑惑的一个模�?我在阅读了很多代码后,才感觉隐�U�掌握其大概原理,我认为理解设计模式最主要是掌握�v原理构�?�q�样才对自己实际�~�程有指��g��?Command模式实际上不是个很具�?规定很多的模�?正是�q�个灉|��?让�h有些confuse.

Command定义
n ��来自客��L��的请求传入一个对象，无需了解�q�个��h��Ȁ�zȝ�� 动作或有��x��受这个请求的处理�l�节�?/p>
�q�是一�U�两台机器之间通讯联系性质的模式，�c�M��传统�q�程�?�a��?CallBack功能�?

优点�Q?br />解耦了发送者和接受者之间联�p�R�?发送者调用一个操作，接受者接受请求执行相应的动作�Q�因��Z��用Command模式解耦，发送者无需知道接受者�Q何接口�?/p>
不少Command模式的代码都是针对图形界面的,它实际就是菜单命�?我们在一个下拉菜单选择一个命令时,然后会执行一些动�?

��这些命令封装成在一个类�?然后用户(调用�?再对�q�个�c�进行操�?�q�就是Command模式,换句话说,本来用户(调用�?是直接调用这些命令的,如菜单上打开文档(调用�?,��q��接指向打开文档的代�?使用Command模式,��是在这两者之间增加一个中间�?��这�U�直接关�p�L��?同时两者之间都隔离,基本没有关系�?

昄��q�样做的好处是符合封装的�Ҏ�?降低耦合�?Command是将对行��行封装的典型模式,Factory是将创徏�q�行��装的模�?
从Command模式,我也发现设计模式一�?通病":好象喜欢��简单的问题复杂�? 喜欢在不同类中增加第三�?当然�q�样做有利于代码的健壮�?可维护�?�q�有复用�?

如何使用?
具体的Command模式代码各式各样,因�ؓ如何��装命��o,不同�pȝ��,有不同的做法.下面事例是将命��o��装在一个Collection的List�?��M��对象一旦加入List�?实际上装入了一个封闭的黑盒�?对象的特性消�׃��,只有取出�?才有可能模糊的分辨出:
典型的Command模式需要有一个接�?接口中有一个统一的方�?�q�就�?��命�?��h��装为对�?:
public interface Command {
　　public abstract void execute ( );
}

具体不同命��o/��h��代码是实现接口Command,下面有三个具体命�?br />
public class Engineer implements Command {

　　public void execute( ) {
　　　　//do Engineer's command
　　}
}
public class Programmer implements Command {

　　public void execute( ) {
　　　　//do programmer's command
　　}
}
public class Politician implements Command {

　　public void execute( ) {
　　　　//do Politician's command
　　}
}

按照通常做法,我们��可以直接调用这三个Command,但是使用Command模式,我们要将他们��装��h��,扔到黑盒子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;
　　}
}
�q�三个命令进入List中后,已经失去了其外表特征,以后再取�?也可能无法分辨出谁是Engineer 谁是Programmer�?看下面客��L��如何调用Command模式:
public class TestCommand {
　　public static void main(String[] args) {
　　　　
　　　　List queue = Producer.produceRequests();
　　　　for (Iterator it = queue.iterator(); it.hasNext(); )
　　　　　　
　//客户端直接调用execute�Ҏ��Q�无需知道被调用者的其它更多�cȝ��Ҏ��名�?br />　　　　　　　　((Command)it.next()).execute();
　　
　　}
}
由此可见,调用者基本只和接口打交道,不合具体实现交互,�q�也体现了一个原�?面向接口�~�程,�q�样,以后增加�W�四个具体命令时,��׃��必修改调用者TestCommand中的代码�?

理解了上面的代码的核心原�?在��用中,��应该各人有自己�Ҏ��?特别是在如何分离调用者和具体命��o�?有很多实现方�?上面的代码是使用"从List�q�一�?的做�?�q�种做法只是��Z��演示.
使用Command模式的一个好理由�q�因为它能实现Undo功能.每个具体命��o都可以记住它刚刚执行的动�?�q�且在需要时恢复.
Command模式在界面设计中应用�q�泛.Java的Swing中菜单命令都是��用Command模式,�׃��Java在界面设计的性能上还有欠�~?因此界面设计具体代码我们��׃��讨论,�|�络上有很多�q�样的示�?
参�?
http://www.patterndepot.com/put/8/command.pdf
http://www.javaworld.com/javaworld/javatips/jw-javatip68.html
设计模式如何在具体项目中应用�?a target="_blank">《Java实用�pȝ��开发指南�?/font>

powerwind 2006-12-11 19:51 发表评论

设计模式之State

powerwind — Mon, 11 Dec 2006 11:51:00 GMT

设计模式之State

板桥里�h http://www.jdon.com 2002/4/6/

模式实战书籍《Java实用�pȝ��开发指南�?/font>

State模式的定�?/b> : 不同的状�?不同的行�?或者说,每个状态有着相应的行�?

何时使用 ?
State模式在实际��用中比较�?适合"状态的切换".因�ؓ我们�l�常会��用If elseif else �q�行状态切�? 如果针对状态的�q�样判断切换反复出现,我们��p��联想到是否可以采取State模式�?

不只是根据状�?也有�Ҏ��属�?如果某个对象的属性不�?对象的行为就不一�?�q�点在数据库�pȝ��中出现频率比较高,我们�l�常会在一个数据表的尾�?加上property属性含义的字段,用以标识记录中一些特�D�性质的记�?�q�种属性的改变(切换)又是随时可能发生�?��有可能要��用State.

是否使用?
在实际��?�c�M��开关一��L��状态切换是很多�?但有时�ƈ不是那么明显,取决于你的经验和对系�l�的理解深度.

�q�里要阐�q�的�?开兛_��换状�? �? 一般的状态判�?是有一些区别的, " 一般的状态判�?也是�?if..elseif�l�构,例如:

　　　　if (which==1) state="hello";
　　　　else if (which==2) state="hi";
　　　　else if (which==3) state="bye";

�q�是一�?" 一般的状态判�?,state值的不同是根据which变量来决定的,which和state没有关系.如果�Ҏ��:

　　　　if (state.euqals("bye")) state="hello";
　　　　else if (state.euqals("hello")) state="hi";
　　　　else if (state.euqals("hi")) state="bye";

�q�就�?"开兛_��换状�?,是将state的状态从"hello"切换�?hi",再切换到""bye";在切换到"hello",好象一个旋转开�?�q�种状态改变就可以使用State模式�?

如果单纯有上面一�U�将"hello"-->"hi"-->"bye"-->"hello"�q�一个方向切�?也不一定需要��用State模式,因�ؓState模式会徏立很多子�c?复杂�?但是如果又发生另外一个行�?��上面的切换方向反过来切�?或者需要�Q意切�?��需要State�?

��L��下例:

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状态切换正好相�?/p>
　　　　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�?�q�两个开兛_��?改变了Context颜色,��x��,我们��需要��用State模式优化�?

另外注意:但就上例,state的变�?只是��单的颜色赋�?�q�个具体行�ؓ是很��单的,State适合巨大的具体行�?因此�?��本�?实际使用中也不一定非要��用State模式,�q�会增加子类的数�?��单的变复�?

例如: 银行帐户, �l�常会在Open 状态和Close状态间转换.

例如: �l�典的TcpConnection, Tcp的状态有创徏侦听关闭三个,�q�且反复转换,其创�?侦听关闭的具体行��Z��是简单一两句��p��完成�?适合使用State

例如:信箱POP帐号, 会有四种状�? start HaveUsername Authorized quit,每个状态对应的行�ؓ应该是比较大�?适合使用State

例如:在工��L��挑选不同工�?可以看成在不同工具中切换,适合使用State.�?具体�l�图�E�序,用户可以选择不同工具�l�制�Ҏ�� 直线曲线,�q�种状态切换可以��用State.

如何使用
State需要两�U�类型实体参�?

1.state manager 状态管理器 ,��是开�?,如上面例子的Context实际��是一个state manager, 在state manager中有对状态的切换动作.
2.用抽象类或接口实现的父类,,不同状态就是��承这个父�cȝ��不同子类.

以上面的Context��Z��.我们要修改它,建立两个�c�d��的实�?
�W�一�? 首先建立一个父�c?

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�?那么在状态父�c�M��p��有具体处理这两个动作:handlepush() handlepull(); 同时�q�需要一个获取push或pull�l�果的方法getcolor()

下面是具体子�cȝ��实现:

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" ;
　　　　c.setState(new RedState());

　　}

　　public abstract void getcolor(){ return (Color.blue)}

}

同样其他状态的子类实现如blue一�?

�W�二�? 要重新改写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(){

　　　　//状态的切换的细节部�?在本例中是颜色的变化,已经��装在子�cȝ��handlepush中实�?�q�里无需兛_��
　　　　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());
　　　　sample2.operate();

　　}

}

��x��,我们也就实现了State的refactorying�q�程.

以上只是相当��单的一个实�?在实际应用中,handlepush或handelpull的处理是复杂�?

状态模式优点：
�Q?�Q?��装转换�q�程�Q�也��是转换规则
�Q?�Q?枚�D可能的状态，因此�Q�需要事先确定状态种�c�R�?br />

状态模式可以允许客��L��改变状态的转换行�ؓ�Q�而状态机则是能够自动改变状态，状态机是一个比较独立的而且复杂的机�Ӟ��具体可参考一个状态机开源项目：http://sourceforge.net/projects/smframework/

状态模式在工作��或游戏�{�各�U�系�l�中有大量��用，甚至是这些系�l�的核心功能设计�Q�例如政府OA中，一个批文的状态有多种�Q�未办；正在办理�Q�正在批�C�；正在审核�Q�已�l�完成等各种状态，使用状态机可以��装�q�个状态的变化规则�Q�从而达到扩充状态时�Q�不必涉及到状态的使用者�?/p>
在网�l�游戏中�Q�一个游戏活动存在开始；开玩；正在玩；输赢�{�各�U�状态，使用状态模式就可以实现游戏状态的��L��Q�而游戏状态决定了游戏的各个方面，使用状态模式可以对整个游戏架构功能实现起到军_��的主��g��用�?/p>
状态模式实�?/strong>�Q?br />使用状态模式前�Q�客��L��外界需要介入改变状态，而状态改变的实现是琐��或复杂的�?/p>
使用状态模式后�Q�客��L��外界可以直接使用事�gEvent实现�Q�根本不必关心该事�g��D��如何状态变化，�q�些是由状态机�{�内部实现�?/p>
�q�是一�U�Event-condition-State�Q�状态模式封装了condition-State部分�?/p>
每个状态�Ş成一个子�c�，每个状态只兛_��它的下一个可能状态，从而无形中形成了状态�{换的规则。如果新的状态加入，只涉及它的前一个状态修改和定义�?/p>
状态�{换有几个�Ҏ��实现�Q�一个在每个状态实现next()�Q�指定下一个状态；�q�有一�U�方法，讑֮�一个StateOwner�Q�在StateOwner讑֮�stateEnter状态进入和stateExit状态退��为�?/p>
状态从一个方面说明了��程�Q�流�E�是随时间而改变，状态是截取��程某个旉��片�?/p>

相关文章�Q?/p>
从工作流状态机实践中�ȝ��状态模式��用心�?/font>

参考资�?
the State and Stategy
How to implement state-dependent behavior
The state patterns

powerwind 2006-12-11 19:51 发表评论

设计模式之Observer

powerwind — Mon, 11 Dec 2006 11:50:00 GMT

设计模式之Observer

板桥里�h http://www.jdon.com 2002/3/16

Java深入��C��定程�?��׃��可避免的��到设计模式(design pattern)�q�一概念,了解设计模式,��自己对java中的接口或抽象类应用有更��q��理解.设计模式在java的中型系�l�中应用�q�泛,遵��@一定的�~�程模式,才能使自��q��代码便于理解,易于交流,Observer(观察�?模式是比较常用的一个模�?��其在界面设计中应用�q�泛,而本站所��x��的是Java在电子商务系�l�中应用,因此想从电子商务实例中分析Observer的应�?

虽然�|�上商店形式多样,每个站点有自��q��特色,但也有其一般的共�?单就"商品的变�?以便及时通知订户"�q�一�?是很多网上商店共有的模式,�q�一模式�c�M��Observer patern观察者模�?

具体的说,如果�|�上商店中商品在名称 ��h��{�方面有变化,如果�pȝ��能自动通知会员,��是�|�上商店区别传统商店的一大特�?�q�就需要在商品product中加入Observer�q�样角色,以便product�l�节发生变化�?Observer能自动观察到�q�种变化,�q�能�q�行及时的update或notify动作.

Java的API�q��ؓ为我们提供现成的Observer接口Java.util.Observer.我们只要直接使用它就可以.

我们必须extends Java.util.Observer才能真正使用�?
1.提供Add/Delete observer的方�?
2.提供通知(notisfy) 所有observer的方�?

//产品�c?可供Jsp直接使用UseBean调用该类主要执行产品数据库插�?更新
public class product extends Observable{
　　private String name;
　　private float price;
　　public String getName(){ return name;}
　　public void setName(String name){
　　 this.name=name;
　　//讄��变化�?
　　 setChanged();
　　 notifyObservers(name);
　　}　　　
　　public float getPrice(){ return price;}
　　public void setPrice(float price){
　　 this.price=price;
　　//讄��变化�?br />　　 setChanged();
　　 notifyObservers(new Float(price));
　　}

　　//以下可以是数据库更新插入命��o.
　　public void saveToDb(){
　　.....................
}

我们注意�?在product�c�M�� 的setXXX�Ҏ��?我们讄��?notify(通知)�Ҏ��, 当Jsp表单调用setXXX(如何调用见我�?a target="_blank">另外一��文�?/font>),实际上就触发了notisfyObservers�Ҏ��,�q�将通知相应观察者应该采取行动了.

下面看看�q�些观察者的代码,他们�I�竟采取了什么行�?

//观察者NameObserver主要用来对��品名�U?name)�q�行观察�?br />public class NameObserver implements Observer{

　　private String name=null;

　　public void update(Observable obj,Object arg){

　　　　if (arg instanceof String){

　　　　 name=(String)arg;
　　　　 //产品名称改变值在name�?br />　　　　 System.out.println("NameObserver :name changet to "+name);

　　　　}

　　}

}

//观察者PriceObserver主要用来对��品�h�?price)�q�行观察�?br />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中我们可以来正式执行�q�段观察者程�?

<%

if (request.getParameter("save")!=null)
{
　　product.saveToDb();

　　out.println("产品数据变动保存! �q�已�l�自动通知客户");

}else{

　　//加入观察�?br />　　product.addObserver(nameobs);

　　product.addObserver(priceobs);

%>

　　//request.getRequestURI()是��生本jsp的程序名,��是自己调用自己
　　

　　
　　产品名称:
　　产品��h��:
　　

　　

<%

}

%>

执行改Jsp�E�序,会出��C��个表单录入界�? 需要输入��品名�U?产品��h��, �Ҏ��Submit�?�q�是执行该jsp�?br />if (request.getParameter("save")!=null)之间的代�?

�׃��q�里使用了数据javabeans的自动赋值概�?实际�E�序自动执行了setName setPrice语句.你会在服务器控制��C��发现下面信息::

NameObserver :name changet to ?????(Jsp表单中输入的产品名称)

PriceObserver :price changet to ???(Jsp表单中输入的产品��h��);

�q�说明观察者已�l�在行动�?!!
同时你会在执行jsp的浏览器端得��C��?

产品数据变动保存! �q�已�l�自动通知客户

上文�׃��使用jsp概念,隐含很多自动动作,现将调用观察者的Java代码写如�?

public class Test {

　　public static void main(String args[]){

Product product=new Product();

NameObserver nameobs=new NameObserver();
PriceObserver priceobs=new PriceObserver();

//加入观察�?br />product.addObserver(nameobs);
product.addObserver(priceobs);

product.setName("��子�U�了");
product.setPrice(9.22f);

　　}

}

你会在发��C��面信�?:

NameObserver :name changet to ��子�U�了

PriceObserver :price changet to 9.22

�q�说明观察者在行动�?!!

设计模式如何在具体项目中应用�?a target="_blank">《Java实用�pȝ��开发指南�?/font>

powerwind 2006-12-11 19:50 发表评论

设计模式之Template

powerwind — Mon, 11 Dec 2006 11:49:00 GMT

设计模式之Template

板桥里�h http://www.jdon.com 2002/05/05

Template模板模式定义:
定义一个操作中��法的骨�?��一些步骤的执行延迟到其子类�?

使用Java的抽象类�Ӟ��q��怼�使用到Template模式,因此Template模式使用很普�?而且很容易理解和使用�?/p>

public abstract class Benchmark
{
　　/**
　　* 下面操作是我们希望在子类中完�?br />　　*/
　　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()的具体内�Ҏ��有说�?而是延迟到其子类中描�q?

public class MethodBenchmark extends Benchmark
{
　　/**
　　* 真正定义benchmark内容
　　*/
　　public void benchmark() {

　　　　for (int i = 0; i < Integer.MAX_VALUE; i++){
　　　　　System.out.printtln("i="+i);　　　
　　　 }
　　}
}

��x��,Template模式已经完成,是不是很��?

我们�U�repeat�Ҏ��为模板方法，它其中的benchmark()实现被�g�q�到子类MethodBenchmark中实��C��Q?/p>
看看如何使用:

Benchmark operation = new MethodBenchmark();
long duration = operation.repeat(Integer.parseInt(args[0].trim()));
System.out.println("The operation took " + duration + " milliseconds");

也许你以前还疑惑抽象�c�L��什么用,现在你应该彻底明白了�? 至于�q�样做的好处,很显然啊,扩展性强,以后Benchmark内容变化,我只要再做一个��承子�c�d��可以,不必修改其他应用代码.

powerwind 2006-12-11 19:49 发表评论

设计模式之Memento(备忘机制)

powerwind — Mon, 11 Dec 2006 11:49:00 GMT

设计模式之Memento(备忘机制)

板桥里�h http://www.jdon.com 2002/05/05

Memento备望录模式定�?
memento是一个保存另外一个对象内部状态拷贝的对象.�q�样以后��可以将该对象恢复到原先保存的状�?

Memento模式相对也比较好理解,我们看下列代�?

public class Originator {

　　 private int number;
　　private File file = null;
　　public Originator(){}
　　// 创徏一个Memento
　　public Memento getMemento(){
　　　　return new Memento(this);
　　}
　　// 恢复到原始�?br />　　public void setMemento(Memento m){
　　　　 number = m.number;
　　　　 file = m.file;
　　}
}

我们再看看Memento�c?

private class Memento implements java.io.Serializable{

　　private int number;

　　private File file = null;

　　public Memento( Originator o){

　　　　number = o.number;
　　　　file = o.file;

　　}

}

可见 Memento中保存了Originator中的number和file的�? 通过调用Originator中number和file值改变的�?通过调用setMemento()�Ҏ��可以恢复.

Memento模式的缺�Ҏ��耗费�?如果内部状态很�?再保存一�?无意要浪费大量内�?

Memento模式在Jsp+Javabean中的应用
在Jsp应用�?我们通常有很多表单要求用戯��?比如用户注册,需要输入姓名和Email�{? 如果一些表��用��h��有填写或者填写错�?我们希望在用��h��"提交Submit"�?通过Jsp�E�序��?发现��实有未填写��目,则在该项目下�U�字昄��警告或错�?同时,�q�要昄��用户刚才已经输入的表��?

如下图中 First Name是用户已�l�输�?Last Name没有输入,我们则提�C�红字警�?:

�q�种技术的实现,��是利用了Javabean的scope="request"或scope="session"�Ҏ�?也就是Memento模式.

具体�C�Z��和代码见 JavaWorld的英文原�?/font> , Javabean表单输入�Ҏ��参见我的另�?a target="_blank">一��文�?

powerwind 2006-12-11 19:49 发表评论

设计模式之Bridge

powerwind — Mon, 11 Dec 2006 11:48:00 GMT

设计模式之Bridge

板桥里�h http://www.jdon.com 2002/05/01

Bridge模式定义 :
��抽象和行�ؓ划分开�?各自独立,但能动态的�l�合�?/p>
��M��事物对象都有抽象和行��Z��分，例如人，人是一�U�抽象，人分男�h和女人等�Q��h有行为，行�ؓ也有各种具体表现�Q�所以，“�h”与“�h的行为”两个概念也反映了抽象和行�ؓ之分�?/p>
在面向对象设计的基本概念中，对象�q�个概念实际是由属性和行�ؓ两个部分�l�成的，属性我们可以认为是一�U�静止的�Q�是一�U�抽象，一般情况下�Q�行为是包含在一个对象中�Q�但是，在有的情况下�Q�我们需要将�q�些行�ؓ也进行归�c�，形成一个�ȝ��行�ؓ接口�Q�这��是桥模式的用处�?/p>
��Z��么��?
不希望抽象部分和行�ؓ有一�U�固定的�l�定关系�Q�而是应该可以动态联�pȝ��?/p>
如果一个抽象类或接口有多个具体实现(子类、concrete subclass),�q�些子类之间关系可能有以下两�U�情�?
1. �q�多个子�c�M��间概忉|��q�列�?如前面�D�?打桩,有两个concrete class:方�Ş桩和圆�Ş�?�q�两个�Ş状上的桩是�ƈ列的,没有概念上的重复�?br />
2.�q�多个子�c�M��中有内容概念上重�?那么需要我们把抽象共同部分和行为共同部分各自独立开�?原来是准备放在一个接口里,现在需要设计两个接口：抽象接口和行为接口，分别攄��抽象和行�?

例如,一杯咖啡�ؓ�?子类实现�c�Mؓ四个�Q�中杯加奶、大杯加奶�?中杯不加奶、大杯不加奶�?/p>
但是�Q�我们注意到�Q�上面四个子�c�M��有概念重叠，可从另外一个角度进行考虑�Q�这四个�c�d��际是两个角色的组合：抽象和行为，其中抽象为：中杯和大杯；行�ؓ为：加奶不加�Ӟ��如加��汁加苹果汁�Q?

实现四个子类在抽象和行�ؓ之间发生了固定的�l�定关系�Q�如果以后动态增加加葡萄汁的行�ؓ�Q�就必须再增加两个类�Q�中杯加葡萄汁和大杯加葡萄汁。显然�؜�?扩展性极差�?/p>
那我们从分离抽象和行为的角度�Q��用Bridge模式来实现�?/p>
如何实现?
以上面提到的咖啡 ��Z��. 我们原来打算只设计一个接�?抽象�c?,使用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 是加不加奶的行�ؓ接口,看其代码如下:

public abstract class CoffeeImp
{
　　public abstract void pourCoffeeImp();
}

现在我们有了两个抽象�c?下面我们分别对其�q�行�l�承,实现concrete class:

//中杯
public class MediumCoffee extends Coffee
{
　　public MediumCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复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();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复5�ơ是大杯
　　　　for (int i = 0; i < 5; i++)
　　　　{

　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

上面分别是中杯和大杯的具体实�?下面再对行�ؓCoffeeImp�q�行�l�承:

//加奶
public class MilkCoffeeImp extends CoffeeImp
{
　　MilkCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("加了��味的牛�?);
　　}
}

//不加�?br />public class FragrantCoffeeImp extends CoffeeImp
{
　　FragrantCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("什么也没加,清香");
　　}
}

Bridge模式的基本框架我们已�l�搭好了,别忘记定义中�q�有一�?动态结�?我们现在可以喝到臛_��四种咖啡:
1.中杯加奶
2.中杯不加�?br />3.大杯加奶
4.大杯不加�?/p>
看看是如何动态结合的,在��用之�?我们做个准备工作,设计一个单态类(Singleton)用来hold当前的CoffeeImp:

public class CoffeeImpSingleton
{
　　private static CoffeeImp coffeeImp;

　　public CoffeeImpSingleton(CoffeeImp coffeeImpIn)
　　 {this.coffeeImp = coffeeImpIn;}

　　public static CoffeeImp getTheCoffeeImp()
　　{
　　　　return coffeeImp;
　　}
}

看看中杯加奶和大杯加�?是怎么出来�?

//拿出牛奶
CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new MilkCoffeeImp());

//中杯加奶
MediumCoffee mediumCoffee = new MediumCoffee();
mediumCoffee.pourCoffee();

//大杯加奶
SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee();
superSizeCoffee.pourCoffee();

注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关�p? 正确创徏CoffeeImp是该模式的关�?

Bridge模式在EJB中的应用
EJB中有一个Data Access Object (DAO)模式,�q�是��商业逻辑和具体数据资源分开�?因�ؓ不同的数据库有不同的数据库操�?��操作不同数据库的行为独立抽象成一个行为接口DAO.如下:

1.Business Object (�c�M��Coffee)

实现一些抽象的商业操作:如寻找一个用户下所有的订单

涉及数据库操作都使用DAOImplementor.

2.Data Access Object (�c�M��CoffeeImp)

一些抽象的�Ҏ��据库资源操作

3.DAOImplementor 如OrderDAOCS, OrderDAOOracle, OrderDAOSybase(�c�M��MilkCoffeeImp FragrantCoffeeImp)

具体的数据库操作,�?INSERT INTO "�{�语�?OrderDAOOracle是Oracle OrderDAOSybase是Sybase数据�?

4.数据�?(Cloudscape, Oracle, or Sybase database via JDBC API)

powerwind 2006-12-11 19:48 发表评论

设计模式之Flyweight(享元) FlyWeight模式

powerwind — Mon, 11 Dec 2006 11:48:00 GMT

设计模式之Flyweight(享元) FlyWeight模式

板桥里�h http://www.jdon.com 2002/05/02

Flyweight模式定义:
避免大量拥有相同内容的小�cȝ��开销(如耗费内存),使大家共享一个类(元类).

��Z��么��?
面向对象语言的原则就是一切都是对�?但是如果真正使用��h��,有时对象数可能显得很庞大,比如,字处理��Y�?如果以每个文字都作�ؓ一个对�?几千个字,对象数就是几�?无疑耗费内存,那么我们�q�是�?求同存异",扑և��q�些对象��的共同�?设计一个元�c?��装可以被共享的�c?另外,�q�有一些特性是取决于应�?context),是不可共享的,�q�也Flyweight中两个重要概念内部状态intrinsic和外部状态extrinsic之分.

说白�?��是先捏一个的原始模型,然后随着不同场合和环�?再��生各��L��征的具体模型,很显�?在这里需要��生不同的新对�?所以Flyweight模式中常出现Factory模式.Flyweight的内部状态是用来�׃�n�?Flyweight factory负责�l�护一个Flyweight pool(模式�?来存攑ֆ�部状态的对象.

Flyweight模式是一个提高程序效率和性能的模�?会大大加快程序的�q�行速度.应用场合很多:比如你要从一个数据库中读取一�p�d��字符�?�q�些字符串中有许多是重复�?那么我们可以��这些字�W�串储存在Flyweight�?pool)�?

如何使用?

我们先从Flyweight抽象接口开�?

public interface Flyweight
{
　　public void operation( ExtrinsicState state );
}

//用于本模式的抽象数据�c�d��(自行设计)
public interface ExtrinsicState { }

下面是接口的具体实现(ConcreteFlyweight) ,�q��ؓ内部状态增加内存空�? ConcreteFlyweight必须是可�׃�n�?它保存的��M��状态都必须是内�?intrinsic),也就是说,ConcreteFlyweight必须和它的应用环境场合无�?

public class ConcreteFlyweight implements Flyweight {
　　private IntrinsicState state;
　　
　　public void operation( ExtrinsicState state )
　　{
　　　　　　//具体操作
　　}
}

当然,�q�不是所有的Flyweight具体实现子类都需要被�׃�n�?所以还有另外一�U�不�׃�n的ConcreteFlyweight:

public class UnsharedConcreteFlyweight implements Flyweight {

　　public void operation( ExtrinsicState state ) { }

}

Flyweight factory负责�l�护一个Flyweight�?存放内部状�?,当客��L��h��一个共享Flyweight�?�q�个factory首先搜烦池中是否已经有可适用�?如果�?factory只是��单返回送出�q�个对象,否则,创徏一个新的对�?加入到池�?再返回送出�q�个对象.�?/p>

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;
　　}
}

��x��,Flyweight模式的基本框架已�l�就�l?我们看看如何调用:

FlyweightFactory factory = new FlyweightFactory();
Flyweight fly1 = factory.getFlyweight( "Fred" );
Flyweight fly2 = factory.getFlyweight( "Wilma" );
......

从调用上�?好象是个�U��a的Factory使用,但奥妙就在于Factory的内部设计上.

Flyweight模式在XML�{�数据源中应�?/b>
我们上面已经提到,当大量从数据源中��d��字符�?其中肯定有重复的,那么我们使用Flyweight模式可以提高效率,以唱片CD��Z��,在一个XML文�g�?存放了多个CD的资�?

每个CD有三个字�D?
1.出片日期(year)
2.歌唱者姓名等信息(artist)
3.��q��曲目 (title)

其中,歌唱者姓名有可能重复,也就是说,可能有同一个演��p��的多个不同时期不同曲目的CD.我们��?歌唱者姓�?作�ؓ可共享的ConcreteFlyweight.其他两个字段作�ؓUnsharedConcreteFlyweight.

首先看看数据源XML文�g的内�?

Another Green World
1978
Eno, Brian

Greatest Hits
1950
Holiday, Billie

Taking Tiger Mountain (by strategy)
1977
Eno, Brian

.......

虽然上面举例CD只有3�?CD可看成是大量重复的小�c?因�ؓ其中成分只有三个字段,而且有重复的(歌唱者姓�?.

CD��是�c�M��上面接口 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 {

　　//内部状�?br />　　private String name;

　　// note that Artist is immutable.
　　String getName(){return name;}

　　Artist(String n){
　　　　name = n;
　　}

}

再看看Flyweight factory,专门用来刉��上面的可共享的ConcreteFlyweight:Artist

public class ArtistFactory {

　　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模式��节省更多空�?�׃�n的flyweight��多,�I�间节省也就��大.

powerwind 2006-12-11 19:48 发表评论

设计模式之Composite(�l�合)

powerwind — Mon, 11 Dec 2006 11:47:00 GMT

设计模式之Composite(�l�合)

板桥里�h http://www.jdon.com 2002/04/27�Q��{载请保留�Q?/p>
Composite模式定义:
��对象以树�Ş�l�构�l�织��h��,以达成“部分－整体�?的层�ơ结构，使得客户端对单个对象和组合对象的使用��h��一致�?

Composite比较�Ҏ��理解�Q�想到Composite��应该想到树形结构图。组合体内这些对象都有共同接�?当组合体一个对象的�Ҏ��被调用执行时�Q�Composite��遍�?Iterator)整个树�Ş�l�构,��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行。可以用牵一动百来�Ş宏V�?/p>
所以Composite模式使用到Iterator模式�Q�和Chain of Responsibility模式�c�M��?/p>
Composite好处:
1.使客��L��调用��单，客户端可以一致的使用�l�合�l�构或其中单个对象，用户��׃��必关�p�自己处理的是单个对象还是整个组合结构，�q�就��化了客户端代码�?br />2.更容易在�l�合体内加入对象部�g. 客户端不必因为加入了新的对象部�g而更改代码�?/p>
如何使用Composite?
首先定义一个接口或抽象�c�，�q�是设计模式通用方式了，其他设计模式�Ҏ��口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和��理Composite�l�合体的对象们（或称部�gComponent�Q?

下面的代码是以抽象类定义�Q�一般尽量用接口interface,

public abstract class Equipment
{
　　private String name;
　　//实�h
　　public abstract double netPrice();
　　//折扣��h��
　　public abstract double discountPrice();
　　//增加部�g�Ҏ��　　
　　public boolean add(Equipment equipment) { return false; }
　　//删除部�g�Ҏ��
　　public boolean remove(Equipment equipment) { return false; }
　　//注意�q�里�Q�这里就提供一�U�用于访问组合体�cȝ��部�g�Ҏ��?br />　　public Iterator iter() { return null; }
　　
　　public Equipment(final String name) { this.name=name; }
}

抽象�c�Equipment��是Component定义�Q�代表着�l�合体类的对象们,Equipment中定义几个共同的�Ҏ��?/p>

public class Disk extends Equipment
{
　　public Disk(String name) { super(name); }
　　//定义Disk实�h�?
　　public double netPrice() { return 1.; }
　　//定义了disk折扣��h��?.5 �Ҏ��?br />　　public double discountPrice() { return .5; }
}

Disk是组合体内的一个对象，或称一个部�Ӟ��q�个部�g是个单独元素( Primitive)�?br />�q�有一�U�可能是�Q�一个部件也是一个组合体�Q�就是说�q�个部�g下面�q�有'儿子'�Q�这是树形结构中通常的情况，应该比较�Ҏ��理解。现在我们先要定义这个组合体�Q?/p>

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())
　　　　　　discountPrice+=((Equipment)iter.next()).discountPrice();
　　　　return discountPrice;
　　}
　　

　　//注意�q�里�Q�这里就提供用于讉K��自己�l�合体内的部件方法�?br />　　//上面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�l�承了Equipment,同时��己里面的对象们提供了外部讉K��的方�?重蝲了Iterator,Iterator是Java的Collection的一个接口，是Iterator模式的实�?

我们再看看CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet�Q�箱子里面可以放很多东西�Q�如底板�Q�电源盒�Q�硬盘盒�{�；盘盒里面可以放一些小讑֤��Q�如��盘软驱�{�。无疑这两个都是属于�l�合体性质的�?/p>

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
{
　　 public Cabinet(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

��x��我们完成了整个Composite模式的架构�?/p>
我们可以看看客户端调用Composote代码:

Cabinet cabinet=new Cabinet("Tower");

Chassis chassis=new Chassis("PC Chassis");
//��PC Chassis装到Tower�?(��盘盒装到箱子里)
cabinet.add(chassis);
//��一�?0GB的硬盘装�?PC Chassis (��硬盘装到盘盒里)
chassis.add(new Disk("10 GB"));

//调用 netPrice()�Ҏ��;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());

上面调用的方法netPrice()或discountPrice()�Q�实际上Composite使用Iterator遍历了整个树形结�?��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行.

Composite是个很��y妙体现智慧的模式�Q�在实际应用中，如果��到树�Ş�l�构�Q�我们就可以��试是否可以使用�q�个模式�?/p>
以论坛�ؓ例，一个版(forum)中有很多帖子(message),�q�些帖子有原始脓�Q�有对原始脓的回应脓�Q�是个典型的树�Ş�l�构�Q�那么当然可以��用Composite模式�Q�那么我们进入Jive中看看，是如何实现的.

Jive解剖
在Jive�?ForumThread是ForumMessages的容器container(�l�合�?.也就是说�Q�ForumThread�c�M��我们上例中的 CompositeEquipment.它和messages的关�p�d��图：
[thread]
　　 |- [message]
　　 |- [message]
　　　　 |- [message]
　　　　 |- [message]
　　　　　　 |- [message]

我们在ForumThread看到如下代码�Q?br />

public interface ForumThread {
　　 ....
　　 public void addMessage(ForumMessage parentMessage, ForumMessage newMessage)
　　　　　　 throws UnauthorizedException;
　　 public void deleteMessage(ForumMessage message)
　　　　　　 throws UnauthorizedException;
　　
　　 public Iterator messages();
　　　　 ....
}

�c�M��CompositeEquipment, 提供用于讉K��自己�l�合体内的部件方�? 增加删除遍历.

�l�合我的其他模式中对Jive的分析，我们已经基本大体理解了Jive论坛体系的框�Ӟ��如果你之前不理解设计模式�Q�而直接去看Jive源代码，你肯定无法看懂�?/p>
参考文章：

Composite模式和树形结构的讨论

powerwind 2006-12-11 19:47 发表评论

设计模式之Decorator(�Ҏ��?

powerwind — Mon, 11 Dec 2006 11:47:00 GMT

设计模式之Decorator(�Ҏ��?

板桥里�h http://www.jdon.com 2002/04/28

装饰模式:Decorator常被��译�?装饰",我觉得翻译成"�Ҏ��?更�Ş象点,�Ҏ��?decorator)是用来刷�Ҏ��?那么被刷�Ҏ��的对象我们称decoratee.�q�两�U�实体在Decorator模式中是必须�?

Decorator定义:
动态给一个对象添加一些额外的职责,��p��在墙上刷�Ҏ��.使用Decorator模式相比用生成子�c�L��式达到功能的扩充昑־�更�ؓ灉|��.

��Z��么��用Decorator?
我们通常可以使用�l�承来实现功能的拓展,如果�q�些需要拓展的功能的种�c�d��J�多,那么势必生成很多子类,增加�pȝ��的复杂�?同时,使用�l�承实现功能拓展,我们必须可预见这些拓展功�?�q�些功能是编译时��q��定了,是静态的.

使用Decorator的理由是:�q�些功能需要由用户动态决定加入的方式和时�?Decorator提供�?��x��即用"的方�?在运行期间决定何时增加何�U�功�?

如何使用?
举Adapter中的打桩�C�Z��,在Adapter中有两种�c?方�Ş�?圆�Ş�?Adapter模式展示如何�l�合使用�q�两个类,在Decorator模式�?我们是要在打桩时增加一些额外功�?比如,挖坑在桩上钉木板�{?不关心如何��用两个不相关的类.

我们先徏立一个接�?

public interface Work
{
　　public void insert();

}

接口Work有一个具体实�?插入方�Ş桩或圆�Ş�?�q�两个区别对Decorator是无所�?我们以插入方形桩��Z��:

public class SquarePeg implements Work{
　　public void insert(){
　　　　System.out.println("方�Ş桩插�?);
　　}
}

现在有一个应�?需要在桩打入前,挖坑,在打入后,在桩上钉木板,�q�些额外的功能是动�?可能随意增加调整修改,比如,可能又需要在打桩之后钉架�?只是比喻).

那么我们使用Decorator模式,�q�里方�Ş桩SquarePeg是decoratee(被刷�Ҏ��?,我们需要在decoratee上刷�?�Ҏ��",�q�些�Ҏ��是那些额外的功�?

public class Decorator implements Work{

　　private Work work;
　　//额外增加的功能被打包在这个List�?br />　　private ArrayList others = new ArrayList();

　　//在构造器中��用组合new方式,引入Work对象;
　　public Decorator(Work work)
　　{
　　　　this.work=work;
　　
　　　　others.add("挖坑");

　　　　others.add("钉木�?);
　　}

　　public void insert(){
　　　　newMethod();
　　}

　　
　　//在新�Ҏ��?我们在insert之前增加其他�Ҏ��,�q�里�ơ序先后是用��L��z�L��定的　　
　　public void newMethod()
　　{
　　　　otherMethod();
　　　　work.insert();

　　}
　　public void otherMethod()
　　{
　　　　ListIterator listIterator = others.listIterator();
　　　　while (listIterator.hasNext())
　　　　{
　　　　　　System.out.println(((String)(listIterator.next())) + " 正在�q�行");
　　　　}

　　}
}

在上例中,我们把挖坑和钉木杉K��排在了打桩insert前面,�q�里只是举例说明额外功能�ơ序可以��L��安排.

好了,Decorator模式出来�?我们看如何调�?

Work squarePeg = new SquarePeg();
Work decorator = new Decorator(squarePeg);
decorator.insert();

Decorator模式��x��完成.

如果你细�?会发�?上面调用�c�M��我们��d��文�g时的调用:

FileReader fr = new FileReader(filename);
BufferedReader br = new BufferedReader(fr);

实际上Java 的I/O API��是使用Decorator实现�?/font>,I/O变种很多,如果都采取��承方�?��会产生很多子类,昄��相当�J�琐.

Jive中的Decorator实现
在论坛系�l�中,有些特别的字是不能出现在论坛中如"打倒XXX",我们需要过滤这�?反动"的字�?不让他们出现或者高亮度昄��.

在IBM Java专栏中专�?a target="_blank">谈Jive的文�?/font>�?有谈及Jive中ForumMessageFilter.java使用了Decorator模式,其实,该程序�ƈ没有真正使用Decorator,而是提示�?针对特别论坛可以设计额外增加的过滤功�?那么��可以重�l�ForumMessageFilter作�ؓDecorator模式�?

所�?我们在分辨是否真正是Decorator模式,以及会真正��用Decorator模式,一定要把握好Decorator模式的定�?以及其中参与的角�?Decoratee 和Decorator).

powerwind 2006-12-11 19:47 发表评论

设计模式之Adapter(适配�?

powerwind — Mon, 11 Dec 2006 11:46:00 GMT

设计模式之Adapter(适配�?

板桥里�h http://www.jdon.com 2002/04/21

适配器模式定�?
��两个不兼容的类�U�合在一起��用，属于�l�构型模�?需要有Adaptee(被适配�?和Adaptor(适配�?两个�w�䆾.

��Z��使用?
我们�l�常��到要将两个没有关系的类�l�合在一起��?�W�一解决�Ҏ��是：修改各自�cȝ��接口�Q�但是如果我们没有源代码�Q�或者，我们不愿意�ؓ了一个应用而修改各自的接口�?怎么�?

使用Adapter�Q�在�q�两�U�接口之间创��Z��个�؜合接�?淯��?.

如何使用?
实现Adapter方式,其实"think in Java"�?�c�d��?一节中已经提到,有两�U�方式：�l�合(composition)和��?inheritance).

假设我们要打桩，有两�U�类�Q�方形桩圆�Ş�?
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);
}
}

现在有一个应�?需要既打方形桩,又打圆�Ş�?那么我们需要将�q�两个没有关�pȝ��cȝ��合应�?假设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);}

}

在上面代码中,RoundPeg属于Adaptee,是被适配�?PegAdapter是Adapter,��Adaptee(被适配者RoundPeg)和Target(目标SquarePeg)�q�行适配.实际上这是将�l�合�Ҏ��(composition)和��?inheritance)�Ҏ��l�合�q�用.

PegAdapter首先�l�承SquarePeg�Q�然后��用new的组合生成对象方式，生成RoundPeg的对象roundPeg�Q�再重蝲父类insert()�Ҏ��。从�q�里,你也了解使用new生成对象和��用extends�l�承生成对象的不�?前者无需对原来的�c�M��?甚至无需要知道其内部�l�构和源代码.

如果你有些Java使用的经验，已经发现�Q�这�U�模式经�怋�用�?/p>
�q�一步��?/b>
上面的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, 除了实现接口�q�一区别�Q�和上面的没什么区别�?br />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;
　　private SquarePeg squarePeg;

　　// 构造方�?br />　　public PegAdapter(RoundPeg peg){this.roundPeg=peg;}
　　// 构造方�?br />　　public PegAdapter(SquarePeg peg)(this.squarePeg=peg;)

　　public void insert(String str){ roundPeg.insertIntoHole(str);}

}

�q�有一�U�叫Pluggable Adapters,可以动态的获取几个adapters中一个。��用Reflection技术，可以动态的发现�c�M��的Public�Ҏ��?br />

powerwind 2006-12-11 19:46 发表评论

设计模式之Proxy(代理)

powerwind — Mon, 11 Dec 2006 11:45:00 GMT

设计模式之Proxy(代理)

板桥里�hbanq http://www.jdon.com 2002/04/21/

理解�q��用设计模�?能够培养我们良好的面向对象编�E�习�?同时在实际应用中,可以如鱼得水,享受游刃有余的乐��?

代理模式是比较有用途的一�U�模�?而且变种较多,应用场合覆盖从小�l�构到整个系�l�的大结�?Proxy是代理的意�?我们也许有代理服务器�{�概�?代理概念可以解释�?在出发点到目的地之间有一道中间层,意�ؓ代理.

设计模式中定�?/b>: 为其他对象提供一�U�代理以控制对这个对象的讉K��.

��Z��么要使用Proxy?
1.授权机制不同�U�别的用户对同一对象拥有不同的访问权�?如Jive论坛�pȝ��?��׃��用Proxy�q�行授权机制控制,讉K��论坛有两�U��h:注册用户和游�?未注册用�?,Jive中就通过�c�M��ForumProxy�q�样的代理来控制�q�两�U�用户对论坛的访问权�?

2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
举例两个具体情况:
(1)如果那个对象是一个是很大的图�?需要花费很长时间才能显�C�出�?那么当这个图片包含在文档中时,使用�~�辑器或��览器打开�q�个文档,打开文档必须很迅�?不能�{�待大图片处理完�?�q�时需要做个图片Proxy来代替真正的囄��.

(2)如果那个对象在Internet的某个远端服务器�?直接操作�q�个对象因�ؓ�|�络速度原因可能比较�?那我们可以先用Proxy来代曉K��个对�?

��M��原则�?对于开销很大的对�?只有在��用它时才创徏,�q�个原则可以为我们节省很多宝�늚�Java内存. 所�?有些��为Java耗费资源内存,我以��和程序编制思�\也有一定的关系.

如何使用Proxy?
�?a >Jive论坛�pȝ��Z��,讉K��论坛�pȝ��的用��h��多种�c�d��:注册普通用�?论坛��理�?�pȝ��理�?游客,注册普通用��h��能发�a�;论坛��理者可以管理他被授权的论坛;�pȝ��理者可以管理所有事务等,�q�些权限划分和管理是使用Proxy完成�?

Forum是Jive的核心接�?在Forum中陈列了有关论坛操作的主要行�?如论坛名�U?论坛描述的获取和修改,帖子发表删除�~�辑�{?

在ForumPermissions中定义了各种�U�别权限的用�?

public class ForumPermissions implements Cacheable {
/**
* 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;
.....
public boolean isSystemOrForumAdmin() {
　　return (values[FORUM_ADMIN] || values[SYSTEM_ADMIN]);
}
.....
}

因此,Forum中各�U�操作权限是和ForumPermissions定义的用��L�别有关系�?作�ؓ接口Forum的实�?ForumProxy正是��这�U�对应关�p�联�p��v�?比如,修改Forum的名�U?只有论坛��理者或�pȝ��理者可以修�?代码如下:

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
{
　　//只有是系�l�或论坛��理者才可以修改名称
　　if (permissions.isSystemOrForumAdmin()) {
　　　　forum.setName(name);
　　}
　　else {
　　　　throw new UnauthorizedException();
　　}
}

...

}

而DbForum才是接口Forum的真正实�?以修改论坛名�U�Cؓ�?

public class DbForum implements Forum, Cacheable {
...

public void setName(String name) throws ForumAlreadyExistsException {

　　....

　　this.name = name;
　　//�q�里真正��新名称保存到数据库�?
　　saveToDb();

　　....
}

...

}

凡是涉及到对论坛名称修改�q�一事�g,其他�E�序都首先得和ForumProxy打交�?由ForumProxy军_��是否有权限做某一样事�?ForumProxy是个名副其实�?�|�关","安全代理�pȝ��".

在��^时应用中,无可避免总要涉及到系�l�的授权或安全体�p?不管你有无意识的使用Proxy,实际你已�l�在使用Proxy�?

我们�l�箋�l�合Jive谈入�׃��?下面要涉及到工厂模式�?如果你不了解工厂模式,��L��我的另外一��文�?设计模式之Factory

我们已经知道,使用Forum需要通过ForumProxy,Jive中创��Z��个Forum是��用Factory模式,有一个�ȝ��抽象�c�ForumFactory,在这个抽象类�?调用ForumFactory是通过getInstance()�Ҏ��实现,�q�里使用了Singleton(也是设计模式之一,�׃��介绍文章很多,我就不写�?看这�?/a>),getInstance()�q�回的是ForumFactoryProxy.

��Z��么不�q�回ForumFactory,而返回ForumFactory的实现ForumFactoryProxy?
原因是明昄��,需要通过代理��定是否有权限创建forum.

在ForumFactoryProxy中我们看��C��码如�?

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
　　{
　　　　//只有�pȝ��理者才可以创徏forum
　　　　if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
　　　　　　Forum newForum = factory.createForum(name, description);
　　　　　　return new ForumProxy(newForum, authorization, permissions);
　　　　}
　　　　else {
　　　　　　throw new UnauthorizedException();
　　}
}

�Ҏ��createForum�q�回的也是ForumProxy, Proxy��p��一道墙,其他�E�序只能和Proxy交互操作.

注意到这里有两个Proxy:ForumProxy和ForumFactoryProxy. 代表两个不同的职�?使用Forum和创建Forum;
至于��Z��么将使用对象和创建对象分开,�q�也是�ؓ什么��用Factory模式的原因所�?是�ؓ�?��装" "分派";换句话说,��可能功能单一�?方便�l�护修改.

Jive论坛�pȝ��中其他如帖子的创建和使用,都是按照Forum�q�个思�\而来�?

以上我们讨论了如何��用Proxy�q�行授权机制的访�?Proxy�q�可以对用户隐藏另外一�U�称为copy-on-write的优化方�?拯��一个庞大而复杂的对象是一个开销很大的操�?如果拯��q�程�?没有对原来的对象有所修改,那么�q�样的拷贝开销��没有必�?用代理�g�q�这一拯��q�程.

比如:我们有一个很大的Collection,具体如hashtable,有很多客��L��会�ƈ发同时访问它.其中一个特别的客户端要�q�行�q�箋的数据获�?此时要求其他客户端不能再向hashtable中增加或删除东东.

最直接的解��x��案是:使用collection的lock,让这特别的客��L��获得�q�个lock,�q�行�q�箋的数据获�?然后再释放lock.
public void foFetches(Hashtable ht){
　　synchronized(ht){
　　　　//具体的连�l�数据获取动�?.
　　}

}

但是�q�一办法可能锁住Collection会很长时�?�q�段旉��,其他客户端就不能讉K��该Collection�?

�W�二个解��x��案是clone�q�个Collection,然后让连�l�的数据获取针对clone出来的那个Collection操作.�q�个�Ҏ��前提�?�q�个Collection是可clone�?而且必须有提供深度clone的方�?Hashtable��提供了对自��q��clone�Ҏ��,但不是Key和value对象的clone,关于Clone含义可以参�?a target="_blank">专门文章.
public void foFetches(Hashtable ht){

　　Hashttable newht=(Hashtable)ht.clone();

}

问题又来�?�׃��是针对clone出来的对象操�?如果原来的母体被其他客户端操作修改了, 那么对clone出来的对象操作就没有意义�?

最后解��x��?我们可以�{�其他客��L��修改完成后再�q�行clone,也就是说,�q�个特别的客��L��先通过调用一个叫clone的方法来�q�行一�p�d��数据获取操作.但实际上没有真正的进行对象拷�?直至有其他客��L��修改了这个对象Collection.

使用Proxy实现�q�个�Ҏ��.�q�就是copy-on-write操作.

Proxy应用范围很广,现在��行的分布计��方式RMI和Corba�{�都是Proxy模式的应�?

更多Proxy应用,�?a target="_blank">http://www.research.umbc.edu/~tarr/cs491/lectures/Proxy.pdf

Sun公司�?Explore the Dynamic Proxy API Dynamic Proxy Classes

powerwind 2006-12-11 19:45 发表评论

设计模式之Facade(外观 �ȝ��　Manager)

powerwind — Mon, 11 Dec 2006 11:44:00 GMT

设计模式之Facade(外观 �ȝ��　Manager)

板桥里�h http://www.jdon.com 2002/4/6/�Q��{载请保留�Q?/p>
Facade模式的定�?/b> : 为子�pȝ��中的一�l�接口提供一个一致的界面.

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中最通常的对数据库操作办�?

在应用中,�l�常需要对数据库操�?每次都写上述一�D�代码肯定比较麻�?需要将其中不变的部分提炼出�?做成一个接�?�q�就引入了facade外观对象.如果以后我们更换Class.forName中的也非常方�?比如从Mysql数据库换到Oracle数据�?只要更换facade接口中的driver��可�?

我们做成了一�?a target="_blank">Facade接口,使用该接�?上例中的�E�序��可以更改如�?

public class DBCompare {

　 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;
　　}
}

可见非常��?所有程序对数据库访问都是��用改接口,降低�pȝ��的复杂�?增加了灵�z�L�?

如果我们要��用连接池,也只要针对facade接口修改��可�?

�׃��囑֏�以看�? facade实际上是个理��系�l�间关系,降低�pȝ��间耦合度的一个常用的办法,也许你已�l�不知不觉在使用,��管不知道它��是facade.

powerwind 2006-12-11 19:44 发表评论

设计模式之Singleton(单�?

powerwind — Mon, 11 Dec 2006 11:43:00 GMT

设计模式之Singleton(单�?

板桥里�h http://www.jdon.com 2002/05/07

单态定�?/strong>:
Singleton模式主要作用是保证在Java应用�E�序中，一个类Class只有一个实例存在�?

在很多操作中�Q�比如徏立目�?数据库连接都需要这��L��单线�E�操作�?/p>
�q�有, singleton能够被状态化; �q�样�Q�多个单态类在一起就可以作�ؓ一个状态仓库一样向外提供服务，比如�Q�你要论坛中的帖子计数器�Q�每�ơ浏览一�ơ需要计敎ͼ�单态类能否保持住这个计敎ͼ��q�且能synchronize的安全自动加1�Q�如果你要把�q�个数字�怹�保存到数据库�Q�你可以在不修改单态接口的情况下方便的做到�?/p>
另外斚w��Q�Singleton也能够被无状态化。提供工��h��质的功能，

Singleton模式��׃ؓ我们提供了这样实现的可能。��用Singleton的好处还在于可以节省内存�Q�因为它限制了实例的个数�Q�有利于Java垃圾回收�Q�garbage collection�Q��?br />
我们常常看到工厂模式中类装入�?class loader)中也用Singleton模式实现�?因�ؓ被装入的�c�d��际也属于资源�?br />

如何使用?
一般Singleton模式通常有几�U��Ş�?

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自�׃��个实例，是不是很奇怪？
　　//注意�q�是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//�q�里提供了一个供外部讉K��本class的静态方法，可以直接讉K��　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

�W�二�U��Ş�?

public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　//�q�个�Ҏ��比上面有所改进�Q�不用每�ơ都�q�行生成对象�Q�只是第一�ơ　　　　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance�Q�new Singleton();
　　return instance; 　　}
}

使用Singleton.getInstance()可以讉K��单态类�?/p>
上面�W�二中�Ş式是lazy initialization�Q�也��是说第一�ơ调用时初始Singleton�Q�以后就不用再生成了�?/p>
注意到lazy initialization形式中的synchronized�Q�这个synchronized很重要，如果没有synchronized�Q�那么��用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴��者进一步研�I��?/p>
一般认为第一�U��Ş式要更加安全些�?br />

使用Singleton注意事项�Q?br />有时在某些情况下�Q��用Singleton�q�不能达到Singleton的目的，如有多个Singleton对象同时被不同的�c�装入器装蝲�Q�在EJB�q�样的分布式�pȝ��中��用也要注意这�U�情况，因�ؓEJB是跨服务器，跨JVM的�?/p>
我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator��Z��E�微分析一下：

在Pet Store中ServiceLocator有两�U�，一个是EJB目录下；一个是WEB目录下，我们��查这两个ServiceLocator会发现内容差不多�Q�都是提供EJB的查询定位服务，可是��Z��么要分开呢？仔细研究对这两种ServiceLocator才发现区别：在WEB中的ServiceLocator的采取Singleton模式�Q�ServiceLocator属于资源定位�Q�理所当然应该使用Singleton模式。但是在EJB中，Singleton模式已经失去作用�Q�所以ServiceLocator才分成两�U�，一�U�面向WEB服务的，一�U�是面向EJB服务的�?/p>
Singleton模式看�v来简单，使用�Ҏ��也很方便�Q�但是真正用好，是非�怸��Ҏ��Q�需要对Java的类 �U�程内存�{�概忉|��相当的了解�?/p>
��M��Q�如果你的应用基于容器，那么Singleton模式��用或者不用，可以使用相关替代技术�?/p>

�q�一步深入可参考：

Double-checked locking and the Singleton pattern

When is a singleton not a singleton?

powerwind 2006-12-11 19:43 发表评论

国内偷自视频区视频综合,亚洲一区二区三区色,久久99国产精品久久99果冻传媒

设计模式之Interpreter(解释�?

设计模式之Interpreter(解释�?

设计模式之Visitor

设计模式之Visitor

设计模式之Strategy(�{�略)

设计模式之Strategy(�{�略)

设计模式之Mediator(中介�?

设计模式之Mediator(中介�?

设计模式之Chain of Responsibility(职责�?

设计模式之Chain of Responsibility(职责�?

设计模式之Command

设计模式之Command

设计模式之State

设计模式之State

设计模式之Observer

设计模式之Observer

设计模式之Template

设计模式之Template

设计模式之Memento(备忘机制)

设计模式之Memento(备忘机制)

设计模式之Bridge

设计模式之Bridge

设计模式之Flyweight(享元) FlyWeight模式

设计模式之Flyweight(享元) FlyWeight模式

设计模式之Composite(�l�合)

设计模式之Composite(�l�合)

设计模式之Decorator(�Ҏ���?

设计模式之Decorator(�Ҏ���?

设计模式之Adapter(适配�?

设计模式之Adapter(适配�?

设计模式之Proxy(代理)

设计模式之Proxy(代理)

设计模式之Facade(外观 �ȝ�� Manager)

设计模式之Facade(外观 �ȝ�� Manager)

设计模式之Singleton(单�?

设计模式之Singleton(单�?

设计模式之Decorator(�Ҏ��?

设计模式之Decorator(�Ҏ��?

设计模式之Facade(外观 �ȝ��　Manager)

设计模式之Facade(外观 �ȝ��　Manager)