应用场景

http web请求处理，请求过来后将经过转码、解析、参数封装、鉴权等一系列的处理(责任)，而且要经过多少处理是可以灵活调整的

那么该怎么做呢？

将所有的处理都写在一个类中行不行呢？

分成多个类又该如何灵活的组合在一起呢？

简单示例

Request类：

public interface Request{

//do something...

}

复制代码

ResponsibilityChain类：

public class ResponsibilityChain{

private List responsibilityList = new ArrayList<>();

private Integer index = 0;

public void process(Request request){

if (this.index < responsibilityList.size()) {

this.responsibilityList.get(index++).process(request, this);

}

}

/** 加入链中 */

public void register(Responsibility responsibility){

this.responsibilityList.add(responsibility);

}

}

复制代码

Responsibility接口：

public interface Responsibility{

void process(Request request, ResponsibilityChain chain);

}

复制代码

Responsibility实现类：

public class ResponsibilityA implements Responsibility{

@Override

public void process(Request request, ResponsibilityChain chain){

System.out.println("转码");

chain.process(request);

}

}

复制代码

public class ResponsibilityB implements Responsibility{

@Override

public void process(Request request, ResponsibilityChain chain){

System.out.println("解析");

chain.process(request);

}

}

复制代码

public class ResponsibilityC implements Responsibility{

@Override

public void process(Request request, ResponsibilityChain chain){

System.out.println("参数封装");

chain.process(request);

}

}

复制代码

public class ResponsibilityD implements Responsibility{

@Override

public void process(Request request, ResponsibilityChain chain){

System.out.println("鉴权");

chain.process(request);

}

}

复制代码

测试类：

public class Test{

public static void main(String[] args){

ResponsibilityChain chain = new ResponsibilityChain();

chain.register(new ResponsibilityA());

chain.register(new ResponsibilityB());

chain.register(new ResponsibilityC());

chain.register(new ResponsibilityD());

chain.process(new Request() {

});

}

}

复制代码

类图：

责任链模式

定义

所有的处理者，都加入到这个链式，一个处理完后，转给下一个

或者说每个接收者都包含对另一个接收者的引用，如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者

抽象出责任接口，具体责任逻辑实现接口

根据处理过程需要，将具体实现组合成链

使用者使用链

典型的代表：Filter、Interceptor

意图

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止

主要解决问题

职责链上的处理者负责处理请求，客户端只需要将请求发送到职责链上就行了，不需要关系处理的细节和请求的传递，请求的发送者和处理者解耦了

何时使用

系统已经有一个由处理者对象组成的链，这个链可能有合成模式给出

有多于一个的处理者对象会处理一个请求，而且事先并不清楚到底由哪一个处理者对象处理一个请求，处理者对象是动态确定的

系统想发出一个请求给多个处理者对象中的某一个，但是不明显指定哪一个处理者对象会处理该请求

处理一个请求的处理者对象集合需要动态的指定时

优缺点

优点：

发送者和接收者解耦，低耦合

简化了对象。使得对象不需要知道链的结构

通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任

增加新的请求处理类很方便

缺点：

不能保证请求一定被接收

系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用

可能不容易观察运行时的特征，有碍于除错

类图如下：

涉及到的角色：

抽象处理者(Handler)角色：定义一个处理请求的接口，如果需要，接口可以定义出一个方法，以设定和返回对下家的引用，这个角色通常由一个抽象类或者接口实现

具体处理者(ConcreteHandler)角色：具体处理者接收到请求后，可以选择将请求处理掉，或者传给下一个；具体处理者持有对下一个的引用，因此如果需要，具体处理者可以访问下一个

代码示例：

Handler类：

public abstract class Handler{

protected Handler successor;

/** 调用此方法处理请求 */

public abstract void handlerRequest();

/** 取值方法 */

public Handler getSuccessor(){

return successor;

}

/** 调用此方法设置下一个 */

public void setSuccessor(Handler successor){

this.successor = successor;

}

}

复制代码

ConcreteHandler类：

public class ConcreteHandler1 extends Handler{

@Override

public void handlerRequest(){

if (getSuccessor() != null) {

System.out.println("请求传递到下一个：" + getSuccessor().getClass().getName());

getSuccessor().handlerRequest();

} else {

System.out.println("请求在ConcreteHandler1被处理了");

}

}

}

复制代码

public class ConcreteHandler2 extends Handler{

@Override

public void handlerRequest(){

if (getSuccessor() != null) {

System.out.println("请求传递到下一个：" + getSuccessor());

getSuccessor().handlerRequest();

} else {

System.out.println("请求在ConcreteHandler2被处理了");

}

}

}

复制代码

客户端：

public class Client{

static private Handler handler1;

static private Handler handler2;

public static void main(String[] args){

handler1 = new ConcreteHandler1();

handler2 = new ConcreteHandler2();

handler1.setSuccessor(handler2);

handler1.handlerRequest();

}

}

复制代码

类图：

击鼓传花的故事

击鼓传花是一种热闹而又紧张的饮酒游戏，在酒宴上宾客依次坐定，由一人击鼓，开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在谁手里，谁就开始饮酒了；下面以《红楼梦》中击鼓传花的故事，写一个小例子：

抽象接口Player类：

public abstract class Player{

private Player player;

/** 需要执行酒令的请求 */

abstract public void handlerRequest(int index);

/** 设置下一个传花人 */

public void setPlayer(Player player){

this.player = player;

}

/** 将花传给下一家，如果没有就结束 */

public void next(int index){

if (player != null) {

player.handlerRequest(index);

} else {

System.out.println("传花结束");

}

}

}

复制代码

参与击鼓传花的人：

public class JiaMu extends Player{

public JiaMu(Player player){

this.setPlayer(player);

}

@Override

public void handlerRequest(int index){

if (index == 1) {

System.out.println("贾母执行酒令");

} else {

System.out.println("贾母将花传给下一个");

next(index);

}

}

}

复制代码

public class JiaShe extends Player{

public JiaShe(Player player){

this.setPlayer(player);

}

@Override

public void handlerRequest(int index){

if (index == 2) {

System.out.println("贾赦执行酒令");

} else {

System.out.println("贾赦将花传给下一个");

next(index);

}

}

}

复制代码

public class JiaZheng extends Player{

public JiaZheng(Player player){

this.setPlayer(player);

}

@Override

public void handlerRequest(int index){

if (index == 3) {

System.out.println("贾政执行酒令");

} else {

System.out.println("贾政将花传给下一个");

next(index);

}

}

}

复制代码

public class JiaBaoYu extends Player{

public JiaBaoYu(Player player){

this.setPlayer(player);

}

@Override

public void handlerRequest(int index){

if (index == 4) {

System.out.println("贾宝玉执行酒令");

} else {

System.out.println("贾宝玉将花传给下一个");

next(index);

}

}

}

复制代码

public class JiaHuan extends Player{

public JiaHuan(Player player){

this.setPlayer(player);

}

@Override

public void handlerRequest(int index){

if (index == 5) {

System.out.println("贾环执行酒令");

} else {

System.out.println("贾环将花传给下一个");

next(index);

}

}

}

复制代码

击鼓者：

public class DrinkingGame{

static private Player player;

public static void main(String[] args){

player = new JiaMu(

new JiaShe(

new JiaZheng(

new JiaBaoYu(

new JiaHuan(null)))));

//设置第四个执行酒令

player.handlerRequest(4);

}

}

复制代码

类图：