国产亚洲精品线观看动态图,亚洲午夜久久久久久尤物,亚洲天堂一区二区

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

哼哼 — Tue, 20 Mar 2007 03:26:00 GMT

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中看看，是如何实现的.

我们在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>

哼哼 2007-03-20 11:26 发表评论

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

哼哼 — Fri, 16 Mar 2007 09:57:00 GMT

装饰模式: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实现�?/a>,I/O变种很多,如果都采取��承方�?��会产生很多子类,昄��相当�J�琐.

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

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

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

哼哼 2007-03-16 17:57 发表评论

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

哼哼 — Fri, 16 Mar 2007 09:42:00 GMT

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.

哼哼 2007-03-16 17:42 发表评论

设计模式之Adapter(适配�?

哼哼 — Fri, 16 Mar 2007 08:36:00 GMT

适配器模式定�?
��两个不兼容的类�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�Ҏ��?/p>

哼哼 2007-03-16 16:36 发表评论

设计模式之Proxy(代理)

哼哼 — Fri, 16 Mar 2007 07:48:00 GMT

理解�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

哼哼 2007-03-16 15:48 发表评论

设计模式之Factory

哼哼 — Fri, 16 Mar 2007 07:28:00 GMT

工厂模式定义:提供创徏对象的接�?

��Z��使用?
工厂模式是我们最常用的模式了,著名的Jive论坛 ,��大量��用了工厂模式�Q�工厂模式在Java�E�序�pȝ��可以说是随处可见�?/span>

��Z��么工厂模式是如此常用�Q�因为工厂模式就相当于创建实例对象的new�Q�我们经常要�Ҏ��c�Class生成实例对象�Q�如A a=new A() 工厂模式也是用来创徏实例对象的，所以以后new时就要多个心��|��是否可以考虑实用工厂模式�Q�虽然这样做�Q�可能多做一些工作，但会�l�你�pȝ��带来更大的可扩展性和��量��的修改量�?/span>

我们以类Sample��Z��Q?如果我们要创建Sample的实例对�?

Sample sample=new Sample();

可是�Q�实际情冉|��Q�通常我们都要在创�?span lang="EN-US">sample实例时做点初始化的工�?比如赋�?查询数据库等�?/span>

首先�Q�我们想到的是，可以使用Sample的构造函敎ͼ��q�样生成实例��写�?

Sample sample=new Sample(参数);

但是�Q�如果创�?span lang="EN-US">sample实例时所做的初始化工作不是象赋��D��L��单的事，可能是很长一�D�代码，如果也写入构造函��C��Q�那你的代码很难看了�Q�就需要Refactor重整�Q��?/span>

��Z��么说代码很难看，初学者可能没有这�U�感觉，我们分析如下�Q�初始化工作如果是很长一�D�代码，说明要做的工作很多，��很多工作装入一个方法中�Q�相当于��很多鸡蛋放在一个篮子里�Q�是很危险的�Q�这也是有背�?span lang="EN-US">Java面向对象的原则，面向对象的封�?Encapsulation)和分�z?Delegation)告诉我们�Q�尽量将长的代码分派“切剜y��成每段�Q�将每段再“封装”�v�?减少�D�和�D�之间偶合联�p�L�?�Q�这��P��׃��风险分散，以后如果需要修改，只要更改每段�Q�不会再发生牵一动百的事情�?/span>

在本例中�Q�首先，我们需要将创徏实例的工�?/font>�?font color="#ff1493">使用实例的工�?/font>分开, 也就是说�Q�让创徏实例所需要的大量初始化工作从Sample的构造函��C��分离出去�?/span>

�q�时我们��需�?span lang="EN-US">Factory工厂模式来生成对象了�Q�不能再用上面简单new Sample(参数)�?/span>�q�有,如果Sample有个�l�承如MySample, 按照面向接口�~�程,我们需要将Sample抽象成一个接�?现在Sample是接�?有两个子�c�MySample 和HisSample .我们要实例化他们�?如下:

Sample mysample=new MySample();
Sample hissample=new HisSample();

随着��目的深�?span lang="EN-US">,Sample可能�q�会"生出很多儿子出来", 那么我们要对�q�些儿子一个个实例�?更糟�p�的�?可能�q�要对以前的代码�q�行修改:加入后来生出儿子的实�?�q�在传统�E�序中是无法避免�?

但如果你一开始就有意识��用了工厂模式,�q�些�ȝ��没有了.

工厂�Ҏ��
你会建立一个专门生�?span lang="EN-US">Sample实例的工�?

public class Factory{

　　public static Sample creator(int which){

　　//getClass 产生Sample 一般可使用动态类装蝲装入�c�R�?br />　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

那么在你的程序中,如果要实例化Sample�?��׃��?/span>

Sample sampleA=Factory.creator(1);

�q�样,在整个就不涉及到Sample的具体子�c?辑ֈ��装效果,也就减少错误修改的机�?�q�个原理可以用很通俗的话来比�?��是具体事情做得��多,��容易范错误.�q�每个做�q�具体工作的人都深有体会,相反,官做得越�?说出的话��抽象越�W�统,范错误可能性就��少.好象我们从编�E�序中也能悟��Z�h生道�?呵呵.

使用工厂�Ҏ�� 要注意几个角�Ԍ��首先你要定义产品接口�Q�如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory�c�，用来生成产品Sample�Q�如下图�Q�最双��是生产的对象Sample�Q?/p>

�q�一步稍微复杂一点，��是在工厂类上进行拓展，工厂�c�M��有��承它的实现类concreteFactory�?b>�?/i>

抽象工厂
工厂模式中有: 工厂�Ҏ��(Factory Method) 抽象工厂(Abstract Factory).

�q�两个模式区别在于需要创建对象的复杂�E�度上。如果我们创建对象的�Ҏ��变得复杂�?如上面工厂方法中是创��Z��个对象Sample,如果我们�q�有新的产品接口Sample2.

�q�里假设�Q�Sample有两个concrete�c�SampleA和SamleB�Q�而Sample2也有两个concrete�c�Sample2A和SampleB2

那么�Q�我们就��上例中Factory变成抽象�c?��共同部分封装在抽象�c�M��,不同部分使用子类实现�Q�下面就是将上例中的Factory拓展成抽象工�?

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}

从上面看��C��个工厂各自生产出一套Sample和Sample2,也许你会疑问�Q��ؓ什么我不可以��用两个工厂方法来分别生��Sample和Sample2?

抽象工厂�q�有另外一个关键要点，是因�?SimpleFactory内，生��Sample和生产Sample2的方法之间有一定联�p�，所以才要将�q�两个方法捆�l�在一个类中，�q�个工厂�c�L��其本�w�特征，也许刉��过�E�是�l�一的，比如�Q�制造工艺比较简单，所以名�U�叫SimpleFactory�?/span>

在实际应用中�Q�工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，

举例

我们�?span lang="EN-US">Jive的ForumFactory��Z��Q�这个例子在前面的Singleton模式中我们讨��Q�现在再讨论其工厂模�?

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 单态模�?br />　　　　if (factory == null) {
　　　　　　synchronized(initLock) {
　　　　　　　　if (factory == null) {
　　　　　　　　　　　　......

　　　　　　　　　　try {
　　　　　　　　　　　　　　//动态�{载类
　　　　　　　　　　　　　　Class c = Class.forName(className);
　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();
　　　　　　　　　　}
　　　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　　　return null;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//Now, �q�回 proxy.用来限制授权对forum的访�?br />　　　　return new ForumFactoryProxy(authorization, factory,
　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));
　　}

　　//真正创徏forum的方法由�l�承forumfactory的子�c�d��完成.
　　public abstract Forum createForum(String name, String description)
　　throws UnauthorizedException, ForumAlreadyExistsException;

　　....

}

因�ؓ现在�?span lang="EN-US">Jive是通过数据库系�l�存放论坛帖子等内容数据,如果希望更改为通过文�g�pȝ��实现,�q�个工厂�Ҏ��ForumFactory��提供了提供动态接�?

private static String className = "com.jivesoftware.forum.database.DbForumFactory";

你可以��用自己开发的创徏forum的方法代替com.jivesoftware.forum.database.DbForumFactory��可�?

在上面的一�D�代码中一��q��了三�U�模�?span lang="EN-US">,除了工厂模式�?�q�有Singleton单态模�?以及proxy模式,proxy模式主要用来授权用户对forum的访�?因�ؓ讉K��forum有两�U��h:一个是注册用户一个是游客guest,那么那么相应的权限就不一�?而且�q�个权限是诏�I�整个系�l�的,因此建立一个proxy,�c�M��|�关的概�?可以很好的达到这个效�?

看看Java宠物店中的CatalogDAOFactory:

public class CatalogDAOFactory {
　　/**
　　* 本方法制定一个特别的子类来实现DAO模式�?br />　　* 具体子类定义是在J2EE的部�|�描�q�器中�?br />　　*/
　　public static CatalogDAO getDAO() throws CatalogDAOSysException {
　　　　CatalogDAO catDao = null;
　　　　try {
　　　　　　InitialContext ic = new InitialContext();
　　　　　　//动态装入CATALOG_DAO_CLASS
　　　　　　//可以定义自己的CATALOG_DAO_CLASS�Q�从而在无需变更太多代码
　　　　　　//的前提下�Q�完成系�l�的巨大变更�?/p>
　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);
　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();
　　　　} catch (NamingException ne) {
　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: NamingException while
　　　　　　　　　　getting DAO type : \n" + ne.getMessage());
　　　　} catch (Exception se) {
　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting
　　　　　　　　　　DAO type : \n" + se.getMessage());
　　　　}
　　　　return catDao;
　　}
}

CatalogDAOFactory是典型的工厂�Ҏ��Q�catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类�Q�这个实现子�c�d��Java宠物店是用来操作catalog数据库，用户可以�Ҏ��数据库的�c�d��不同�Q�定制自��q��具体实现子类�Q�将自己的子�c�d��l�与CATALOG_DAO_CLASS变量��可以�?/span>

由此可见�Q�工厂方法确实�ؓ�pȝ��l�构提供了非常灵�z�d��大的动态扩展机�Ӟ��只要我们更换一下具体的工厂�Ҏ��Q�系�l�其他地�Ҏ��需一点变换，��有可能��系�l�功能进行改头换面的变化�?/p>

哼哼 2007-03-16 15:28 发表评论

设计模式之Singleton(单�?

哼哼 — Fri, 16 Mar 2007 06:59:00 GMT

单态定�?/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�这�?font color="#ff1493">synchronized很重�?/font>�Q�如果没有synchronized�Q�那么��用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴��者进一步研�I��?/p>
一般认为第一�U��Ş式要更加安全些�?/font>

使用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?font color="#0000ff">如果你的应用��Z��容器�Q�那么Singleton模式��用或者不用，可以使用相关替代技术�?/font>

�q�一步深入可参考：

Double-checked locking and the Singleton pattern

When is a singleton not a singleton?

Singleton是邪恶的

哼哼 2007-03-16 14:59 发表评论

设计模式之Builder

哼哼 — Fri, 16 Mar 2007 05:52:00 GMT

Builder模式定义:
��一个复杂对象的构徏与它的表�C�分��?使得同样的构��E�可以创��Z��同的表示.

Builder模式是一步一步创��Z��个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容��可以构建它�?用户不知道内部的具体构徏�l�节.Builder模式是非常类似抽象工厂模�?�l�微的区别大概只有在反复使用中才能体会到.

��Z��使用?
是�ؓ了将构徏复杂对象�?b>�q�程和它�?i>部�g解�?注意: 是解�?b>�q�程�?i>部�g.

因�ؓ一个复杂的对象,不但有很多大量组成部�?如汽�?有很多部�?车轮方向�?发动��有各�U�小零�g�{�等,部�g很多,但远不止�q�些,如何��这些部件装配成一辆汽�?�q�个装配�q�程也很复杂(需要很好的�l�装技�?,Builder模式��是��Z��部件和�l�装�q�程分开.

如何使用?
首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部�g的创建分别开�?分别用Builder�c�d��Director�c�L��表示.

首先,需要一个接�?它定义如何创建复杂对象的各个部�g:

public interface Builder {

　　//创徏部�gA　　比如创徏汽�R车轮
　　void buildPartA();
　　//创徏部�gB 比如创徏汽�R方向�?br />　　void buildPartB();
　　//创徏部�gC 比如创徏汽�R发动�?br />　　void buildPartC();

　　//�q�回最后组装成品结�?(�q�回最后装配好的汽�?
　　//成品的组装过�E�不在这里进�?而是转移��C��面的Director�c�M��q�行.
　　//从而实��C��解�?b>�q�程�?i>部�g
　　Product getResult();

}

用Director构徏最后的复杂对象,而在上面Builder接口中封装的是如何创��Z��个个部�g(复杂对象是由�q�些部�g�l�成�?,也就是说Director的内�Ҏ��如何��部件最后组装成成品:

public class Director {

　　private Builder builder;

　　public Director( Builder builder ) {
　　　　this.builder = builder;
　　}
　　// ��部件partA partB partC最后组成复杂对�?br />　　//�q�里是将车轮方向盘和发动机组装成汽�R的过�E?br />　　public void construct() {
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

}

Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部�?
定义�q�明��它所要创建的是什么具体东�?
提供一个可以重新获取��品的接口:

public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC;
　　public void buildPartA() {
　　　　//�q�里是具体如何构建partA的代�?br />
　　};
　　public void buildPartB() {
　　　　//�q�里是具体如何构建partB的代�?br />　　};
　　 public void buildPartC() {
　　　　//�q�里是具体如何构建partB的代�?br />　　};
　　 public Product getResult() {
　　　　//�q�回最后组装成品结�?br />　　};

}

复杂对象:产品Product:

public interface Product { }

复杂对象的部�?

public interface Part { }

我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct(); //部�g的创�?/font>
Product product = builder.getResult(); //对象�Q��品）的创�?/font>

Builder模式的应�?br />在Java实际使用�?我们�l�常用到"�?(Pool)的概�?当资源提供者无法提供��够的资源,�q�且�q�些资源需要被很多用户反复�׃�n�?��需要��用池.

"�?实际是一�D�内�?当池中有一些复杂的资源�?断肢"(比如数据库的�q�接�?也许有时一个连接会中断),如果循环再利用这�?断肢",��提高内存��用效�?提高池的性能.修改Builder模式中Director�c�M��之能诊断"断肢"断在哪个部�g�?再修复这个部�?

哼哼 2007-03-16 13:52 发表评论

设计模式之Prototype(原型)

哼哼 — Fri, 16 Mar 2007 05:18:00 GMT

原型模式定义:
用原型实例指定创建对象的�U�类,�q�且通过拯��q�些原型创徏新的对象.

Prototype模式允许一个对象再创徏另外一个可定制的对象，�Ҏ��无需知道��M��如何创徏的细�?工作原理�?通过��一个原型对象传�l�那个要发动创徏的对象，�q�个要发动创建的对象通过��h��原型对象拯��它们自己来实施创建�?/p>
如何使用?
因�ؓJava中的提供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");
　　}
}

调用Prototype模式很简�?

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();

当然也可以结合工厂模式来创徏AbstractSpoon实例�?/p>
在Java中Prototype模式变成clone()�Ҏ��的��用，�׃��Java的纯�z�的面向对象�Ҏ��，使得在Java中��用设计模式变得很自然�Q�两者已�l�几乎是��然一体了。这反映在很多模式上�Q�如Interator遍历模式�?/p>

哼哼 2007-03-16 13:18 发表评论

国产亚洲精品线观看动态图,亚洲午夜久久久久久尤物,亚洲天堂一区二区

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

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

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

设计模式之Adapter(适配�?

设计模式之Proxy(代理)

设计模式之Factory

设计模式之Singleton(单�?

设计模式之Builder

设计模式之Prototype(原型)

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