设计模式——中介者模式

什么是中介者模式

如果我们想让两个对象之间进行通信，一种方法是让对象互相持有对方的引用，在需要的时候将消息通过引用传递给对方，这种方式在需要通信的对象不多的时候不会有问题，当通信的对象数目增多时，一个对象持有的引用就会非常多，为了克服这种问题，就用一个类（中介者）专门负责对象之间的交互，所有的对象都通过中介者进行通信

 

中介者模式的角色

Mediator：抽象中介者角色，需要定义对象交互信息的方法

ConcreteMediator：具体中介者角色，实现具体的交互信息的方法

Colleague：抽象同事类角色，定义向中介者提交请求的接口

ConcreteColleague1、ConcreteColleague2：具体同事类角色，继承于抽象同事类

 

实例：A与B之间进行实时通信

 

Mediator：

public abstract class Mediator {  
    
    protected User_A A;
    protected User_B B;
    
    public Mediator(User_A A,User_B B){
        this.A=A;
        this.B=B;
    }
    
    public abstract void notifyA(String message);  
    public abstract void notifyB(String message);
}

 

User（colleague）：

public abstract class User {
    public Mediator mediator;
    
    public abstract void setMediator(Mediator mediator);
    
    public abstract void reciveMessage(String message);
    public abstract void sendMessage(String message);
}

 

User_A：

public class User_A extends User{
    
    public void setMediator(Mediator mediator){
        super.mediator=mediator;
    }
    
    
    public void reciveMessage(String message) {
        System.out.println("A接收到B的消息："+message);
    }

    public void sendMessage(String message) {
        mediator.notifyB(message);
    }
    
    
}

 

User_B：

public class User_B extends User{
    
    @Override
    public void reciveMessage(String message) {
        System.out.println("B接收到A的消息:"+message);
    }

    @Override
    public void sendMessage(String message) {
       mediator.notifyA(message);
    }

    @Override
    public void setMediator(Mediator mediator) {
        super.mediator=mediator;
    }
    
}

 

ConcreteMediator：

public class ConcreteMediator extends Mediator{

    public ConcreteMediator(User_A A, User_B B) {
        super(A, B);
    }

    @Override
    public void notifyA(String message) {
        A.reciveMessage(message);
    }

    @Override
    public void notifyB(String message) {
        B.reciveMessage(message);
    }
    
}

 

main：

public class main {
    
    public static void main(String[] args){
       User_A A=new User_A();
       User_B B=new User_B();
       
       Mediator mediator=new ConcreteMediator(A,B);
       A.setMediator(mediator);
       B.setMediator(mediator);
       
       A.sendMessage("学车教练有点烦耶");
       B.sendMessage("我也觉得是");
    } 
    
}

 

效果图：

 

中介者模式的一点思考

中介者模式使对象之间是松耦合的，当对象与对象之间的关系比较混乱的时候才使用中介者模式，当对象多起来后，中介者本身的代码量可能会变得非常巨大，在构造中介者模式时，需要注意一点，因为具体同事类持有抽象中介者类的应用，抽象中介者持有同事类的引用，所以不要在构造函数中初始化引用，这样会陷入无法初始化一个类的尴尬情况（就和spring中的循环注入一样）