加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 百科 > 正文

java设计模式之装饰器模式

发布时间:2020-12-14 04:41:20 所属栏目:百科 来源:网络整理
导读:装饰器模式的定义: 装饰器模式也叫作包装器模式,指在不改变原有对象的基础上,动态地给一个对象添加一些额外的职责。就增加功能来说,装饰器模式相比生成子类更为灵活,属于结构性设计模式。 装饰器模式提供了比继承更有弹性的替代方案(扩展原有对象的功能

装饰器模式的定义:

  装饰器模式也叫作包装器模式,指在不改变原有对象的基础上,动态地给一个对象添加一些额外的职责。就增加功能来说,装饰器模式相比生成子类更为灵活,属于结构性设计模式。

装饰器模式提供了比继承更有弹性的替代方案(扩展原有对象的功能)将功能附加到对象上,因此装饰器模式的核心是扩展功能,使用装饰器模式可以透明且动态地扩展类地功能。

装饰器模式地应用场景:

  • 用于扩展一个类地功能,或者给一个类添加职责。
  • 动态地给一个对象添加功能,这些功能可以再动态地撤销。
  • 需要为一批平行的兄弟类进行改装或加装功能。

装饰器模式的UML类图:

 

?

?

?由上图可以看到,装饰器模式主要包含以下4个角色:

  • 抽象组件(Component):可以是一个接口或者抽象类,充当被装饰类的原始对象,规定了被装饰对象的行为。
  • 具体组件(ConcreteComponent):实现/继承Component的一个具体对象,即被装饰对象。
  • 抽象装饰器(Decorator):通用的装饰concreteComponent的装饰器,其内部必然有一个属性指向Component;其实现一般是一个抽象类,主要是为了让其子类按照其构造形式传入一个Component,这是强制的通用行为。如果系统中装饰逻辑单一,则并不需要实现许多的装饰器,可以直接省略该类,而直接实现一个具体的装饰器即可。
  • 具体装饰器(ConcreteDecorator):Decorator的具体实现类,理论上,每个ConcreteDecorator都扩展了Component对象的一种功能。

装饰器模式的通用写法:


package com.liuyi.designmode.structure.decorator;

import javax.swing.*;

public class Client {
public static void main(String[] args){
Component c1 = new ConcreteComponent (); //首先创建需要被装饰的原始对象(即要被装饰的对象)
Decorator decoratorA = new ConcreteDecoratorA(c1); //给对象透明的增加功能A并调用
decoratorA .operation();
Decorator decoratorB = new ConcreteDecoratorB(c1); //给对象透明的增加功能B并调用
decoratorB .operation();
Decorator decoratorBandA = new ConcreteDecoratorB(decoratorA);//装饰器也可以装饰具体的装饰对象,此时相当于给对象在增加A的功能基础上在添加功能B
decoratorBandA.operation();
}

//抽象组件
static interface Component {
/**
* 示例方法
*/
public void operation();
}

//具体组件
static class ConcreteComponent implements Component {
public void operation() {
//相应的功能处理
System.out.println("处理业务逻辑");
}
}

static abstract class Decorator implements Component {
/**
* 持有组件对象
*/
protected Component component;

/**
* 构造方法,传入组件对象
* @param component 组件对象
*/
public Decorator(Component component) {
this.component = component;
}

public void operation() {
//转发请求给组件对象,可以在转发前后执行一些附加动作
component.operation();
}
}

//具体装饰器A
static class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
private void operationFirst(){ } //在调用父类的operation方法之前需要执行的操作
private void operationLast(){ } //在调用父类的operation方法之后需要执行的操作
public void operation() {
//调用父类的方法,可以在调用前后执行一些附加动作
operationFirst(); //添加的功能
super.operation(); //这里可以选择性的调用父类的方法,如果不调用则相当于完全改写了方法,实现了新的功能
operationLast(); //添加的功能
}
}

//具体装饰器B
static class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
private void operationFirst(){ } //在调用父类的operation方法之前需要执行的操作
private void operationLast(){ } //在调用父类的operation方法之后需要执行的操作
public void operation() {
//调用父类的方法,可以在调用前后执行一些附加动作
operationFirst(); //添加的功能
super.operation(); //这里可以选择性的调用父类的方法,如果不调用则相当于完全改写了方法,实现了新的功能
operationLast(); //添加的功能
}
}
}
?

分析装饰器模式在IO流中的使用:

  java中的IO流主要分为字符流和字节流,这里我们以常用的字符流的读(Reader)为例来分析。首先我觉得要理解装饰器模式在IO中的使用,首先我们必须要

明白怎么去区分哪些是装饰类,哪些是被装饰类。我们看上面的例子,发现具体的装饰类ConcreteDecoratorA和ConcreteDecoratorB的构造函数的参数都是顶层接

口的实例对象。我们先通过JDK API文档查看Reader接口有哪些实现类,然后我们根据这个规则去判断哪些实现类是装饰类,哪些实现类是被装饰类。

?

?我们先来查看BufferedReader的构造方法,发现传入的参数是顶层抽象的实例对象,所以可以判定BufferedReader是一个装饰类,并且它不是抽象的,所以这里直接忽略

了抽象装饰器,直接实现了具体的装饰器。当然Reader也有抽象的装饰器,比如FilterReader,感兴趣的同学可以自己去看API,但是它的具体的装饰器实现很少用,当然

如果需要自定义Reader装饰器,可以去继承这个抽象装饰器实现。

我们再来看InputStreamReader的构造方法,发现传入的参数不是顶层抽象的实例对象,所以可以判断InputStreamReader是一个被装饰的类。

?这里只列举这两个常用的被装饰类和装饰的类,目的只是为了让大家理解装饰器模式在IO流中是怎么运用的,来看看具体的使用,我们读取项目路径下的

名字为xiaoniu.txt文件里面的内容,然后打印出来,先来看不使用装饰类即用InputStreamReader的情况下怎么使用:

package com.liuyi.designmode.structure.decorator;

import java.io.FileInputStream;
 java.io.FileReader;
 java.io.InputStreamReader;

/**
 * @ClassName IoTest
 * @description:
 * @author:liuyi
 * @Date:2020/11/14 23:01
 */
public class IOTest {
    static void main(String[] args) throws Exception {
        //读取当前项目下的xiaoniu.txt
        FileInputStream fileInputStream = new FileInputStream("xiaoniu.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
        设置一次读取1024个字节
        char[] chars = new char[1024];
        int index;
        while ((index=inputStreamReader.read(chars))!=-1){
            System.out.println(String.valueOf(chars));
        }
        fileInputStream.close();
        inputStreamReader.close();
    }
}

先不着急使用装饰类,我们发现使用的时候还要传入一个InputStream的实例对象,通过查看JDK文档,我们发现InputStreamReader还有一个子类FileReader,

看看FileReader怎么使用:

 java.io.FileReader;

读取当前项目下的xiaoniu.txt
        FileReader fileReader = new FileReader("xiaoniu.txt");
        while ((index=fileReader.read(chars))!=-1){
            System.out.println(String.valueOf(chars));
        }
        fileReader.close();
    }
}

FileReader也起到增强的作用,只不过是通过子类的方式实现的,只是这种方式不符合开闭原则,如果需要添加功能必须要修改子类,还要在接口添加抽象方法。

我们通常会读取文件里面的内容的时候,需要一行一行的读取,如果只用被装饰类的方法是很难实现的,这个时候我们的装饰器BufferedReader就闪亮登场了。

 java.io.BufferedReader;
);
        BufferedReader bufferedReader =  BufferedReader(fileReader);
        设置一次读取1024个字节
        String readLine = bufferedReader.readLine();
        System.out.println(readLine);
    }
}

装饰器模式与代理模式的区别:

  从代理模式UML类图和通用代码实现来看,代理模式与装饰器模式几乎一模一样。从代码实现来看,代理模式确实与装饰器模式也是一样的,但是这两种设计模式

所面向的功能扩展面是不一样的。

  装饰器模式强调自身的功能扩展,着重类功能的变化,比如添加方法。而代理模式强调对代理过程的控制,主要是对已有的方法进行功能增强,比如spring中通过

AOP实现客户端请求日志的记录。

装饰器模式的优点:

  • 装饰器是继承的有力补充,比继承灵活,在不改变原对象的情况下,动态地给一个对象扩展功能,即插即用。
  • 通过使用不同装饰类及这些装饰类的排列组合,可以实现不同效果。
  • 装饰器模式完全遵守开闭原则。

装饰器模式的缺点:

  • 会出现更多的代码、更多的类,增加程序的复杂性。
  • 动态装饰在多层装饰时会更复杂。

?

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读