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

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

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

基本介绍

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

责任链案例

类图

实现代码

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类扮演此角色。

类图

GitHub：DesignPatternStudy

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