设计模式之——Chain of Responsibility

Chain of Responsibility模式又叫做责任链模式，是将多个对象组成一条职责链，然后按照职责链上的顺序一个一个的找出是谁来负责处理。

这个模式很简单，下面就是一个实例程序，有六个处理器，能分别处理一些六个级别的问题，现在有一堆问题在那，那么我们就把处理器进行串行连接，依次将问题通过，如果是自己的那就处理，不是自己的那就不处理，让下一个处理器处理，最后都没处理器处理的就直接输出，控制台打印没处理器处理。

• Trouble问题的类

package site.wangxin520.gof.chain;

/**
 * 责任链模式的问题 在责任链处理的过程中，将问题传入责任链中，在符合要求的责任链中进行操作
 * 
 * @author wangXgnaw
 *
 */
public class Trouble {

    // 级别
    private int number;

    // 问题名字
    private String name;

    /**
     * 传入问题的级别和名字
     * 
     * @param number
     * @param name
     */
    public Trouble(int number, String name) {
        super();
        this.number = number;
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

• Chain处理器的父类

package site.wangxin520.gof.chain;

/**
 * 责任链的抽象类 定义了责任链的规范和方法
 * 
 * @author wangXgnaw
 *
 */
public abstract class Chain {

    // 定义责任链的名字
    private String name;

    // 下一个责任链
    private Chain next;

    /**
     * 构造方法，责任链的构造
     * @param name
     */
    public Chain(String name) {
        this.name=name;
    }

    /**
     * 这个是重点,设置责任链下一个责任人，并且返回下一个责任人。
     * 这个样子就可以使用链式编程的方式进行操作。
     * @param next
     * @return
     */
    public Chain setNextChain(Chain next){
        this.next=next;
        return next;
    }
    
    /**
     * 这个方法是规定了子类实现的方法,用于解决问题
     * @param trouble 传入问题
     * @return boolean 返回是否解决成功
     */
    protected abstract boolean solveProblem(Trouble trouble);
    
    /**
     * 解决问题的方法，传入问题
     * @param trouble
     */
    public void solve(Trouble trouble){
        if(solveProblem(trouble)){
            System.out.println(name+"把"+trouble.getName()+trouble.getNumber()+"级别的问题解决了");
        }else if(null ==next){
            System.out.println(trouble.getName()+"这个问题解决不了!");
        }else{
            next.solve(trouble);
        }
    }
    
}

• 处理器，这里只列举了处理器1，其他的都一样

package site.wangxin520.gof.chain;

/**
 * 解决一级问题
 * @author wangXgnaw
 *
 */
public class Chain1 extends Chain{

    public Chain1(String name) {
        super(name);
    }

    @Override
    protected boolean solveProblem(Trouble trouble) {
        if(trouble.getNumber()==1){
            return true;
        }
        return false;
    }

}

• 测试类

package site.wangxin520.gof.chain;

import java.util.Random;

/**
 * 责任链模式的测试
 * 
 * @author wangXgnaw
 *
 */
public class Test {

    public static void main(String[] args) {

        //新建一些处理器
        Chain1 chain1 = new Chain1("处理器1");
        Chain2 chain2 = new Chain2("处理器2");
        Chain3 chain3 = new Chain3("处理器3");
        Chain4 chain4 = new Chain4("处理器4");
        Chain5 chain5 = new Chain5("处理器5");
        Chain6 chain6 = new Chain6("处理器6");

        //设置各个处理器之间的链关系，这里注意的是，不要弄成环，只要是链就行
        chain1.setNextChain(chain2).setNextChain(chain3).setNextChain(chain4).setNextChain(chain5).setNextChain(chain6);

        Random r=new Random();
        
        //设置是个问题，让处理器1去执行，如果1执行不了的话，就会自动找到下一个处理器2执行依次下去。。。
        for (int i = 0; i <10; i++) {
            int num=r.nextInt(10)+1;
            Trouble trouble = new Trouble(num, "问题"+（i+1）+"号");
            chain1.solve(trouble);
        }
        
    }
}

• 控制台输出

由控制台可以看出，问题一号一直被推脱给了六号处理器，问题2号还没有被解决……

可见责任链模式还是很简单的！