行为型-责任链模式

1. 项目结构

	chain-of-responsibility-demo/
	├── pom.xml
	└── src/
	    └── main/
	        ├── java/
	        │   └── com/
	        │       └── example/
	        │           └── chainofresponsibility/
	        │               ├── handler/
	        │               │   ├── ApprovalHandler.java
	        │               │   ├── DepartmentManager.java
	        │               │   ├── GeneralManager.java
	        │               │   ├── HandlerChain.java
	        │               │   └── ProjectManager.java
	        │               ├── model/
	        │               │   └── PurchaseRequest.java
	        │               └── Main.java
	        └── resources/

Maven 配置文件 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>chain-of-responsibility-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Chain of Responsibility Pattern Demo</name>
    <description>A demo project for Chain of Responsibility pattern</description>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 添加测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 代码实现

PurchaseRequest.java - 请求类

package com.example.chainofresponsibility.model;

/**
 * 采购请求类
 */
public class PurchaseRequest {
    private int id;
    private String description;
    private double amount;
    
    public PurchaseRequest(int id, String description, double amount) {
        this.id = id;
        this.description = description;
        this.amount = amount;
    }
    
    public int getId() {
        return id;
    }
    
    public String getDescription() {
        return description;
    }
    
    public double getAmount() {
        return amount;
    }
    
    @Override
    public String toString() {
        return String.format("采购申请[ID: %d, 描述: %s, 金额: %.2f]", 
            id, description, amount);
    }
}

ApprovalHandler.java - 抽象处理器

package com.example.chainofresponsibility.handler;

import com.example.chainofresponsibility.model.PurchaseRequest;

/**
 * 审批处理器抽象类
 */
public abstract class ApprovalHandler {
    protected ApprovalHandler nextHandler; // 下一个处理器
    
    // 设置下一个处理器
    public void setNextHandler(ApprovalHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    
    // 处理请求的方法
    public abstract void processRequest(PurchaseRequest request);
    
    // 模板方法：处理请求并传递给下一个处理器
    protected void process(PurchaseRequest request) {
        if (nextHandler != null) {
            nextHandler.processRequest(request);
        } else {
            System.out.println("请求处理完成，没有更多审批者");
        }
    }
}

ProjectManager.java - 项目经理处理器

package com.example.chainofresponsibility.handler;

import com.example.chainofresponsibility.model.PurchaseRequest;

/**
 * 项目经理审批处理器
 */
public class ProjectManager extends ApprovalHandler {
    private static final double MAX_AMOUNT = 1000.0;
    
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= MAX_AMOUNT) {
            System.out.printf("项目经理批准%s，金额：%.2f%n", 
                request.getDescription(), request.getAmount());
        } else {
            System.out.printf("项目经理无权审批%s，金额：%.2f，转交上级%n", 
                request.getDescription(), request.getAmount());
            process(request);
        }
    }
}

DepartmentManager.java - 部门经理处理器

package com.example.chainofresponsibility.handler;

import com.example.chainofresponsibility.model.PurchaseRequest;

/**
 * 部门经理审批处理器
 */
public class DepartmentManager extends ApprovalHandler {
    private static final double MAX_AMOUNT = 5000.0;
    
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= MAX_AMOUNT) {
            System.out.printf("部门经理批准%s，金额：%.2f%n", 
                request.getDescription(), request.getAmount());
        } else {
            System.out.printf("部门经理无权审批%s，金额：%.2f，转交上级%n", 
                request.getDescription(), request.getAmount());
            process(request);
        }
    }
}

GeneralManager.java - 总经理处理器

package com.example.chainofresponsibility.handler;

import com.example.chainofresponsibility.model.PurchaseRequest;

/**
 * 总经理审批处理器
 */
public class GeneralManager extends ApprovalHandler {
    private static final double MAX_AMOUNT = 10000.0;
    
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= MAX_AMOUNT) {
            System.out.printf("总经理批准%s，金额：%.2f%n", 
                request.getDescription(), request.getAmount());
        } else {
            System.out.printf("总经理无权审批%s，金额：%.2f，需要董事会审批%n", 
                request.getDescription(), request.getAmount());
            process(request);
        }
    }
}

HandlerChain.java - 责任链构建器

package com.example.chainofresponsibility.handler;

import java.util.Arrays;
import java.util.List;

/**
 * 责任链构建器
 */
public class HandlerChain {
    private ApprovalHandler chain;
    
    public HandlerChain() {
        buildChain();
    }
    
    private void buildChain() {
        // 创建处理器
        ProjectManager projectManager = new ProjectManager();
        DepartmentManager departmentManager = new DepartmentManager();
        GeneralManager generalManager = new GeneralManager();
        
        // 构建责任链
        projectManager.setNextHandler(departmentManager);
        departmentManager.setNextHandler(generalManager);
        
        // 设置责任链起点
        this.chain = projectManager;
    }
    
    // 处理请求
    public void processRequest(com.example.chainofresponsibility.model.PurchaseRequest request) {
        System.out.println("\n=== 开始处理" + request + " ===");
        if (chain != null) {
            chain.processRequest(request);
        }
    }
    
    // 动态构建责任链
    public static ApprovalHandler buildChain(ApprovalHandler... handlers) {
        if (handlers == null || handlers.length == 0) {
            return null;
        }
        
        for (int i = 0; i < handlers.length - 1; i++) {
            handlers[i].setNextHandler(handlers[i + 1]);
        }
        
        return handlers[0];
    }
}

Main.java - 主程序

package com.example.chainofresponsibility;

import com.example.chainofresponsibility.handler.*;
import com.example.chainofresponsibility.model.PurchaseRequest;

/**
 * 主程序 - 演示责任链模式
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("===== 责任链模式演示 =====");
        
        // 方法1: 使用责任链构建器
        System.out.println("\n--- 方法1: 使用责任链构建器 ---");
        HandlerChain chain = new HandlerChain();
        
        // 创建采购请求
        PurchaseRequest request1 = new PurchaseRequest(1, "购买办公用品", 800);
        PurchaseRequest request2 = new PurchaseRequest(2, "购买服务器", 4500);
        PurchaseRequest request3 = new PurchaseRequest(3, "公司团建活动", 8500);
        PurchaseRequest request4 = new PurchaseRequest(4, "购买新办公楼", 20000);
        
        // 处理请求
        chain.processRequest(request1);
        chain.processRequest(request2);
        chain.processRequest(request3);
        chain.processRequest(request4);
        
        // 方法2: 动态构建责任链
        System.out.println("\n--- 方法2: 动态构建责任链 ---");
        
        // 创建处理器
        ApprovalHandler projectManager = new ProjectManager();
        ApprovalHandler departmentManager = new DepartmentManager();
        ApprovalHandler generalManager = new GeneralManager();
        
        // 动态构建责任链
        ApprovalHandler dynamicChain = HandlerChain.buildChain(
            projectManager, departmentManager, generalManager
        );
        
        // 处理请求
        System.out.println("\n处理新的采购请求：");
        PurchaseRequest request5 = new PurchaseRequest(5, "购买开发软件", 3000);
        System.out.println("=== 开始处理" + request5 + " ===");
        if (dynamicChain != null) {
            dynamicChain.processRequest(request5);
        }
        
        // 演示部分责任链
        System.out.println("\n--- 方法3: 部分责任链（只有项目经理和总经理） ---");
        ApprovalHandler partialChain = HandlerChain.buildChain(
            new ProjectManager(), new GeneralManager()
        );
        
        PurchaseRequest request6 = new PurchaseRequest(6, "部门聚餐", 2500);
        System.out.println("=== 开始处理" + request6 + " ===");
        if (partialChain != null) {
            partialChain.processRequest(request6);
        }
    }
}

3. 构建和运行

1. 编译项目

   mvn clean compile

2. 运行项目

   # 方法1: 使用 Maven 运行
   mvn exec:java -Dexec.mainClass="com.example.chainofresponsibility.Main"
   
   # 方法2: 编译后直接运行
   mvn clean package
   java -cp target/chain-of-responsibility-demo-1.0-SNAPSHOT.jar com.example.chainofresponsibility.Main

4. 核心概念

• 模式结构：

  • 抽象处理器（ApprovalHandler）
  • 具体处理器（ProjectManager、DepartmentManager、GeneralManager）
  • 客户端（Main）
  • 请求类（PurchaseRequest）

• 优点：

  • 降低耦合度：请求发送者和接收者解耦
  • 灵活性：可以动态改变处理链
  • 符合开闭原则：可以方便地添加新的处理器

• 适用场景：

  • 多个对象可以处理同一请求，但具体由哪个对象处理在运行时决定
  • 需要在不明确指定接收者的情况下，向多个对象中的一个提交请求
  • 可动态指定一组对象处理请求