掌握设计模式--装饰模式

装饰模式（Decorator Pattern）

装饰模式是一种结构型设计模式，旨在在不改变原有对象结构的情况下动态地为对象添加功能。通过将对象封装到一系列装饰器类中，可以以灵活和透明的方式扩展功能。
如果要扩展功能，装饰模式提供了比继承更有弹性的替代方案，装饰模式强调的是功能的扩展和灵活组合。
装饰模式强调的是扩展对象的功能及扩展功能的组合。比如，对象A，需要扩展X、Y的功能，这些扩展功能按不同的顺序组合可以实现不同的效果，先执行X再执行Y扩展功能或者先执行Y再执行X扩展功能。而继承实现的只是单一的顺序扩展功能，并且继承是单一的。看后面的例子就很好理解了。
结构

通常包含一个核心对象和若干装饰对象，这些装饰对象通过引用同一接口或抽象类实现功能的叠加。
装饰模式包含以下主要角色：

• Component（组件接口）
  定义核心对象的公共接口，允许动态添加行为。
  
• ConcreteComponent（具体组件）
  具体实现了 Component 接口的类，表示被装饰的核心对象。
  
• Decorator（装饰器抽象类）
  实现 Component 接口，同时持有一个 Component 的引用，表示对该对象的包装。
  
• ConcreteDecorator（具体装饰器）
  在装饰器抽象类的基础上，添加具体的功能。
  

代码示例

实现对Socket报文的多层加密，加密顺序可随意组合。示例中使用到了国密SM4加密和Base64编码。Socket 报文可以先加密再编码，也可以先编码在加密，跟根据不同组合来实现不同的增强。
类图

定义核心接口

1. public interface SocketStream {
2.     void writeData(String data) throws IOException;
3.     String readData() throws IOException;
4.     void close() throws IOException;
5. }

复制代码

被装饰的核心对象

1. public class SimpleSocketStream implements SocketStream {
2.     private Socket socket;
3.     private OutputStream outputStream;
4.     private InputStream inputStream;
5.     public SimpleSocketStream(Socket socket){
6.         this.socket = socket;
7.         try {
8.             this.outputStream = socket.getOutputStream();
9.             this.inputStream = socket.getInputStream();
10.         } catch (IOException e) {
11.             throw new RuntimeException(e);
12.         }
13.     }
16.     @Override
17.     public void writeData(String data) throws IOException {
18.         outputStream.write(data.getBytes(StandardCharsets.UTF_8));
19.         outputStream.flush();
20.         socket.shutdownOutput();
21.     }
23.     @Override
24.     public String readData() throws IOException {
25.         // 读取客户端请求并解密
26.         BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
27.         String message = reader.readLine();
28.         return message;
29.     }
31.     @Override
32.     public void close() throws IOException {
33.         if(inputStream!=null)
34.             inputStream.close();
35.         if(outputStream!=null)
36.             outputStream.close();
37.         if(socket!=null)
38.             socket.close();
39.     }
40. }

复制代码

抽象装饰器

1. public abstract class SocketStreamDecorator implements SocketStream{
2.     private SocketStream socketStream;
4.     public SocketStreamDecorator(SocketStream socketStream){
5.         this.socketStream = socketStream;
6.     }
8.     @Override
9.     public void writeData(String data) throws IOException {
10.         socketStream.writeData(data);
11.     }
13.     @Override
14.     public String readData() throws IOException {
15.         return socketStream.readData();
16.     }
18.     @Override
19.     public void close() throws IOException {
20.         socketStream.close();
21.     }
22. }

复制代码

具体装饰器1--SM4 加密处理

1. public class SM4CipherSocketStreamDecorator extends SocketStreamDecorator{
3.     public SM4CipherSocketStreamDecorator(SocketStream socketStream) {
4.         super(socketStream);
5.     }
7.     @Override
8.     public void writeData(String data) throws IOException {
9.         // 加密
10.         String sm4Encrypt = SM4EncryptUtil.sm4Encrypt(data);
11.         System.out.println("--SM4加密数据："+sm4Encrypt);
12.         super.writeData(sm4Encrypt);
13.     }
15.     @Override
16.     public String readData() throws IOException {
17.         String readData = super.readData();
18.         // 解密
19.         System.out.println("--SM4解密前数据："+readData);
20.         String sm4Decrypt = SM4EncryptUtil.sm4Decrypt(readData);
21.         return sm4Decrypt;
22.     }
23. }

复制代码

工具类

1. public class SM4EncryptUtil {
2.     // 秘钥
3.     private static final String key = "1234567812345678";
5.     static {
6.         // 添加安全提供者（SM2，SM3，SM4等加密算法，CBC、CFB等加密模式，PKCS7Padding等填充方式，不在Java标准库中，由BouncyCastleProvider实现）
7.         Security.addProvider(new BouncyCastleProvider());
8.     }
10.     /**
11.      * 输入：待加密的字符串，16或24或32位字符串密码
12.      * 输出：16进制字符串或Base64编码的字符串密文（常用）
13.      */
14.     public static String sm4Encrypt(String encrypt) {
15.         String cipherString = null;
16.         try {
17.             // 指定加密算法
18.             String algorithm = "SM4";
19.             // 创建密钥规范
20.             SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
21.             // 获取Cipher对象实例（BC中SM4默认使用ECB模式和PKCS5Padding填充方式，因此下列模式和填充方式无需指定）
22.             Cipher cipher = Cipher.getInstance(algorithm + "/ECB/PKCS5Padding");
23.             // 初始化Cipher为加密模式
24.             cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
25.             // 获取加密byte数组
26.             byte[] cipherBytes = cipher.doFinal(encrypt.getBytes(StandardCharsets.UTF_8));
27.             // 输出为Base64编码
28.             cipherString = Base64.getEncoder().encodeToString(cipherBytes);
29.         } catch (Exception e) {
30.             e.printStackTrace();
31.         }
32.         return cipherString;
33.     }
35.     /**
36.      * 输入：密文，16或24或32位字符串密码
37.      * 输出：明文
38.      */
39.     public static String sm4Decrypt(String cipherString) {
40.         String plainString = null;
41.         try {
42.             // 指定加密算法
43.             String algorithm = "SM4";
44.             // 创建密钥规范
45.             SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
46.             // 获取Cipher对象实例（BC中SM4默认使用ECB模式和PKCS5Padding填充方式，因此下列模式和填充方式无需指定）
47.             Cipher cipher = Cipher.getInstance(algorithm + "/ECB/PKCS5Padding");
48.             // 初始化Cipher为解密模式
49.             cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
50.             // 获取加密byte数组
51.             byte[] cipherBytes = cipher.doFinal(Base64.getDecoder().decode(cipherString));
52.             // 输出为字符串
53.             plainString = new String(cipherBytes);
54.         } catch (Exception e) {
55.             e.printStackTrace();
56.         }
57.         return plainString;
58.     }
60. }

复制代码

具体装饰器2--Base64 编码处理

1. public class Base64SocketStreamDecorator extends SocketStreamDecorator{
3.     public Base64SocketStreamDecorator(SocketStream socketStream) {
4.         super(socketStream);
5.     }
7.     @Override
8.     public void writeData(String data) throws IOException {
9.         String encode = this.encode(data);
10.         System.out.println("--base64编码后的数据：" + encode);
11.         super.writeData(encode);
12.     }
14.     @Override
15.     public String readData() throws IOException {
16.         String readData = super.readData();
17.         System.out.println("--base64解密前的数据：" + readData);
18.         String decode = this.decode(readData);
19.         return decode;
20.     }
21.     /**
22.      * base64编码
23.      */
24.     public String encode(String str) {
25.         if (str == null || str.isEmpty()) {
26.             return "";
27.         }
28.         // String 转 byte[]
29.         byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
30.         // 编码（base64字符串）
31.         return Base64.getEncoder().encodeToString(bytes);
32.     }
34.     /**
35.      * base64解码
36.      */
37.     public String decode(String base64Str) {
38.         if (base64Str == null || base64Str.isEmpty()) {
39.             return "";
40.         }
41.         // 编码
42.         byte[] base64Bytes = Base64.getDecoder().decode(base64Str);
43.         // byte[] 转 String（解码后的字符串）
44.         return new String(base64Bytes, StandardCharsets.UTF_8);
45.     }
47. }

复制代码

测试代码

测试Socket 服务端代码

1. public class SM4SocketServer {
3.     public static void main(String[] args) throws IOException {
4.         ServerSocket serverSocket = new ServerSocket(9999);
5.         System.out.println("Server started...");
7.         while (true) {
8.             try (Socket socket = serverSocket.accept()) {
9.                 System.out.println("Client connected...\n");
11.                 // 加密数据流
12.                 SocketStream socketStreamDecorator = new Base64SocketStreamDecorator(
13.                                                         new SM4CipherSocketStreamDecorator(
14.                                                           new SimpleSocketStream(socket)));
15.                 // 读取客户端请求并解密
16.                 String message = socketStreamDecorator.readData();
17.                 System.out.println("服务端读取数据: " + message);
19.                 // 处理请求并加密响应
20.                 String response = "我来自服务端！";
21.                 System.out.println("服务端发送数据: " + response);
22.                 socketStreamDecorator.writeData(response);
23.             } catch (Exception e) {
24.                 e.printStackTrace();
25.             }
26.         }
27.     }
28. }

复制代码

测试Socket 客户端代码

1. public class SM4SocketClient {
3.     public static void main(String[] args) throws IOException {
4.         // 连接到服务器
5.         try (Socket socket = new Socket("localhost", 9999)) {
6.             System.out.println("Connected to server...\n");
8.             // 读取服务器的响应并解密
9.             SocketStream socketStreamDecorator = new Base64SocketStreamDecorator(
10.                                                     new SM4CipherSocketStreamDecorator(
11.                                                       new SimpleSocketStream(socket)));
12.             // 要发送的消息
13.             String message = "我来自客户端！";
14.             System.out.println("客户端发送数据: " + message);
16.             // 使用加密流将消息发送到服务器
17.             socketStreamDecorator.writeData(message);
19.             // 读取客户端请求并解密
20.             String readData = socketStreamDecorator.readData();
21.             System.out.println("客户端读取数据: " + readData);
22.             socketStreamDecorator.close();
23.         } catch (IOException e) {
24.             e.printStackTrace();
25.         }
26.     }
27. }

复制代码

测试结果分析

先启动Socket服务，再发起Socket请求。
客户端输出结果

Connected to server...
客户端发送数据: 我来自客户端！
--base64编码后的数据：5oiR5p2l6Ieq5a6i5oi356uv77yB
--SM4加密数据：anTSZv18wcQOxQtA82w9ap2j8DjagsX9QqRVjzFCjWU=
--SM4解密前数据：5azwyKP7MB6jSyG3eDlJmfOYx5y+woud2WgE2Jjf5lA=
--base64解密前的数据：5oiR5p2l6Ieq5pyN5Yqh56uv77yB
客户端读取数据: 我来自服务端！

服务端输出结果

Server started...
Client connected...
--SM4解密前数据：anTSZv18wcQOxQtA82w9ap2j8DjagsX9QqRVjzFCjWU=
--base64解密前的数据：5oiR5p2l6Ieq5a6i5oi356uv77yB
服务端读取数据: 我来自客户端！
服务端发送数据: 我来自服务端！
--base64编码后的数据：5oiR5p2l6Ieq5pyN5Yqh56uv77yB
--SM4加密数据：5azwyKP7MB6jSyG3eDlJmfOYx5y+woud2WgE2Jjf5lA=

这行代码new的先后顺序决定代码执行的先后顺序：new Base64SocketStreamDecorator(new SM4CipherSocketStreamDecorator(new SimpleSocketStream(socket))); ，所以文中的案例测试执行顺序如下：
数据流方向

• 写入数据时：外层到内层逐步加工数据。
  
  
  
  • 数据先经过 Base64 编码，再经过 SM4 加密，最后写入 SimpleSocketStream。
    
  
  
• 读取数据时：内层到外层逐步还原数据。
  
  
  
  • 数据从 SimpleSocketStream 读取后，先解密（SM4），再解码（Base64）。
    
  
  

代码层面的调用顺序

• 构造阶段：
  
  
  
  • SimpleSocketStream(socket) → SM4CipherSocketStreamDecorator → Base64SocketStreamDecorator。
    
  
  
• 方法调用阶段（如 write(data) 或 read()）：
  
  
  
  • 调用 Base64SocketStreamDecorator.write(data)。
    
  • 该方法内部会调用 SM4CipherSocketStreamDecorator.write(data)。
    
  • 最终调用 SimpleSocketStream.write(data) 执行实际的数据写入。
    
  
  

调整组合顺序测试

如果哪天有需求要改为先执行SM4加密，再执行Base64编码，则代码只需要修改为new SM4CipherSocketStreamDecorator(new Base64SocketStreamDecorator(new SimpleSocketStream(socket)));
测试结果变为：
客户端输出结果

客户端发送数据: 我来自客户端！
--SM4加密数据：YoNCZhEm1shIjPWO5vyhsFRWq+XUdHPggFiE325GCKc=
--base64编码后的数据：WW9OQ1poRW0xc2hJalBXTzV2eWhzRlJXcStYVWRIUGdnRmlFMzI1R0NLYz0=
--base64解密前的数据：OUJTQ0ZLUVFIa2dxSGs0WTd2enB1RlJXcStYVWRIUGdnRmlFMzI1R0NLYz0=
--SM4解密前数据：9BSCFKQQHkgqHk4Y7vzpuFRWq+XUdHPggFiE325GCKc=
客户端读取数据: 我来自服务端！

服务端输出结果变为

--base64解密前的数据：WW9OQ1poRW0xc2hJalBXTzV2eWhzRlJXcStYVWRIUGdnRmlFMzI1R0NLYz0=
--SM4解密前数据：YoNCZhEm1shIjPWO5vyhsFRWq+XUdHPggFiE325GCKc=
服务端读取数据: 我来自客户端！
服务端发送数据: 我来自服务端！
--SM4加密数据：9BSCFKQQHkgqHk4Y7vzpuFRWq+XUdHPggFiE325GCKc=
--base64编码后的数据：OUJTQ0ZLUVFIa2dxSGs0WTd2enB1RlJXcStYVWRIUGdnRmlFMzI1R0NLYz0=

装饰模式的应用

Java标准库中的装饰模式之一：IO流体系
示例代码

1. BufferedReader bufferedReader = new BufferedReader(
2.                                           new InputStreamReader(
3.                                             new FileInputStream(
4.                                               new File("test.txt"))));

复制代码

逐步增强功能：IO流的增强组合有顺序要求

• 每一层包装器都增加了功能：
  
  
  
  • File：创建一个表示文件的对象 test.txt；
    
  • FileInputStream：从文件中读取字节；
    
  • InputStreamReader：将字节流转换为字符流；
    
  • BufferedReader：提供字符缓冲功能，支持高效读取和按行读取。
    
  
  

总结

装饰模式是一种灵活的结构型模式，允许我们在不修改现有类的情况下，动态地添加功能。它尤其适合于功能可以按需组合叠加、扩展的场景，但需要权衡复杂性与性能开销。

什么是设计模式？
单例模式及其思想
设计模式--原型模式及其编程思想
掌握设计模式之生成器模式
掌握设计模式之简单工厂模式
掌握设计模式之工厂方法模式
超实用的SpringAOP实战之日志记录
2023年下半年软考考试重磅消息
通过软考后却领取不到实体证书？
计算机算法设计与分析（第5版）
Java全栈学习路线、学习资源和面试题一条龙
软考证书=职称证书？
软考中级--软件设计师毫无保留的备考分享

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！