设计模式之职责链模式

职责链模式简介及UML

职责链也叫责任链，它为请求创建了一个接收请求者对象的链，并且沿着这条链传递请求，直到有对象处理为止。职责链模式将请求的发送者或接收者剥离开来。

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

范例

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

处理者抽象类

internal abstract class ToleranceHandler
{
    protected ToleranceHandler handler;

    public void SetToleranceHandler(ToleranceHandler handler)
    {
        this.handler = handler;
    }

    public abstract Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request);
}

服务中心处理

internal class ConsulHandler : ToleranceHandler
{
    public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
    {
        if (request == 2)
        {
            var result = await this.GetRegisterServiceDictionary();
            return result == null ? await this.handler.HandlerRequestAsync(1) : result;
        }
        else
        {
            return  await this.handler.HandlerRequestAsync(request);
        }
    }
}

文件处理

internal class FileHandler:ToleranceHandler
{
    private static readonly string fileName = "SubscribeService.json";

    public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
    {
        if (request == 0)
        {
            StreamReader sr = File.OpenText(fileName);
            string result = await sr.ReadToEndAsync();

            return result.FromJson<Dictionary<string, List<Service>>>();
        }
        else
        {
            return await this.handler.HandlerRequestAsync(request);
        }
    }
}

内存处理

internal class InMemoryHandler : ToleranceHandler
{
    public override async Task<Dictionary<string, List<Service>>> HandlerRequestAsync(int request)
    {
        if (request == 1)
        {
            IMemoryCache memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));

            var result = memoryCache.Get<Dictionary<string, List<Service>>>("ServiceRegisterDiscovery:List");

            return result == null ? await this.handler.HandlerRequestAsync(0) : result;
        }

        return await this.handler.HandlerRequestAsync(request);
    }
}

客户端调用

public async Task<List<Service>> GetService(string serviceName)
{
    ToleranceHandler consulHandler = new ConsulHandler();    
    ToleranceHandler fileHandler = new FileHandler();
    ToleranceHandler inMemoryHandler = new InMemoryHandler();

    consulHandler.SetToleranceHandler(fileHandler);
    fileHandler.SetToleranceHandler(inMemoryHandler);

    Dictionary<string, List<Service>> serviceDic = await consulHandler.HandlerRequestAsync(2);

    return serviceDic[serviceName];
}

优缺点

优点：

1、降低了请求的发送者和接收者的耦合度，使得发送者和接收者关于自有功能的定制更加简单，即便是新增新的请求处理类也是如此。
2、简化了对象，对象的功能更加单一，而且对象也无需知道链的结构。
3、由于链内的对象是职责明确，并且彼此之间没有耦合，这也就提供了一种可能，一种动态新增或者删除的去控制职责链组成的可能，可以通过配置方式实现

缺点

1、可能会导致类文件过多，也在一定程度上对系统的性能造成不利影响
2、如果编写不注意，极有可能导致循环调用