设计模式学习笔记——责任链(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
——————参考《图解设计模式》