设计模式学习笔记——责任链(Chain of Responsibility)模式

你的名字 2022-06-17 01:53 131阅读 0赞

# 设计模式学习笔记——责任链(Chain of Responsibility)模式 #

@(设计模式)\[设计模式, 责任链模式, chain of responsibility\]

*  设计模式学习笔记责任链Chain of Responsibility模式
    
     *  基本介绍
     *  责任链案例
        
         *  类图
         *  实现代码
            
             *  Trouble类
             *  Support抽象类
             *  NoSupport类
             *  LimitSupport类
             *  OddSupport类
             *  SpecialSupport类
             *  测试类
             *  运行结果
     *  责任链模式中的角色
        
         *  Handler处理者
         *  ConcreteHandler具体的处理者
         *  Client请求者
         *  类图

## 基本介绍 ##

责任链模式的意图在于将问题的产生和处理进行解耦合。通过链式的处理方式，使在责任链上的所有处理对象都能处理其能处理的问题。不能处理的问题则传递给下一个处理对象，直到问题被处理或责任链走完。

## 责任链案例 ##

### 类图 ###

![责任链案例类图][SouthEast]

### 实现代码 ###

#### Trouble类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 问题类 * Created by Switch on 2017/3/30. */
    public class Trouble { 
        /** * 问题编号 */
        private int number;
    
        /** * 构造方法，设置问题编号 * * @param number 问题标号 */
        public Trouble(int number) {
            this.number = number;
        }
    
        /** * 获取问题编号 * * @return 问题编号 */
        public int getNumber() {
            return number;
        }
    
        @Override
        public String toString() {
            return "Trouble{ number=" + number + "}";
        }
    }

#### Support抽象类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 支持抽象类 * Created by Switch on 2017/3/30. */
    public abstract class Support { 
        /** * 解决问题的实例名 */
        private String name;
        /** * 要推卸给的对象 */
        private Support next;
    
        /** * 构造方法，设置名字 * * @param name 实例名 */
        public Support(String name) {
            this.name = name;
        }
    
        /** * 设置要推卸给的对象 * * @param next 要推卸给的对象 * @return 要推卸给的对象 */
        public Support setNext(Support next) {
            this.next = next;
            return next;
        }
    
        /** * 解决问题的步骤 * * @param trouble 问题 */
        public final void support(Trouble trouble) {
            if (this.resolve(trouble)) {
                done(trouble);
            } else if (this.next != null) {
                next.support(trouble);
            } else {
                fail(trouble);
            }
        }
    
        @Override
        public String toString() {
            return "Support{ name='" + name + '\'' + '}';
        }
    
        /** * 解决问题的方法 * * @param trouble 问题对象 * @return 如果解决返回true, 否则false */
        protected abstract boolean resolve(Trouble trouble);
    
        /** * 解决 * * @param trouble 问题 */
        protected void done(Trouble trouble) {
            System.out.println(trouble + " is resolved by " + this + ".");
        }
    
        /** * 未解决 * * @param trouble 问题 */
        protected void fail(Trouble trouble) {
            System.out.println(trouble + " cannot be resolved.");
        }
    
    }

#### NoSupport类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 不支持类 * Created by Switch on 2017/3/30. */
    public class NoSupport extends Support { 
        public NoSupport(String name) {
            super(name);
        }
    
        @Override
        protected boolean resolve(Trouble trouble) {
            // 什么也不处理
            return false;
        }
    }

#### LimitSupport类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 限制支持类 * Created by Switch on 2017/3/30. */
    public class LimitSupport extends Support { 
        /** * 可以解决编号小于limit的问题 */
        private int limit;
    
        /** * 构造方法，设置实例名和limit限制值 * * @param name 实例名 * @param limit 限制值 */
        public LimitSupport(String name, int limit) {
            super(name);
            this.limit = limit;
        }
    
        @Override
        protected boolean resolve(Trouble trouble) {
            // 问题编号小于limit则解决问题
            return trouble.getNumber() < limit;
        }
    }

#### OddSupport类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 奇数支持类 * Created by Switch on 2017/3/30. */
    public class OddSupport extends Support { 
        public OddSupport(String name) {
            super(name);
        }
    
        @Override
        protected boolean resolve(Trouble trouble) {
            // 问题编号为奇数则解决
            return trouble.getNumber() % 2 == 1;
        }
    }

#### SpecialSupport类 ####

package com.pc.chainofresponsibility.example;
    
    /** * 特殊支持类 * Created by Switch on 2017/3/30. */
    public class SpecialSupport extends Support { 
        /** * 只解决特定编号的问题 */
        private int number;
    
        /** * 构造方法，设置实例名和特定编号 * * @param name 实例名 * @param number 特定编号 */
        public SpecialSupport(String name, int number) {
            super(name);
            this.number = number;
        }
    
        @Override
        protected boolean resolve(Trouble trouble) {
            // 特定编号则解决
            return trouble.getNumber() == number;
        }
    }

#### 测试类 ####

package com.pc.chainofresponsibility.example.test;
    
    import com.pc.chainofresponsibility.example.*;
    import org.junit.Test;
    
    /** * Support Tester. * * @author Switch * @version 1.0 */
    public class SupportTest { 
        /** * 测试责任链模式 */
        @Test
        public void testSupport() {
            Support alice = new NoSupport("Alice");
            Support bob = new LimitSupport("Bob", 100);
            Support charlie = new SpecialSupport("Charlie", 429);
            Support diana = new LimitSupport("Diana", 200);
            Support elmo = new OddSupport("Elmo");
            Support fred = new LimitSupport("Fred", 300);
    
            // 形成责任链
            alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);
            // 制造各种问题
            for (int i = 0; i < 500; i += 33) {
                alice.support(new Trouble(i));
            }
        }
    
    }

#### 运行结果 ####

Trouble{ number=0} is resolved by Support{ name='Bob'}.
    Trouble{ number=33} is resolved by Support{ name='Bob'}.
    Trouble{ number=66} is resolved by Support{ name='Bob'}.
    Trouble{ number=99} is resolved by Support{ name='Bob'}.
    Trouble{ number=132} is resolved by Support{ name='Diana'}.
    Trouble{ number=165} is resolved by Support{ name='Diana'}.
    Trouble{ number=198} is resolved by Support{ name='Diana'}.
    Trouble{ number=231} is resolved by Support{ name='Elmo'}.
    Trouble{ number=264} is resolved by Support{ name='Fred'}.
    Trouble{ number=297} is resolved by Support{ name='Elmo'}.
    Trouble{ number=330} cannot be resolved.
    Trouble{ number=363} is resolved by Support{ name='Elmo'}.
    Trouble{ number=396} cannot be resolved.
    Trouble{ number=429} is resolved by Support{ name='Charlie'}.
    Trouble{ number=462} cannot be resolved.
    Trouble{ number=495} is resolved by Support{ name='Elmo'}.

## 责任链模式中的角色 ##

### Handler(处理者) ###

`Handler`角色定义了处理请求的接口（`API`）。`Handler`角色知道“下一个处理者”是谁，如果向己无法处理请求，它会将请求转给“下一个处理者”。当然，“下一个处理者”也是`Handler`角色。在案例中，由`Support`类扮演此角色。负责处理请求的是`support`方法。

### ConcreteHandler(具体的处理者) ###

`ConcreteVisitor`角色是处理请求的具体角色。在案例中，由`NoSupport`、`LimitSupport`、`OddSupport`、`SpecialSupport`等各个类扮演此角色。

### Client(请求者) ###

`Client`角色是向第一个`ConcreteHandler`角色发送请求的角色。在案例中，由`Main`类扮演此角色。

### 类图 ###

![责任链模式类图][SouthEast 1]

GitHub：[DesignPatternStudy][]

——————参考《图解设计模式》

[SouthEast]: /images/20220617/4c312dad1b6d43949396ec287eb8ba4d.png
[SouthEast 1]: /images/20220617/b8e6f8a8aa924eee880fd96c51583c69.png
[DesignPatternStudy]: https://github.com/Switch-vov/DesignPatternStudy