责任链模式

Posted on | Edited on | In | Views:

责任链模式

有多个对象, 每个对象都持有下一个对象的引用,这样就会形成一条责任链,请求在这条链上进行传递,知道某一对象决定处理该请求.但是发出者并不知道那个对象处理的请求.责任链模式的好处就是在隐瞒客户端的情况下,对系统进行动态的调整.
类结构图
三个继承了Handle的类组成了一个责任链,每个对象获取请求后都会看自己是否能处理,不能处理则放在最顶端.

handle抽象类

1
2
3
4
5
6
7
8
9
10
public abstract class Handle {

    protected Handle successor;

    void SetSuccessor(Handle successor){
        this.successor=successor;
    }

    abstract void HandleRequest(int request);
}

三个责任链上的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ConcreteHandle1 extends Handle {
    @Override
    void HandleRequest(int request) {
        if(request<10 && request>0){
            System.out.println("concreteHandler1 处理请求");
        }else{
            successor.HandleRequest(request);
        }
    }
}

public class ConcreteHandle2 extends Handle {
    @Override
    void HandleRequest(int request) {
        if(request<20 && request>10){
            System.out.println("concreteHandler2 处理请求");
        }else{
            successor.HandleRequest(request);
        }
    }
}
public class ConcreteHandle3 extends Handle {
    @Override
    void HandleRequest(int request) {
        if(request<30 && request>20){
            System.out.println("concreteHandler3 处理请求");
        }else{
            successor.HandleRequest(request);
        }
    }
}

这里链上的对象分别处理不同的请求.

客户端代码

1
2
3
4
5
6
7
8
9
10
11
public class Client {
    public static void main(String[] args) {
        Handle h1 = new ConcreteHandle1();
        Handle h2 = new ConcreteHandle2();
        Handle h3 = new ConcreteHandle3();
        h1.SetSuccessor(h2);
        h2.SetSuccessor(h3);

        h1.HandleRequest(15);
    }
}

这里如果要改变处理流程,客户端代码完全可以不用改变,改变责任链上的某些对象就可以更改执行逻辑,这就是责任链模式.

中介者模式

中介者模式是用来降低类类之间的耦合的.就是将一个系统分割成许多对象,对象间的通信不彼此直接通讯,而是通过一个中介者来进行通信,进行协调对象之间的关系.如果使用直接依赖对象来进行通讯的话,如果要更改一个对象,那么和他有关联的对象都会更改.但是使用中介者模式的话,更改对象只需要改变他和中介的关系就可以了.具体的调度类或者通信通过中介来实现.

从类图中能够看出来两个colleague两个类之间没有关系,都是通过一个mediator类在中间协调,当这样子的类多了之后,更改起来就只需要更改mediator类就可以了,方便维护.

同事接口
确保每一个类关联着mediator

1
2
3
4
5
6
7
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

}

具体同事类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class RealColleague1 extends Colleague {
    public RealColleague1(Mediator mediator) {
        super(mediator);
    }

    public void send(String message){
        mediator.send(message,this);
    }
    public void Notify(String message){
        System.out.println("同事1获得消息");
    }

}

public class RealColleague2 extends Colleague {
    public RealColleague2(Mediator mediator) {
        super(mediator);
    }
    public void send(String message){
        mediator.send(message,this);
    }
    public void Notify(String message){
        System.out.println("同事2获得消息");
    }
}

mediator类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public abstract class Mediator {
    public abstract void send(String message,Colleague colleague);
}
public class ConcreteMediator extends Mediator {

    private RealColleague1 colleague1;
    private RealColleague2 colleague2;

    public void setColleague1(RealColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(RealColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if(colleague == colleague1){
            colleague2.Notify(message);
        }else{
            colleague1.Notify(message);
        }
    }
}

其实中介模式就是实现了迪米特法则,也就是最小知道原则,对于自己依赖的类知道的越少越好,在中介这模式中,每个同事只需要知道一个中介就可以,干什么都和中介说,然后中介帮他去做事.降低耦合性. 但是中介这也有一个坏处,就是中介者的需要干的事情比较多,也就比较复杂,维护也是个不小的成本.