中介者模式(Mediaer)-优快云博客

本文链接：https://blog.youkuaiyun.com/xufei96/article/details/5426870

本文介绍了一种通过中介者模式协调两个组件间通信的设计方案，并提供了C#与Python两种语言的具体实现示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

个人理解：

Sender是ComponentA与ComponentB之间的中介，ComponentA与Component维护一个Sender，SEnders也维护ComponentA与ComponentB。

UML类图

代码实现

    public abstract class Sender
    {
        public abstract void Send(ContractBase contract, string message);
    }

    public class ConcreteSender : Sender
    {
        private ContractBase contract1;
        private ContractBase contract2;
        public ConcreteSender(ContractBase contract1, ContractBase contract2)
        {
            this.contract1 = contract1;
            this.contract2 = contract2;
        }

        public override void Send(ContractBase contract, string message)
        {
            if (contract == contract1)
                contract2.Notify(message);
            else if (contract == contract2)
                contract1.Notify(message);
        }
    }

    public abstract class ContractBase
    {
        protected Sender sender;
        public abstract void Send(string message);
        public abstract void Notify(string message);
        public void SetSender(Sender sender)
        {
            this.sender = sender;
        }
    }

    public class ContractA:ContractBase
    {
        public override void Notify(string message)
        {
            Console.WriteLine("Message for B:{0}", message);
        }

        public override void Send(string message)
        {
            this.sender.Send(this, message);
        }
    }

    public class ContractB : ContractBase
    {
        public override void Notify(string message)
        {
            Console.WriteLine("Message for A:{0}", message);
        }

        public override void Send(string message)
        {
            this.sender.Send(this, message);
        }
    }

Python代码实现

class Manager(object):
    def Transfer(self, sendconstract):
        raise NotImplementedError("abstract")

class Contract(object):
    manager=None
    def SetManager(self, manager):
        self.manager=manager
    def Notify(self):
        raise NotImplementedError("abstract")
    def Send(self):
        raise NotImplementedError("abstract")

class ConcreteManager(Manager):
    contract1=None
    contract2=None
    def __init__(self,contract1,contract2):
        self.contract1=contract1
        self.contract2=contract2
    def Transfer(self, sendcontract):
        if sendcontract == self.contract1:
            self.contract2.Notify()
        elif sendcontract == self.contract2:
            self.contract1.Notify()

class ContractA(Contract):
    def Notify(self):
        print "contractB send a message to contractA"
    def Send(self):
        self.manager.Transfer(self)

class ContractB(Contract):
    def Notify(self):
        print "contractA send a message to contractB"
    def Send(self):
        self.manager.Transfer(self)

if __name__ == "__main__":
    contractA=ContractA()
    contractB=ContractB()
    manager=ConcreteManager(contractA, contractB)
    
    contractA.SetManager(manager)
    contractB.SetManager(manager)

    contractA.Send()
    contractB.Send()