【设计模式】【结构型模式】装饰器模式

概念

定义

装饰模式指动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。在不想增加很多子类的情况下扩展类时可以使用装饰器模式。

对象增强的常用方式

很多时候我们可能对Java提供给我们的对象不满意，不能满足我们的功能。此时我们就想对Java原对象进行增强，能够实现我们想要的功能就好~

一般来说，实现对象增强有三种方式：

1、继承:继承父类，子类扩展
2、装饰器模式:使用“包装”的方式来增强对象
3、代理模式:静态代理和动态代理

继承

最简单的方式就是继承父类，子类扩展来达到目的。虽然简单，但是这种方式的缺陷非常大：

1、如果父类是带有数据、信息、属性的话，那么子类无法增强。
2、子类实现了之后需求无法变更，增强的内容是固定的。

第一个缺点就拿以前在学JDBC的时候来说：

开始想要自己写一个简易的JDBC连接池，连接池由List来管理。显然我们的对象是Connection，当写到close()方法的时候卡住了。

因为我们想要的功能是：调用close()是Connection返回到“连接池”(集合)中，而不是关闭掉。

此时我们不能使用继承父类的方式来实现增强。因为Connection对象是由数据库厂商来实现的，在得到Connection对象的时候绑定了各种信息(数据库的username、password、具体的数据库是啥等等)。我们子类继承Connection是无法得到对应的数据的！就更别说调用close()方法了。

第二点我也举个例子：

现在我设计一个电话类：

public class Phone {
    // 可以打电话
    public void call() {
        System.out.println("打电话给周围的人关注公众号Java3y");
    }
}

此时，我想打电话之前能听彩铃，于是我继承Phone类，实现我想要的功能。

public class MusicPhone extends Phone {

    // 听彩铃
    public void listenMusic() {
        System.out.println("我怀念的是无话不说,我怀念的是一起做梦~~~~~~");
    }

    @Override
    public void call() {

        // 在打电话之前听彩铃
        listenMusic();

        super.call();
    }
}

我们的功能就做好了。此时，我又突然想实现多一个需求了，我想要听完电话之后告诉我一下当前的时间是多少。没事，我们又继承来增强一下：

// 这里继承的是MusicPhone类
public class GiveCurrentTimePhone extends MusicPhone {

    // 给出当前的时间
    public void currentTime() {
        System.out.println("当前的时间是：" + System.currentTimeMillis());
    }

    @Override
    public void call() {
        super.call();

        // 打完电话提示现在的时间是多少啦
        currentTime();
    }
}

所以我们还是可以完成这种需求的。

可是我需求现在又想变了：

我不想听彩铃了，只想听完电话通知一下时间就好了(可是我们的通知时间电话类是继承在听彩铃的电话类基础之上的)。

我又有可能：我想在听电话之前报告一下时间，听完电话听音乐。

如果需求变动很大的情况下，而我们又用继承的方式来实现这样会导致一种现象：类爆炸(类数量激增)！并且继承的层次可能会比较多。

所以，我们可以看到子类继承父类这种方式来扩展是十分局限的，不灵活。

因此就引出了装饰模式！

装饰模式实例

首先我们来看看装饰模式是怎么用的吧。

示例

1、定义Component接口Phone和具体实现IphoneX

电话接口：

// 一个良好的设计是抽取成接口或者抽象类的
public interface Phone {

    // 可以打电话
    void call();
}

具体的实现：

public class IphoneX implements Phone {


    @Override
    public void call() {
        System.out.println("打电话给周围的人关注公众号Java3y");
    }
}

2、定义装饰器 PhoneDecorate，它实现了接口Phone，以组合的方式接收具体实现类IphoneX。

// 装饰器，实现接口
public abstract class PhoneDecorate implements Phone {

    // 以组合的方式来获取默认实现类
    private Phone phone;
    public PhoneDecorate(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void call() {
        phone.call();
    }
}

3、有了装饰器以后，就可以通过继承装饰器来进行功能扩展了。

定义需要扩展的装饰器。

我们想要在打电话之前听音乐：

// 继承着装饰器PhoneDecorate来扩展
public class MusicPhone extends PhoneDecorate {

    public MusicPhone(Phone phone) {
        super(phone);
    }

    // 定义想要扩展的功能
    public void listenMusic() {

        System.out.println("继续跑 带着赤子的骄傲，生命的闪耀不坚持到底怎能看到，与其苟延残喘不如纵情燃烧");

    }

    // 重写打电话的方法
    @Override
    public void call() {

        // 在打电话之前听音乐
        listenMusic();
        super.call();
    }
}

现在我也想在打完电话后通知当前的时间，于是我们也继承装饰类来扩展：

// 这里继承的是装饰器类PhoneDecorate
public class GiveCurrentTimePhone extends PhoneDecorate  {


    public GiveCurrentTimePhone(Phone phone) {
        super(phone);
    }

    // 自定义想要实现的功能：给出当前的时间
    public void currentTime() {
        System.out.println("当前的时间是：" + System.currentTimeMillis());
    }

    // 重写要增强的方法
    @Override
    public void call() {
        super.call();
        // 打完电话后通知一下当前时间
        currentTime();
    }
}

需求变更

就目前这样看起来，比我直接继承父类要麻烦，而功能效果是一样的。那么装饰模式的优势在哪呢？

如果此时，我不想在打电话之前听到彩铃了，很简单：我们不装饰它就好了！

此时，我想在打电话前报告一下时间，在打完电话之后听彩铃。

注意：
虽然说要改动类中的代码，但是这种改动是合理的。 因为我定义出的GiveCurrentTimePhone类和MusicPhone类本身从语义上就没有规定扩展功能的执行顺序。

而继承不一样：先继承Phone->实现MusicPhone->再继承MusicPhone实现GiveCurrentTimePhone。这是固定的，从继承的逻辑上已经写死了具体的代码，是难以改变的。

所以我们还是可以很简单地完成功能:

示例解说

可能有的同学在看完上面的代码之后，还是迷迷糊糊地不知道装饰模式是怎么实现“装饰”的。下面我就再来解析一下：

第一步：我们有一个Phone接口，该接口定义了Phone的功能

第二步：我们有一个最简单的实现类iPhoneX

第三步：写一个装饰器抽象类PhoneDecorate，以组合(构造函数传递)的方式接收我们最简单的实现类iPhoneX。其实装饰器抽象类的作用就是代理(核心的功能还是由最简单的实现类iPhoneX来做，只不过在扩展的时候可以添加一些没有的功能而已)。

第四步：想要扩展什么功能，就继承PhoneDecorate装饰器抽象类，将想要增强的对象(最简单的实现类iPhoneX或者已经被增强过的对象)传进去，完成我们的扩展！
再来看看下面的图，就懂了！

往往我们的代码可以省略起来，成了这个样子(是不是和IO的非常像！)

// 先增强听音乐的功能，再增强通知时间的功能
Phone phone = new GiveCurrentTimePhone(new MusicPhone(new IphoneX()));

结果是一样的：

应用

Java中的IO

JavaI/O库的对象结构图如下：

抽象被装饰者(Component)角色：由InputStream扮演。这是一个抽象类，为各种子类型提供统一的接口。

具体被装饰者(ConcreteComponent)角色：由ByteArrayInputStream、FileInputStream、PipedInputStream、StringBufferInputStream等类扮演。它们实现了抽象构件角色所规定的接口。

抽象装饰(Decorator)角色：由FilterInputStream扮演。它实现了InputStream所规定的接口。

具体装饰(ConcreteDecorator)角色：由几个类扮演，分别是BufferedInputStream、DataInputStream以及两个不常用到的类LineNumberInputStream、PushbackInputStream。

抽象被装饰者InputStream

具体被装饰者FileInputStream

public class FileInputStream extends InputStream
{}

抽象装饰者类FilterInputStream

具体装饰角色PushbackInputStream

使用I/O流读取文件内容的简单操作示例。

FileInputStream对象相当于原始的被装饰的对象, 而BufferedInputStream对象和DataInputStream对象则相当于装饰器。

使用Decorator设计模式增强request对象

有一种情况下，必须使用Decorator设计模式：即被增强的对象，开发人员只能得到它的对象，无法得到它的class文件。

比如request、response对象，开发人员之所以在servlet中能通过sun公司定义的HttpServletRequest esponse接口去操作这些对象，是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时，会用这些接口的实现类创建出对象，然后传递给servlet程序。

此种情况下，由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个？在程序中只能拿到服务器厂商提供的对象，因此就只能采用Decorator设计模式对这些对象进行增强。

Decorator设计模式的实现

1、首先看需要被增强对象继承了什么接口或父类，编写一个类也去继承这些接口或父类。
2、在类中定义一个变量，变量类型即需增强对象的类型。
3、在类中定义一个构造函数，接收需增强的对象。
4、覆盖需增强的方法，编写增强的代码。

使用Decorator设计模式增强request对象

Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper，HttpServletRequestWrapper 类实现了request 接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法，以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

编写一个用于处理中文乱码的过滤器CharacterEncodingFilter，代码如下：

package me.gacl.web.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

/**
* @ClassName: CharacterEncodingFilter
* @Description: 此过滤器用来解决解决get、post请求方式下的中文乱码问题
* @author: 孤傲苍狼
* @date: 2014-8-31 下午11:09:37
*
*/ 
public class CharacterEncodingFilter implements Filter {

    private FilterConfig filterConfig = null;
    //设置默认的字符编码
    private String defaultCharset = "UTF-8";

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //得到在web.xml中配置的字符编码
        String charset = filterConfig.getInitParameter("charset");
        if(charset==null){
            charset = defaultCharset;
        }
        request.setCharacterEncoding(charset);
        response.setCharacterEncoding(charset);
        response.setContentType("text/html;charset="+charset);
        
        MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
        chain.doFilter(requestWrapper, response);
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        //得到过滤器的初始化配置信息
        this.filterConfig = filterConfig;
    }
    
    public void destroy() {

    }
}

/**
* @ClassName: MyCharacterEncodingRequest
* @Description: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,
* (HttpServletRequestWrapper类实现了request接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)
* 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。
* 所以当需要增强request对象时，只需要写一个类继承HttpServletRequestWrapper类，然后在重写需要增强的方法即可
* @author: 孤傲苍狼
* @date: 2014-9-2 下午10:42:57
*     1.实现与被增强对象相同的接口 
    2、定义一个变量记住被增强对象
    3、定义一个构造函数，接收被增强对象
    4、覆盖需要增强的方法
    5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法
*/ 
class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
    //定义一个变量记住被增强对象(request对象是需要被增强的对象)
    private HttpServletRequest request;
    //定义一个构造函数，接收被增强对象
    public MyCharacterEncodingRequest(HttpServletRequest request) {
        super(request);
        this.request = request;
    }
    /* 覆盖需要增强的getParameter方法
     * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
     */
    @Override
    public String getParameter(String name) {
        try{
            //获取参数的值
            String value= this.request.getParameter(name);
            if(value==null){
                return null;
            }
            //如果不是以get方式提交数据的，就直接返回获取到的值
            if(!this.request.getMethod().equalsIgnoreCase("get")) {
                return value;
            }else{
                //如果是以get方式提交数据的，就对获取到的值进行转码处理
                value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
                return value;
            }
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

优缺点

优点：
1、装饰类和被装饰类可以独立发展，不会相互耦合，互相都不用知道对方的存在
2、装饰模式是继承的一个替代模式，无论包装多少层，返回的对象都是is-a的关系(上面的例子：包装完还是Phone类型)。对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。
3、装饰模式可以动态扩展一个实现类的功能，只要继承了装饰器就可以动态扩展想要的功能了。
4、可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。
5、用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合“开闭原则”。

缺点：
1、多层装饰比较复杂，提高了系统的复杂度，不利于调试。
2、使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。
3、使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，大量小对象的产生势必会占用更多的系统资源，在一定程序上影响程序的性能。

总结

对象增强的三种方式：

• 继承
• 装饰器模式
• 代理模式

那么只要遇到Java提供给我们的API不够用，增强一下就行了。在写代码时，某个类被写死了，功能不够用，增强一下就可以了！本文介绍了继承和装饰模式进行增强的方式，代理模式后续专门进行讲解。

装饰器模式适用于在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

特点
1、装饰者和被装饰者有相同的接口（或有相同的父类）。
2、装饰者保存了一个被装饰者的引用。
3、在运行时动态地为对象添加属性，不必改变对象的结构。

参考资料：
包装模式就是这么简单啦
装饰器模式
JAVA设计模式初探之装饰者模式
javaweb学习总结(四十三)——Filter高级开发