设计模式代码详解--责任链模式

责任链模式的定义（百度的）：
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

简单粗暴上代码，每行代码都有注释：

/**
 * 责任链模式 模拟工厂
 * 工厂有3个生产车间
 */
public abstract class AbstractFactory {
    //责任判断常量
    public static int FIRST = 1;
    public static int SECOND = 2;
    public static int THIRD = 3;

    //当前等级
    protected int level;

    //责任链中的下一个元素
    protected AbstractFactory nextFactory;
    public void setNextLogger(AbstractFactory nextFactory){
        this.nextFactory = nextFactory;
    }
    //执行生产方法
    public void doProduction(int level, String message){
        //判断是否要当前‘工厂执行’ 判断是不是自己的责任
        if(this.level == level){
            production(message);
        }
        //不是就下一个
        if(nextFactory !=null){
            nextFactory.doProduction(level, message);
        }
    }

    abstract public void production(String message);

}
/**
 * 一号工厂
 */
public  class FirstFactory extends AbstractFactory{

    //设置当前工厂执行等级（责任链的顺序）
    public FirstFactory(int level){
        this.level = level;
    }
    //每个工厂特有方法
    @Override
    public void production(String message){
        System.out.println("一号工厂执行："+message);
    }
}

/**
 * 二号工厂
 */
public  class SecondFactory extends AbstractFactory{

    //设置当前工厂执行等级（责任链的顺序）
    public SecondFactory(int level){
        this.level = level;
    }
    //每个工厂特有方法
    @Override
    public void production(String message){
        
        System.out.println("二号工厂执行："+message);
    }
}
/**
 * 三号工厂
 */
public  class ThirdFactory extends AbstractFactory{

    //设置当前工厂执行等级（责任链的顺序）
    public ThirdFactory(int level){
        this.level = level;
    }
    //每个工厂特有方法
    @Override
    public void production(String message){
        System.out.println("三号工厂执行："+message);
    }
}
public class Test {
    //先创建责任链
    public static AbstractFactory getFactory(){
        //创建对象
        AbstractFactory  firstFactory = new FirstFactory(AbstractFactory.FIRST);
        AbstractFactory  secondFactory = new SecondFactory(AbstractFactory.SECOND);
        AbstractFactory  thirdFactory = new ThirdFactory(AbstractFactory.THIRD);
        //把对象连起来
        firstFactory.setNextLogger(secondFactory);
        secondFactory.setNextLogger(thirdFactory);
        return  firstFactory;
    }

    public static void main(String[] args) {
        //获取工厂链（责任链）
        AbstractFactory af = getFactory();
        af.doProduction(AbstractFactory.FIRST,"生产滚珠");
        af.doProduction(AbstractFactory.SECOND,"生产轴承");
        af.doProduction(AbstractFactory.THIRD,"生产轮子");


    }
}
//输出：
//一号工厂执行：生产滚珠
//二号工厂执行：生产轴承
//三号工厂执行：生产轮子