设计模式（12）--责任链模式

• 责任链模式原理：

  • 购买请求一个决策项目

  • 决策因素：价格，

  • 决策级别：组长，部长，副总，总裁

  • 考虑扩展性：

    • 根据请求需要的东西

    • 根据请求的总额

    • 可能审核时还要删减

• 如果使用switch语句，会增加耦合性，所以将原来的switch处理逻辑体现在链上，谁能处理就留下处理

• 责任链模式：如果由多个对象都有机会处理请求，责任链可以使请求的发送者和处理者解耦，请求沿着责任链传递，直到有一个对象处理为止（实现Handler之间的解耦）

• 优点：

  • 请求的发送者和接收者解耦，使多个对象都有机会处理这个请求

  • 可以简化对象，因为他无需知道链的结构

  • 可以动态的增加或删减处理请求的链结构，把successhandler指向下一个过滤者即可。就是链表的增删改查

  • 链的结构可以多样化

• 缺点：

  • 请求从链的开头进行遍历，对性能有一定的损耗

  • 并不保证请求一定被处理

• 代码分析：

  • 首先创建请求对象：

package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:06
*/
public class PurchaseRequest {




    private int Type = 0;
    private int Number = 0;
    private float Price = 0;
    //请求的ID号
    private int ID = 0;




    public PurchaseRequest(int Type, int Number, float Price){
        this.Type = Type;
        this.Number = Number;
        this.Price = Price;
    }


    public int getType() {
        return Type;
    }


    public float getSum(){
        return Number * Price;
    }


    public int getId(){
        return (int)(Math.random()*1000);
    }
}

• 然后创建处理者的抽象类：

package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:09
*/
/**
* 抽象handler
*/
public abstract class Approver {
    //后续处理者的变量
    Approver successor;
    String Name;
    public Approver(String Name){
        //返回部长或者组长的名字
        this.Name = Name;
    }
    //·各个部门有不同的处理方法
    public abstract void ProcessRequest(PurchaseRequest request);
    //设置这个对象后继可以处理的对象
    public void SetSuccessor(Approver successor){
        this.successor = successor;
    }
}

• 设置处理者们：

package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:12
*/
public class GroupApprover extends Approver {


    public GroupApprover(String Name){
        super(Name + " GroupApprover");
    }
    @Override
    public void ProcessRequest(PurchaseRequest request) {
        if(request.getSum() < 5000){
            System.out.println("This request "+ request.getId() + " will be handled by "+ this.Name);


        }else{
            //处理不了不用管是谁直接丢给下一个
            successor.ProcessRequest(request);
        }


    }
}


package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:15
*/
public class DepartMentApprover extends Approver {
    public DepartMentApprover(String Name){
        super(Name + " DepartMentApprover");
    }
    @Override
    public void ProcessRequest(PurchaseRequest request) {
        //一定要写上下范围，否则就会有耦合
        if((request.getSum()>=5000)&&(request.getSum()<=10000)){
            System.out.println("This request "+ request.getId() + " will be handled by "+ this.Name);
        }else{
            successor.ProcessRequest(request);
        }
    }
}



package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:17
*/
public class VicePresidentApprover extends Approver{
    public VicePresidentApprover(String Name){
        super(Name + " Vice Approver");
    }
    @Override
    public void ProcessRequest(PurchaseRequest request) {
        if((request.getSum()>=10000)&&(request.getSum()<=50000)){
            System.out.println("This request "+ request.getId() + " will be handled by "+ this.Name);
        }else{
            successor.ProcessRequest(request);
        }
    }
}



package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:20
*/
public class PisesidentApprover extends Approver {
    public PisesidentApprover(String Name){
        super(Name + " Piesident");
    }
    @Override
    public void ProcessRequest(PurchaseRequest request) {
        if(request.getSum()>=50000){
            System.out.println("This request "+ request.getId() + " will be handled by "+ this.Name);
        }else{
            //因为责任链无序，所以可能第一个就是老总所以还是要抛给下一个
            successor.ProcessRequest(request);
        }
    }
}

• 设置客户端：

package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:21
*/
public class Client {
    public Client(){


    }


    public PurchaseRequest sendRequest(int Type, int Number, float Price){
        //只发送请求完全解耦
        return new PurchaseRequest(Type, Number, Price);
    }
}

• 测试：

package zerenlianmoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-05
* Time: 20:23
*/
public class MainTest {
    public static void main(String[] args) {
        Client client = new Client();
        Approver GroupLeader = new GroupApprover("GTom");
        Approver DepartmentLeader = new DepartMentApprover("DJerry");
        Approver VicePresident = new VicePresidentApprover("VKate");
        Approver President = new PisesidentApprover("Pwjx");


        //设置责任链
        GroupLeader.SetSuccessor(DepartmentLeader);
        DepartmentLeader.SetSuccessor(VicePresident);
        VicePresident.SetSuccessor(President);
        President.SetSuccessor(GroupLeader);


        GroupLeader.ProcessRequest(client.sendRequest(1, 100, 40));
        GroupLeader.ProcessRequest(client.sendRequest(2,200,40));
        GroupLeader.ProcessRequest(client.sendRequest(3,300,40));
        GroupLeader.ProcessRequest(client.sendRequest(4,400,140));


        //设置成环的用处，因为不一定会从头开始，所以设置成环，后继会从头开始，只要成环，结果相同
        //但是如果某些文件会经过多手审阅，这时候就要是按照顺序设置链
        VicePresident.ProcessRequest(client.sendRequest(1, 100, 40));
        VicePresident.ProcessRequest(client.sendRequest(2,200,40));
        VicePresident.ProcessRequest(client.sendRequest(3,300,40));
        VicePresident.ProcessRequest(client.sendRequest(4,400,140));
    }
}