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

时间  2019-12-05
标签 设计模式 结构型模式 装饰 模式 繁體版
原文   原文链接

概念

定义

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

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

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

通常的，咱们为了扩展一个类常用继承方式实现，因为继承为类引入静态特征，而且随着扩展功能的增多，子类会很膨胀。在不想增长不少子类的状况下扩展类时可使用装饰器模式。数据库

对象加强的经常使用方式

不少时候咱们可能对Java提供给咱们的对象不满意，不能知足咱们的功能。此时咱们就想对Java原对象进行加强，可以实现咱们想要的功能就好~设计模式

通常来讲，实现对象加强有三种方式：服务器

一、继 承:继承父类，子类扩展
二、装饰器模式:使用“包装”的方式来加强对象
三、代理模式:静态代理和动态代理app

继承ide

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

一、若是父类是带有数据、信息、属性的话，那么子类没法加强。
二、子类实现了以后需求没法变动，加强的内容是固定的。post

第一个缺点就拿之前在学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();
    }
}

因此咱们仍是能够完成这种需求的。

但是我需求如今又想变了：

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

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

若是需求变更很大的状况下，而咱们又用继承的方式来实现这样会致使一种现象：类爆炸(类数量激增)！而且继承的层次可能会比较多。

因此，咱们能够看到子类继承父类这种方式来扩展是十分局限的，不灵活。

所以就引出了装饰模式！

装饰模式实例

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

示例

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

电话接口：

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

    // 能够打电话
    void call();
}

具体的实现：

public class IphoneX implements Phone {


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

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

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

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

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

三、有了装饰器之后，就能够经过继承装饰器来进行功能扩展了。

定义须要扩展的装饰器。

咱们想要在打电话以前听音乐：

// 继承着装饰器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\response接口去操做这些对象，是由于Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时，会用这些接口的实现类建立出对象，而后传递给servlet程序。

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

Decorator设计模式的实现

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

使用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.实现与被加强对象相同的接口 
    二、定义一个变量记住被加强对象
    三、定义一个构造函数，接收被加强对象
    四、覆盖须要加强的方法
    五、对于不想加强的方法，直接调用被加强对象（目标对象）的方法
*/ 
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);
        }
    }
}

优缺点

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

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

总结

对象加强的三种方式：

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

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

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

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

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程