职责链也叫责任链，它为请求创建了一个接收请求者对象的链，并将请求沿着这条链传递到目标对象去处理。

该模式最简单的实现方式就是运用里氏替换原则，对每个职责所持有的对象进行抽象，并使得每个职责对象都拥有共同的父类，通过对外提供出具有一般意义的接口。

该范例，是我在对微服务中，服务发现的容错性进行处理的一种处理方案，考虑到服务发现过程中，如果注册中心宕机，那么可以使用本地文件存放的临时性信息，如果本地文件不存在，那么就直接用内容中存放的信息。在整个流程中，我从注册中心获取服务信息，然后写入到文件中，最终存放到内存。

处理者抽象类

  1. internal abstract class ToleranceHandler
  2. {
  3.     protected ToleranceHandler handler;
  5.     public void SetToleranceHandler(ToleranceHandler handler)
  6.     {
  7.         this.handler = handler;
  8.     }
  10.     public abstract Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request);
  11. }

服务中心处理

  1. internal class ConsulHandler : ToleranceHandler
  2. {
  3.     public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
  4.     {
  5.         if (request == 2)
  6.         {
  7.             var result = await this.GetRegisterServiceDictionary();
  8.             return result == null ? await this.handler.HandlerRequestAsync(1) : result;
  9.         }
  10.         else
  11.         {
  12.             return  await this.handler.HandlerRequestAsync(request);
  13.         }
  14.     }
  15. }

文件处理

  1. internal class FileHandler:ToleranceHandler
  2. {
  3.     private static readonly string fileName = "SubscribeService.json";
  5.     public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
  6.     {
  7.         if (request == 0)
  8.         {
  9.             StreamReader sr = File.OpenText(fileName);
  10.             string result = await sr.ReadToEndAsync();
  12.             return result.FromJson<Dictionary<string, List<Service>>>();
  13.         }
  14.         else
  15.         {
  16.             return await this.handler.HandlerRequestAsync(request);
  17.         }
  18.     }
  19. }

内存处理

  1. internal class InMemoryHandler : ToleranceHandler
  2. {
  3.     public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
  4.     {
  5.         if (request == 1)
  6.         {
  7.             IMemoryCache memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
  9.             var result = memoryCache.Get<Dictionary<string, List<Service>>>("ServiceRegisterDiscovery:List");
  11.             return result == null ? await this.handler.HandlerRequestAsync(0) : result;
  12.         }
  14.         return await this.handler.HandlerRequestAsync(request);
  15.     }
  16. }

客户端调用

  1. public async Task<List<Service>> GetService(string serviceName)
  2. {
  3.     ToleranceHandler consulHandler = new ConsulHandler();    
  4.     ToleranceHandler fileHandler = new FileHandler();
  5.     ToleranceHandler inMemoryHandler = new InMemoryHandler();
  7.     consulHandler.SetToleranceHandler(fileHandler);
  8.     fileHandler.SetToleranceHandler(inMemoryHandler);
  10.     Dictionary<string, List<Service>> serviceDic = await consulHandler.HandlerRequestAsync(2);
  12.     return serviceDic[serviceName];
  13. }

优点：

1、职责链模式将请求的发送者与接收者剥离开来，实现了双方的解耦，而解耦后的最佳效果就是，双方关于自有功能的定制更加简单，修改产生的影响也大大减轻。
2、发送方调用时，无需知道链的结构，只需要设置好链路结构即可。
3、可以利用链路的组合特性，实现职责链组合的配置化，当然需要额外编写控制代码

缺点

1、可能会导致类文件过多，当然也有人说职责链会在一定程度上对系统的性能造成不利影响，不过这条我认为可以忽略，因为从系统维护的角度来说，这点牺牲是允许的。
2、如果编写不注意，极有可能导致循环调用

版权声明：本文为edison0621原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/edison0621/p/10546060.html