大话设计模式-----(十)职责链模式、中介者模式

职责链模式

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

就像我找版主申请请假，但是请假时间过长那么就要找导员请假才行。如果更长那么就要找院领导才能请假。一直传递这个请求。一直到他的权限能够处理这件事

定义一个抽象处理请求的抽象类

//抽象一个处理请求的接口

abstract class Handler{
    Handler successorHandler;
    //设置他的领导，也就是他处理不了后交给谁
    public void SetSuccessor(Handler successorHandler){
        this.successorHandler = successorHandler;   
    }
    //向上传递请求
    public abstract void HandlerRequest(int request);


}

然后继承类，也就是各位领导

class ConcreteHandler1 extends Handler{

    @Override
    public void HandlerRequest(int request) {
        // TODO Auto-generated method stub
        if(request<=10){
            System.out.println("ConcreteHandler1:处理");
        }else{
            successorHandler.HandlerRequest(request);
        }
    }

}


class ConcreteHandler2 extends Handler{

    @Override
    public void HandlerRequest(int request) {
        // TODO Auto-generated method stub
        if(10<request&&request<=20){
            System.out.println("ConcreteHandler2:处理");
        }else{
            successorHandler.HandlerRequest(request);
        }
    }

}


class ConcreteHandler3 extends Handler{

    @Override
    public void HandlerRequest(int request) {
        // TODO Auto-generated method stub
        if(20<request&&request<50){
            System.out.println("ConcreteHandler3:处理");
        }else{
            System.out.println("老哥，我们处理不了");
        }
    }

}

客户端

public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.SetSuccessor(handler2);
        handler2.SetSuccessor(handler3);
        handler1.HandlerRequest(10);
        handler1.HandlerRequest(80);
    }

就是所有的都有一个处理请求的方法，有一个上级领导，自己处理不了就调用领导的处理请求方法。

接受者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链结构。
之间解耦

中介者模式

先定义个抽象的中介，这个中介知道所有同事，同事们之间传递消息都由他

//抽象中介
 abstract class Mediator{
     public abstract void Send(String messageString, Colleague colleague);

 }

定义抽象同事

//抽象对象类，抽象同事

 abstract class Colleague{
     Mediator mediator;
     public Colleague(Mediator mediator){
         this.mediator = mediator;
     }
     public  abstract void Notify(String mesString); 
 }

具体中介

 //具体中介者

 class ConcreteMediator extends Mediator{
     //中介者知道所有人。
     private Colleague colleague1;
     private Colleague colleague2;
    public void setColleague1(Colleague colleague1) {
        this.colleague1 = colleague1;
    }
    public void setColleague2(Colleague colleague2) {
        this.colleague2 = colleague2;
    }
    @Override
    public void Send(String messageString, Colleague colleague) {
    if(colleague==colleague1){
    //如果是同事1发的那么就将消息通知给同事2
        colleague2.Notify(messageString);
    }else{
        colleague1.Notify(messageString);
    }

    }


 }

具体同事

 //具体同事类

 class ConcreteColleague1 extends Colleague{

    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
        // TODO Auto-generated constructor stub
    }
    public void Send(String messageString){
        mediator.Send(messageString, this);

    } 
    public void Notify(String messageString){
        System.out.println("同事1得到消息:"+messageString);
    } 

 }



 class ConcreteColleague2 extends Colleague{

    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
        // TODO Auto-generated constructor stub
    }
    public void Send(String messageString){
        mediator.Send(messageString, this);

    } 
    public void Notify(String messageString){
        System.out.println("同事2得到消息:"+messageString);
    } 

 }

客户端

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ConcreteMediator mediator = new ConcreteMediator();
        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);
        colleague1.Send("你好，同事2");
        colleague2.Send("你也好");
    }

中介者中定义所有同事属性类，并设置其值进行初始化。
每个具体同事都只认识中介。减少各个同事之间的耦合。
在构造函数就传入中介

同事的发送消息Send方法。因为只认识中介，调用中介的传递消息方法。传入消息和告诉他我是谁。
中介进行判断，啊，是你啊。你的信息要传递给同事2.然后调用同事2的通知方法。告知同事2

中介者模式一般用于一组对象以定义良好但是复杂的方式进行通信的场合。以及想定制一个分布在多个类中的行为。而又不想生成太多的子类的场合。