结构型模式-装饰模式

已于 2023-06-10 14:03:57 修改
阅读量87 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 装饰器模式
于 2023-06-10 10:57:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NaShiYu/article/details/131139074
版权

定义: 允许动态地向一个现有的对象添加新的功能，同时又不改变其结构，相当于对现有的对象进行了一个包装

UML图

装饰器模式
装饰模式的四个关键角色

  • 组件：作为装饰器类包装的目标类
  • 具体组件：实现组件的基础子类
  • 装饰器：一个抽象类，其中包含对组件的引用，并且还重写了组件接口方法
  • 具体装饰器：继承扩展了装饰器，并重写组件接口方法，同时可以添加附加功能

使用场景

  • 快速动态扩展和撤销一个类的功能场景。 比如，有的场景下对 API
    接口的安全性要求较高，那么就可以使用装饰模式对传输的字符串数据进行压缩或加密。如果安全性要求不高，则可以不使用。
  • 可以通过顺序组合包装的方式来附加扩张功能的场景。
    比如，加解密的装饰器外层可以包装压缩解压缩的装饰器，而压缩解压缩装饰器外层又可以包装特殊字符的筛选过滤的装饰器等。
  • 不支持继承扩展类的场景。 比如，使用 final 关键字的类，或者系统中存在大量通过继承产生的子类。

为什么使用装饰模式

  • 第一个，为了快速动态扩展类功能，降低开发的时间成本
  • 第二个，希望通过继承的方式扩展老旧功能

示例代码1

/**
 * @Description 组件-定义了组件具备的基本功能
 */
public interface ComponentService {
    void excute();
}

/**
 * @Description 具体组件
 */
public class BaseComponentServiceImpl implements ComponentService {
    @Override
    public void excute() {
        // 基础功能的实现
    }
}

/**
 * @Description 装饰器
 */
public class BaseDecorator implements ComponentService {

    private ComponentService wrapper;

    public BaseDecorator(ComponentService wrapper) {
        this.wrapper = wrapper;
    }

    @Override
    public void excute() {
        wrapper.excute();
    }
}

/**
 * @Description 具体装饰器A
 */
public class DecoratorA extends BaseDecorator {
    public DecoratorA(ComponentService wrapper) {
        super(wrapper);
    }

    @Override
    public void excute() {
        super.excute(); // 原本服务执行
        // TODO 后续扩展  在方法执行 之前 之后 都可以
    }
}

示例代码2

/**
 * @Description  文件读取服务
 */
public interface DataLoaderService {

     String readFromFile();

     void write2File(String data);
}

import lombok.extern.slf4j.Slf4j;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

/**
 * @Description 文件读取服务实现  
 */
@Slf4j
public class BaseDataLoaderServceImpl implements DataLoaderService {

    public String filePath;

    public BaseDataLoaderServceImpl(String filePath){
        this.filePath = filePath;
    }

    @Override
    public String readFromFile() {
        char[] buffer = null;
        File file = new File(this.filePath);
        try (FileReader reader = new FileReader(file)){
            buffer = new char[(int)file.length()];
            reader.read(buffer);
        }catch (IOException e){
            log.error("BaseDataLoaderServceImpl read error.", e);
        }
        return new String(buffer);
    }

    @Override
    public void write2File(String data) {

        File file = new File(this.filePath);
        try(OutputStream fos = new FileOutputStream(file)){

            fos.write(data.getBytes(StandardCharsets.UTF_8), 0, data.length());
        }catch (IOException e){
            log.error("BaseDataLoaderServceImpl write error.", e);
        }
    }
}

/**
 * @Description 基础装饰功能  
 */
public class DataLoaderDecorator implements DataLoaderService {

    private DataLoaderService dataLoaderService;

    public DataLoaderDecorator(DataLoaderService dataLoaderService) {
        this.dataLoaderService = dataLoaderService;
    }

    @Override
    public String readFromFile() {
        return dataLoaderService.readFromFile();
    }

    @Override
    public void write2File(String data) {
        dataLoaderService.write2File(data);
    }
}

/**
 * @Description  加密装饰
 */
public class EncryptDataLoaderDecorator extends DataLoaderDecorator {

    public EncryptDataLoaderDecorator(DataLoaderService dataLoaderService) {
        super(dataLoaderService);
    }

    @Override
    public String readFromFile() {
        return decrypt(super.readFromFile());
    }

    @Override
    public void write2File(String data) {
        super.write2File(encrypt(data));
    }

    private String encrypt(String data){
        byte[] res = data.getBytes(StandardCharsets.UTF_8);

        for (int idx = 0 , len = res.length; idx < len; idx++){
            res[idx] += (byte) 1;
        }
        return Base64.getEncoder().encodeToString(res);
    }

    private String decrypt(String data){
        byte[] res = Base64.getDecoder().decode(data);
        for (int idx = 0, len = res.length ; idx < len; idx++ ){
            res[idx] -= (byte)1;
        }
        return new String(res, StandardCharsets.UTF_8);
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Base64;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

/**
 * @Description 压缩装饰
 */
public class CompressionDataLoaderDecorator extends DataLoaderDecorator {

    public CompressionDataLoaderDecorator(DataLoaderService dataLoaderService) {
        super(dataLoaderService);
    }

    @Override
    public void write2File(String data) {
        super.write2File(this.compress(data));
    }

    @Override
    public String readFromFile() {
        return this.decompress(super.readFromFile());
    }

    private String compress(String stringData) {
        byte[] data = stringData.getBytes();
        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(512);
            DeflaterOutputStream dos = new DeflaterOutputStream(bout, new Deflater());
            dos.write(data);
            dos.close();
            bout.close();
            return Base64.getEncoder().encodeToString(bout.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    private String decompress(String stringData) {
        byte[] data = Base64.getDecoder().decode(stringData);
        try {
            InputStream in = new ByteArrayInputStream(data);
            InflaterInputStream iin = new InflaterInputStream(in);
            ByteArrayOutputStream bout = new ByteArrayOutputStream(512);
            int b;
            while ((b = iin.read()) != -1) {
                bout.write(b);
            }
            in.close();
            iin.close();
            bout.close();
            return new String(bout.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

/**
 * @Description 测试代码
 */
public class Test {

    public static void main(String[] args) {
        String tesInfo = "hello";
        String filePath = "demo2.txt";
        /*DataLoaderDecorator compression = new CompressionDataLoaderDecorator(
                   new BaseDataLoaderServceImpl(filePath));

        compression.write2File(tesInfo);
        String s = compression.readFromFile();
        System.out.println(s);*/

        /*DataLoaderDecorator encrypt = new EncryptDataLoaderDecorator(
                new BaseDataLoaderServceImpl(filePath));

        encrypt.write2File(tesInfo);
        System.out.println(encrypt.readFromFile());*/

        // 先 压缩 再加密
        // TODO 可以通过 不同的 排列组合  不同的顺序 来实现功能
        DataLoaderDecorator compressonAndencrypt =
                new CompressionDataLoaderDecorator(
                        new EncryptDataLoaderDecorator(
                                new BaseDataLoaderServceImpl(filePath)
                        )
                );

        compressonAndencrypt.write2File(tesInfo);
        System.out.println(compressonAndencrypt.readFromFile());

    }
}

示例代码3

import lombok.Data;

/**
 * @Description  饮料
 */
@Data
public abstract class Drink {

    private String desc;

    private float price = 0.0F;

    /**
     * 计算费用
     * @return
     */
    public abstract float cost();
}

/**
 * @Description 咖啡的共同特点 抽取出来 
 */
public class Coffee extends Drink {
    @Override
    public float cost() {
        return super.getPrice();
    }
}

/**
 * @Description  意大利咖啡
 */
public class EspressoCoffee extends Coffee {
    public EspressoCoffee() {
        setDesc("意大利咖啡");
        setPrice(6.6f);
    }
}

public class AmericanoCoffee extends Coffee {

    public LongBlack() {
        setDesc("美式咖啡");
        setPrice(5.5f);
    }

}

public class CappuccinoCoffee extends Coffee {

    public LongBlack() {
        setDesc("卡布奇诺");
        setPrice(7.7f);
    }

}

/**
 * @Description 基础装饰器 
 */
public class Decorator extends Drink {

    /**
     * 被装饰者
     */
    private Drink drink;

    public Decorator(Drink drink) {
        this.drink = drink;
    }

    @Override
    public float cost() {
        // super.getPrice() 装饰者的价格     调料的价格
        // drink.cost()   被装饰者的价格   咖啡的价格
        return super.getPrice() + drink.cost();
    }

    @Override
    public String getDesc() {
        // drink.getDesc() 被装饰者的描述
        return super.getDesc() + " " + super.getPrice() + " && " + drink.getDesc();
    }
}

public class ChocolateDecorator extends Decorator {

    public ChocolateDecorator(Drink obj) {
        super(obj);
        setDesc("巧克力");
        setPrice(3.0f);
    }
}

public class MilkDecorator extends Decorator {

    public MilkDecorator(Drink obj) {
        super(obj);
        setDesc("牛奶");
        setPrice(2.0f);
    }
}

public class SoyDecorator extends Decorator {

    public SoyDecorator(Drink obj) {
        super(obj);
        setDesc("豆浆");
        setPrice(1.5f);
    }
}



/**
 * @Description  测试代码
 */
public class CoffeeClient {

    public static void main(String[] args) {
        Drink drinkOrder = new AmericanoCoffee();


        System.out.println("描述: " + drinkOrder.getDesc());
        System.out.println("价格: " + drinkOrder.cost());

        drinkOrder = new MilkDecorator(drinkOrder);

        System.out.println("描述: " + drinkOrder.getDesc());
        System.out.println("价格: " + drinkOrder.cost());

        drinkOrder = new SoyDecorator(drinkOrder);

        System.out.println("描述: " + drinkOrder.getDesc());
        System.out.println("价格: " + drinkOrder.cost());

    }
}

运行结果:

 
描述: 美式咖啡
价格: 5.5
描述: 牛奶 2.0 && 美式咖啡
价格: 7.5
描述: 豆浆 1.5 && 牛奶 2.0 && 美式咖啡
价格: 9.0
NaShiYu
关注
专栏目录
JAVA-设计模式-结构型模式-装饰模式
08-10
JAVA-设计模式-结构型模式-装饰模式
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；...装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
设计模式之结构型模式
12-15
在本文中，我们将深入探讨结构型设计模式，特别是桥接模式、适配器模式、装饰者模式和组合模式，以及它们在实际场景中的应用。 1. **桥接模式**： 桥接模式将抽象部分与实现部分分离，使得它们可以独立进行变化。...
Java设计模式-装饰者模式
12-21
装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在运行时给对象增加新的行为或责任，而无需修改其源代码。这种模式通过创建一个与原对象具有相同接口的新对象（装饰者），并把原对象作为其内部成员，...
【设计模式】结构型模式（四）：组合模式、享元模式
书山有路，学海无涯。记录成长，追逐梦想
11-09 961
组合模式（Composite Pattern）是一种设计模式，用于处理树形结构的数据。它的主要目的是将对象组合成树形结构来表示 “部分 - 整体” 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
【设计模式】工厂模式
weixin_56520780的博客
11-11 486
把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象。客户不用自己负责new对象，不用了解对象创建的详细过程把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品。假如一类工厂如宝马工厂多做了一项业务如轮胎，那么就得在抽象工厂里面增加一个创建轮胎的产品接口（纯虚函数），所有的工厂都得重写该接口，否则都成了抽象类...
设计模式学习总结（一）
huanggang982的专栏
11-09 490
设计模式学习笔记面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象 现在，主流的编程范式或者是编程风格有三种：面向过程、面向对象和函数式编程。 需要掌握七大知识点： 1、面向对象的四大特性：封装、抽象、继承、多态 2、面向对象编程与面向过程编程的区别和联系 3、面向对象分析、面向对象设计、面向对象编程 4、接口和抽象类的区别以及各自的应用场景 5、基于接口而非实现编程的设计思想 6、多用组合少用继承的设计思想 7、面向过程的贫血模型和面
golang 泛型 middleware 设计模式: 一次只做一件事
半亩方糖
11-10 360
本文主要介绍 在使用 gRPC 和 Gin 框架中常用的 middleware 设计模式还有几种叫法。
设计模式之——观察者模式
m0_71974552的博客
11-07 1755
深入理解观察者模式：高效解耦的设计利器
设计模式-状态模式（State）
最新发布
zhao_kang_cheng的专栏
11-12 370
其主要思想是程序在任意时刻仅可处于几种有限的状态中。而状态判断通常是由比较多的条件判断语句实现（而过多的状态判断会导致我们项目维护变得更加困难，而且还很臃肿），也可以依据当前对象状态选择响应的行为。这个结构可能看上去与策略模式相似， 但有一个关键性的不同——在状态模式中， 特定状态知道其他所有状态的存在， 且能触发从一个状态到另一个状态的转换；原始对象被称为上下文 （context）， 它并不会自行实现所有行为， 而是会保存一个指向表示当前状态的状态对象的引用， 且将所有与状态相关的工作委派给该对象。
设计模式-七个基本原则之一-里氏替换原则
m0_63920681的博客
11-08 540
开闭原则:(SRP) 面向对象六个基本原则之一。
Python实现PageRank算法
qq_42568323的博客
11-11 285
PageRank算法是由Google的创始人Larry Page和Sergey Brin提出的，用于评估网页的“重要性”。PageRank通过考虑网页的链接结构来确定一个网页的重要性，假设一个网页的重要性由指向它的网页数量和这些网页的重要性决定。每个网页有一个初始的“PageRank值”，通常设为相同。在每次迭代中，网页的PageRank值通过计算所有指向该网页的网页的PageRank值加权平均来更新。每个网页的PageRank值越高，表示它越重要。
【Rust设计模式之Fold模式】
m0_37719524的博客
11-08 540
如Rust Collection中的fold方法，是消耗迭代器适配器，将闭包应用于每一个元素，并将结果返回一样。Fold模式的中心思想也是如此，将元素折叠处理，最终计算出新的元素。而我们自己实现的Fold模式，一般用于映射数据结构，不同于面向对象的原地修改，由于Rust的引用和借用以及不可变性，生成新的结构从而替代老的结构调理更为清晰。总结：通常来说只有我们在自己编写一些数据结构的时候方才用得到这种fold模式，一般的业务逻辑相对的较少能够涉及到此，不过多懂一些也是极好的~“万全之计便是即刻行动”
【设计模式系列】享元模式（十五）
LHW0621的专栏
11-10 1117
享元模式核心思想是使用共享的方式来高效地管理大量细粒度的对象。
中介者设计模式 软考
求学如是，不可入宝山而空归。。。
11-09 395
中介者设计模式（Mediator Design Pattern）是一种行为型设计模式，旨在通过定义一个中介者对象来封装一系列对象之间的交互，使得对象之间不需要直接交互，而是通过中介者进行通信，从而减少系统的复杂度。
15分钟学 Go 第 47 天 ：并发进阶——深入了解Go语言的并发模型！
weixin_40780178的博客
11-10 812
Go语言以其内置的并发支持而闻名。通过轻量级的goroutine和强大的channel，Go提供了一种易于使用且高效的并发编程方法。并发：处理多件事情的能力，但不一定同时。并行：同一时刻处理多件事情。今天我们深入探讨了Go语言的并发模型。理解如何有效地创建和管理Goroutines和Channels是写出高效并发程序的关键。通过示例代码和设计模式，你学会了如何利用Go的并发特性来解决复杂的问题。怎么样今天的内容还满意吗？
【设计模式】单例设计模式
m0_73839343的博客
11-09 1484
为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有。
设计模式之抽象工厂模式(替换Redis双集群升级，代理类抽象场景)
CSDN_LiMingfly的博客
11-08 1211
那么这个设计模式满足了；并且这里还有一点非常重要，由于集群A和集群B在部分方法提供上是不同的，因此需要做一个接口适配，而这个适配类就相当于工厂中的工厂，用于创建把不同的服务抽象为统一的接口做相同的业务。A:在代理类的实现中其实也非常简单，通过穿透进来的集群服务进行方法操作另外在invoke中通过使B:用获取方法名称反射方式，调用对应的方法功能，也就简化了整体的使用。研发自我能力的提升远不是外接的压力就是编写一坨坨代码的接口，如果你已经熟练了很多技能，那么可以在即使紧急的情况下，也能做出完善的方案。
并发编程（9）——Actor/CSP设计模式
m0_63086198的博客
11-11 830
简单来说，Actor在发送消息前必须知道接收方是谁，而接受方收到消息后也需知道发送方是谁，更像是邮件的通信模式。而csp是完全解耦合的，不关心消息从哪来或到哪去，只关心消息是通过哪个channel传递的。这里有一个问题需要注意：消费者线程是在生产者线程结束之后才运行的（消费者线程延迟500ms），那么就没有代码唤醒消费者线程，为什么消费者线程可以正常运行？主要步骤是通过条件变量挂起当前线程，若当前线程被唤醒，并且满足判断条件，则继续执行下面的代码，过程如下。如果不满足，线程继续挂起，等待被再次唤醒；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值