说说设计模式~管道模式(pipeline)

回到目录
说明

复合的责任链，类似于管道模式，只要符合条件，说会向下传递，不会终止
算法说明

• 按最高优先级去使用，符合就用，不符合就走下一个策略
  
• 具体链条,有点像pipeline管道模式
  
  
  
  • BlackHandler ip=172.17.0.11
    
  • RateLimitHandler header=is-black
    
  • WriteBlackHandler header=real-black
    
  
  

继承抽象类

• AbstractHandler 抽象的责任处理者
  
  
  
  • 抽象方法action，需要各个子类【具体的责任处理者】自己去实现
    
  • final修饰的方法，封装了实现细节，子类不能重写
    
  • setNextHandler方法，设置下一个链条的【责任处理者】
    
  
  
• HandlerFactory 责任工厂
  
  
  
  • 通过一个责任处理列表，返回一个责任链条
    
  • 责任链条可以持久化到数据库里
    
  
  

责任链如果没有终止条件，就类似于pipeline管道了

graph  TDRequest[post body]-->A[BlackHandler]A --> B[RateLimitHandler]B --> C[WriteBlackHandler]C --> D[EndHandler]测试代码

抽象处理者

1. public abstract class AbstractHandler<T> {
3.         private AbstractHandler nextHandler;
5.         public final void setNextHandler(AbstractHandler nextHandler) {
6.                 this.nextHandler = nextHandler;
7.         }
9.         protected abstract void action(T body);
11.         // final表示不允许子类重写
12.         public final void handleRequest(T body) {
13.                 action(body);
15.                 if (this.nextHandler != null)
16.                         this.nextHandler.handleRequest(body);
17.         }
19. }

复制代码

具体处理者

1. public class BlackHandler extends AbstractHandler<Request> {
3.         private static final Logger logger = LoggerFactory.getLogger(CouponHandler.class);
5.         @Override
6.         public void action(Request body) {
7.                 logger.info("BlackHandler 处理");
8.         }
10. }
11. public class RateLimitHandler extends AbstractHandler<Request> {
13.         private static final Logger logger = LoggerFactory.getLogger(CouponHandler.class);
15.         @Override
16.         protected void action(Request body) {
17.                 logger.info("RateLimitHandler 处理");
19.         }
21. }
22. public class WriteBlackHandler extends AbstractHandler<Request> {
24.         private static final Logger logger = LoggerFactory.getLogger(CouponHandler.class);
26.         @Override
27.         protected void action(Request body) {
28.                 logger.info("WriteBlackHandler 处理");
30.         }
32. }
33. public class EndHandler extends AbstractHandler<Request> {
35.         private static final Logger logger = LoggerFactory.getLogger(CouponHandler.class);
37.         @Override
38.         protected void action(Request body) {
39.                 logger.info("EndHandler 处理");
41.         }
43. }

复制代码

处理者工厂和请求数据体

1. public class HandlerFactory {
3.         public static <T extends Request> AbstractHandler<T> createHandler(List> handlerModels) {
4.                 AbstractHandler<T> handler = null;
5.                 AbstractHandler<T> previousHandler = null;
7.                 for (AbstractHandler<T> currentHandler : handlerModels.stream().collect(Collectors.toList())) {
9.                         if (previousHandler != null) {
10.                                 previousHandler.setNextHandler(currentHandler);
11.                         }
12.                         else {
13.                                 handler = currentHandler;
14.                         }
15.                         previousHandler = currentHandler;
17.                 }
19.                 return handler;
20.         }
22. }
23. @AllArgsConstructor
24. @NoArgsConstructor
25. @Data
26. public class Request {
28.         private String ip;
30.         private String userId;
32. }

复制代码

测试用例

1. public static void main(String[] args) {
2.                 List> abstractHandlers = Arrays.asList(new RateLimitHandler(), new BlackHandler(),
3.                                 new WriteBlackHandler(),new EndHandler());
4.                 AbstractHandler<Request> abstractHandler = HandlerFactory.createHandler(abstractHandlers);
5.                 abstractHandler.handleRequest(new Request("1", "user1"));
6.         }

复制代码

如果希望将你的责任链处理存储到数据库中，那个在handleFactory里，就需要接口className了,例如下面的代码：

1. public static Handler handlerFactory() {
2.                 List<HandlerModel> handlerModels = new ArrayList<>();
3.                 handlerModels
4.                                 .add(new HandlerModel("CouponHandler", "com.lind.common.pattern.chinaorder.handler.CouponHandler", 1));
5.                 handlerModels.add(
6.                                 new HandlerModel("DiscountHandler", "com.lind.common.pattern.chinaorder.handler.DiscountHandler", 2));
7.                 handlerModels.add(
8.                                 new HandlerModel("BigGiftHandler", "com.lind.common.pattern.chinaorder.handler.BigGiftHandler", 3));
9.                 handlerModels.add(new HandlerModel("VipHandler", "com.lind.common.pattern.chinaorder.handler.VipHandler", 4));
10.                 return createHandler(handlerModels);
11.         }
13.         private static Handler createHandler(List<HandlerModel> handlerModels) {
14.                 Handler handler = null;
15.                 Handler previousHandler = null;
17.                 for (HandlerModel handlerModel : handlerModels.stream().sorted().collect(Collectors.toList())) {
18.                         try {
19.                                 Handler currentHandler = (Handler) Class.forName(handlerModel.getClassPath()).newInstance();
20.                                 if (previousHandler != null) {
21.                                         previousHandler.setNextHandler(currentHandler);
22.                                 }
23.                                 else {
24.                                         handler = currentHandler;
25.                                 }
26.                                 previousHandler = currentHandler;
27.                         }
28.                         catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
29.                                 throw new RuntimeException(e);
30.                         }
31.                 }
33.                 return handler;
34.         }

复制代码

回到目录

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