什么是责任链模式

项目有个请求，需要有对应的服务来处理，然后这个请求可能需要被很多个层级权限的服务来处理。我们将这些处理该请求的服务放在一条链上，链从前往后，是层级更高的服务，第一个服务处理不了，传递到链上的下一个服务，直到这个请求被处理成功。

责任链模式（Chain of Responsibility）是一种处理请求的模式，它让多个处理器都有机会处理该请求，直到其中某个处理器成功处理该请求，责任链模式把多个处理器串成链，然后让请求在链上传递。

1. 如何把多个处理器串成链，然后让请求在链上传递
   客户端发送请求，处理类去处理它的请求，所以有个处理方法（handleRequest），处理类要连接在一起，所以**处理类要有一个方法（成员变量nextHandler）**指向下一个处理类。
   我们抽象出一个公共的父类，然后去定义不同的处理类，这些处理类通过nextHandler连接起来。
2. 代码演示

package interview.pattern;

public class ChainRespPattern {
    Handler level1 = new Leader();
    Handler level2 = new Boss();
    level1.setNextHandler(level2);
    level1(10);
    level1(11);
    
}

abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nexthandler) {
        this.nextHandler = nexthandler;
    }

    public abstract void handleRequest(Integer info);
}

class Leader extends Handler {
    @Override
    public void handleRequest(Integer info) {
        if (info > 0 && info < 11)
            System.out.println("Leader处理！");
        else
            nextHandler.handleRequest(info);
    }
}

class Boss extends Handler {
    @Override
    public void handleRequest(Integer info) {
        System.out.println("Boss处理！");
    }
}

责任链模式总结

1. 优点
   • 责任链模式将请求和处理分开，请求者不需要谁去处理，处理者也不需要知道请求的全貌
   • 提高系统灵活性，新增一个处理器到系统中代价非常小
2. 缺点
   • 降低系统性能，某一个请求如果要到最高级别，需要一级一级的传递
   • 不易于调试，不知道请求在哪个处理器

责任链模式实现短信发送必填校验、数据校验、黑名单、超发等具体业务逻辑

import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 定义责任链节点接口
interface MessageHandler {
   MessageResult handleRequest(MessageRequest request);
}

// 必填校验处理器
class RequiredFieldValidationHandler implements MessageHandler {
   private MessageHandler nextHandler;

   public void setNextHandler(MessageHandler nextHandler) {
      this.nextHandler = nextHandler;
   }

   @Override
   public MessageResult handleRequest(MessageRequest request) {
      // 检查消息内容是否为空
      if (request.getMessageContent() == null || request.getMessageContent().isEmpty()) {
         return new MessageResult(false, "消息内容不能为空");
      } else if (nextHandler != null) {
         // 如果有下一个处理器，则传递请求
         return nextHandler.handleRequest(request);
      } else {
         return new MessageResult(true, "必填校验通过");
      }
   }
}

// 数据校验处理器
class DataValidationHandler implements MessageHandler {
   private MessageHandler nextHandler;

   public void setNextHandler(MessageHandler nextHandler) {
      this.nextHandler = nextHandler;
   }

   @Override
   public MessageResult handleRequest(MessageRequest request) {
      // 进行数据校验，这里只是示范，具体校验逻辑根据业务需求实现
      // 如果数据校验通过，则继续向下传递请求
      // 这里假设数据校验通过的条件为消息长度不超过50个字符
      if (request.getMessageContent().length() <= 50) {
         if (nextHandler != null) {
            return nextHandler.handleRequest(request);
         } else {
            return new MessageResult(true, "数据校验通过");
         }
      } else {
         return new MessageResult(false, "消息长度超过50个字符");
      }
   }
}

// 黑名单校验处理器
class BlacklistValidationHandler implements MessageHandler {
   private MessageHandler nextHandler;
   private Set<String> blacklist;

   public void setNextHandler(MessageHandler nextHandler) {
      this.nextHandler = nextHandler;
   }

   public void setBlacklist(Set<String> blacklist) {
      this.blacklist = blacklist;
   }

   @Override
   public MessageResult handleRequest(MessageRequest request) {
      // 检查消息内容是否在黑名单中
      if (blacklist.contains(request.getMessageContent())) {
         return new MessageResult(false, "消息内容在黑名单中");
      } else if (nextHandler != null) {
         // 如果不在黑名单中，并且有下一个处理器，则传递请求
         return nextHandler.handleRequest(request);
      } else {
         return new MessageResult(true, "黑名单校验通过");
      }
   }
}

// 超发校验处理器
class OverdraftValidationHandler implements MessageHandler {
   private MessageHandler nextHandler;
   private Map<String, Integer> messageCounts = new ConcurrentHashMap<>();
   private Lock lock = new ReentrantLock();

   public void setNextHandler(MessageHandler nextHandler) {
      this.nextHandler = nextHandler;
   }

   @Override
   public MessageResult handleRequest(MessageRequest request) {
      try {
         // 尝试获取分布式锁
         lock.lock();

         // 检查消息发送次数是否超过限制
         int count = messageCounts.getOrDefault(request.getMessageContent(), 0);
         if (count >= 10) { // 假设超过 10 次为超发
            return new MessageResult(false, "消息发送超过限制");
         }
         // 更新消息发送次数记录
         messageCounts.put(request.getMessageContent(), count + 1);

         // 如果不超发，并且有下一个处理器，则传递请求
         if (nextHandler != null) {
            return nextHandler.handleRequest(request);
         } else {
            return new MessageResult(true, "超发校验通过");
         }
      } finally {
         // 释放锁
         lock.unlock();
      }
   }
}

// 客户端代码
public class Client {
   public static void main(String[] args) {
      // 创建责任链节点
      RequiredFieldValidationHandler requiredFieldHandler = new RequiredFieldValidationHandler();
      DataValidationHandler dataHandler = new DataValidationHandler();
      BlacklistValidationHandler blacklistHandler = new BlacklistValidationHandler();
      OverdraftValidationHandler overdraftHandler = new OverdraftValidationHandler();

      // 设置责任链节点的顺序
      requiredFieldHandler.setNextHandler(dataHandler);
      dataHandler.setNextHandler(blacklistHandler);
      blacklistHandler.setNextHandler(overdraftHandler);

      // 初始化黑名单
      Set<String> blacklist = new HashSet<>();
      blacklist.add("spam");
      blacklist.add("virus");
      blacklistHandler.setBlacklist(blacklist);

      // 创建消息请求
      MessageRequest request = new MessageRequest("Important message");

      // 处理消息请求
      MessageResult result = requiredFieldHandler.handleRequest(request);
      System.out.println("处理结果: " + result.isSuccess() + ", " + result.getMessage());
   }
}