设计形式之权利链方式,职务链情势

2019-10-06 作者:yzc216.com官网   |   浏览(154)

职责链模式(Chain of Responsibility):使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到又一个对象处理它为止。

Chain Of Responsibility 职责链模式(行为型模式)

源文地址:

请求的发送者与接受者

适用场景

  1. 有多个对象可以处理同一个请求,具体哪个对象处理该请求由运行时刻自动确定
  2. 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求
  3. 可动态指定一组对象处理请求

某些对象请求的接受者可能有多种多样,变化无常……

优点

  1. 降低耦合度
  2. 可简化对象的相互连接
  3. 增强给对象指派职责的灵活性
  4. 增加新的请求处理类很方便

图片 1

缺点

  1. 不能保证请求一定被接收
  2. 系统性能将受到一定影响,而且在进行代码调试时不太方便;可能会造成循环调用

动机(Motivation)

UML结构图

图片 2Chain Of Responsibility Pattern

在软件构建过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个接受者,如果显示指定,将必不可少地带来请求发送者与接受者的紧耦合。

源码

定义一个处理请求的接口

public abstract class Handler { protected Handler successor; public void setSuccessor(Handler successor) { this.successor = successor; } public abstract void handlerRequest(int request);}

具体处理者类1当请求数在0到10之间则有权处理,否则转到下一位。

public class ConcreteHandler1 extends Handler { @Override public void handlerRequest(int request) { if (request >= 0 && request < 10) { System.out.println(getClass().getSimpleName()   " 处理请求 "   request); } else if (successor != null) { successor.handlerRequest; } }}

具体处理者者2当请求数在10到20之间则有权处理,否则转到下一位

public class ConcreteHandler2 extends Handler { @Override public void handlerRequest(int request) { if (request >= 10 && request < 20) { System.out.println(getClass().getSimpleName()   " 处理请求 "   request); } else if (successor != null) { successor.handlerRequest; } }}

具体处理者者3当请求数在20到30之间则有权处理,否则转到下一位

public class ConcreteHandler3 extends Handler { @Override public void handlerRequest(int request) { if (request >= 20 && request < 30) { System.out.println(getClass().getSimpleName()   " 处理请求 "   request); } else if (successor != null) { successor.handlerRequest; } }}

客户端调用职责链模式(Chain of Responsibility),使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

public class Client { public static void main(String[] args) { Handler handler1 = new ConcreteHandler1(); Handler handler2 = new ConcreteHandler2(); Handler handler3 = new ConcreteHandler3(); handler1.setSuccessor; handler2.setSuccessor; int[] requests = {2, 15, 25, 10, 20}; for (int request : requests) { handler1.handlerRequest; } }}

设计模式系列:

创建型 结构型 行为型
工厂方法简单工厂 抽象工厂建造者模式单例模式原型模式 组合模式 外观模式 桥接模式 代理模式 享元模式 适配器模式 装饰模式 策略模式 模板方法 状态模式 观察者模式 备忘录模式 迭代器模式 命令模式 职责链模式 解释器模式 访问者模式 中介者模式

如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求,从而使两者解耦。

意图(Intent)

使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止。——《设计模式》GoF

 

示例代码

    public abstract class BaseHandler
    {
        public abstract void HandleRequest(Request request);
        public abstract bool CanHandleRequest(Request request);
    }

    public class AHandler : BaseHandler
    {
        public override void HandleRequest(Request request)
        {
            //...
        }

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class BHandler : BaseHandler
    {
        public override void HandleRequest(Request request)
        {
            //...
        }

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class CHandler : BaseHandler
    {
        public override void HandleRequest(Request request)
        {
            //...
        }

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class Request
    {
        //...
    }

    public class Sender
    {
        public void Process()
        {
            Request request=new Request();
            //...
            List<BaseHandler> handlerList=new List<BaseHandler>();
            handlerList.Add(new AHandler());
            handlerList.Add(new BHandler());
            handlerList.Add(new CHandler());

            foreach (var handler in handlerList)
            {
                if (handler.CanHandleRequest(request))
                {
                    handler.HandleRequest(request);
                }
            }
        }
    }

如果我们不希望Sender中有这么多的Handler的调用,可以通过指责链模式修改:

    public abstract class BaseHandler
    {
        public BaseHandler(BaseHandler next)
        {
            this.Next = next;
        }

        public BaseHandler Next { get; set; }

        protected abstract bool CanHandleRequest(Request request);

        public virtual void HandleRequest(Request request)
        {
            if (this.Next != null)
            {
                this.Next.HandleRequest(request);
            }
        }
    }

    public class AHandler : BaseHandler
    {
        public AHandler(BaseHandler next)
            : base(next)
        {
        }

        public override void HandleRequest(Request request)
        {
            if (this.CanHandleRequest(request))
            {
                //...
            }
            else
            {
                base.HandleRequest(request);
            }
        }

        protected override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class BHandler : BaseHandler
    {
        public BHandler(BaseHandler next)
            : base(next)
        {
        }

        public override void HandleRequest(Request request)
        {
            //...
        }

        protected override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class CHandler : BaseHandler
    {
        public CHandler(BaseHandler next)
            : base(next)
        {
        }

        public override void HandleRequest(Request request)
        {
            //...
        }

        protected override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class Request
    {
        //...
    }

    public class Sender
    {
        public void Process(BaseHandler handler)
        {
            Request request = new Request();
            //...
            handler.HandleRequest(request);
        }
    }

客户端调用:

        static void Main(string[] args)
        {
            Sender sender=new Sender();

            BaseHandler handler1 = new AHandler(null);
            BaseHandler handler2 = new BHandler(handler1);
            BaseHandler handler3 = new CHandler(handler2);

            sender.Process(handler3);

            Console.ReadKey();
        }

 

结构(Structure)

图片 3

一个典型的对象结构可能如下图所示:

图片 4

 

Handler——定义一个处理请求的接口。(可选)实现后继链。
ConcreteHandler——处理它所负责的请求。可访问它的后继者。如果可处理该请求,就处理之;否则将该请求转发给它的后继者。
Client——向链上的具体处理者(ConcreteHandler)对象提交请求。

 

 

Chain Of Responsibility 模式的几个要点

 

  • Chain Of Responsibility 模式的应用场合在于“一个请求可能有多个接受者,但是最后真正的接受者只有一个”,只有这时候请求发送者与接受者的耦合才有可能出现“变化脆弱”的症状,职责链的目的就是将两者解耦,从而更好地应对变化。
  • 应用了Chain Of Responsibility 模式后,对象的职责分派将更具灵活性。我们可以在运行时动态添加、修改请求的处理职责。
  • 如果请求传递到职责链的末尾仍得不到处理,应该有一个处理的缺省机制。这也是每一个接受对象的责任,而不是发出请求的对象的责任。
  • 这种链传递的方式效率较低。

 

 

转载请注明出处:

作者:JesseLZJ
出处:http://jesselzj.cnblogs.com

本文由yzc216亚洲城发布于yzc216.com官网,转载请注明出处:设计形式之权利链方式,职务链情势

关键词: yzc216亚洲城 yzc216.com官网