行为型--中介者模式

桃扇骨 2021-09-28 16:54 318阅读 0赞

## 概念 ##

--------------------

用来降低多个对象和类之间的通信复杂性。该模式用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，仅仅只需要把一个对象的请求交给它的中介者即可，从而使其耦合松散，而且可以独立地改变它们之间的交互。

优点：

1.  降低了类的复杂度，将一对多转化成了一对一。(一个对象与多个对象交互变成与一个中介者交互)
2.  各个类之间的解耦。
3.  符合迪米特原则。

缺点：

1.  中介者类会很庞大，变得复杂难以维护。

## 举例 ##

--------------------

import java.util.Hashtable;
    public class User1{
    	public static void main(String[] args) {  
            //创建一个中介者  
            AbstractMediator mediator = new Mediator();  
            //创建两个同事  
            ColleagueA colleagueA = new ColleagueA(mediator);  
            ColleagueB colleagueB = new ColleagueB(mediator);  
            //中介者分别与每个同事建立联系  
            mediator.addColleague("ColleagueA", colleagueA);  
            mediator.addColleague("ColleagueB", colleagueB);  
            //同事们开始工作  
            colleagueA.self();  
            colleagueA.out();  
            //System.out.println("======================合作愉快，任务完成！\n");  
            colleagueB.self();  
            colleagueB.out();  
            //System.out.println("======================合作愉快，任务完成！");  
        }  
    }
    // 同事类族:同时要能与中介者沟通
    abstract class AbstractColleague {  
        protected AbstractMediator mediator;  
        /* 既然有中介者，那么每个具体同事必然要与中介者有联系，
             *  否则就没必要存在于 这个系统当中，这里的构造函数相当  
             * 于向该系统中注册一个中介者，以取得联系
             * 既然有中介者，那么每个具体同事必然要与中介者有联系，  
         * */ 
        public AbstractColleague(AbstractMediator mediator) {  
            this.mediator = mediator;  
        }  
        // 在抽象同事类中添加用于与中介者取得联系（即注册）的方法  
        //可以不写
        public void setMediator(AbstractMediator mediator) {  
            this.mediator = mediator;  
        }
    }  
    // 具体A类同事
    class ColleagueA extends AbstractColleague {  
        //每个具体同事都通过父类构造函数与中介者取得联系  
        public ColleagueA(AbstractMediator mediator) {  
            super(mediator);  
        }  
        //每个具体同事必然有自己分内的事，没必要与外界相关联  
        public void self() {  
            System.out.println("同事A --> 已完成自己分内的事情:A.self");  
        }  
        //每个具体同事总有需要与外界交互的操作，通过中介者来处理这些逻辑并安排工作  
        public void out() {  
            System.out.println("同事A --> 请求同事B做好分内工作:B.self");  
            super.mediator.execute("ColleagueB", "self");
            System.out.println("请求工作已完成"); 
        }  
    }  
    //具体B类同事
    class ColleagueB extends AbstractColleague {  
    	// 分配一个中介者
        public ColleagueB(AbstractMediator mediator) {  
            super(mediator);  
        }  
        public void self() {  
            System.out.println("同事B --> 已完成自己分内的事情:B.self");  
        }  
        public void out() {  
            System.out.println("同事B --> 请求同事A做好分内工作:A.self.");  
            super.mediator.execute("ColleagueA", "self");  
            System.out.println("请求工作已完成"); 
        }  
    }
    // 中介者类族:
    abstract class AbstractMediator {  
        //中介者肯定需要保持有若干同事的联系方式  
    	// 同事名,所属同事类
        protected Hashtable<String, AbstractColleague> colleagues 
                      = new Hashtable<String, AbstractColleague>();  
        //中介者可以动态地与某个同事建立联系  
        //添加一个能被某中介者处理的同事
        public void addColleague(String name, AbstractColleague c) {  
            this.colleagues.put(name, c);  
        }     
        //中介者也可以动态地撤销与某个同事的联系  
        public void deleteColleague(String name) {  
            this.colleagues.remove(name);  
        }  
        //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作  
        public abstract void execute(String name, String method);   
    }  
    //具体中介者  
    class Mediator extends AbstractMediator{  
        //中介者最重要的功能，来回奔波与各个同事之间  
    	// 为某个同事name分配某个任务method
        public void execute(String name, String method) {  
            if("self".equals(method)){  //各自做好分内事  
                if("ColleagueA".equals(name)) {  
                    ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  
                    colleague.self();  
                }else {  
                    ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  
                    colleague.self();  
                }  
            }else { //与其他同事合作  
                if("ColleagueA".equals(name)) {  
                    ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");  
                    colleague.out();  
                }else {  
                    ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");  
                    colleague.out();  
                }  
            }  
        }  
    } 
    
    Output:
    同事A --> 已完成自己分内的事情:A.self
    同事A --> 请求同事B做好分内工作:B.self
    同事B --> 已完成自己分内的事情:B.self
    请求工作已完成
    同事B --> 已完成自己分内的事情:B.self
    同事B --> 请求同事A做好分内工作:A.self.
    同事A --> 已完成自己分内的事情:A.self
    请求工作已完成