责任链模式(chain of responsibility)

1.意图

使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这
些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

2.特点

Hander 抽象处理者 具有抽象的处理方法
ConcreteHander 具体处理者 实现Hander 并且实现处理方法
将所有的处理者连成一个链 从上到下向下调用,直到处理完毕或者无法处理返回.

3.UML类图

4.代码

/**
 * 责任链模式 Hander 角色 抽象处理者 
 * 
 * 抽象的处理方法 有具体处理者实现 
 */
public abstract class Hander {
    private Hander nextHander;


    public Hander getNextHander() {
        return nextHander;
    }

    public void setNextHander(Hander nextHander) {
        this.nextHander = nextHander;
    }

    public abstract void process(int money);
}

/**
 * Created by lyy on 18-3-13.
 * 责任链模式 ConcreteHander1 角色 具体处理者
 * 实现Hander 抽象类 实现process 抽象方法
 */
public class ConcreteHander1 extends Hander {


    /**
     * 实现抽象方法 具体的逻辑
     * @param money
     */
    @Override
    public void process(int money) {
        if(money<100){
            System.out.println("concreteHander1 处理了");
        }else{
            if(this.getNextHander()==null)
                System.out.println("没有可处理类");
            else
                this.getNextHander().process(money);
        }
    }
}

/**
 * Created by lyy on 18-3-13.
 */
public class ConcreteHander2 extends Hander {
    @Override
    public void process(int money) {
        if(money<500){
            System.out.println("concreteHander2 处理了");
        }else{
            if(this.getNextHander()==null)
                System.out.println("没有可处理类");
            else
                this.getNextHander().process(money);
        }
    }
}

public class ConcreteHander3 extends Hander {
    @Override
    public void process(int money) {
        if(money<1000){
            System.out.println("concreteHander3 处理了");
        }else{
            if(this.getNextHander()==null)
                System.out.println("没有可处理类");
            else
                this.getNextHander().process(money);
        }
    }
}

/**
 * Created by lyy on 18-3-13.
 *
 * 将具体处理者连成链 进行处理
 */
public class ChainTest {
    public static void main(String[] args) {
        Hander hander1 = new ConcreteHander1();
        Hander hander2 = new ConcreteHander2();
        Hander hander3 = new ConcreteHander3();
        hander1.setNextHander(hander2);
        hander2.setNextHander(hander3);
        hander1.process(1599);
    }
}

5.总结

模式的优点:1,请求者和接受者松散耦合2,动态组合职责
模式的缺点:1,产生许多细粒度对象2,不一定能被处理
模式本质：分离职责，动态组合。分离职责是前提，动态组合是精华所在。