精通设计模式.docx

精通设计模式.docx

《精通设计模式.docx》由会员分享，可在线阅读，更多相关《精通设计模式.docx（32页珍藏版）》请在冰豆网上搜索。

精通设计模式

1.    设计模式的起源

最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。

在1970年他的《建筑的永恒之道》里描述了投计模式的发现，因为它已经存在了千百年之久，而现代才被通过大量的研究而被发现。

在《建筑的永恒之道》里这样描述：

模式是一条由三个部分组成的通用规则：

它表示了一个特定环境、一类问题和一个解决方案之间的关系。

每一个模式描述了一个不断重复发生的问题，以及该问题解决方案的核心设计。

在他的另一本书《建筑模式语言》中提到了现在已经定义了253种模式。

比如：

说明城市主要的结构：

亚文化区的镶嵌、分散的工作点、城市的魅力、地方交通区

住宅团组：

户型混合、公共性的程度、住宅团组、联排式住宅、丘状住宅、老人天地室内环境和室外环境、阴和阳总是一气呵成

针对住宅：

夫妻的领域、儿童的领域、朝东的卧室、农家的厨房、私家的沿街露台、个人居室、起居空间的序列、多床卧室、浴室、大储藏室

针对办公室、车间和公共建筑物：

灵活办公空间、共同进餐、共同小组、宾至如归、等候场所、小会议室、半私密办公室

尽管亚力山大的著作是针对建筑领域的，但他的观点实际上适用于所有的工程设计领域，其中也包括软件设计领域。

“软件设计模式”，这个术语是在1990年代由ErichGamma等人从建筑设计领域引入到计算机科学中来的。

目前主要有23种。

2.    软件设计模式的分类

2.1.  创建型

创建对象时，不再由我们直接实例化对象；而是根据特定场景，由程序来确定创建对象的方式，从而保证更大的性能、更好的架构优势。

创建型模式主要有简单工厂模式（并不是23种设计模式之一）、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式。

2.2.  结构型

用于帮助将多个对象组织成更大的结构。

结构型模式主要有适配器模式adapter、桥接模式bridge、组合器模式component、装饰器模式decorator、门面模式、亨元模式flyweight和代理模式proxy。

2.3.  行为型

用于帮助系统间各对象的通信，以及如何控制复杂系统中流程。

行为型模式主要有命令模式command、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式state、策略模式、模板模式和访问者模式。

3.    常见设计模式介绍

3.1. 单例模式（singleton）

有些时候，允许自由创建某个类的实例没有意义，还可能造成系统性能下降。

如果一个类始终只能创建一个实例，则这个类被称为单例类，这种模式就被称为单例模式。

   一般建议单例模式的方法命名为：

getInstance（），这个方法的返回类型肯定是单例类的类型了。

getInstance方法可以有参数，这些参数可能是创建类实例所需要的参数，当然，大多数情况下是不需要的

publicclass Singleton{

    publicstaticvoid main（String[]args）

    {

       //创建Singleton对象不能通过构造器，只能通过getInstance方法

       Singletons1=Singleton.getInstance（）;

       Singletons2=Singleton.getInstance（）;

       //将输出true

       System.out.println（s1==s2）;

    }

    //使用一个变量来缓存曾经创建的实例

    privatestatic Singleton instance;

    //将构造器使用private修饰，隐藏该构造器

    private Singleton（）{

       System.out.println（"Singleton被构造！

"）;

    }

    //提供一个静态方法，用于返回Singleton实例

    //该方法可以加入自定义的控制，保证只产生一个Singleton对象

    publicstatic SingletongetInstance（）

    {

       //如果instance为null，表明还不曾创建Singleton对象

       //如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法

       if （instance == null）

       {

           //创建一个Singleton对象，并将其缓存起来

           instance = new Singleton（）;

       }

       returninstance;

    }

}

单例模式主要有如下两个优势：

1）      减少创建Java实例所带来的系统开销

2）      便于系统跟踪单个Java实例的生命周期、实例状态等。

3.2. 简单工厂（StaticFactoryMethod）

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

A实例调用B实例的方法，称为A依赖于B。

如果使用new关键字来创建一个B实例（硬编码耦合），然后调用B实例的方法。

一旦系统需要重构：

需要使用C类来代替B类时，程序不得不改写A类代码。

而用工厂模式则不需要关心B对象的实现、创建过程。

Output，接口

publicinterface Output

{

    //接口里定义的属性只能是常量

    intMAX_CACHE_LINE =50;

    //接口里定义的只能是public的抽象实例方法

    void out（）;

    void getData（Stringmsg）;

}

Printer，Output的一个实现

//让Printer类实现Output

publicclass Printer implements Output

{

    private String[] printData = new String[MAX_CACHE_LINE];

    //用以记录当前需打印的作业数

    privateintdataNum =0;

    publicvoid out（）

    {

       //只要还有作业，继续打印

       while（dataNum >0）

       {

          System.out.println（"打印机打印：

" + printData[0]）;

           //把作业队列整体前移一位，并将剩下的作业数减1

           System.arraycopy（printData ,1, printData,0,--dataNum）;

       }

    }

    publicvoid getData（Stringmsg）

    {

       if （dataNum >= MAX_CACHE_LINE）

       {

           System.out.println（"输出队列已满，添加失败"）;

       }

       else

       {

           //把打印数据添加到队列里，已保存数据的数量加1。

           printData[dataNum++]=msg;

       }

    }

}

BetterPrinter，Output的一个实现

publicclass BetterPrinter implements Output

{

    private String[] printData = new String[MAX_CACHE_LINE *2];

    //用以记录当前需打印的作业数

    privateintdataNum =0;

    publicvoid out（）

    {

       //只要还有作业，继续打印

       while（dataNum >0）

       {

           System.out.println（"高速打印机正在打印：

" + printData[0]）;

           //把作业队列整体前移一位，并将剩下的作业数减1

           System.arraycopy（printData ,1, printData,0,--dataNum）;

       }

    }

    publicvoid getData（Stringmsg）

    {

       if （dataNum >= MAX_CACHE_LINE *2）

       {

           System.out.println（"输出队列已满，添加失败"）;

       }

       else

       {

           //把打印数据添加到队列里，已保存数据的数量加1。

           printData[dataNum++]=msg;

       }

    }

}

OutputFactory，简单工厂类

    public OutputgetPrinterOutput（Stringtype）{

       if （type.equalsIgnoreCase（"better"））{

           returnnew BetterPrinter（）;

       } else {

           returnnew Printer（）;

       }

    }

Computer

publicclass Computer

{

    private Output out;

    public Computer（Outputout）

    {

       this.out =out;

    }

    //定义一个模拟获取字符串输入的方法

    publicvoid keyIn（Stringmsg）

    {

       out.getData（msg）;

    }

    //定义一个模拟打印的方法

    publicvoid print（）

    {

       out.out（）;

    }

    publicstaticvoid main（String[]args）

    {

       //创建OutputFactory

       OutputFactoryof= new OutputFactory（）;

       //将Output对象传入，创建Computer对象

       Computerc= new Computer（of.getPrinterOutput（"normal"））;

       c.keyIn（"建筑永恒之道"）;

       c.keyIn（"建筑模式语言"）;

       c.print（）;

       c= new Computer（of.getPrinterOutput（"better"））;

       c.keyIn（"建筑永恒之道"）;

       c.keyIn（"建筑模式语言"）;

       c.print（）;

    }

使用简单工厂模式的优势：

让对象的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂请求即可。

从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性、可扩展性。

工厂模式也有一个小小的缺陷：

当产品修改时，工厂类也要做相应的修改。

3.3. 工厂方法（FactoryMethod）和抽象工厂（AbstractFactory）

如果我们不想在工厂类中进行逻辑判断，程序可以为不同产品类提供不同的工厂，不同的工厂类和产不同的产品。

当使用工厂方法设计模式时，对象调用者需要与具体的工厂类耦合，如：

//工厂类的定义1

publicclass BetterPrinterFactory

    implements OutputFactory

{

    public OutputgetOutput（）

    {

       //该工厂只负责产生BetterPrinter对象

       returnnew BetterPrinter（）;

    }

}

//工厂类的定义2

publicclass PrinterFactory

    implements OutputFactory

{

    public OutputgetOutput（）

    {

       //该工厂只负责产生Printer对象

       returnnew Printer（）;

    }

}

//工厂类的调用

//OutputFactoryof=newBetterPrinterFactory（）;

OutputFactoryof= new PrinterFactory（）;

Computer c= new Computer（of.getOutput（））;

使用简单工厂类，需要在工厂类里做逻辑判断。

而工厂类虽然不用在工厂类做判断。

但是带来了另一种耦合：

客户端代码与不同的工厂类耦合。

为了解决客户端代码与不同工厂类耦合的问题。

在工厂类的基础上再增加一个工厂类，该工厂类不制造具体的被调用对象，而是制造不同工厂对象。

如：

//抽象工厂类的定义，在工厂类的基础上再建一个工厂类

publicclass OutputFactoryFactory

{

    //仅定义一个方法用于返回输出设备。

    publicstatic OutputFactorygetOutputFactory（

       Stringtype）

    {

       if （type.equalsIgnoreCase（"better"））

       {

           returnnew BetterPrinterFactory（）;

       }

       else

       {

           returnnew PrinterFactory（）;

       }

    }

}

//抽象工厂类的调用

OutputFactoryof=OutputFactoryFactory.getOutputFactory（"better"）;

Computerc= new Computer（of.getOutput（））;

3.4. 代理模式（Proxy）

代理模式是一种应用非常广泛的设计模式，当客户端代码需要调用某个对象时，客户端实际上不关心是否准确得到该对象，它只要一个能提供该功能的对象即可，此时我们就可返回该对象的代理（Proxy）。

代理就是一个Java对象代表另一个Java对象来采取行动。

如：

publicclass ImageProxy implements Image

{

    //组合一个image实例，作为被代理的对象

    private Image image;

    //使用抽象实体来初始化代理对象

    public ImageProxy（Imageimage）

    {

       this.image =image;

    }

    /**

     * 重写Image接口的show（）方法

     * 该方法用于控制对被代理对象的访问，

     * 并根据需要负责创建和删除被代理对象

     */

    publicvoid show（）

    {

       //只有当真正需要调用image的show方法时才创建被代理对象

       if （image == null）

       {

           image = new BigImage（）;

       }

       image.show（）;

    }

}

调用时，先不创建：

Imageimage=newImageProxy（null）;

hibernate默认启用延迟加载，当系统加载A实体时，A实体关联的B实体并未被加载出来，A实体所关联的B实体全部是代理对象——只有等到A实体真正需要访问B实体时，系统才会去数据库里抓取B实体所对应的记录。

借助于Java提供的Proxy和InvocationHandler，可以实现在运行时生成动态代理的功能，而动态代理对象就可以作为目标对象使用，而且增强了目标对象的功能。

如：

Panther

publicinterface Panther

{

    //info方法声明

    publicvoid info（）;

    //run方法声明

    publicvoid run（）;

}

GunPanther

publicclass GunPanther implements Panther

{

    //info方法实现，仅仅打印一个字符串

    publicvoid info（）

    {

       System.out.println（"我是一只猎豹！

"）;

    }

    //run方法实现，仅仅打印一个字符串

    publicvoid run（）

    {

       System.out.println（"我奔跑迅速"）;

    }

}

MyProxyFactory，创建代理对象

publicclass MyProxyFactory

{

    //为指定target生成动态代理对象

    publicstatic ObjectgetProxy（Objecttarget）

       throws Exception

    {

       //创建一个MyInvokationHandler对象

       MyInvokationHandlerhandler=

           new MyInvokationHandler（）;

       //为MyInvokationHandler设置target对象

       handler.setTarget（target）;

       //创建、并返回一个动态代理

       return Proxy.newProxyInstance（target.getClass（）.getClassLoader（）

           ,target.getClass（）.getInterfaces（）,handler）;

    }

}

MyInvokationHandler，增强代理的功能

publicclass MyInvokationHandler implements InvocationHandler

{

    //需要被代理的对象

    private Object target;

    publicvoid setTarget（Objecttarget）

    {

       this.target =target;

    }

    //执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法

    public Objectinvoke（Objectproxy,Methodmethod,Object[]args）

       throws Exception

    {

       TxUtiltx= new TxUtil（）;

       //执行TxUtil对象中的beginTx。

       tx.beginTx（）;

       //以target作为主调来执行method方法

       Objectresult=method.invoke（target ,args）;

       //执行TxUtil对象中的endTx。

       tx.endTx（）;

       return result;

    }

}

TxUtil

publicclass TxUtil

{

    //第一个拦截器方法:

模拟事务开始

    publicvoid beginTx（）

    {

       System.out.println（"=====模拟开始事务====="）;

    }

    //第二个拦截器方法:

模拟事务结束

    publicvoid endTx（）

    {

       System.out.println（"=====模拟结束事务====="）;

    }

}

测试

    publicstaticvoid main（String[]args）

       throws Exception

    {

       //创建一个原始的GunDog对象，作为target

       Panthertarget= new GunPanther（）;

       //以指定的target来创建动态代理

       Pantherpanther=（Panther）MyProxyFactory.getProxy（target）;

       //调用代理对象的info（）和run（）方法

       panther.info（）;

       panther.run（）;

    }

spring所创建的AOP代理就是这种动态代理。

但是SpringAOP更灵活。

3.5. 命令模式（Command）

某个方法需要完成某一个功能，完成这个功能的大部分步骤已经确定了，但可能有少量具体步骤无法确定，必须等到执行该方法时才可以确定。

（在某些编程语言如Ruby、Perl里，允许传入一个代码块作为参数。

但Jara暂时还不支持代码块作为参数）。

在Java中，传入该方法的是一个对象，该对象通常是某个接口的匿名实现类的实例，该接口通常被称为命令接口，这种设计方式也被称为命令模式。

如：

Command

publicinterface Command

{

    //接口里定义的process方法用于封装“处理行为”

    void process（int[]target）;

}

ProcessArray

publicclass ProcessArray

{

    //定义一个each（）方法，用于处理数组，

    publicvoid each（int[]target,Command cmd）

    {

       cmd.process（target）;

    }

}

TestCommand

publicclass TestCommand

{

    publicstaticv