连载:面向对象葵花宝典:思想、技巧与实践(40) - DECORATOR模式

掌握了设计模式之道后,我们将以全新的方法来理解设计模式,这个方法更简单、更直观,不信?看几个样例就知道了

=====================================================================

DECORATOR模式(以设计模式之道来理解)

【业务】

假设你进入了一个信息安全管理非常严格的公司,这家公司不允许员工自行打印文档,所有的文档打印都需要交给文档打印系统统一管理。文档打印系统会记录每次打印的时间、内容、打印人员。。。。。。等等,以便后续出现问题的时候进行追查。

由于公司有很多的部门,每个部门的安全要求并不完全一样,同时每个部门关于文档打印也有自己的一些规定。

我们的任务就是要开发一套能够支持整个公司文档打印需求的系统。

【发现变化】

文档打印系统面对的变化主要体现在:文档打印要求是变化的,不同的部门有不同的要求,同一个部门也可能修改自己的打印需求。

例如:

A部门是一个战略规划的部门,里面的资料都非常重要,打印的时候需要在页眉位置打印“绝密”,在页脚的位置打印“密级申明”,同时要加上“绝密文档”的水印;

B部门是内部培训部门,打印培训材料的时候需要在页眉位置打印“内部公开”,但不需要密级申明,同时加上“培训资料”的水印

C部门是对外宣传部门,打印宣传材料的时候只需要加上“公司logo”的水印;

【传统方法】

传统方法使用类继承来封装打印请求,为每个部门创建一个打印的子类。详细示例代码如下:

PrintTask.java -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator;

/**
 * 打印任务类
 *
 */
abstract public class PrintTask {

    abstract public void print(String text);

}

SecretPrint.java -- 文档打印系统开发小组负责维护:

package com.oo.designpattern.decorator;

/**
 * 绝密文档的打印
 *
 */
public class SecretPrint extends PrintTask{

    @Override
    public void print(String text) {
        Printer.printHeader("绝密");
        Printer.printText(text);
        Printer.printFooter("本文包含绝密信息,请勿泄露!");
        Printer.printTextWaterMark("绝密文档");
    }

}

InternalPrint.java -- 文档打印系统开发小组负责维护:

package com.oo.designpattern.decorator;

/**
 * 内部公开的文档打印
 *
 */
public class InternalPrint extends PrintTask {

    @Override
    public void print(String text) {
        Printer.printHeader("内部公开");
        Printer.printText(text);
        Printer.printTextWaterMark("培训资料");
    }

}

PublicPrint.java -- 文档打印系统开发小组负责维护:

package com.oo.designpattern.decorator;

import java.awt.Image;

/**
 * 对外宣传的文档打印
 *
 */
public class PublicPrint extends PrintTask {

    private Image _logo;
    @Override
    public void print(String text) {
        Printer.printText(text);
        Printer.printImgWaterMark(_logo);
    }

}

文档打印系统实现如下:

PrintServer -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator;

/**
 * 文档打印系统
 *
 */
public class PrintServer {

    /**
     * 执行打印任务
     * @param task
     * @param text
     */
    public static void executePrintTask(PrintTask task, String text){
        log();
        task.print(text);
        audit();
    }

    /**
     * 记录日志
     */
    private static void log(){
        //省略具体实现代码
    }

    /**
     * 记录审计相关信息
     */
    private static void audit(){
        //省略具体实现代码
    }
}

定义好不同的打印任务后,每个部门根据自己的需要,选择不同的任务发给文档打印系统。

例如,A部门的打印处理如下:

SecretDepartment.java  -- A部门负责维护

package com.oo.designpattern.decorator;

/**
 * A部门的打印处理
 *
 */
public class SecretDepartment {

    public void print(String text){
        PrintTask task = new SecretPrint();

        //PrintServer即“文档打印系统”
        PrintServer.executePrintTask(task, text);
    }
}

传统方法使用类继承来封装变化的打印需求,当面对变化时,存在如下问题:

1)新增部门的时候,需要文档打印系统提供一个新的打印任务类,将导致出现大量的***Print类;

例如:新建了一个D部门,D部门只需要打印纯文本即可,那么已有的SecretPrint、InternalPrint、PublicPrint类都无法满足需求,必须新增一个PurePrint的类;

2)某个部门的打印需求变更的时候,需要改变已有的***Print类;

例如:C部门希望在对外宣传材料的页眉上打印公司名称,则需要修改PublicPrint类。

【设计模式方法】

设计模式封装变化的方法就是Decorator模式。Decorator模式定义如下:

“动态的给一个对象添加一些额外的职责”

《设计模式》一书中关于Decorator模式的描述并不很直观,我理解Decorator模式为“通过聚合的方式将动态变化的职责组合起来”。

我们详细看看Decorator模式是如何封装变化的。

首先,将变化的职责封装为独立的类。传统方式实现中,不同的职责是对应不同的函数调用,而设计模式中,不同的职责是不同的类;

其次,通过聚合将变化的职责组合起来。传统方式中,不同职责的组合是通过在一个函数中写多行代码来体现的,而设计模式中,通过对象的聚合将不同职责组合起来。

【Decorator模式结构】

Component:定义一个对象接口(对应结构图中的operation函数),可以给这些对象动态添加职责

ConcreteComponent:定义一个对象,这个对象是实际的Component,将被Decorator修饰

Decorator:定义修饰对象的接口,Decorator实现的关键在于聚合了一个Component对象

ConcreteDecorator:具体的修饰对象

【代码实现】

使用Decorator设计模式实现的文档打印系统代码如下:

*********************类设计*****************************

PrintComponent.java -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator2;

/**
 * 打印组件的父类
 *
 */
abstract public class PrintComponent {

    abstract public void print();
}

PrintDecorator.java -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator2;

/**
 * 修饰的打印任务,对应Decorator模式中的Decorator
 * Decorator可以聚合ConcreteComponent或者其他Decorator
 * 这样可以使得打印任务能够嵌套执行下去,直到最后完成所有打印任务
 *
 */
public abstract class PrintDecorator extends PrintComponent {

    abstract public void print();
}

TextComponent.java -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator2;

import com.oo.designpattern.decorator.Printer;

/**
 * 文本打印,对应Decorator模式中的ConcreteComponent
 * 打印任务到ConcreteComponent就算真正完成了
 *
 */
public class TextComponent extends PrintComponent {

    private String _text;
    TextComponent(String text){
        this._text = text;
    }

    @Override
    public void print() {
        Printer.printText(this._text);
    }
}

HeaderDecorator.java -- 文档打印系统开发小组负责维护

package com.oo.designpattern.decorator2;

import com.oo.designpattern.decorator.Printer;

/**
 * 页眉打印
 *
 */
public class HeaderDecorator extends PrintDecorator {

    private PrintComponent _comp; //被修饰的打印组件
    private String _text;         //需要打印的页眉内容

    /**
     * 初始化的时候,必须包含其它打印组件comp,这是实现Decorator模式的前提
     * 同时也需要指定当前组件所需的参数,不能在print函数的参数中指定,
     * 因为每个Decorator所需的参数是不一样的
     * @param comp
     * @param text
     */
    HeaderDecorator(PrintComponent comp, String text) {
        this._comp = comp;
        this._text = text;
    }

    /**
     * 打印
     */
    @Override
    public void print() {

        //打印的时候将当前Decorator和被修饰的Component分开,这是Decorator模式的关键
        Printer.printHeader(_text);  //打印页眉

        //_comp本身如果是Decorator,就会嵌套打印下去
        //_comp本身如果不是Decorator,而是ConcreteComponent,则打印任务到此结束
        _comp.print();
    }
}

FooterDecorator.java

package com.oo.designpattern.decorator2;

import com.oo.designpattern.decorator.Printer;

/**
 * 页脚打印,和页眉打印类似,此处省略相同的注释代码
 *
 */
public class FooterDecorator extends PrintDecorator {

    private PrintComponent _comp;
    private String _text;         

    FooterDecorator(PrintComponent comp, String text) {
        this._comp = comp;
        this._text = text;
    }

    /**
     * 打印
     */
    @Override
    public void print() {

        Printer.printFooter(_text);  //打印页脚

        _comp.print();
    }
}

TextWatermarkDecorator.java

package com.oo.designpattern.decorator2;

import com.oo.designpattern.decorator.Printer;

/**
 * 文本水印打印,和页眉打印类似,此处省略相同的注释代码
 *
 */
public class TextWatermarkDecorator extends PrintDecorator{

    private PrintComponent _comp;
    private String _text;         

    TextWatermarkDecorator(PrintComponent comp, String text) {
        this._comp = comp;
        this._text = text;
    }

    /**
     * 打印
     */
    @Override
    public void print() {

        Printer.printTextWaterMark(_text);  //打印文本水印

        _comp.print();
    }

}

ImgWatermarkDecorator.java

package com.oo.designpattern.decorator2;

import java.awt.Image;

import com.oo.designpattern.decorator.Printer;

/**
 * 图片水印打印,和页眉打印类似,此处省略相同的注释代码
 *
 */
public class ImgWatermarkDecorator extends PrintDecorator {

    private PrintComponent _comp;
    private static Image _logo; //图片水印只能是公司logo        

    ImgWatermarkDecorator(PrintComponent comp) {
        this._comp = comp;
    }

    /**
     * 打印
     */
    @Override
    public void print() {

        Printer.printImgWaterMark(ImgWatermarkDecorator._logo);  //打印图片水印

        _comp.print();
    }

}

PrintServer.java

package com.oo.designpattern.decorator2;

public class PrintServer {

    /**
     * 执行打印任务
     * @param comp
     */
    public static void executePrintTask(PrintComponent comp){
        log();
        comp.print();
        audit();
    }

    /**
     * 记录日志
     */
    private static void log(){
        //省略具体实现代码
    }

    /**
     * 记录审计相关信息
     */
    private static void audit(){
        //省略具体实现代码
    }
}

*********************类使用*****************************

A部门的打印处理如下(如下代码请仔细阅读,特别是注释部分):

SecretDepartment.java  -- A部门负责维护

package com.oo.designpattern.decorator2;

/**
 * A部门的打印处理,注意与传统方法中的SecretDepartment类对比
 *
 */
public class SecretDepartment {

    /**
     * 打印任务1,对应传统方式的SecretePrint类
     * @param text
     */
    public void print(String text){

        /**
         * 使用Decorator设计模式后,打印任务不再是一个单独的类SecretPrint类,
         * 而是通过将多个打印项目聚合成一个打印任务
         */
        PrintComponent textComp = new TextComponent(text);

        //注意header聚合了textComp
        PrintDecorator header = new HeaderDecorator(textComp, "绝密");
        //注意footer聚合了header,而不是textComp,这样就能够嵌套执行下去
        PrintDecorator footer = new FooterDecorator(header, "本文包含绝密信息,请勿泄露!");
        //注意watermark聚合了footer,而不是textComp,这样就能够嵌套执行下去
        PrintDecorator watermark = new TextWatermarkDecorator(footer, "绝密文档");

        //PrintServer即“文档打印系统”,与传统的PrintServer相比,这里不需要知道打印的text内容
        //text内容已经封装到TextComponent中去了(对应代码行14行)
        PrintServer.executePrintTask(watermark);  //注意这里传递给打印系统的是最后一个Decorator对象watermark
    }

    /**
     * A部门的第二个打印任务,将文本水印改为图片水印,并且不再打印页脚
     * @param text
     */
    public void print2(String text){

        /**
         * 新增打印任务,无需文档管理系统增加新的类,只要A部门自己修改代码即可
         */
        PrintComponent textComp = new TextComponent(text);

        //注意header聚合了textComp
        PrintDecorator header = new HeaderDecorator(textComp, "绝密");
        //注意watermark聚合了header,而不是textComp,这样就能够嵌套执行下去
        PrintDecorator watermark = new ImgWatermarkDecorator(header);

        PrintServer.executePrintTask(watermark);
    }
}

可以看到,使用了设计模式的方法后,打印业务的变化,可以通过类似数学上的排列组合已有的打印功能来完成,而不再需要新的打印类了。

================================================ 
转载请注明出处:http://blog.csdn.net/yunhua_lee/article/details/38865605
================================================

时间: 2024-10-14 09:14:58

连载:面向对象葵花宝典:思想、技巧与实践(40) - DECORATOR模式的相关文章

连载:面向对象葵花宝典:思想、技巧与实践(33) - ISP原则

 ISP,Interface Segregation Principle,中文翻译为"接口隔离原则". 和DIP原则一样,ISP原则也是大名鼎鼎的Martin大师提出来的,他在1996年的C++ Reporter发表" The Interface Segregation Principle"的文章详细阐述了ISP原则,并且在他的经典著作< Agile Software Development, Principles, Patterns>(中文翻译为:敏捷

连载:面向对象葵花宝典:思想、技巧与实践(34) - DIP原则

DIP,dependency inversion principle,中文翻译为"依赖倒置原则". DIP是大名鼎鼎的Martin大师提出来的,他在1996 5月的C++ Reporter发表" The Dependency Inversion Principle"的文章详细阐述了DIP原则,并且在他的经典著作< Agile Software Development, Principles, Patterns>(中文翻译为:敏捷软件开发:原则.模式与实践

连载:面向对象葵花宝典:思想、技巧与实践(32) - LSP原则

LSP是唯一一个以人名命名的设计原则,并且作者还是一个"女博士"  ============================================================= LSP,Liskov substitution principle,中文翻译为"里氏替换原则". 这是面向对象原则中唯一一个以人名命名的原则,尽管Liskov在中国的知名度没有UNIX的几位巨匠(Kenneth Thompson.Dennis Ritchie).GOF四人帮那么

连载:面向对象葵花宝典:思想、技巧与实践(31) - OCP原则

开闭原则是一个大部分人都知道,但大部分人都不懂的设计原则! ==================================================================== OCP,Open-Closed Principle,中文翻译为"开闭原则". 当我第一次看到OCP原则时,我的感觉就是这原则也太抽象了吧,什么开,什么闭呢? 然后我去寻找更加详细的答案,最经典也是最常见的解释就是维基百科了: http://en.wikipedia.org/wiki/Open

连载:面向对象葵花宝典:思想、技巧与实践(36) - 设计原则如何用?

经过前面深入的阐述,SOLID的原则我们已经基本上讲清楚了,但如果想熟练的应用SOLID原则,仅仅知道SOLID是什么(what)还不够,我们还需要知道SOLID原则在什么时候和什么场景应用(when或where). 幸运的是,SOLID原则的5个独立原则在实际应用中基本上都是独挡一面,并不会在某个地方需要同时从可选的几个原则中挑选一个最优的原则来应用,这样大大降低了我们应用SOLID原则的难度. SOLID原则具体的应用场景如下: SRP原则:用于类的设计 当我们想出一个类,或者设计出一个类的

连载:面向对象葵花宝典:思想、技巧与实践(35) - NOP原则

NOP,No Overdesign Priciple,不要过度设计原则. 这应该是你第一次看到这个原则,而且你也不用上网查了,因为这个不是大师们创造的,而是我创造的:) 之所以提出这个原则,是我自己吃过苦头,也在工作中见很多人吃过类似的苦头. 你可能也见过这样的场景: 产品提出了一个需求,设计师眼光非常长远,他甚至把5年后可能的业务变化都提出来并且加以设计了,让你不得不佩服设计师的高瞻远瞩的眼光,并且由衷的从心底赞叹:牛逼啊! 但很快你就会发现,设计师是很牛逼,但你开发的时候就很苦逼了,设计方案

连载:面向对象葵花宝典:思想、技巧与实践(37) - 设计模式:瑞士军刀 or 锤子?

"设计模式"这个词几乎成为了软件设计的代名词,很多人非常天真的以为掌握了设计模式就掌握了软件设计,但实际上如果只是握了设计模式,软件设计的门都还没摸到! ======================================================== 谈起设计模式,那是几乎无人不知,无人不晓,大名鼎鼎的"GOF"(中文有的翻译为"四人帮")惊世之作,真是"平生不识GOF,学尽设计也枉然!" 然而,设计模式真的是

连载:面向对象葵花宝典:思想、技巧与实践(39) - 设计原则 vs 设计模式

又是设计原则,又是设计模式,到底该用哪个呢? ============================================================================= 在"设计模型"一章中,我们提到设计原则和设计模式是互补的,设计原则和设计模式互补体现在:设计原则主要用于指导"类的定义"的设计,而设计模式主要用于指导"类的行为"的设计. 举一个很简单的例子:假设我们要设计一个图形类Shape,这个类既支持三角形,

连载:面向对象葵花宝典:思想、技巧与实践(29) - 高内聚低耦合

高内聚低耦合,可以说是每个程序猿,甚至是编过程序,或者仅仅只是在大学里面学过计算机,都知道的一个简单的设计原则. 虽然如此流行和人所众知,但其实真正理解的人并不多,很多时候都是人云亦云. =============================================================== 要想真正理解"高内聚低耦合",需要回答两个问题: 1)为什么要高内聚低耦合? 2)高内聚低耦合是否意味内聚越高越好,耦合越低越好? 第一个问题:为什么要高内聚低耦合? 经典的

连载:面向对象葵花宝典:思想、技巧与实践(38) - 设计模式之道

很多人能够熟练背诵出所有的设计模式,能够快速画出各种设计模式的UML类图,也能够熟练的写出<设计模式>一书中各个模式的样例代码.但一到实际的项目设计和开发的时候,往往都会陷入迷茫:要么无从下手,不知道哪个地方要用设计模式:要么生搬硬套,胡乱使用设计模式,将方案和代码搞得一团乱麻. =========================================================================== [知易行难 -- 设计模式应用的问题] 形而下者谓之器,形而上者