Python演绎的精彩故事（二）

最新推荐文章于 2024-10-13 23:13:44 发布

原创最新推荐文章于 2024-10-13 23:13:44 发布 · 置顶 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种名为Softchip的软件架构，重点讲述了其设计理念及模块间如何通过API和Event进行解耦，使得各模块能够专注于自身功能而不必关心其他模块的具体实现。

书接上回。在展示了App最顶层的代码后，我们去看看各模块如何编程。

为了能看懂各模块的代码，首先需要铺垫一下Softchip架构的基本概念和设计规范。

1、任意模块不持有其他模块的实例，自然不再显式使用句柄调用任何方法。

这意味着模块之间不存在编码期和编译期的耦合。

2、每个模块在形式上只与Machine之间存在接口，该接口以API和Event两种形态存在。

API将直接映射到函数入口地址，使用者可直接调用，运行期性能高。主要用于Utility性质的方法和需要高性能的场合。

Event也是同步调用，但运行期性低于API。它的关键作用是在逻辑上切割冗长的调用链。在传统套路中，一个模块在完成自己的处理后，往往还要辛苦地触发其他模块的相关后续动作，这在逻辑上相当于惦记着“别人的事儿”。Event的引入相当于将原来长长的调用链在时间上切分为一个一个的阶段状态。每个模块只需要告诉Machine“X的事情Y完了”，Machine会自动查找谁需要在“X的事情Y完了”之后继续。Machine寻找后续操作的依据就是目标模块在自己的接口中所做的事件监听声明。

3、模块接口由自行声明，包括：

3-1) outAPI : 自己需要调用的API名称列表。

3-2) inAPI : 自己可以提供其他模块调用的API名称列表(附带对应的函数入口地址)。

3-3) inEvent : 自己要监听的事件名称列表(附带对应的事件处理函数入口地址)。

3-4) outEvent: 自己是否要发送事件。

基于各模块声明，Machine自动将各模块“插入”，完成运行期API的绑定和event的分发。

4、概括来说，各模块基本只需要关心“自己的事情”：

4-1) 我提供什么API？

4-2) 我需要调用什么API？

4-3) 我监听并处理什么事件？

4-4) 我产生什么事件？

反过来讲，模块不需要关心“别人的事情”：

4-5) 谁使用我的API？

4-6) 谁提供API给我用？

4-7) 我监听的事件是谁产生的？(我干活之前是谁在干？)

4-8) 我产生的事件谁处理？(我干完了谁来继续？)

举个简单的例子，在TextChat的设计中，LoginWindow登录成功后，不需要显式通知ChatWindow，因为那是ChatWindow的事情。LoginWindow只需要告诉Machine“LoginWindow登录成功了”。Machine会自动找到ChatWindow出来干活，因为ChatWindow之前已经告诉过Machine，如果“LiginWindow登录成功了”，请通知我。

OK，有了上面的铺垫，下面的代码就比较容易看懂了，基本套路是：

1、每个模块都继承Chip类。

2、实现_DefineInterface()方法以完成接口声明。

3、实现_PowerOn()方法以接收Machine发出的"上电"通知。

除此以外，每个模块就完全自由了，爱怎么玩就怎么玩吧。

新版的模块关系参照下图。

from Softchip import Chip

class Controller(Chip):            
    def __init__(self, chipID):
        Chip.__init__(self, chipID)

    def _DefineInterface(self):
        outAPIList = [
            u'connect_server',
            u'disconnect_server',
        ]

        inAPIList = [
            (u'api_start_work', self.__apiStartWork),
        ]

        inEventList = [
            (u'evt_logout_done', self.__evtOnLogoutDone),
        ]

        self.__interface = {
            Chip.TYPE_INT_API  : inAPIList,
            Chip.TYPE_OUT_API  : outAPIList,
            Chip.TYPE_OUT_EVENT: None,
        }

        return self.__interface

    def _PowerOn(self):
        self._eHandler = self.__interface[CHIP.TYPE_OUT_EVENT]

        apiMap = self._DefineInterface[CHIP.TYPE_OUT_API]
        self.__apiConnect    = apiMap[u'connect_server']
        self.__apiDisconnect = apiMap[u'disconnect_server']

    def __apiStartWork(self, serverHost, serverPort):
        succeeded = self.__apiConnect(serverHost, serverPort)

        if not succeeded:
            self._eHandler(u'evt_connect_failed')
        return

        self._eHandler(u'evt_connect_succeeded')

    def __evtOnLogoutDone(self):
        self.__apiDisconnect()


class CommunicationManager(Chip):
    def __init__(self, chipID):
        Chip.__init__(self, chipID)

    def _DefineInterface(self):
        inAPIList = [
            (u'connect_server',    self.__Connect     ),
            (u'disconnect_server', self.__DisConnect  ),
            (u'log_in',            self.__Login       ),
            (u'log_out',           self.__Logout      ),
            (u'invite_friend',     self.__InviteFriend),
            (u'send_message',      self.__SendMessage ),
        ]

        self.__interface = {
            Chip.TYPE_IN_API   : inAPIList,
            Chip.TYPE_OUT_EVENT: None,
        }

        return self.__interface

    def _PowerOn(self):
        self._eHandler = self.__interface[Chip.TYPE_OUT_EVENT]

    def __Connect(serverHost, serverPort):
        pass

    def __DisConnect(serverHost, serverPort):
        pass

    def __Login(username, password):
        pass

    def __Logout():
        pass

    def __InviteFriend(friendName):
        ...
        self.__MessageReceiveThread()
        ...

    def __SendMessage(message):
        pass

    def __MessageReceiveThread():
        while(True):
        ...
        message = xxx
        self._eHandler(u'evt_message_arrived', message)
        ...

class LoginWindow(Chip):
    def __init__(self, chipID):
        Chip.__init__(self, chipID)

    def _DefineInterface(self):
        outAPIList = [
            u'log_in',
            u'log_out',
        ]

        inEventList = [
            (u'evt_connect_succeeded', self.__evtOnConnectSucceeded),
            (u'evt_chat_closed',       self.__evtOnChatClosed      ),
        ]

        self.__interface = {
            Chip.TYPE_OUT_API  : outAPIList,
            Chip.TYPE_INT_EVENT: inEventList,
            Chip.TYPE_OUT_EVENT: None,
        }

        return self.__interface

    def _PowerOn(self):
        self._eHandler = self.__interface[CHIP.TYPE_OUT_EVENT]

        apiMap = self._DefineInterface[CHIP.TYPE_OUT_API]
        self.__apiLogin  = apiMap[u'log_in']
        self.__apiLogout = apiMap[u'log_out']

    def __evtOnConnectSucceeded(self):
        self.Show()

    def __evtOnChatClosed(self):
        self.__apiLogout()

        self._eHandler(u'evt_logout_done')

    def __OnLoginButtonPressed(self):
        username = xxx.GetValue()
        password = xxx.GetValue()
        succeeded = self.__apiLogin(username, password)

        if not succeeded:
            self._eHandler(u'evt_login_failed')
            return

        self._eHandler(u'evt_login_succeeded')
        self.Hide()


class ChatWindow(Chip):
    def __init__(self, chipID):
        Chip.__init__(self, chipID)

    def _DefineInterface(self):
        outAPIList = [
            u'invite_friend',
            u'send_message',
            u'log_out',
            u'disconnect_server',
        ]

        inEventList = [
            (u'evt_login_succeeded', self.__evtOnLoginSucceeded ),
            (u'evt_message_arrived', self.__evtOnMessageReceived),
        ]

        self.__interface = {
            Chip.TYPE_OUT_API  : outAPIList,
            Chip.TYPE_IN_API   : inEventList,
            Chip.TYPE_OUT_EVENT: None,
        }

        return self.__interface

    def _PowerOn(self):
        self._eHandler = self.__interface[CHIP.TYPE_OUT_EVENT]

        apiMap = self._DefineInterface[CHIP.TYPE_OUT_API]
        self.__apiInvite     = apiMap[u'invite_friend']
        self.__apiSendMsg    = apiMap[u'send_message']
        self.__apiLogout     = apiMap[u'log_out']
        self.__apiDisconnect = apiMap[u'disconnect_server']

    def __evtOnLoginSucceeded(self):
        self.Show()

    def __evtOnMessageReceived(self, message):
        xxx.ShowText(message)

    def __OnInviteButtonPressed(self):
        friendName = xxx.GetValue()

        succeeded = self.__apiInvite(friendName, self.__OnMessageReceived)
        if not succeeded:
            self._eHandler(u'evt_invite_failed')
            return

        self._eHandler(u'evt_invite_succeeded')

    def __OnSendButtonPressed(self):
        message = xxx.GetValue()

        self.__apiSendMsg(message)

    def __OnWindowClosing(self):
        self._eHandle(u'evt_chat_closed')

在本系列的下一篇，我们将简要分析一下Softchip框架的意义。