责任链模式 (Chain of Responsibility Pattern)

// 请假请求类
class LeaveRequest {
    private String employeeName;
    private int leaveDays;
    
    public LeaveRequest(String employeeName, int leaveDays) {
        this.employeeName = employeeName;
        this.leaveDays = leaveDays;
    }
    
    public String getEmployeeName() { return employeeName; }
    public int getLeaveDays() { return leaveDays; }
}

// 抽象处理者
abstract class Approver {
    protected Approver successor; // 后继者
    protected String name;
    
    public Approver(String name) {
        this.name = name;
    }
    
    // 设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }
    
    // 处理请求的抽象方法
    public abstract void processRequest(LeaveRequest request);
}

// 主管 - 可以批准1-3天的请假
class Director extends Approver {
    public Director(String name) {
        super(name);
    }
    
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 3) {
            System.out.println(name + " 批准了 " + request.getEmployeeName() + 
                              " 的 " + request.getLeaveDays() + " 天请假申请");
        } else if (successor != null) {
            // 转发给经理
            successor.processRequest(request);
        }
    }
}

// 经理 - 可以批准4-7天的请假
class Manager extends Approver {
    public Manager(String name) {
        super(name);
    }
    
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 7) {
            System.out.println(name + " 批准了 " + request.getEmployeeName() + 
                              " 的 " + request.getLeaveDays() + " 天请假申请");
        } else if (successor != null) {
            // 转发给总监
            successor.processRequest(request);
        }
    }
}

// 总监 - 可以批准8-14天的请假
class GeneralManager extends Approver {
    public GeneralManager(String name) {
        super(name);
    }
    
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 14) {
            System.out.println(name + " 批准了 " + request.getEmployeeName() + 
                              " 的 " + request.getLeaveDays() + " 天请假申请");
        } else {
            System.out.println("请假天数过长，拒绝申请！");
        }
    }
}

// 客户端代码
public class LeaveApprovalDemo {
    public static void main(String[] args) {
        // 创建处理者
        Approver director = new Director("张主管");
        Approver manager = new Manager("王经理");
        Approver generalManager = new GeneralManager("李总监");
        
        // 组建责任链
        director.setSuccessor(manager);
        manager.setSuccessor(generalManager);
        
        // 创建请假请求并发送
        LeaveRequest request1 = new LeaveRequest("小明", 2);
        LeaveRequest request2 = new LeaveRequest("小红", 5);
        LeaveRequest request3 = new LeaveRequest("小李", 10);
        LeaveRequest request4 = new LeaveRequest("小张", 20);
        
        // 处理请求
        director.processRequest(request1); // 张主管处理
        director.processRequest(request2); // 王经理处理
        director.processRequest(request3); // 李总监处理
        director.processRequest(request4); // 拒绝申请
    }
}
                                        

# 定义日志级别
class LogLevel:
    INFO = 1
    DEBUG = 2
    ERROR = 3

# 抽象日志处理者
class Logger:
    def __init__(self, level):
        self.level = level
        self.next_logger = None
    
    # 设置下一个处理者
    def set_next_logger(self, next_logger):
        self.next_logger = next_logger
        return next_logger  # 返回下一个处理者，便于链式调用
    
    # 处理日志请求
    def log_message(self, level, message):
        if self.level <= level:
            self.write(message)
        
        # 传递给下一个处理者
        if self.next_logger is not None:
            self.next_logger.log_message(level, message)
    
    # 由子类实现的写日志方法
    def write(self, message):
        pass

# 控制台日志处理者
class ConsoleLogger(Logger):
    def write(self, message):
        print(f"控制台日志: {message}")

# 文件日志处理者
class FileLogger(Logger):
    def write(self, message):
        print(f"文件日志: {message}")  # 实际应用中会写入文件

# 错误日志处理者
class ErrorLogger(Logger):
    def write(self, message):
        print(f"错误日志: {message}")  # 实际应用中可能会发送邮件或短信通知

# 客户端代码
def get_logger_chain():
    # 创建处理者
    console_logger = ConsoleLogger(LogLevel.INFO)    # 处理所有级别
    file_logger = FileLogger(LogLevel.DEBUG)         # 处理DEBUG及以上级别
    error_logger = ErrorLogger(LogLevel.ERROR)       # 只处理ERROR级别
    
    # 构建责任链
    console_logger.set_next_logger(file_logger).set_next_logger(error_logger)
    
    return console_logger

# 使用日志链
if __name__ == "__main__":
    logger_chain = get_logger_chain()
    
    # 记录不同级别的日志
    print("记录INFO级别日志:")
    logger_chain.log_message(LogLevel.INFO, "这是一条信息日志")
    
    print("\n记录DEBUG级别日志:")
    logger_chain.log_message(LogLevel.DEBUG, "这是一条调试日志")
    
    print("\n记录ERROR级别日志:")
    logger_chain.log_message(LogLevel.ERROR, "这是一条错误日志")