第三章：中介模式

一、什么是中介模式

故事
李力最近换了一份工作，大城市换工作意味着就要换一个房子。找房子是一个特别繁琐的过程，而且在北京这座城市，你几乎找不到一手房东，因为90%的房源都掌握在房屋中介的手里。所以李力准备找一个靠谱的中介，通过中介，他省去很多麻烦的细节，合同也是跟中介签的，甚至不知道房东是谁！
我们通过程序来模拟上面找房子的过程。

class HouseInfo:
    """房源信息"""

    def __init__(self, area, price, hasWindow, hasBathroom, hasKitchen, address, owner):
        self.__area = area
        self.__price = price
        self.__hasWindow = hasWindow
        self.__hasBathroom = hasBathroom
        self.__hasKitchen = hasKitchen
        self.__address = address
        self.__owner = owner

    def getAddress(self):
        return self.__address

    def getOwnerName(self):
        return self.__owner.getName()

    def showInfo(self, isShowOwner=True):
        print("面积：" + str(self.__area) + "平方米",
              "价格：" + str(self.__price) + "元",
              "窗户：" + "有" if self.__hasWindow else "没有",
              "卫生间：" + self.__hasBathroom,
              "厨房：" + ("有" if self.__hasKitchen else "没有"),
              "地址：" + self.__address,
              "房东：" + self.getOwnerName() if isShowOwner else "")


class HousingAgency:
    """房屋中介"""

    def __init__(self, name):
        self.__houseInfos = []
        self.__name = name

    def getName(self):
        return self.__name

    def addHouseInfo(self, houseInfo):
        self.__houseInfos.append(houseInfo)

    def removeHouseInfo(self, houseInfo):
        for info in self.__houseInfos:
            if info == houseInfo:
                self.__houseInfos.remove(info)

    def getSearchCondition(self, description):
        """这里有一个将用户描述信息转换成搜索条件的逻辑，为节省篇幅这里原样返回描述"""
        return description

    def getMatchInfos(self, searchCondition):
        """根据房源信息的各个属性查找最匹配的信息，这里直接返回所有房源信息"""
        print(self.getName(), "为您找到以下最适合的房源：")
        for info in self.__houseInfos:
            info.showInfo(False)
        return self.__houseInfos

    def signContract(self, houseInfo, period):
        """与房东签订协议"""
        print(self.getName(), "与房东", houseInfo.getOwnerName(), "签订", houseInfo.getAddress(), "的房子的租赁合同，租期",
              period, "年。合同期内", self.getName(), "有权对其进行使用和转租！")

    def signContracts(self, period):
        for info in self.__houseInfos:
            self.signContract(info, period)


class HouseOwner:
    """房东"""

    def __init__(self, name):
        self.__name = name
        self.__houseInfo = None

    def getName(self):
        return self.__name

    def setHouseInfo(self, address, area, price, hasWindow, bathroom, kitchen):
        self.__houseInfo = HouseInfo(area, price, hasWindow, bathroom, kitchen, address, self)

    def publishHouseInfo(self, agency):
        agency.addHouseInfo(self.__houseInfo)
        print(self.getName() + "在", agency.getName(), "发布房源出租信息:")
        self.__houseInfo.showInfo()


class Customer:
    """用户，租房的贫下中农"""

    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

    def findHouse(self, description, agency):
        print("我是" + self.getName() + ",我想要找一个\"" + description + "\"的房子")
        print()
        return agency.getMatchInfos(agency.getSearchCondition(description))

    def seeHouse(self, houseInfos):
        """去看房子"""
        size = len(houseInfos)
        return houseInfos[size - 1]

    def signContract(self, houseInfo, agency, period):
        """与中介签订协议"""
        print(self.getName(), "与中介", agency.getName(), "签订", houseInfo.getAddress(), "的房子的租赁合同，租期", period, "年。合同期内，",
              self.__name, "有权对其进行使用！")


def testRenting():
    myHome = HousingAgency("我爱我家")
    zhangsan = HouseOwner("张三")
    zhangsan.setHouseInfo("上地西里", 20, 2500, 1, "独立卫生间", 0)
    zhangsan.publishHouseInfo(myHome)
    lisi = HouseOwner("李四")
    lisi.setHouseInfo("当代城市家园", 16, 1800, 1, "公用卫生间", 0)
    lisi.publishHouseInfo(myHome)
    wangwu = HouseOwner("王五")
    wangwu.setHouseInfo("四季花园", 18, 2600, 1, "独立卫生间", 1)
    wangwu.publishHouseInfo(myHome)
    print()

    myHome.signContracts(3)
    print()

    lili = Customer("李力")
    houseInfos = lili.findHouse("18 平方米左右，要有独立卫生间，要有窗户，最好朝南，有厨房更好！价位在2000元左右", myHome)
    print()
    print("正在看房，寻找最合适的住巣......")
    print()
    AppropriateHouse = lili.seeHouse(houseInfos)
    lili.signContract(AppropriateHouse, myHome, 1)


if __name__ == "__main__":
    testRenting()

% python house.py

张三在 我爱我家 发布房源出租信息:
面积：20平方米 价格：2500元 窗户：有 卫生间：独立卫生间 厨房：没有 地址：上地西里 房东：张三
李四在 我爱我家 发布房源出租信息:
面积：16平方米 价格：1800元 窗户：有 卫生间：公用卫生间 厨房：没有 地址：当代城市家园 房东：李四
王五在 我爱我家 发布房源出租信息:
面积：18平方米 价格：2600元 窗户：有 卫生间：独立卫生间 厨房：有 地址：四季花园 房东：王五

我爱我家 与房东 张三 签订 上地西里 的房子的租赁合同，租期 3 年。合同期内 我爱我家 有权对其进行使用和转租！
我爱我家 与房东 李四 签订 当代城市家园 的房子的租赁合同，租期 3 年。合同期内 我爱我家 有权对其进行使用和转租！
我爱我家 与房东 王五 签订 四季花园 的房子的租赁合同，租期 3 年。合同期内 我爱我家 有权对其进行使用和转租！

我是李力,我想要找一个"18 平方米左右，要有独立卫生间，要有窗户，最好朝南，有厨房更好！价位在2000元左右"的房子

我爱我家 为您找到以下最适合的房源：
面积：20平方米 价格：2500元 窗户：有 卫生间：独立卫生间 厨房：没有 地址：上地西里 
面积：16平方米 价格：1800元 窗户：有 卫生间：公用卫生间 厨房：没有 地址：当代城市家园 
面积：18平方米 价格：2600元 窗户：有 卫生间：独立卫生间 厨房：有 地址：四季花园 

正在看房，寻找最合适的住巣......

李力 与中介 我爱我家 签订 四季花园 的房子的租赁合同，租期 1 年。合同期内， 李力 有权对其进行使用！

二、中介模式的定义

用一个中介对象来封装一系列对象交互，中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

在上面的故事剧情中，由中介来承接房客与房东之间的交互过程，可以使整个过程更加畅通、高效。这在程序中叫做中介模式，中介模式又称为调停模式。
在很多系统中，多个类很容易相互耦合，形成网状结构。中介模式的作用就是将这种网状结构（图3-1） 分离成星型结构（图3-2）。这样调整之后，使得对象间的结构更加简洁，交互更加顺畅。

图3-1 网状结构.jpg
图3-2星状结构.jpg

2.1中介模式的的模型抽象

class InteractiveObject:
    """进行交互的对象"""
    pass


class InteractiveObjectImplA:
    """实现类A"""
    pass


class InteractiveObjectImplB:
    """实现类B"""
    pass


class Meditor:
    """中介类"""

    def __init__(self):
        self.__interactiveObjA = InteractiveObjectImplA()
        self.__interactiveObjB = InteractiveObjectImplB()

    def interative(self):
        """进行交互的操作"""
        # 通过self.__interactiveObjA和self.__interactiveObjB完成相应的交互操作
        pass

Mediator就是中介类，用来协调对象间的交互，如故事剧情中的HousingAgency。InteractiveObject是要进行交互的对象，如故事剧情中的HouseOwner和Customer。InteractiveObject可以是互不相干的多个类的对象，也可以是具有继承关系的相似类。

2.2模型说明

1. 设计要点：
   中介模式主要有以下三个角色，在设计中介模式时要找到并区分这些角色:
   (1). 交互对象（InteractiveObject），要进行交互的一系列对象。
   (2). 中介者（Mediator），负责协调各个对象之间的交互。
   (3). 具体中介者（Mediator），中介的具体实现。
2. 应用场景
   (1). 一组对象以定义良好但复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
   (2). 一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。
   (3). 想通过一个中间类来封装多个类的行为，同时又不想生成太多的子类。