设计模式-职责链模式 （分离职责，动态组合）

为什么80%的码农都做不了架构师？>>>   

一：业务场景

我们申请聚餐经费的审批：

项目经理只能审批500元以下的，

部门经理可以审批1000元以下的，

总经理可以审批1000元以上的

二：看看我们不用设计模式的平时代码逻辑

/**
 * 处理聚餐费用的对象
 * @author dy
 * @since 2016-08-12  & JDK 1.8.0_91
 */
public class FeeRequest_demo {


    public String requestToProjectManager(String user,double fee){
        String result = "";
        if (fee<500)
            result = this.projectManagerHandler(user, fee);
        else if (fee< 1000)
            result = this.dptManagerHandler(user, fee);
        else if (fee>1000)
            result = this.generalManagerHandler(user, fee);
        return result;
    }

    private  String projectManagerHandler(String user,double fee){
        return "项目经理同意给你报销:"+fee;
    }

    private  String dptManagerHandler(String user,double fee){
        return "部门经理同意给你报销:"+fee;
    }

    private  String generalManagerHandler(String user,double fee){
        return "总经理同意给你报销:"+fee;
    }

这里例子比较简单，主要是学习设计模式，又不是学习处理业务的，哈哈

ok，我们来测试下

public static void main(String[] args) {
    FeeRequest_demo feeRequest =new FeeRequest_demo();
    System.out.println(feeRequest.requestToProjectManager("", 300));
    System.out.println(feeRequest.requestToProjectManager("", 600));
    System.out.println(feeRequest.requestToProjectManager("", 1200));

}

 

思考，以上代码有什么问题？实际业务场景中，我们的审批流程经常变更，业务处理也经常变更，这就要求我们必须设计更加灵活的程序。

三：职责链设计模式

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

四：使用设计模式重写示例：

 

/**
 * 定义职责对象接口
 * @author dy
 * @since 2016-08-12  & JDK 1.8.0_91
 */
public abstract class Handler {

    /**
     * 通常持有下一个处理的请求对象
     */
    protected Handler nextHandler;

    public Handler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }


    /**
     * 处理申请
     * @param user
     * @param fee
     * @return
     */
    public abstract String requestToFee(String user,double fee);
}

public class ProjectManagerHandler extends Handler {
    public ProjectManagerHandler(Handler nextHandler) {
        super(nextHandler);
    }
    @Override
    public String requestToFee(String user, double fee) {
        if (fee<500){
            return "项目经理同意给你报销:"+fee;
        }
        else{
            if (nextHandler != null) {
                return nextHandler.requestToFee(user, fee);
            }
        }
        return "非法处理";
    }
}

public class DptManagerHandler extends Handler {
    public DptManagerHandler(Handler nextHandler) {
        super(nextHandler);
    }
    @Override
    public String requestToFee(String user, double fee) {
        if (fee<1000){
            return "部门经理同意给你报销:"+fee;
        }
        else{
            if (nextHandler != null) {
                return nextHandler.requestToFee(user, fee);
            }
        }
        return "非法处理";
    }
}

 

public class GeneralManagerHandler extends Handler {

    public GeneralManagerHandler(Handler nextHandler) {
        super(nextHandler);
    }

    @Override
    public String requestToFee(String user, double fee) {
        if (fee>1000){
            return "总经理同意给你报销:"+fee;
        }
        else{
            if (nextHandler != null) {
                return nextHandler.requestToFee(user, fee);
            }
        }
        return "非法处理";
    }
}

 

ok，让我们来测试下吧！

/**
 * @author dy
 * @since 2016-08-12  & JDK 1.8.0_91
 */
public class Client {


    public static void main(String[] args) {
        /**
         * 组装职责链
         */
        Handler generalHandler = new GeneralManagerHandler(null);
        Handler depHandler = new DptManagerHandler(generalHandler);
        Handler prjHandler = new ProjectManagerHandler(depHandler);


        System.out.println(prjHandler.requestToFee("", 300));
        System.out.println(prjHandler.requestToFee("", 600));
        System.out.println(prjHandler.requestToFee("", 1200));
    }
}

运行结果：

是不是和没有设计模式的 运行结果一抹一眼啊 ！

这里就不演示处理多种请求了 ，大同小异的！

想想我们平时用到的拦截器，是不是用到了职责链设计模式啊！看来这个也很重要哦

转载于:https://my.oschina.net/dyyweb/blog/731924