设计模式之职责链模式

 

职责链模式简介及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、如果编写不注意，极有可能导致循环调用