feat: 责任链模式-未完成。。。

README/设计模式-v2.md

@@ -479,7 +479,190 @@ public class CameraDemo {
 
 **Client**：客户端，负责创建并配置命令对象，将命令与接收者绑定，并传递给调用者执行。
 
+### 简单示例
 
+![image-20250201205350467](./images/设计模式-v2/image-20250201205350467.png)
+
+#### 示例代码
+
+```java
+public class CommandDemo {
+    public static void main(String[] args) {
+        Receiver receiver = new Receiver();
+
+        ConcreteCommand concreteCommand = new ConcreteCommand(receiver);
+
+        Invoker invoker = new Invoker();
+        invoker.setCommand(concreteCommand);
+        invoker.invoke();
+    }
+
+    // 命令接口
+    interface Command {
+
+        /**
+         * 执行方法
+         */
+        void execute();
+    }
+
+    //  接受者
+    static class Receiver {
+        public void action() {
+            System.out.println("接受者 执行。。。");
+        }
+    }
+
+    // 具体的执行命令
+    static class ConcreteCommand implements Command {
+
+        private final Receiver receiver;
+
+        public ConcreteCommand(Receiver receiver) {
+            this.receiver = receiver;
+        }
+
+        /**
+         * 执行方法
+         */
+        @Override
+        public void execute() {
+            receiver.action();
+        }
+    }
+
+    @Setter
+    static class Invoker {
+        private Command command;
+
+        public void invoke() {
+            command.execute();
+        }
+    }
+}
+```
+
+#### 执行结果：
+
+```java
+接受者 执行。。。
+```
+
+### 示例-烧烤店
+
+![image-20250201205232542](./images/设计模式-v2/image-20250201205232542.png)
+
+
+
+#### 示例代码
+
+```java
+public class BakeDemo {
+
+    // 充当客户端
+    public static void main(String[] args) {
+        Waiter waiter = new Waiter();
+        Barbecue barbecue = new Barbecue();
+
+        waiter.addCommand(new BakeChickenWing(barbecue));
+        waiter.addCommand(new BakeMutton(barbecue));
+
+        waiter.notifyCommand();
+    }
+
+    // 接受者-厨师
+    static class Barbecue {
+
+        /**
+         * 烤串
+         */
+        public void bakeMutton() {
+            System.out.println("开始烤串。。。");
+        }
+
+        /**
+         * 烤鸡翅
+         */
+        public void bakeChickenWing() {
+            System.out.println("开始烤鸡翅。。。");
+        }
+    }
+
+    // 请求者-invoker-服务员
+    public static class Waiter {
+        private final List<Command> commandList = new ArrayList<>();
+
+        public void addCommand(Command command) {
+            commandList.add(command);
+        }
+
+        /**
+         * 通知厨师开始制作
+         */
+        public void notifyCommand() {
+            for (Command command : commandList) {
+                command.execute();
+            }
+        }
+    }
+
+    public static abstract class Command {
+        protected Barbecue barbecue;
+
+        public Command(Barbecue barbecue) {
+            this.barbecue = barbecue;
+        }
+
+        /**
+         * 执行方法
+         */
+        public abstract void execute();
+    }
+
+    // 命令-烤鸡翅
+    public static class BakeChickenWing extends Command {
+
+        public BakeChickenWing(Barbecue barbecue) {
+            super(barbecue);
+        }
+
+        /**
+         * 执行方法
+         */
+        @Override
+        public void execute() {
+            barbecue.bakeChickenWing();
+        }
+    }
+
+    // 命令-烤串
+    public static class BakeMutton extends Command {
+
+        public BakeMutton(Barbecue barbecue) {
+            super(barbecue);
+        }
+
+        /**
+         * 执行方法
+         */
+        @Override
+        public void execute() {
+            barbecue.bakeMutton();
+        }
+    }
+}
+```
+
+#### 执行结果：
+
+```java
+开始烤鸡翅。。。
+开始烤串。。。
+```
+
+---
+
+## 工厂模式
 
 ---
 
@@ -536,11 +719,6 @@ public class Singleton {
 - 在低并发环境或单线程环境下，懒汉模式使用较为简单，不会有多线程安全问题。
 - 对于高并发且需要频繁访问单例的场景，推荐使用**静态内部类**或**饿汉模式**来避免懒汉模式可能带来的性能问题。
 
-#### 总结
-
-懒汉模式有时为了延迟初始化而牺牲了性能，特别是在多线程环境下。为了保证线程安全，可以采用双重检查锁定（DCL）或静态内部类的方式，而**静态内部类方式是最推荐的方式**
-，它避免了同步开销，同时也能确保线程安全。
-
 - **优点**：
   1. 延迟加载，节省资源。
   2. 内存优化，只有在需要时才实例化。
@@ -579,8 +757,6 @@ public class Singleton {
 - **实例化不耗费太多资源**：如果单例对象的初始化过程非常轻量级且无须延迟初始化，可以使用饿汉模式。
 - **类加载顺序固定**：如果不在乎单例对象在启动时是否初始化，且单例对象的初始化过程没有严重性能损失，可以选择饿汉模式。
 
-#### 总结
-
 - **优点**：简单、线程安全、性能高（没有锁机制）、实现方便。
 - **缺点**：不支持延迟加载、可能会浪费资源（如果单例对象不常用时）。
 
@@ -775,7 +951,7 @@ public class CommandDemo {
 }
 ```
 
-#### 运行结果
+#### 运行结果：
 
 ```java
 CommandDemo.Computer(CPU=Low CPU, RAM=Low RAM, hardDrive=Low Driver)
@@ -785,3 +961,89 @@ CommandDemo.Computer(CPU=Low CPU, RAM=Low RAM, hardDrive=Low Driver)
 CommandDemo.Computer(CPU=High CPU, RAM=High RAM, hardDrive=High Driver)
 ```
 
+## 责任链模式-未完成。。。
+
+主要有两个角色：抽象处理者（Handler）、具体处理者（ConcreteHandler）
+
+![image-20250202201204954](./images/设计模式-v2/image-20250202201204954.png)
+
+### 简单示例
+
+#### 代码示例
+
+```java
+public class Chain {
+
+    // 过滤垃圾请求，为了演示需要清除【垃圾，辣鸡，腊鸡】这些词
+    public static void main(String[] args) {
+        Handler handlerA = new ConcreteHandlerA();
+        Handler handlerB = new ConcreteHandlerB();
+        Handler handlerC = new ConcreteHandlerC();
+
+        // 设置责任链
+        handlerA.setNextHandler(handlerB);
+        handlerB.setNextHandler(handlerC);
+
+        // 发起请求
+        handlerA.handleRequest("过滤垃圾请求，为了演示需要清除【垃圾，辣鸡，腊鸡】这些词");
+    }
+
+    // ConcreteHandler类
+    static class ConcreteHandlerA extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"垃圾"
+            String updatedRequest = request.replaceAll("垃圾", "");
+            System.out.println("Handler A处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    static class ConcreteHandlerB extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"辣鸡"
+            String updatedRequest = request.replaceAll("辣鸡", "");
+            System.out.println("Handler B处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    static class ConcreteHandlerC extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"腊鸡"
+            String updatedRequest = request.replaceAll("腊鸡", "");
+            System.out.println("Handler C处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    // Handler类
+    @Setter
+    abstract static class Handler {
+        protected Handler nextHandler;
+
+        public abstract void handleRequest(String request);
+    }
+}
+```
+
+#### 运行结果：
+
+```java
+Handler A处理后: 过滤请求，为了演示需要清除【，辣鸡，腊鸡】这些词
+Handler B处理后: 过滤请求，为了演示需要清除【，，腊鸡】这些词
+Handler C处理后: 过滤请求，为了演示需要清除【，，】这些词
+```
+
+### 

pattern/src/main/java/cn/bunny/pattern5/demo3/CommandDemo.java

@@ -1,146 +1,58 @@
 package cn.bunny.pattern5.demo3;
 
-import lombok.Data;
+import lombok.Setter;
 
 public class CommandDemo {
     public static void main(String[] args) {
-        ConcreteLowComputerBuilder concreteLowComputerBuilder = new ConcreteLowComputerBuilder();
+        Receiver receiver = new Receiver();
-        Director director = new Director(concreteLowComputerBuilder);
-        director.constructComputer();
-        System.out.println(concreteLowComputerBuilder.getComputer());
 
-        System.out.println("\n-----------------分割线-----------------\n");
+        ConcreteCommand concreteCommand = new ConcreteCommand(receiver);
-        
+
-        ConcreteHighComputerBuilder concreteHighComputerBuilder = new ConcreteHighComputerBuilder();
+        Invoker invoker = new Invoker();
-        director = new Director(concreteHighComputerBuilder);
+        invoker.setCommand(concreteCommand);
-        director.constructComputer();
+        invoker.invoke();
-        System.out.println(concreteHighComputerBuilder.getComputer());
     }
 
-    // 构建产品接口
+    // 命令接口
-    interface ComputerBuilder {
+    interface Command {
 
         /**
-         * 构建 CPU 方法
+         * 执行方法
          */
-        void buildCPU();
+        void execute();
-
-        /**
-         * 构建 RAM 方法
-         */
-        void buildRAM();
-
-        /**
-         * 构建 磁盘 方法
-         */
-        void buildHardDrive();
-
-        /**
-         * 返回产品
-         *
-         * @return Computer
-         */
-        Computer getComputer();
     }
 
-    // 产品类
+    //  接受者
-    @Data
+    static class Receiver {
-    static class Computer {
+        public void action() {
-        private String CPU;
+            System.out.println("接受者 执行。。。");
-        private String RAM;
-        private String hardDrive;
-    }
-
-    // 构建低端产品
-    static class ConcreteLowComputerBuilder implements ComputerBuilder {
-        private final Computer computer = new Computer();
-
-        /**
-         * 构建 CPU 方法
-         */
-        @Override
-        public void buildCPU() {
-            computer.setCPU("Low CPU");
-        }
-
-        /**
-         * 构建 RAM 方法
-         */
-        @Override
-        public void buildRAM() {
-            computer.setRAM("Low RAM");
-        }
-
-        /**
-         * 构建 磁盘 方法
-         */
-        @Override
-        public void buildHardDrive() {
-            computer.setHardDrive("Low Driver");
-        }
-
-        /**
-         * 返回产品
-         *
-         * @return Computer
-         */
-        @Override
-        public Computer getComputer() {
-            return computer;
         }
     }
 
-    // 构建高端产品
+    // 具体的执行命令
-    static class ConcreteHighComputerBuilder implements ComputerBuilder {
+    static class ConcreteCommand implements Command {
-        private final Computer computer = new Computer();
 
-        /**
+        private final Receiver receiver;
-         * 构建 CPU 方法
+
-         */
+        public ConcreteCommand(Receiver receiver) {
-        @Override
+            this.receiver = receiver;
-        public void buildCPU() {
-            computer.setCPU("High CPU");
         }
 
         /**
-         * 构建 RAM 方法
+         * 执行方法
          */
         @Override
-        public void buildRAM() {
+        public void execute() {
-            computer.setRAM("High RAM");
+            receiver.action();
-        }
-
-        /**
-         * 构建 磁盘 方法
-         */
-        @Override
-        public void buildHardDrive() {
-            computer.setHardDrive("High Driver");
-        }
-
-        /**
-         * 返回产品
-         *
-         * @return Computer
-         */
-        @Override
-        public Computer getComputer() {
-            return computer;
         }
     }
 
-    // 构建者
+    @Setter
-    public static class Director {
+    static class Invoker {
-        private final ComputerBuilder builder;
+        private Command command;
 
-        public Director(ComputerBuilder builder) {
+        public void invoke() {
-            this.builder = builder;
+            command.execute();
-        }
-
-        public void constructComputer() {
-            builder.buildCPU();
-            builder.buildRAM();
-            builder.buildHardDrive();
         }
     }
 }

pattern/src/main/java/cn/bunny/pattern5/demo4/BakeDemo.java

@@ -0,0 +1,99 @@
+package cn.bunny.pattern5.demo4;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BakeDemo {
+
+    // 充当客户端
+    public static void main(String[] args) {
+        Waiter waiter = new Waiter();
+        Barbecue barbecue = new Barbecue();
+
+        waiter.addCommand(new BakeChickenWing(barbecue));
+        waiter.addCommand(new BakeMutton(barbecue));
+
+        waiter.notifyCommand();
+    }
+
+    // 接受者-厨师
+    static class Barbecue {
+
+        /**
+         * 烤串
+         */
+        public void bakeMutton() {
+            System.out.println("开始烤串。。。");
+        }
+
+        /**
+         * 烤鸡翅
+         */
+        public void bakeChickenWing() {
+            System.out.println("开始烤鸡翅。。。");
+        }
+    }
+
+    // 请求者-invoker-服务员
+    public static class Waiter {
+        private final List<Command> commandList = new ArrayList<>();
+
+        public void addCommand(Command command) {
+            commandList.add(command);
+        }
+
+        /**
+         * 通知厨师开始制作
+         */
+        public void notifyCommand() {
+            for (Command command : commandList) {
+                command.execute();
+            }
+        }
+    }
+
+    public static abstract class Command {
+        protected Barbecue barbecue;
+
+        public Command(Barbecue barbecue) {
+            this.barbecue = barbecue;
+        }
+
+        /**
+         * 执行方法
+         */
+        public abstract void execute();
+    }
+
+    // 命令-烤鸡翅
+    public static class BakeChickenWing extends Command {
+
+        public BakeChickenWing(Barbecue barbecue) {
+            super(barbecue);
+        }
+
+        /**
+         * 执行方法
+         */
+        @Override
+        public void execute() {
+            barbecue.bakeChickenWing();
+        }
+    }
+
+    // 命令-烤串
+    public static class BakeMutton extends Command {
+
+        public BakeMutton(Barbecue barbecue) {
+            super(barbecue);
+        }
+
+        /**
+         * 执行方法
+         */
+        @Override
+        public void execute() {
+            barbecue.bakeMutton();
+        }
+    }
+}

pattern/src/main/java/cn/bunny/pattern6/BuilderDemo.java

@@ -0,0 +1,146 @@
+package cn.bunny.pattern6;
+
+import lombok.Data;
+
+public class BuilderDemo {
+    public static void main(String[] args) {
+        ConcreteLowComputerBuilder concreteLowComputerBuilder = new ConcreteLowComputerBuilder();
+        Director director = new Director(concreteLowComputerBuilder);
+        director.constructComputer();
+        System.out.println(concreteLowComputerBuilder.getComputer());
+
+        System.out.println("\n-----------------分割线-----------------\n");
+
+        ConcreteHighComputerBuilder concreteHighComputerBuilder = new ConcreteHighComputerBuilder();
+        director = new Director(concreteHighComputerBuilder);
+        director.constructComputer();
+        System.out.println(concreteHighComputerBuilder.getComputer());
+    }
+
+    // 构建产品接口
+    interface ComputerBuilder {
+
+        /**
+         * 构建 CPU 方法
+         */
+        void buildCPU();
+
+        /**
+         * 构建 RAM 方法
+         */
+        void buildRAM();
+
+        /**
+         * 构建 磁盘 方法
+         */
+        void buildHardDrive();
+
+        /**
+         * 返回产品
+         *
+         * @return Computer
+         */
+        Computer getComputer();
+    }
+
+    // 产品类
+    @Data
+    static class Computer {
+        private String CPU;
+        private String RAM;
+        private String hardDrive;
+    }
+
+    // 构建低端产品
+    static class ConcreteLowComputerBuilder implements ComputerBuilder {
+        private final Computer computer = new Computer();
+
+        /**
+         * 构建 CPU 方法
+         */
+        @Override
+        public void buildCPU() {
+            computer.setCPU("Low CPU");
+        }
+
+        /**
+         * 构建 RAM 方法
+         */
+        @Override
+        public void buildRAM() {
+            computer.setRAM("Low RAM");
+        }
+
+        /**
+         * 构建 磁盘 方法
+         */
+        @Override
+        public void buildHardDrive() {
+            computer.setHardDrive("Low Driver");
+        }
+
+        /**
+         * 返回产品
+         *
+         * @return Computer
+         */
+        @Override
+        public Computer getComputer() {
+            return computer;
+        }
+    }
+
+    // 构建高端产品
+    static class ConcreteHighComputerBuilder implements ComputerBuilder {
+        private final Computer computer = new Computer();
+
+        /**
+         * 构建 CPU 方法
+         */
+        @Override
+        public void buildCPU() {
+            computer.setCPU("High CPU");
+        }
+
+        /**
+         * 构建 RAM 方法
+         */
+        @Override
+        public void buildRAM() {
+            computer.setRAM("High RAM");
+        }
+
+        /**
+         * 构建 磁盘 方法
+         */
+        @Override
+        public void buildHardDrive() {
+            computer.setHardDrive("High Driver");
+        }
+
+        /**
+         * 返回产品
+         *
+         * @return Computer
+         */
+        @Override
+        public Computer getComputer() {
+            return computer;
+        }
+    }
+
+    // 构建者
+    public static class Director {
+        private final ComputerBuilder builder;
+
+        public Director(ComputerBuilder builder) {
+            this.builder = builder;
+        }
+
+        public void constructComputer() {
+            builder.buildCPU();
+            builder.buildRAM();
+            builder.buildHardDrive();
+        }
+    }
+}

pattern/src/main/java/cn/bunny/pattern7/demo1/Chain.java

@@ -0,0 +1,69 @@
+package cn.bunny.pattern7.demo1;
+
+import lombok.Setter;
+
+public class Chain {
+
+    // 过滤垃圾请求，为了演示需要清除【垃圾，辣鸡，腊鸡】这些词
+    public static void main(String[] args) {
+        Handler handlerA = new ConcreteHandlerA();
+        Handler handlerB = new ConcreteHandlerB();
+        Handler handlerC = new ConcreteHandlerC();
+
+        // 设置责任链
+        handlerA.setNextHandler(handlerB);
+        handlerB.setNextHandler(handlerC);
+
+        // 发起请求
+        handlerA.handleRequest("过滤垃圾请求，为了演示需要清除【垃圾，辣鸡，腊鸡】这些词");
+    }
+
+    // ConcreteHandler类
+    static class ConcreteHandlerA extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"垃圾"
+            String updatedRequest = request.replaceAll("垃圾", "");
+            System.out.println("Handler A处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    static class ConcreteHandlerB extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"辣鸡"
+            String updatedRequest = request.replaceAll("辣鸡", "");
+            System.out.println("Handler B处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    static class ConcreteHandlerC extends Handler {
+        @Override
+        public void handleRequest(String request) {
+            // 处理"腊鸡"
+            String updatedRequest = request.replaceAll("腊鸡", "");
+            System.out.println("Handler C处理后: " + updatedRequest);
+
+            if (nextHandler != null) {
+                nextHandler.handleRequest(updatedRequest);  // 传递修改后的请求
+            }
+        }
+    }
+
+    // Handler类
+    @Setter
+    abstract static class Handler {
+        protected Handler nextHandler;
+
+        public abstract void handleRequest(String request);
+    }
+}
+