客户端软件的结构思考（一）

最新推荐文章于 2024-07-26 22:58:36 发布
最新推荐文章于 2024-07-26 22:58:36 发布
阅读量599 收藏 2
点赞数 1
分类专栏： Other 文章标签： 客户端 通信结构
本文探讨了PC端软件设计中的关键问题，包括UI流畅性、网络通信层设计及线程间通信。作者分享了多年实践经验，提出了一些独到见解，并以FileZilla为例进行了深入分析。

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

文章中有些思路还是可以借鉴下。不过感觉目前公司项目中应用的通信类结构比文章中介绍的思路要强多了。


https://blog.youkuaiyun.com/analogous_love/article/details/78395024

关于这个标题的内容我思考了很多年，也求索了很多年，每次遇到一份新的质量看起来不错客户端软件的源码时，我总是忍不住地去学习和研究，以期能解决我的困惑，希望能达到我心中“完美”方案的样子。但是直到今天，我仍然没找到所谓的“完美”的答案，但是在这个过程中，因为借鉴、融合和吸纳了许多其他客户端软件的设计思想和技巧，我在做pc软件整体结构设计时越来越得心应手。这个系列文章将是我的成长的心路历程，故事很长，有太多前程往事，如果你准备好听我说一说，那咱们就开始吧。当然，这是这个系列的第一篇。

      注意：下面的软件内容是关于pc端软件的，但是不局限于pc端，移动端也类似。


一、困惑我的问题

       互联网从业多年，设计过很多pc端产品，让这个产品性能卓越、界面流畅、用户体验好一直是我追求的目标。然而，从接触Windows程序设计以来，我一直被这样一些问题困惑着：

1.  对UI流畅性的追求

       软件UI流畅性直接影响到软件的用户体验。Windows程序的消息机制原理决定着主线程必然是UI线程（当然你的程序如果没有GUI那就另当别论了），那么决定一款软件的界面的流畅性很大程度上取决于这个主线程中对Windows消息处理的时耗，对一个消息处理的时耗越长，界面将越卡顿，反之，可能会越流畅。（注意，我这里只是说“可能会越流畅”，因为除了这里讨论的因素外，还有其他因素决定者Windows UI的流畅性，所以这里讨论的因素只是UI流畅性的必要因素之一。）所以，为了达到这个目标，一般比较耗时的操作，例如网络收发数据、磁盘读写较大文件，我都会开启新的工作线程来处理这些耗时的操作。在这种认知和实践过程中，我走了很多弯路，有段时间，我甚至认为所有的非UI逻辑都应该搬到工作线程里面去，这样才能最大程度地保证UI在用户操作时响应的及时性。这种想法其实有点极端了，毫不委婉地说这种想法也是错误的，理由有以下两点：

a. 只要UI线程在处理事件时不阻塞，不做那些明显耗时（人能感知）的操作，不一定要把非UI逻辑移到工作线程里面去；因为现代计算机在执行这些代码时耗相对于人类所能感知的基本上是可以忽略不计的；反过来，因为计算机执行这些消息处理代码非常快，所以消息队列大多数情况下是空的（没有消息），有大量的空闲时间（Idle time）。所以即使你利用这些空闲时间，也不会对界面流畅性有任何影响。反过来说，如果不用，却是“暴殄天物”，大大的浪费了。为什么这么说呢？因为理由b：

b.将非UI逻辑移到工作线程，不仅要开启新的线程，而且新线程在逻辑处理完之后通知UI线程更新界面（线程之间通信），这样的步骤明显地加大了实际的项目代码的复杂度和开发周期，写出来的代码从结构上来说更加复杂、更容易出错。

      所以我的观点是，让UI流畅，只要不是长时间阻塞UI线程，即使是千行万行代码，放到主线程的消息处理函数中执行又何妨。而filezilla的CAsyncSocketEx类代码就是这么做的（filezilla项目下载地址https://github.com/baloonwj/filezilla，电驴客户端也用了CAsyncSocketEx这个类https://github.com/baloonwj/easyMule））。我这里简化一下细枝末节，抽出主干框架：

[cpp]  view plain  copy
  1. //Processes event notifications sent by the sockets or the layers  
  2. static LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)  
  3. {  
  4.     if (message>=WM_SOCKETEX_NOTIFY)  
  5.     {  
  6.         //此处省略195行代码  
  7.     }  
  8.     else if (message == WM_USER) //Notification event sent by a layer  
  9.     {  
  10.         //此处省略138行代码  
  11.     }  
  12.     else if (message == WM_USER+1)  
  13.     {  
  14.         //此处省略40行代码  
  15.     }  
  16.     else if (message == WM_USER + 2)  
  17.     {  
  18.         //此处省略23行代码  
  19.     }  
  20.     else if (message == WM_TIMER)  
  21.     {  
  22.         //次数省略21行代码  
  23.     }  
  24.     return DefWindowProc(hWnd, message, wParam, lParam);  
  25. }  


以上面的代码为例，省略195行那个地方的是收发socket数据的，因为产生这个窗口消息之前，已经检测了相应的socket是否可读可写了。所以不会执行的时候不会阻塞，虽然代码两比较大，因为不会阻塞或者很耗时，所以filezilla的界面还是非常流畅的。

       当然上面的代码有Windows平台特有的特点，Windows平台专门提供了一个WSAAsyncSelect函数来将网络收发数据的通知与Windows窗口关联起来，甚至提供了专门用于处理非UI逻辑的窗口类型（HWND_MESSAGE，术语叫Message-Only Windows：https://msdn.microsoft.com/en-us/library/windows/desktop/ms632599(v=vs.85).aspx#message_only）。


2. pc端网络通信层的设计

        可能有人会觉得这个问题有什么好令你苦恼的呢？请听我说。我理想中的pc端网络通信层应该是专注于网络通信细节，不涉及任何业务细节。其他模块只要调用它封装好的接口就可以了，但是呢，实际上做到这一点很难。举几个例子：

a. 在通信协议不明确的的情况下，解包操作到底应该属于网络层本身还是其他层呢？我说的通信协议不明确，指的是数据包无法按统一格式来解包，比如逐个解析字段，但是字段数量和类型因协议类型不同而发生变化。再比如重连机制，重连一般不仅是操作系用API connec()t函数的重连，还有业务上的重连（比如重新发送登录数据包请求），那必然需要记录用户名、密码等信息，但是这样的信息却是不属于网络层。即使封装成Relogin()这样的函数，网络层在涉及到重连时，很多内部状态也依赖于UI层。

b.心跳包的产生到底应该由网络层本身产生还是其他层，比如UI层。心跳包一般和断线重连、维持连接存活有关，而网络状态一般需要反映在UI界面上，甚至用户可能需要加以干预的（比如用户主动下线或者用户点击界面上重连或者重试按钮）。用户的干预，可能会影响心跳包的发送（例如用户主动下线，就不要发送心跳包），从这个意义上说心跳包似乎不单属于网络层。

c.我曾经存在这样一个认识，假如现在有一个socket与服务器保持连接，这个socket上不仅有主动发包应答，还有服务器随时给你推送的数据。因为socket是全双工的，收和发我一般都会单独开一个线程来操作，这样收数据和发数据就会独立开，在一定的情况下互不影响。如果某一方（收或者发）比较频繁，也不会影响对方。但是，因为同时存在收发两个线程，逻辑处理时就会非常复杂了。举个例子，如果收发数据任一个的过程中出错（不一定是网络出错，可能是逻辑上认为不正确），到底要不要关闭socket，如果关闭了socket，那么在更新m_bConnected这样表示网络状态的字段时，可能会涉及到两个线程同时操作这个字段，那么势必要加锁保护这个变量，有锁的话，势必对性能有影响。这还不是大问题，假设这个软件需要定时重连，那到底是放在收线程重连还是发线程重连呢？重连过程中，另外一个线程需不需要停止或者暂停呢？而这样的设计导致重连逻辑非常复杂，因为：如果如果是用户主动下线或者被踢下线，那么就不该重连。综合上面，在设计代码结构和逻辑时，变得非常复杂。所以，回过头来认真地想一想，对于客户端软件真的有必要做成开启两个线程、收发分离吗？如果我们开启两个线程真能带来效率上的提升，那我们这样做也是可以考虑的。但是对于大多数pc端软件来说，就算你这么做，我觉得带来的效率提升也是上层界面或者用户无法察觉的。既然用户无法察觉，那就不会带来用户体验的提升。然而这种结构，在网络通信层代码结构设计上却非常麻烦。那不如收发数据都放在一个线程中，这样不仅没有了收发两个线程同时读写状态标志需要加锁带来性能损失的问题，而且代码结构也简单许多。

3.工作线程与UI层如何通信的问题

        为了避免在非UI线程直接操作UI元素，目前Windows上的主流做法是工作线程通过PostMessage()携带堆内存数据给UI线程指定的元素发消息。当然在Windows上从来没有规定不能在非UI线程直接操作界面元素，有的时候迫不得已，我们还得这么做(当然这是一种不好的使用方案，应该尽量避免）。举个迫不得已的例子，比如一款即时通讯软件聊天中的窗口抖动效果，实现原理是几个MoveWindow函数调用之间，嵌入几个Sleep函数，代码实例如下：

[cpp]  view plain  copy
  1. RECT rtWindow;  
  2. ::GetWindowRect(hwnd, &rtWindow);  
  3. long x = rtWindow.left;  
  4. long y = rtWindow.top;  
  5. long cxWidth = rtWindow.right - rtWindow.left;  
  6. long cyHeight = rtWindow.bottom - rtWindow.top;  
  7. const long nOffset = 9;  
  8. const long SLEEP_INTERAL = 60;  
  9.   
  10. for (long i = 0; i <= 2; ++i)  
  11. {  
  12.     ::MoveWindow(hwnd, x + nOffset, y - nOffset, cxWidth, cyHeight, FALSE);  
  13.     ::Sleep(SLEEP_INTERAL);  
  14.     ::MoveWindow(hwnd, x - nOffset, y - nOffset, cxWidth, cyHeight, FALSE);  
  15.     ::Sleep(SLEEP_INTERAL);  
  16.     ::MoveWindow(hwnd, x - nOffset, y + nOffset, cxWidth, cyHeight, FALSE);  
  17.     ::Sleep(SLEEP_INTERAL);  
  18.     ::MoveWindow(hwnd, x + nOffset, y + nOffset, cxWidth, cyHeight, FALSE);  
  19.     ::Sleep(SLEEP_INTERAL);  
  20.     ::MoveWindow(hwnd, x, y, cxWidth, cyHeight, FALSE);  
  21.     ::Sleep(SLEEP_INTERAL);  
  22. }  

        如果这段代码放在主线程里面，由于Sleep的使用会导致消息队列中其他消息不能及时处理，导致界面卡顿，尤其是用户在频繁地抖动窗口时（假设允许用户频繁地发送窗口抖动）。所以Teamtalk这款蘑菇街开源的即时通讯软件里面（pc端源码，源码下载： https://github.com/baloonwj/TeamTalk ）是开启单独一个线程来调用上面的代码。但是随着技术的发展，后来的操作系统比如安卓就未必允许这么做了，安卓操作系统是一直不允许在非UI线程直接操作UI元素，即使是一个小小的toast提示。所以，我们只能老老实实地给UI线程PostMessage()，但是这样也存在问题——如果PostMessage时需要携带复杂类型数据，那么我们必须使用堆内存，以确保消息到达UI线程并处理的时候，这块数据的内存仍然存在。这样做存在两个问题：第一，很容易造成内存泄漏，因为工作线程不断new出内存，UI线程不断delete，尤其是在多个中间窗口中转时，万一哪一个中间步骤处理后不继续往下抛消息，这块内存就不会被释放了。我的意思是工作线程A new出数据通过PostMessage发给窗口A，窗口A处理或者不处理再PostMessage给窗口B，B同样处理或不处理再给窗口C，等等。这个过程非常容易造成内存泄漏，比如窗口B被关闭了。为了做到万无一失，我们也许会在各个窗口的事件处理函数里面出现大量半途delete的代码，非常分散，很难管理。我曾经尝试着用C++11 std::shared_ptr或std::unique_ptr这样的智能指针去解决，但是这些智能指针是否在多个线程之间工作的很好，显然是一个问题。当然你可以采用内存池技术，但是让大多数人设计一个不出问题且性能不错的内存池还是有点难度的。这是这种方法存在的缺点之一。缺点之二是，频繁的new和delete将产生大量的内存碎片。虽然客户端软件一般不用考虑这个问题，但是我有时候还是会表示忧虑的。

      既然这种传堆内存的方法不好，另外一种可以使用全局对象，这个全局对象有大量getter和setter方法。但是在每次getter和setter时，由于涉及到多个线程操作，还是同样得加上锁，这又回归到上面提的锁带来的性能降低问题。

      上面的讨论，让我想起仓颉嘉措的诗：“自恐多情损梵行，入山又恐失倾城。世间安得两全法，不负如来不负卿？”如何二者都兼顾呢？真是个头痛的问题。那到底该如何解决呢？我目前的做法是自己定义一个智能指针对象（实现技术是引用计数），PostMessage需要new出来并传递的对象都继承自这个智能指针对象，这样就能做到自释放了。因为是自己定义的智能指针，所以我们可以自己加上额外的代码保证多线程之间的操作的原子性。例如下面的代码可以参考一下：

[cpp]  view plain  copy
  1. class TTPUBAPI atomic_count  
  2. {  
  3. public:  
  4.     explicit atomic_count( long v = 0) ;  
  5.     long increment() ;  
  6.     long decrement() ;  
  7.     long value() const ;      
  8. private:  
  9.   
  10.     atomic_count( atomic_count const & );  
  11.     atomic_count & operator=( atomic_count const & );  
  12.   
  13.     long volatile value_;  
  14. };  
[cpp]  view plain  copy
  1. atomic_count::atomic_count( long v )  
  2. {  
  3.     value_ = v ;  
  4. }  
  5.   
  6. long atomic_count::increment()  
  7. {  
  8.     return InterlockedIncrement( &value_ );  
  9. }  
  10.   
  11. long atomic_count::decrement()  
  12. {  
  13.     return InterlockedDecrement( &value_ );  
  14. }  
  15.   
  16. long atomic_count::value() const  
  17. {  
  18.     return static_cast<long const volatile &>( value_ );  
  19. }  

[cpp]  view plain  copy
  1. class TTPUBAPI safe_object : public tt::atomic_count {  
  2. public:  
  3.     virtual ~safe_object() {}  
  4. } ;  
  5.   
  6. class TTPUBAPI safe_object_ref {  
  7. private:  
  8.     safe_object * object_ ;  
  9.     bool auto_free_ ;  
  10. public:  
  11.     safe_object_ref() ;  
  12.     safe_object_ref(safe_object * object , bool auto_free = true) ;  
  13.     safe_object_ref(const safe_object_ref &ref) ;  
  14.     virtual ~safe_object_ref() ;  
  15.   
  16.     safe_object * get() const;  
  17.   
  18.     bool get_auto_free() const ;  
  19.   
  20.     void attach(safe_object *object , bool auto_free = true) ;  
  21.     void detach() ;  
  22.   
  23.     safe_object_ref& operator=(const safe_object_ref& ref) ;  
  24.     bool operator==(const safe_object_ref& ref) ;  
  25.   
  26.     safe_object * operator->() const ;  
  27.   
  28.     bool check_valid() const ;  
  29. } ;  

[cpp]  view plain  copy
  1. safe_object_ref::safe_object_ref()  
  2. {  
  3.     object_ = NULL ;  
  4.     auto_free_ = true ;  
  5. }  
  6.   
  7. safe_object_ref::safe_object_ref(safe_object * object , bool auto_free)  
  8. {  
  9.     object_ = NULL ;  
  10.     attach(object , auto_free) ;  
  11. }  
  12.   
  13. safe_object_ref::safe_object_ref(const safe_object_ref &ref)  
  14. {  
  15.     object_ = NULL ;  
  16.     attach(ref.object_ , ref.auto_free_) ;  
  17. }  
  18.   
  19. safe_object_ref& safe_object_ref::operator=(const safe_object_ref& ref)  
  20. {  
  21.     attach(ref.object_ , ref.auto_free_) ;  
  22.     return (*this) ;  
  23. }  
  24.   
  25. safe_object_ref::~safe_object_ref()  
  26. {  
  27.     detach() ;  
  28. }  
  29.   
  30. safe_object * safe_object_ref::get() const  
  31. {  
  32.     return object_ ;  
  33. }  
  34.   
  35. bool safe_object_ref::get_auto_free() const  
  36. {  
  37.     return auto_free_ ;   
  38. }  
  39.   
  40. void safe_object_ref::attach(safe_object *object , bool auto_free)   
  41. {  
  42.     if(object != NULL)  
  43.     {  
  44.         object->increment() ;  
  45.     }  
  46.   
  47.     detach() ;  
  48.     object_ = object ;  
  49.     auto_free_ = auto_free ;  
  50. }  
  51.   
  52. void safe_object_ref::detach()   
  53. {  
  54.     if(object_ != NULL)  
  55.     {  
  56.         long val = object_->decrement() ;  
  57.         if(val == 0 && auto_free_ == true)  
  58.         {  
  59.             delete object_ ;  
  60.         }  
  61.         object_ = NULL ;      
  62.     }  
  63. }  
  64.   
  65. safe_object * safe_object_ref::operator->() const  
  66. {  
  67.     return object_ ;  
  68. }  
  69.   
  70. bool safe_object_ref::check_valid() const  
  71. {  
  72.     return (object_ != NULL) ;  
  73. }  
  74.   
  75. bool safe_object_ref::operator==(const safe_object_ref& ref)  
  76. {  
  77.     return (object_ == ref.object_) ;  
  78. }  


二、案例分析

       上面讨论的一些疑惑以及解决办法只是一些具体而微的东西，下面我们来实际讨论一个pc端软件的架构，先看我个人的一款即时通讯软件的pc端（flamingo: 源码下载地址：https://github.com/baloonwj/flamingo，关于flamingo的介绍，您可以参考这篇文章： http://blog.youkuaiyun.com/analogous_love/article/details/69481542 ），这个软件的基础功能和qq一样，可以进行单聊和群聊，当然也可以自定义用户信息，工程代码结构如下：



这个软件的框架结构图如下：


理论上说只要有UI层和网络层就够了，但是为了保证UI界面的流畅和网络通信层单纯高效地收发网络数据，加了一个中间层，即数据加工层。从上往下看，UI层产生调用网络请求或者数据处理请求，如果这些数据需要进行加工，而加工过程比较耗时，那么无论放在UI层还是网络层都不合适；从下往上看，网络上收到数据以后，将这些数据解包后，必须加工成界面层需要的格式，这些数据加工工作也放在数据加工层。我们现在来详细介绍一下每一层如何实现的：

1. 数据加工层

该层实际上是一组线程组成的，每一个线程都是一个从自己的任务队列中取任务执行，这些任务处理完之后产生网络数据包，或者直接放到网络层的发送队列中去，或者直接调用网络层接口函数将数据发出去。

其中SendMsgThread会将自己的队列中任务加工成网络数据格式放到网络层的发送缓冲区中去，RecvMsgThread会自己任务队列中的数据加工成界面层需要的样子，然后PostMessage给界面。而FileTaskThread、ImageTaskThread分别处理即时通讯聊天中与文件和图片相关的任务，根据任务类型，或者发送出去，或者显示到界面上去。每个任务队列的结构都是差不多的（这里以SendMsgThread为例）：

[cpp]  view plain  copy
  1. //处理任务的线程函数  
  2. void CSendMsgThread::Run()  
  3. {  
  4.     while (!m_bStop)  
  5.     {  
  6.         CNetData* lpMsg;  
  7.         {  
  8.             std::unique_lock<std::mutex> guard(m_mtItems);  
  9.             while (m_listItems.empty())  
  10.             {  
  11.                 if (m_bStop)  
  12.                     return;  
  13.   
  14.                 m_cvItems.wait(guard);  
  15.             }  
  16.   
  17.             lpMsg = m_listItems.front();  
  18.             m_listItems.pop_front();  
  19.         }  
  20.   
  21.         HandleItem(lpMsg);  
  22.     }  
  23. }  

[cpp]  view plain  copy
  1. //供UI层调用的、产生新任务的接口函数  
  2. void CSendMsgThread::AddItem(CNetData* pItem)  
  3. {  
  4.     std::lock_guard<std::mutex> guard(m_mtItems);  
  5.     m_listItems.push_back(pItem);  
  6.     m_cvItems.notify_one();  
  7. }  


每个任务处理好之后，会产生界面需要的数据，然后new出堆对象，用PostMessage携带发给UI层，这里以创建群组成功的代码为例：

[cpp]  view plain  copy
  1. BOOL CRecvMsgThread::HandleCreateNewGroupResult(const std::string& strMsg)  
  2. {  
  3.     //{"code":0, "msg": "ok", "groupid": 12345678, "groupname": "我的群名称"}  
  4.     Json::Reader JsonReader;  
  5.     Json::Value JsonRoot;  
  6.     if (!JsonReader.parse(strMsg, JsonRoot))  
  7.         return FALSE;  
  8.   
  9.     if (!JsonRoot["code"].isInt() || !JsonRoot["groupid"].isInt() || !JsonRoot["groupname"].isString())  
  10.         return FALSE;  
  11.   
  12.     CCreateNewGroupResult* pResult = new CCreateNewGroupResult();  
  13.     pResult->m_uAccountID = JsonRoot["groupid"].asInt();  
  14.     strcpy_s(pResult->m_szGroupName, ARRAYSIZE(pResult->m_szGroupName), JsonRoot["groupname"].asCString());  
  15.   
  16.      
  17.     //发给主线程  
  18.     ::PostMessage(m_lpUserMgr->m_hProxyWnd, FMG_MSG_CREATE_NEW_GROUP_RESULT, 0, (LPARAM)pResult);  
  19.   
  20.     return TRUE;  
  21. }  

[cpp]  view plain  copy
  1. //具体每个任务的处理过程  
  2. void CSendMsgThread::HandleItem(CNetData* pNetData)  
  3. {  
  4.     if(pNetData == NULL)  
  5.         return;  
  6.   
  7.     switch(pNetData->m_uType)  
  8.     {  
  9.     case NET_DATA_REGISTER:  
  10.         HandleRegister((const CRegisterRequest*)pNetData);  
  11.         break;  
  12.   
  13.     case NET_DATA_LOGIN:  
  14.         HandleLogon((const CLoginRequest*)pNetData);  
  15.         break;  
  16.   
  17.     case NET_DATA_USER_BASIC_INFO:  
  18.         HandleUserBasicInfo((const CUserBasicInfoRequest*)pNetData);  
  19.         break;  
  20.         case msg_type_creategroup:  
  21.             HandleCreateNewGroupResult(data);  
  22.             break;  
  23.               
  24.     //创建群  
  25.     case msg_type_creategroup:  
  26.         HandleCreateNewGroupResult(data);  
  27.         break;  
  28.   
  29.     //类似代码省略  
  30.   
  31.     default:  
  32. #ifdef _DEBUG  
  33.         ::MessageBox(::GetForegroundWindow(), _T("Be cautious! Unhandled data type in send queen."), _T("Warning"), MB_OK|MB_ICONERROR);  
  34. #else  
  35.         LOG_WARNING("Be cautious! Unhandled data type in send queen.");  
  36. #endif  
  37.     }  
  38.   
  39.     m_seq++;  
  40.       
  41.     delete pNetData;      
  42. }  


2. 网络层

网络层就是按照我上面介绍的同一个socket收发分开成两个线程。

[cpp]  view plain  copy
  1. //网络层发送数据的线程函数  
  2. void CIUSocket::SendThreadProc()  
  3. {  
  4.     LOG_INFO("Recv data thread start...");  
  5.       
  6.     while (!m_bStop)  
  7.     {  
  8.         std::unique_lock<std::mutex> guard(m_mtSendBuf);  
  9.         while (m_strSendBuf.empty())  
  10.         {  
  11.             if (m_bStop)  
  12.                 return;  
  13.   
  14.             m_cvSendBuf.wait(guard);  
  15.         }  
  16.          
  17.         if (!Send())  
  18.         {  
  19.             //进行重连，如果连接不上，则向客户报告错误  
  20.         }  
  21.     }  
  22.   
  23.     LOG_INFO("Recv data thread finish...");  
  24. }  
  25.   
  26.   
  27. //供数据加工层调用的、产生网络数据包的接口函数  
  28. void CIUSocket::Send(const std::string& strBuffer)  
  29. {   
  30.     std::lock_guard<std::mutex> guard(m_mtSendBuf);  
  31.     //插入包头  
  32.     int32_t length = (int32_t)strBuffer.length();  
  33.     msg header = { length };  
  34.     m_strSendBuf.append((const char*)&header, sizeof(header));  
  35.     m_strSendBuf.append(strBuffer.c_str(), length);  
  36.     m_cvSendBuf.notify_one();  
  37. }  

[cpp]  view plain  copy
  1. //接收数据的网络线程  
  2. void CIUSocket::RecvThreadProc()  
  3. {  
  4.     LOG_INFO("Recv data thread start...");  
  5.       
  6.     int nRet;  
  7.     //上网方式   
  8.     DWORD   dwFlags;                
  9.     BOOL    bAlive;  
  10.     while (!m_bStop)  
  11.     {  
  12.         //检测到数据则收数据  
  13.         nRet = CheckReceivedData();  
  14.         //出错  
  15.         if (nRet == -1)  
  16.         {              
  17.             m_pRecvMsgThread->NotifyNetError();  
  18.         }  
  19.         //无数据  
  20.         else if (nRet == 0)  
  21.         {                
  22.             bAlive = ::IsNetworkAlive(&dwFlags);        //是否在线      
  23.             if (!bAlive && ::GetLastError() == 0)  
  24.             {  
  25.                 //网络已经断开  
  26.                 m_pRecvMsgThread->NotifyNetError();  
  27.                 LOG_ERROR("net error, exit recv and send thread...");  
  28.                 Uninit();  
  29.                 break;  
  30.             }  
  31.               
  32.             long nLastDataTime = 0;  
  33.             {  
  34.                 std::lock_guard<std::mutex> guard(m_mutexLastDataTime);  
  35.                 nLastDataTime = m_nLastDataTime;  
  36.             }  
  37.   
  38.             if (m_nHeartbeatInterval > 0)  
  39.             {  
  40.                 if (time(NULL) - nLastDataTime >= m_nHeartbeatInterval)  
  41.                     SendHeartbeatPackage();  
  42.             }  
  43.         }  
  44.         //有数据  
  45.         else if (nRet == 1)  
  46.         {  
  47.             if (!Recv())  
  48.             {  
  49.                 m_pRecvMsgThread->NotifyNetError();  
  50.                 continue;  
  51.             }  
  52.               
  53.             //解包，并将得到的业务数据交给RecvMsgThread的任务队列   
  54.             DecodePackages();  
  55.         }// end if  
  56.     }// end while-loop  
  57.   
  58.     LOG_INFO("Recv data thread finish...");  
  59. }  
  60.   
  61. bool CIUSocket::DecodePackages()  
  62. {  
  63.     //一定要放在一个循环里面解包，因为可能一片数据中有多个包，  
  64.     //对于数据收不全，这个地方我纠结了好久T_T  
  65.     while (true)  
  66.     {  
  67.         //接收缓冲区不够一个包头大小  
  68.         if (m_strRecvBuf.length() <= sizeof(msg))  
  69.             break;  
  70.   
  71.         msg header;  
  72.         memcpy_s(&header, sizeof(msg), m_strRecvBuf.data(), sizeof(msg));  
  73.         //防止包头定义的数据是一些错乱的数据，这里最大限制每个包大小为10M  
  74.         if (header.packagesize >= MAX_PACKAGE_SIZE || header.packagesize <= 0)  
  75.         {  
  76.             LOG_ERROR("Recv a strange packagesize in header, packagesize=%d", header.packagesize);  
  77.             m_strRecvBuf.clear();  
  78.             return false;  
  79.         }  
  80.   
  81.         //接收缓冲区不够一个整包大小（包头+包体）  
  82.         if (m_strRecvBuf.length() < sizeof(msg) + header.packagesize)  
  83.             break;  
  84.   
  85.         //去除包头信息  
  86.         m_strRecvBuf.erase(0, sizeof(msg));  
  87.         std::string strBody;  
  88.         strBody.append(m_strRecvBuf.c_str(), header.packagesize);  
  89.         //去除包体信息  
  90.         m_strRecvBuf.erase(0, header.packagesize);  
  91.   
  92.         m_pRecvMsgThread->AddMsgData(strBody);  
  93.     }  
  94.   
  95.     return true;  
  96. }  



3. UI层

UI层实际上包含两部分，一部分是包含各种程序的界面，还有一个所谓的代理窗口，数据加工层将数据先发到这个窗口上，然后可能在这里进一步处理一下界面的逻辑，然后再发给目标窗口。当然有些数据只是原封不动地转发：

[cpp]  view plain  copy
  1. LRESULT CALLBACK CFlamingoClient::ProxyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)  
  2. {  
  3.     CFlamingoClient* lpFMGClient = (CFlamingoClient*)::GetWindowLong(hWnd, GWL_USERDATA);  
  4.     if (NULL == lpFMGClient)  
  5.         return ::DefWindowProc(hWnd, message, wParam, lParam);  
  6.   
  7.     if (message < FMG_MSG_FIRST || message > FMG_MSG_LAST)  
  8.         return ::DefWindowProc(hWnd, message, wParam, lParam);  
  9.   
  10.     switch (message)  
  11.     {  
  12.     //网络错误  
  13.     case FMG_MSG_NET_ERROR:  
  14.         ::PostMessage(lpFMGClient->m_UserMgr.m_hCallBackWnd, FMG_MSG_NET_ERROR, 0, 0);  
  15.         break;  
  16.   
  17.     case FMG_MSG_HEARTBEAT:  
  18.         lpFMGClient->OnHeartbeatResult(message, wParam, lParam);  
  19.         break;  
  20.   
  21.     case FMG_MSG_NETWORK_STATUS_CHANGE:  
  22.         lpFMGClient->OnNetworkStatusChange(message, wParam, lParam);  
  23.         break;  
  24.       
  25.     case FMG_MSG_REGISTER:              // 注册结果  
  26.         lpFMGClient->OnRegisterResult(message, wParam, lParam);  
  27.         break;  
  28.     case FMG_MSG_LOGIN_RESULT:          // 登录返回消息  
  29.         lpFMGClient->OnLoginResult(message, wParam, lParam);  
  30.         break;  
  31.     case FMG_MSG_LOGOUT_RESULT:         // 注销返回消息  
  32.     case FMG_MSG_UPDATE_BUDDY_HEADPIC:  // 更新好友头像  
  33.         //::MessageBox(NULL, _T("Change headpic"), _T("Change head"), MB_OK);  
  34.     case FMG_MSG_UPDATE_GMEMBER_HEADPIC:    // 更新群成员头像  
  35.     case FMG_MSG_UPDATE_GROUP_HEADPIC:  // 更新群头像  
  36.         ::SendMessage(lpFMGClient->m_UserMgr.m_hCallBackWnd, message, wParam, lParam);  
  37.         break;  
  38.     case FMG_MSG_UPDATE_USER_BASIC_INFO:    //收到用户的基本信息  
  39.         lpFMGClient->OnUpdateUserBasicInfo(message, wParam, lParam);  
  40.         break;  
  41.   
  42.     case FMG_MSG_UPDATE_GROUP_BASIC_INFO:  
  43.         lpFMGClient->OnUpdateGroupBasicInfo(message, wParam, lParam);  
  44.         break;  
  45.   
  46.     case FMG_MSG_MODIFY_USER_INFO:              //修改个人信息结果  
  47.         lpFMGClient->OnModifyInfoResult(message, wParam, lParam);  
  48.         break;  
  49.     case FMG_MSG_RECV_USER_STATUS_CHANGE_DATA:  
  50.         lpFMGClient->OnRecvUserStatusChangeData(message, wParam, lParam);  
  51.         break;  
  52.       
  53.     case FMG_MSG_USER_STATUS_CHANGE:  
  54.         lpFMGClient->OnUserStatusChange(message, wParam, lParam);  
  55.         break;  
  56.   
  57.     case FMG_MSG_UPLOAD_USER_THUMB:  
  58.         lpFMGClient->OnSendConfirmMessage(message, wParam, lParam);  
  59.         break;  
  60.   
  61.     case FMG_MSG_UPDATE_USER_CHAT_MSG_ID:  
  62.         lpFMGClient->OnUpdateChatMsgID(message, wParam, lParam);  
  63.         break;    
  64.     case FMG_MSG_FINDFREIND:  
  65.         lpFMGClient->OnFindFriend(message, wParam, lParam);  
  66.         break;  
  67.   
  68.     case FMG_MSG_DELETEFRIEND:  
  69.         lpFMGClient->OnDeleteFriendResult(message, wParam, lParam);  
  70.         break;  
  71.   
  72.     case FMG_MSG_RECVADDFRIENDREQUSET:  
  73.         lpFMGClient->OnRecvAddFriendRequest(message, wParam, lParam);  
  74.         break;  
  75.   
  76.     case FMG_MSG_CUSTOMFACE_AVAILABLE:  
  77.         lpFMGClient->OnBuddyCustomFaceAvailable(message, wParam, lParam);  
  78.         break;  
  79.   
  80.     case FMG_MSG_MODIFY_PASSWORD_RESULT:  
  81.         lpFMGClient->OnModifyPasswordResult(message, wParam, lParam);  
  82.         break;  
  83.   
  84.     case FMG_MSG_CREATE_NEW_GROUP_RESULT:  
  85.         lpFMGClient->OnCreateNewGroupResult(message, wParam, lParam);  
  86.         break;  
  87.   
  88.     case FMG_MSG_UPDATE_BUDDY_LIST:             //更新好友列表  
  89.         lpFMGClient->OnUpdateBuddyList(message, wParam, lParam);  
  90.         break;  
  91.     case FMG_MSG_UPDATE_GROUP_LIST:     // 更新群列表消息  
  92.         lpFMGClient->OnUpdateGroupList(message, wParam, lParam);  
  93.         break;  
  94.     case FMG_MSG_UPDATE_RECENT_LIST:        // 更新最近联系人列表消息  
  95.         lpFMGClient->OnUpdateRecentList(message, wParam, lParam);  
  96.         break;  
  97.     case FMG_MSG_BUDDY_MSG:             // 好友消息  
  98.         lpFMGClient->OnBuddyMsg(message, wParam, lParam);  
  99.         break;  
  100.     case FMG_MSG_GROUP_MSG:             // 群消息  
  101.         lpFMGClient->OnGroupMsg(message, wParam, lParam);  
  102.         break;  
  103.     case FMG_MSG_SESS_MSG:              // 临时会话消息  
  104.         lpFMGClient->OnSessMsg(message, wParam, lParam);  
  105.         break;  
  106.     case FMG_MSG_STATUS_CHANGE_MSG:     // 好友状态改变消息  
  107.         lpFMGClient->OnStatusChangeMsg(message, wParam, lParam);  
  108.         break;  
  109.     case FMG_MSG_SELF_STATUS_CHANGE:    //自己的状态发生改变，例如被踢下线消息  
  110.         lpFMGClient->OnKickMsg(message, wParam, lParam);  
  111.         break;  
  112.     case FMG_MSG_SCREENSHOT:    //截屏消息  
  113.         lpFMGClient->OnScreenshotMsg(message, wParam, lParam);          
  114.         break;  
  115.     case FMG_MSG_SYS_GROUP_MSG:         // 群系统消息  
  116.         lpFMGClient->OnSysGroupMsg(message, wParam, lParam);  
  117.         break;  
  118.     case FMG_MSG_UPDATE_BUDDY_NUMBER:   // 更新好友号码  
  119.         lpFMGClient->OnUpdateBuddyNumber(message, wParam, lParam);  
  120.         break;  
  121.     case FMG_MSG_UPDATE_GMEMBER_NUMBER: // 更新群成员号码  
  122.         lpFMGClient->OnUpdateGMemberNumber(message, wParam, lParam);  
  123.         break;  
  124.     case FMG_MSG_UPDATE_GROUP_NUMBER:   // 更新群号码  
  125.         lpFMGClient->OnUpdateGroupNumber(message, wParam, lParam);  
  126.         break;  
  127.     case FMG_MSG_UPDATE_BUDDY_SIGN:     // 更新好友个性签名  
  128.         lpFMGClient->OnUpdateBuddySign(message, wParam, lParam);  
  129.         break;  
  130.     case FMG_MSG_UPDATE_GMEMBER_SIGN:   // 更新群成员个性签名  
  131.         lpFMGClient->OnUpdateGMemberSign(message, wParam, lParam);  
  132.         break;  
  133.     case FMG_MSG_UPDATE_BUDDY_INFO:     // 更新用户信息  
  134.         lpFMGClient->OnUpdateBuddyInfo(message, wParam, lParam);  
  135.         break;  
  136.     case FMG_MSG_UPDATE_GMEMBER_INFO:   // 更新群成员信息  
  137.         lpFMGClient->OnUpdateGMemberInfo(message, wParam, lParam);  
  138.         break;  
  139.     case FMG_MSG_UPDATE_GROUP_INFO:     // 更新群信息  
  140.         lpFMGClient->OnUpdateGroupInfo(message, wParam, lParam);  
  141.         break;  
  142.     case FMG_MSG_UPDATE_C2CMSGSIG:      // 更新临时会话信令  
  143.         //lpFMGClient->OnUpdateC2CMsgSig(message, wParam, lParam);  
  144.         break;  
  145.     case FMG_MSG_CHANGE_STATUS_RESULT:  // 改变在线状态返回消息  
  146.         lpFMGClient->OnChangeStatusResult(message, wParam, lParam);  
  147.         break;  
  148.     case FMG_MSG_TARGET_INFO_CHANGE:        //有用户信息发生改变：  
  149.         lpFMGClient->OnTargetInfoChange(message, wParam, lParam);  
  150.         break;  
  151.   
  152.     case FMG_MSG_INTERNAL_GETBUDDYDATA:  
  153.         lpFMGClient->OnInternal_GetBuddyData(message, wParam, lParam);  
  154.         break;  
  155.     case FMG_MSG_INTERNAL_GETGROUPDATA:  
  156.         lpFMGClient->OnInternal_GetGroupData(message, wParam, lParam);  
  157.         break;  
  158.     case FMG_MSG_INTERNAL_GETGMEMBERDATA:  
  159.         lpFMGClient->OnInternal_GetGMemberData(message, wParam, lParam);  
  160.         break;  
  161.     case FMG_MSG_INTERNAL_GROUPID2CODE:  
  162.         return lpFMGClient->OnInternal_GroupId2Code(message, wParam, lParam);  
  163.         break;  
  164.   
  165.     default:  
  166.         return ::DefWindowProc(hWnd, message, wParam, lParam);  
  167.     }  
  168.     return 0;  
  169. }  

这里的代理窗口其实就是上文中说的HWND_MESSAGE窗口。之所以在UI层创建一个窗口进行中转一下的原因是，给所有消息有一个集中处理的机会，方便因数据变化带来的UI逻辑的统一处理（说白了，就是将界面逻辑的代码集中在这个模块这里）。

     UI层与数据加工层通信、往数据加工层的各个线程加工队列中产生数据，是通过一个专门的类提供的各种接口：

[cpp]  view plain  copy
  1. class CFlamingoClient  
  2. {  
  3. public:  
  4.     static CFlamingoClient& GetInstance();  
  5.   
  6. public:  
  7.     CFlamingoClient(void);  
  8.     ~CFlamingoClient(void);  
  9.   
  10. public:  
  11.     bool InitProxyWnd();                                        // 初始化代理窗口  
  12.     bool InitNetThreads();                                      // 初始化网络线程  
  13.     void Uninit();                                              // 反初始化客户端  
  14.   
  15.     void SetServer(PCTSTR pszServer);  
  16.     void SetFileServer(PCTSTR pszServer);  
  17.     void SetImgServer(PCTSTR pszServer);  
  18.     void SetPort(short port);  
  19.     void SetFilePort(short port);  
  20.     void SetImgPort(short port);  
  21.   
  22.     void SetUser(LPCTSTR lpUserAccount, LPCTSTR lpUserPwd);     // 设置UTalk号码和密码  
  23.     void SetLoginStatus(long nStatus);                          // 设置登录状态  
  24.     void SetCallBackWnd(HWND hCallBackWnd);                     // 设置回调窗口句柄  
  25.     void SetRegisterWindow(HWND hwndRegister);                  // 设置注册结果的反馈窗口  
  26.     void SetModifyPasswordWindow(HWND hwndModifyPassword);      // 设置修改密码结果反馈窗口  
  27.     void SetCreateNewGroupWindow(HWND hwndCreateNewGroup);      // 设置创建群组结果反馈窗口  
  28.     void SetFindFriendWindow(HWND hwndFindFriend);              // 设置查找用户结果反馈窗口  
  29.   
  30.     void StartCheckNetworkStatusTask();                           
  31.     //void StartGetUserInfoTask(long nType);                    //获取好友  
  32.     void StartHeartbeatTask();  
  33.   
  34.     void Register(PCTSTR pszAccountName, PCTSTR pszNickName, PCTSTR pszPassword);  
  35.     void Login(int nStatus = STATUS_ONLINE);                    // 登录  
  36.     BOOL Logout();                                              // 注销  
  37.     void CancelLogin();                                         // 取消登录  
  38.     void GetFriendList();                                       // 获取好友列表  
  39.     void GetGroupMembers(int32_t groupid);                      // 获取群成员  
  40.     void ChangeStatus(int32_t nNewStatus);                      // 更改自己的登录状态          
  41.   
  42.     BOOL FindFriend(PCTSTR pszAccountName, long nType, HWND hReflectionWnd);// 查找好友  
  43.     BOOL AddFriend(UINT uAccountToAdd);  
  44.     void ResponseAddFriendApply(UINT uAccountID, UINT uCmd);    //回应加好友请求任务  
  45.     BOOL DeleteFriend(UINT uAccountID);                         // 删除好友  
  46.     BOOL UpdateLogonUserInfo(PCTSTR pszNickName,   
  47.                              PCTSTR pszSignature,  
  48.                              UINT uGender,  
  49.                              long nBirthday,  
  50.                              PCTSTR pszAddress,  
  51.                              PCTSTR pszPhone,  
  52.                              PCTSTR pszMail,  
  53.                              UINT uSysFaceID,  
  54.                              PCTSTR pszCustomFacePath,  
  55.                              BOOL bUseCustomThumb);  
  56.   
  57.     void SendHeartbeatMessage();  
  58.     void ModifyPassword(PCTSTR pszOldPassword, PCTSTR pszNewPassword);  
  59.     void CreateNewGroup(PCTSTR pszGroupName);  
  60.     void ChangeStatus(long nStatus);                            // 改变在线状态  
  61.     void UpdateBuddyList();                                     // 更新好友列表  
  62.     void UpdateGroupList();                                     // 更新群列表  
  63.     void UpdateRecentList();                                    // 更新最近联系人列表  
  64.     void UpdateBuddyInfo(UINT nUTalkUin);                       // 更新好友信息  
  65.     void UpdateGroupMemberInfo(UINT nGroupCode, UINT nUTalkUin);// 更新群成员信息  
  66.     void UpdateGroupInfo(UINT nGroupCode);                      // 更新群信息  
  67.     void UpdateBuddyNum(UINT nUTalkUin);                        // 更新好友号码  
  68.     void UpdateGroupMemberNum(UINT nGroupCode, UINT nUTalkUin); // 更新群成员号码  
  69.     void UpdateGroupMemberNum(UINT nGroupCode, std::vector<UINT>* arrUTalkUin);   // 更新群成员号码  
  70.     void UpdateGroupNum(UINT nGroupCode);                                           // 更新群号码  
  71.     void UpdateBuddySign(UINT nUTalkUin);                                           // 更新好友个性签名  
  72.     void UpdateGroupMemberSign(UINT nGroupCode, UINT nUTalkUin);                    // 更新群成员个性签名  
  73.     void ModifyUTalkSign(LPCTSTR lpSign);                                           // 修改UTalk个性签名  
  74.     void UpdateBuddyHeadPic(UINT nUTalkUin, UINT nUTalkNum);                        // 更新好友头像  
  75.     void UpdateGroupMemberHeadPic(UINT nGroupCode, UINT nUTalkUin, UINT nUTalkNum); // 更新群成员头像  
  76.     void UpdateGroupHeadPic(UINT nGroupCode, UINT nGroupNum);                       // 更新群头像  
  77.     void UpdateGroupFaceSignal();                                                   // 更新群表情信令  
  78.   
  79.   
  80.     BOOL SendBuddyMsg(UINT nFromUin, const tstring& strFromNickName, UINT nToUin, const tstring& strToNickName, time_t nTime, const tstring& strChatMsg, HWND hwndFrom = NULL);// 发送好友消息  
  81.     BOOL SendGroupMsg(UINT nGroupId, time_t nTime, LPCTSTR lpMsg, HWND hwndFrom);   // 发送群消息  
  82.     BOOL SendSessMsg(UINT nGroupId, UINT nToUin, time_t nTime, LPCTSTR lpMsg);      // 发送临时会话消息  
  83.     BOOL SendMultiChatMsg(const std::set<UINT> setAccountID, time_t nTime, LPCTSTR lpMsg, HWND hwndFrom=NULL);//群发消息  
  84.   
  85.     BOOL IsOffline();                                           // 是否离线状态  
  86.   
  87.   
  88.     long GetStatus();                                           // 获取在线状态  
  89.     BOOL GetVerifyCodePic(const BYTE*& lpData, DWORD& dwSize);  // 获取验证码图片  
  90.     void SetBuddyListAvailable(BOOL bAvailable);  
  91.     BOOL IsBuddyListAvailable();  
  92.   
  93.     CBuddyInfo* GetUserInfo(UINT uAccountID=0);         // 获取用户信息  
  94.     CBuddyList* GetBuddyList();                     // 获取好友列表  
  95.     CGroupList* GetGroupList();                     // 获取群列表  
  96.     CRecentList* GetRecentList();                       // 获取最近联系人列表  
  97.     CMessageList* GetMessageList();                 // 获取消息列表  
  98.     CMessageLogger* GetMsgLogger();                 // 获取消息记录管理器  
  99.   
  100.     tstring GetUserFolder();                            // 获取用户文件夹存放路径  
  101.   
  102.     tstring GetPersonalFolder(UINT nUserNum = 0);       // 获取个人文件夹存放路径  
  103.     tstring GetChatPicFolder(UINT nUserNum = 0);        // 获取聊天图片存放路径  
  104.   
  105.     tstring GetUserHeadPicFullName(UINT nUserNum = 0);  // 获取用户头像图片全路径文件名  
  106.     tstring GetBuddyHeadPicFullName(UINT nUTalkNum);    // 获取好友头像图片全路径文件名  
  107.     tstring GetGroupHeadPicFullName(UINT nGroupNum);    // 获取群头像图片全路径文件名  
  108.     tstring GetSessHeadPicFullName(UINT nUTalkNum);     // 获取群成员头像图片全路径文件名  
  109.     tstring GetChatPicFullName(LPCTSTR lpszFileName);   // 获取聊天图片全路径文件名  
  110.     tstring GetMsgLogFullName(UINT nUserNum = 0);       // 获取消息记录全路径文件名  
  111.   
  112.     BOOL IsNeedUpdateBuddyHeadPic(UINT nUTalkNum);      // 判断是否需要更新好友头像  
  113.     BOOL IsNeedUpdateGroupHeadPic(UINT nGroupNum);      // 判断是否需要更新群头像  
  114.     BOOL IsNeedUpdateSessHeadPic(UINT nUTalkNum);       // 判断是否需要更新群成员头像  
  115.   
  116.     void RequestServerTime();                           // 获取服务器时间  
  117.     time_t GetCurrentTime();                            // 获取当前时间(以服务器时间为基准)  
  118.     void LoadUserConfig();                              // 加载用户设置信息  
  119.     void SaveUserConfig();                              // 保存用户设置信息  
  120.   
  121.     void GoOnline();                                      
  122.     void GoOffline();                                   // 掉线或者下线  
  123.   
  124.     long ParseBuddyStatus(long nFlag);                  // 解析用户在线状态  
  125.     void CacheBuddyStatus();                            // 缓存用户在线状态  
  126.     BOOL SetBuddyStatus(UINT uAccountID, long nStatus);  
  127.     BOOL SetBuddyClientType(UINT uAccountID, long nNewClientType);  
  128.   
  129. private:  
  130.     void OnHeartbeatResult(UINT message, WPARAM wParam, LPARAM lParam);  
  131.     void OnNetworkStatusChange(UINT message, WPARAM wParam, LPARAM lParam);  
  132.     void OnRegisterResult(UINT message, WPARAM wParam, LPARAM lParam);  
  133.     void OnLoginResult(UINT message, WPARAM wParam, LPARAM lParam);  
  134.     void OnUpdateUserBasicInfo(UINT message, WPARAM wParam, LPARAM lParam);  
  135.     void OnUpdateGroupBasicInfo(UINT message, WPARAM wParam, LPARAM lParam);  
  136.     void OnModifyInfoResult(UINT message, WPARAM wParam, LPARAM lParam);  
  137.     void OnRecvUserStatusChangeData(UINT message, WPARAM wParam, LPARAM lParam);  
  138.     void OnRecvAddFriendRequest(UINT message, WPARAM wParam, LPARAM lParam);  
  139.     void OnUserStatusChange(UINT message, WPARAM wParam, LPARAM lParam);  
  140.     void OnSendConfirmMessage(UINT message, WPARAM wParam, LPARAM lParam);  
  141.     void OnUpdateChatMsgID(UINT message, WPARAM wParam, LPARAM lParam);  
  142.     void OnFindFriend(UINT message, WPARAM wParam, LPARAM lParam);  
  143.     void OnBuddyCustomFaceAvailable(UINT message, WPARAM wParam, LPARAM lParam);  
  144.     void OnModifyPasswordResult(UINT message, WPARAM wParam, LPARAM lParam);  
  145.     void OnCreateNewGroupResult(UINT message, WPARAM wParam, LPARAM lParam);      
  146.     void OnDeleteFriendResult(UINT message, WPARAM wParam, LPARAM lParam);  
  147.     void OnUpdateBuddyList(UINT message, WPARAM wParam, LPARAM lParam);  
  148.     void OnUpdateGroupList(UINT message, WPARAM wParam, LPARAM lParam);  
  149.     void OnUpdateRecentList(UINT message, WPARAM wParam, LPARAM lParam);  
  150.     void OnBuddyMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  151.     void OnGroupMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  152.     void OnSessMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  153.     void OnSysGroupMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  154.     void OnStatusChangeMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  155.     void OnKickMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  156.     void OnScreenshotMsg(UINT message, WPARAM wParam, LPARAM lParam);  
  157.     void OnUpdateBuddyNumber(UINT message, WPARAM wParam, LPARAM lParam);  
  158.     void OnUpdateGMemberNumber(UINT message, WPARAM wParam, LPARAM lParam);  
  159.     void OnUpdateGroupNumber(UINT message, WPARAM wParam, LPARAM lParam);  
  160.     void OnUpdateBuddySign(UINT message, WPARAM wParam, LPARAM lParam);  
  161.     void OnUpdateGMemberSign(UINT message, WPARAM wParam, LPARAM lParam);  
  162.     void OnUpdateBuddyInfo(UINT message, WPARAM wParam, LPARAM lParam);  
  163.     void OnUpdateGMemberInfo(UINT message, WPARAM wParam, LPARAM lParam);  
  164.     void OnUpdateGroupInfo(UINT message, WPARAM wParam, LPARAM lParam);  
  165.     //void OnUpdateC2CMsgSig(UINT message, WPARAM wParam, LPARAM lParam);  
  166.     void OnChangeStatusResult(UINT message, WPARAM wParam, LPARAM lParam);  
  167.     void OnTargetInfoChange(UINT message, WPARAM wParam, LPARAM lParam);  
  168.   
  169.     void OnInternal_GetBuddyData(UINT message, WPARAM wParam, LPARAM lParam);  
  170.     void OnInternal_GetGroupData(UINT message, WPARAM wParam, LPARAM lParam);  
  171.     void OnInternal_GetGMemberData(UINT message, WPARAM wParam, LPARAM lParam);  
  172.     UINT OnInternal_GroupId2Code(UINT message, WPARAM wParam, LPARAM lParam);  
  173.   
  174.     BOOL CreateProxyWnd();      // 创建代理窗口  
  175.     BOOL DestroyProxyWnd();     // 销毁代理窗口  
  176.     static LRESULT CALLBACK ProxyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);  
  177.   
  178. public:  
  179.     CUserMgr                        m_UserMgr;  
  180.     CCheckNetworkStatusTask         m_CheckNetworkStatusTask;  
  181.   
  182.     CSendMsgThread                  m_SendMsgThread;  
  183.     CRecvMsgThread                  m_RecvMsgThread;  
  184.     CFileTaskThread                 m_FileTask;  
  185.     CImageTaskThread                m_ImageTask;  
  186.       
  187.     CUserConfig                     m_UserConfig;  
  188.   
  189.     std::vector<AddFriendInfo*>       m_aryAddFriendInfo;  
  190.   
  191. private:  
  192.     time_t                          m_ServerTime;           //服务器时间  
  193.     DWORD                           m_StartTime;            //开始计时的时间  
  194.   
  195.     BOOL                            m_bNetworkAvailable;    //网络是否可用  
  196.   
  197.     HWND                            m_hwndRegister;         //注册窗口  
  198.     HWND                            m_hwndFindFriend;       //查找好友窗口  
  199.     HWND                            m_hwndModifyPassword;   //修改密码窗口  
  200.     HWND                            m_hwndCreateNewGroup;   //创建群组窗口  
  201.   
  202.     BOOL                            m_bBuddyIDsAvailable;   //用户好友ID是否可用  
  203.     BOOL                            m_bBuddyListAvailable;  //用户好友列表信息是否可用  
  204.   
  205.     std::map<UINT, long>          m_mapUserStatusCache;   //好友在线状态缓存：key是账户ID，value是状态码  
  206.     std::map<UINT, UINT>          m_mapAddFriendCache;    //加好友操作缓存: key是账户ID，value是操作码  
  207.   
  208.     long                            m_nGroupCount;  
  209.     BOOL                            m_bGroupInfoAvailable;  
  210.     BOOL                            m_bGroupMemberInfoAvailable;  
  211. };  

举个具体的例子，以删除好友为例：

[cpp]  view plain  copy
  1. // 删除好友  
  2. BOOL CFlamingoClient::DeleteFriend(UINT uAccountID)  
  3. {  
  4.     //TODO: 先判断是否离线  
  5.     COperateFriendRequest* pRequest = new COperateFriendRequest();  
  6.     pRequest->m_uCmd = Delete;  
  7.     pRequest->m_uAccountID = uAccountID;  
  8.       
  9.     m_SendMsgThread.AddItem(pRequest);  
  10.   
  11.     return TRUE;  
  12. }  


实际上也是产生一个任务丢到SendMsgThread所属的消息队列中去。

我的即时通讯软flamingo pc端的基本框架大致介绍完毕了。这种架构，基本上是目前大多数客户端软件的通用结构（包括安卓，上文中介绍的filezilla是将利用Windows API WSAAsyncSelect将UI层与网络层合并了），只不过不同的软件在细节上可能做的比flamingo好。那么我们来看下flamingo pc端的这种设计在细节上有哪些地方需要优化的呢？

1. 缺点一： 请求是无状态无反馈的。比如某个请求，加到SendMsgThread中之后，如果处理失败（可能在数据加工层或者网络层没发出去），对应的产生这个请求的UI元素无法得到任何反馈，所以也就没法重试。解决办法是，UI元素记录一下自己发送的请求，然后开启一个定时器，在一定时间后，该请求无应答，则重试。

2. 缺点二： 网络层收发不必分开，原因上文也具体分析过了。这种分开，导致我现在给flamingo增加断线重连机制非常麻烦。因为涉及到用户主动下线、掉线和被同名用户在另外机器上登录踢下线。这也是今后flamingo要重点优化的一个地方。

3. 缺点三：有些数据可以抽象出一个公共的模块变量出来，允许在多个线程（UI线程和数据加工层）中读写（当然需要加锁），这样可以减少一部分通过PostMessage携带的、new出来的对象。（安卓中这种方法就很舒服了，因为Java中不需要自己做内存回收）。其实这种方法是结合上文中讨论的两个方法的综合运用。

4. 缺点四：缺少定时器，缺点一我介绍了UI层需要的定时器，其实网络层也需要一个定时器，可用于网络层心跳包的发送、或者自动重连。所以定时器是pc端软件中非常重要的一个模块。


三、pc端软件中很有意思的设计技巧

当然，客户端软件还涉及到一些具体的细节设计技巧。这里介绍几个：

1. 放入任务队列中、new出来的任务对象是使用它的父模块删除，还是自我删除，所以有的客户端软件给每个这样的任务提供一个自我删除的接口，里面delete this。看看teamtalk pc版就是这么做的：

[cpp]  view plain  copy
  1. struct MODULE_API IHttpOperation : public ICallbackOpertaion  
  2. {  
  3. public:  
  4.     IHttpOperation(IOperationDelegate& callback)  
  5.         :ICallbackOpertaion(callback)  
  6.     {  
  7.   
  8.     }  
  9.     inline void cancel() { m_bIsCancel = TRUE; }  
  10.     inline BOOL isCanceled() const { return m_bIsCancel; }  
  11.   
  12.     virtual void release() = 0;  
  13.   
  14. private:  
  15.     BOOL        m_bIsCancel = FALSE;  
  16. };  

注意release()和cancel()接口，release()接口一般就是自我释放资源和删除自己，cancel()允许取消任务的执行。


2. 同步的、且带超时时间的网络通信接口该怎么设计

一个系统在启动之前，或者在登录成功之前，其实一般不需要启动上面所说数据加工层和网络层。所以登录成功之前，尤其是有登录界面的客户端，都可以使用同步的登录接口，因为登录之前服务器一般不会有推送的数据给你，一般你发生的什么请求，收到的数据就是该请求的应答。具体做法如下：

a. 用户点击了登录按钮之后，开启一个新的线程（开启新线程是为了防止网络通信阻塞界面）

b. 新线程函数中，调用网络接口API发送数据和接收应答。当然涉及的socket，你仍然需要设置成非阻塞的，这样，你可以在网络接口中不必等待或者调用select函数等待socket可写或者可读一段你规定的时间。

c. 这样的接口设计，你可以先连接服务器，再检测socket是否可写，如果可写，发送数据，接着检测socket是否可读，如果可读，收取一个包头数据大小，接着根据包头数据中指定的包体大小收取一个包体大小，然后解包数据，最后判断是否是正确的应答。

d. 需要注意的是，新开启的工作线程得到结果以后或者一定时间内超时，向界面元素反馈信息，也是通过PostMessage返回给界面的。

我以flamingo里面的登录过程为例：

[cpp]  view plain  copy
  1. // “登录”按钮  
  2. void CLoginDlg::OnBtn_Login(UINT uNotifyCode, int nID, CWindow wndCtl)  
  3. {     
  4.     if (m_cboUid.IsDefaultText())  
  5.     {  
  6.         MessageBox(_T("请输入账号！"), _T("提示"), MB_OK|MB_ICONINFORMATION);  
  7.         m_cboUid.SetFocus();  
  8.         return;  
  9.     }  
  10.   
  11.     if (m_edtPwd.IsDefaultText())  
  12.     {  
  13.         MessageBox(_T("请输入密码！"), _T("提示"), MB_OK|MB_ICONINFORMATION);  
  14.         m_edtPwd.SetFocus();  
  15.         return;  
  16.     }  
  17.   
  18.     m_cboUid.GetWindowText(m_stAccountInfo.szUser, ARRAYSIZE(m_stAccountInfo.szUser));  
  19.     m_edtPwd.GetWindowText(m_stAccountInfo.szPwd, ARRAYSIZE(m_stAccountInfo.szPwd));  
  20.     m_stAccountInfo.bRememberPwd = (m_btnRememberPwd.GetCheck() == BST_CHECKED);  
  21.     m_stAccountInfo.bAutoLogin = (m_btnAutoLogin.GetCheck() == BST_CHECKED);  
  22.   
  23.     // 记录当前用户信息  
  24.     m_lpFMGClient->m_UserMgr.m_UserInfo.m_strAccount = m_stAccountInfo.szUser;  
  25.       
  26.     //开启线程  
  27.     HANDLE hLoginThread = (HANDLE)::_beginthreadex(NULL, 0, LoginThreadProc, this, 0, NULL);  
  28.     if (hLoginThread != NULL)  
  29.         ::CloseHandle(hLoginThread);  
  30.   
  31.     EndDialog(IDOK);  
  32. }  

[cpp]  view plain  copy
  1. UINT CLoginDlg::LoginThreadProc(void* pParam)  
  2. {  
  3.     CLoginDlg* pLoginDlg = (CLoginDlg*)pParam;  
  4.     if (pLoginDlg == NULL)  
  5.         return 0;  
  6.   
  7.     char szUser[64] = { 0 };  
  8.     EncodeUtil::UnicodeToUtf8(pLoginDlg->m_stAccountInfo.szUser, szUser, ARRAYSIZE(szUser));  
  9.     char szPassword[64] = { 0 };  
  10.     EncodeUtil::UnicodeToUtf8(pLoginDlg->m_stAccountInfo.szPwd, szPassword, ARRAYSIZE(szPassword));  
  11.   
  12.     std::string strReturnData;  
  13.     //调用网络接口，超时时间设置为3秒  
  14.     bool bRet = CIUSocket::GetInstance().Login(szUser, szPassword, 1, 1, 3000, strReturnData);  
  15.     int nRet = LOGIN_FAILED;  
  16.     CLoginResult* pLoginResult = new CLoginResult();  
  17.     pLoginResult->m_LoginResultCode = LOGIN_FAILED;  
  18.     if (bRet)  
  19.     {  
  20.         //{"code": 0, "msg": "ok", "userid": 8}  
  21.         Json::Reader JsonReader;  
  22.         Json::Value JsonRoot;  
  23.         if (JsonReader.parse(strReturnData, JsonRoot) && !JsonRoot["code"].isNull() && JsonRoot["code"].isInt())  
  24.         {  
  25.             int nRetCode = JsonRoot["code"].asInt();  
  26.   
  27.             if (nRetCode == 0)  
  28.             {  
  29.                 if (!JsonRoot["userid"].isInt() || !JsonRoot["username"].isString() || !JsonRoot["nickname"].isString() ||  
  30.                     !JsonRoot["facetype"].isInt() || !JsonRoot["gender"].isInt() || !JsonRoot["birthday"].isInt() ||  
  31.                     !JsonRoot["signature"].isString() || !JsonRoot["address"].isString() ||  
  32.                     !JsonRoot["customface"].isString() || !JsonRoot["phonenumber"].isString() ||  
  33.                     !JsonRoot["mail"].isString())  
  34.                 {  
  35.                     LOG_ERROR(_T("login failed, login response json is invalid, json=%s"), strReturnData.c_str());  
  36.                     pLoginResult->m_LoginResultCode = LOGIN_FAILED;  
  37.                 }  
  38.                 else  
  39.                 {  
  40.                     pLoginResult->m_LoginResultCode = 0;  
  41.                     pLoginResult->m_uAccountID = JsonRoot["userid"].asInt();  
  42.                     strcpy_s(pLoginResult->m_szAccountName, ARRAYSIZE(pLoginResult->m_szAccountName), JsonRoot["username"].asCString());  
  43.                     strcpy_s(pLoginResult->m_szNickName, ARRAYSIZE(pLoginResult->m_szNickName), JsonRoot["nickname"].asCString());  
  44.                     //pLoginResult->m_nStatus = JsonRoot["status"].asInt();  
  45.                     pLoginResult->m_nFace = JsonRoot["facetype"].asInt();  
  46.                     pLoginResult->m_nGender = JsonRoot["gender"].asInt();  
  47.                     pLoginResult->m_nBirthday = JsonRoot["birthday"].asInt();  
  48.                     strcpy_s(pLoginResult->m_szSignature, ARRAYSIZE(pLoginResult->m_szSignature), JsonRoot["signature"].asCString());  
  49.                     strcpy_s(pLoginResult->m_szAddress, ARRAYSIZE(pLoginResult->m_szAddress), JsonRoot["address"].asCString());  
  50.                     strcpy_s(pLoginResult->m_szCustomFace, ARRAYSIZE(pLoginResult->m_szCustomFace), JsonRoot["customface"].asCString());  
  51.                     strcpy_s(pLoginResult->m_szPhoneNumber, ARRAYSIZE(pLoginResult->m_szPhoneNumber), JsonRoot["phonenumber"].asCString());  
  52.                     strcpy_s(pLoginResult->m_szMail, ARRAYSIZE(pLoginResult->m_szMail), JsonRoot["mail"].asCString());  
  53.                 }  
  54.             }  
  55.             else if (nRetCode == 102)  
  56.                 pLoginResult->m_LoginResultCode = LOGIN_UNREGISTERED;  
  57.             else if (nRetCode == 103)  
  58.                 pLoginResult->m_LoginResultCode = LOGIN_PASSWORD_ERROR;  
  59.             else  
  60.                 pLoginResult->m_LoginResultCode = LOGIN_FAILED;  
  61.         }      
  62.     }  
  63.     //m_lpUserMgr为野指针  
  64.     ::PostMessage(pLoginDlg->m_lpFMGClient->m_UserMgr.m_hProxyWnd, FMG_MSG_LOGIN_RESULT, 0, (LPARAM)pLoginResult);  
  65.   
  66.     return 1;  
  67. }  

[cpp]  view plain  copy
  1. bool CIUSocket::Login(const char* pszUser, const char* pszPassword, int nClientType, int nOnlineStatus, int nTimeout, std::string& strReturnData)  
  2. {  
  3.     if (!Connect())  
  4.         return false;  
  5.       
  6.     char szLoginInfo[256] = { 0 };  
  7.     sprintf_s(szLoginInfo,  
  8.         ARRAYSIZE(szLoginInfo),  
  9.         "{\"username\": \"%s\", \"password\": \"%s\", \"clienttype\": %d, \"status\": %d}",  
  10.         pszUser,  
  11.         pszPassword,  
  12.         nClientType,  
  13.         nOnlineStatus);  
  14.   
  15.     std::string outbuf;  
  16.     BinaryWriteStream writeStream(&outbuf);  
  17.     writeStream.WriteInt32(msg_type_login);  
  18.     writeStream.WriteInt32(0);  
  19.     //std::string data = szLoginInfo;  
  20.     writeStream.WriteCString(szLoginInfo, strlen(szLoginInfo));  
  21.     writeStream.Flush();  
  22.   
  23.     LOG_INFO("Request logon: Account=%s, Password=*****, Status=%d, LoginType=%d.", pszUser, pszPassword, nOnlineStatus, nClientType);  
  24.   
  25.     int32_t length = (int32_t)outbuf.length();  
  26.     msg header = { length };  
  27.     std::string strSendBuf;  
  28.     strSendBuf.append((const char*)&header, sizeof(header));  
  29.     strSendBuf.append(outbuf.c_str(), length);  
  30.       
  31.     //超时时间设置为3秒  
  32.     if (!SendData(strSendBuf.c_str(), strSendBuf.length(), nTimeout))  
  33.         return false;  
  34.   
  35.     memset(&header, 0, sizeof(header));  
  36.     if (!RecvData((char*)&header, sizeof(header), nTimeout))  
  37.         return false;  
  38.       
  39.     if (header.packagesize <= 0)  
  40.         return false;  
  41.   
  42.     CMiniBuffer minBuff(header.packagesize);  
  43.     if (!RecvData(minBuff, header.packagesize, nTimeout))  
  44.     {  
  45.         return false;  
  46.     }  
  47.   
  48.     BinaryReadStream readStream(minBuff, header.packagesize);  
  49.     int32_t cmd;  
  50.     if (!readStream.ReadInt32(cmd))  
  51.         return false;  
  52.   
  53.     int32_t seq;  
  54.     if (!readStream.ReadInt32(seq))  
  55.         return false;  
  56.   
  57.     size_t datalength;  
  58.     if (!readStream.ReadString(&strReturnData, 0, datalength))  
  59.     {  
  60.         return false;  
  61.     }  
  62.   
  63.     return true;  
  64. }  

[cpp]  view plain  copy
  1. bool CIUSocket::SendData(const char* pBuffer, int nBuffSize, int nTimeout)  
  2. {  
  3.     //TODO：这个地方可以先加个select判断下socket是否可写  
  4.   
  5.     int64_t nStartTime = time(NULL);  
  6.       
  7.     int nSentBytes = 0;  
  8.     int nRet = 0;  
  9.     while (true)  
  10.     {  
  11.         nRet = ::send(m_hSocket, pBuffer, nBuffSize, 0);  
  12.         if (nRet == SOCKET_ERROR)  
  13.         {  
  14.             //对方tcp窗口太小暂时发布出去，同时没有超时，则继续等待  
  15.             if (::WSAGetLastError() == WSAEWOULDBLOCK && time(NULL) - nStartTime < nTimeout)  
  16.             {  
  17.                 continue;  
  18.             }  
  19.             else  
  20.                 return false;  
  21.         }  
  22.         else if (nRet < 1)  
  23.         {  
  24.             //一旦出现错误就立刻关闭Socket  
  25.             LOG_ERROR("Send data error, disconnect server:%s, port:%d.", m_strServer.c_str(), m_nPort);  
  26.             Close();  
  27.             return false;  
  28.         }  
  29.   
  30.         nSentBytes += nRet;  
  31.         if (nSentBytes >= nBuffSize)  
  32.             break;  
  33.   
  34.         pBuffer += nRet;  
  35.         nBuffSize -= nRet;  
  36.   
  37.         ::Sleep(1);  
  38.     }  
  39.       
  40.     return true;  
  41. }  

[cpp]  view plain  copy
  1. bool CIUSocket::RecvData(char* pszBuff, int nBufferSize, int nTimeout)  
  2. {  
  3.     int64_t nStartTime = time(NULL);  
  4.       
  5.     fd_set writeset;  
  6.     FD_ZERO(&writeset);  
  7.     FD_SET(m_hSocket, &writeset);  
  8.   
  9.     timeval timeout;  
  10.     timeout.tv_sec = nTimeout;  
  11.     timeout.tv_usec = 0;  
  12.   
  13.     int nRet = ::select(m_hSocket + 1, NULL, &writeset, NULL, &timeout);  
  14.     if (nRet != 1)  
  15.     {  
  16.         Close();  
  17.         return false;  
  18.     }  
  19.       
  20.     int nRecvBytes = 0;  
  21.     int nBytesToRecv = nBufferSize;  
  22.     while (true)  
  23.     {  
  24.         nRet = ::recv(m_hSocket, pszBuff, nBytesToRecv, 0);  
  25.         if (nRet == SOCKET_ERROR)               //一旦出现错误就立刻关闭Socket  
  26.         {  
  27.             if (::WSAGetLastError() == WSAEWOULDBLOCK && time(NULL) - nStartTime < nTimeout)  
  28.                 continue;  
  29.             else  
  30.             {  
  31.                LOG_ERROR("Recv data error, disconnect server:%s, port:%d.", m_strServer.c_str(), m_nPort);  
  32.                 Close();  
  33.                 return false;  
  34.             }  
  35.         }  
  36.         else if (nRet < 1)  
  37.         {  
  38.             LOG_ERROR("Recv data error, disconnect server:%s, port:%d.", m_strServer.c_str(), m_nPort);  
  39.             Close();  
  40.             return false;  
  41.         }  
  42.   
  43.         nRecvBytes += nRet;  
  44.         if (nRecvBytes >= nBufferSize)  
  45.             break;  
  46.   
  47.         pszBuff += nRet;  
  48.         nBytesToRecv -= nRet;  
  49.   
  50.         ::Sleep(1);  
  51.     }  
  52.       
  53.     return true;  
  54. }  

3. 不少pc客户端软件，会设计一个接口，这个接口含有所有可以处理收到的网络数据的方法，也就是说所有继承自这个接口的子类都可以处理收到的网络数据，这些子类会在程序初始化的时候，被加入到网络层或者数据加工层的一个接受者集合中去。这样的话，网络层在收到数据后，遍历这个对象，然后利用C++多态，分别调用各个改写的方法去处理具体的数据。举个代码例子：

[cpp]  view plain  copy
  1. interface IMessageRevcer  
  2. {  
  3. virtual CString GetRecverName() = 0;  
  4. virtual void OnDataPackRecv(GWBasePack *pPack);  
  5. virtual void OnConnectEvent(GWConnectEventType nEvent) = 0;  
  6. };  

[cpp]  view plain  copy
  1. else if(pPack->nType == PT_MARKETINIT)  
  2. {  
  3.     GWMarketInitPack* pMarketInitPack = (GWMarketInitPack* )pPack;  
  4.     ASSERT(pMarketInitPack != NULL);  
  5.     // 广播市场初始化信息  
  6.     CAutoCritical lock(&m_lockRecver);  
  7.     //注意这一行，m_vecRecver就是一个存放IMessageRevcer具体子类实例指针的stl容器  
  8.     std::for_each(m_vecRecver.begin(), m_vecRecver.end(), bind2nd(mem_fun(&IMessageRevcer::OnDataPackRecv), pMarketInitPack));  
  9.     lock.UnLock();  
  10. }  


而flamingo中是抛携带数据的消息到一个代理窗口中统一处理的，然后再分发到各处，这两种做法各有千秋吧。
TCP服务器客户端程序框架
朝辞暮见的博客
05-28 2163
1. TCP服务器端流程2. TCP客户端流程 3. TCP/IP服务器端与客户端框架  示例代码： TCP服务器端：/************************************************************************* @Author: wanghao @Created Time : Fri 25 May 2018 08:09:19 PM PDT @...
客户端架构
热门推荐
淡然坊
05-29 1万+
Blog2-客户端架构 一.客户端架构简介    客户端（Client）或称为用户端，是指与服务器相对应，为客户提供本地服务的程序。除了一些只在本地运行的应用程序之外，一般安装在普通的客户机上，需要与服务端互相配合运行。 架构，又名软件架构，是有关软件整体结构与组件的抽象描述，用于指导大型软件系统各个方面的设计。软件架构是一系列相关的抽象模式，用于指导大型软件系统各个方面的设计。软件架构是一
客户端程序架构反思
qthello
02-10 725
12年参加工作以来，一直从事客户端程序的开发，因为参与的都是单独模块，架构的问题基本不用考虑。但是经过16、17年的磨练，随着遇到的问题越来越多，发现了一个好的架构的必要性。 本人从事无人机产测软件的研发，也就是 在无人机量产阶段，需要提供一些客户端软件给工厂的工人使用，用来排查组装过程中遇到的问题。最开始的时候是在一款开源地面站的基础上更改，但是慢慢的发现不太适用，因...
客户端整体架构 架构/框架总结 组件化
baidu_40537062的博客
08-05 1414
返回上级目录：iOS面试专题一 文章目录 你所在公司的客户端整体架构是怎样的？如果让你设计，你会怎样设计？（高级资深） 独立于App的通用层（放到任何一个app中都需要）：如时长统计框架，崩溃的统计，网络的第三方库 通用的业务层：针对当前公司有某些通用的组件，如自定义的布景控件，特殊的UIImageView的封装。这些往往是和当下公司的业务相关的，但是对于整体的app来说，各个业务线对于这些通用控件都有需求，我们可以把这些内容沉降到通用的业务层 中间层：起到协调和解耦的作用 在中间层之上是各个业务线的
美团 iOS 客户端的构建思考与实践
12-02
在本文档中，美团大众点评的高级工程师罗泽响分享了关于美团iOS客户端构建过程中的思考和实践经验。...通过这些思考与实践，我们可以更好地理解如何打造一个高效、稳定且易于维护的移动应用客户端。
一个支持私有部署的云端存储双链笔记软件，支持 Windows，Mac，网页客户端，网页移动端 同时还是一个个人博客
12-30
标题中的“云端存储双链笔记软件”是指一种创新的笔记管理工具，它结合了云存储技术和双链结构，提供了一种高效、灵活的个人知识管理解决方案。私有部署的特性意味着用户可以选择将自己的数据存储在自己的服务器上，...
美团 iOS 客户端的构建思考与实践 罗泽响 .pdf
09-18
罗泽响作为美团大众点评的高级工程师，在这份文档中，详细介绍了美团iOS客户端的构建思考与实践，其中包括了iOS客户端构建的关键理念、技术选型、实践过程、优化策略以及未来展望等内容。 首先，文档提到了iOS...
软件设计实验一（结构建模技术）
10-31
软件设计实验一（结构建模技术） 本实验的主要目的是了解面向对象开发方法的基本概念，掌握使用类图、包图、构件图、部署图进行软件设计的基本能力，并结合实际问题使用结构建模技术设计。在本实验中，我们将使用 ...
设计模式实战：电子邮件客户端的设计与实现
最新发布
qq_40254606的博客
07-26 1466
通过本项目，我们综合应用了观察者模式、装饰模式和责任链模式，解决了电子邮件客户端的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
IT行业软件总体架构图
03-02
某软件的总体架构图,文档中有详细的设计分析,图文结合。
建立客户端程序目录架构并完成登录模块
宜家软件
05-16 474
建立客户端程序目录架构并完成登录模块 客户端文件目录： v9(根目录)   --bin 编译后的可执行程序（EXE）和动态链接库（DLL）   --source 项目源文件   --res 资源文件（多媒体文件）   --doc 帮助文档   --unit 编译中间文件 任务： 设计人员数据库结构 配置公共模块 设计登录界面和主界面
1.3 客户端-设计思路
每天都在摸鱼
02-17 338
1需求 ​ 1 需求(视频播放器) ->功能 ​ 2 核心功能(libvlc)<<.团队情况.未来发展,功能的完备性>> ->设计 2设计 ​ 首先从架构的角度去思考一个客户端应该选用什么架构 ​ MVC: model(模型层 数据) View (视图 UI) Control(中间层 业务) ​ .COM/.NET: 软件即服务 ​ ​ MVC 架构 ​ 播放器需要有播放、暂停/继续、停止、进度显示、跳转位置、地址输入等基本功能 ​ 整个应该使用MFC的视窗模式UI呈
PC客户端的互联网化设计
沉森心与思考同行
06-21 3889
伴随着手机，平板电脑为代表的移动互联网的不断发展，云计算和云服务的兴起，更是推动着传统企业不断地往互联网方向转型。作为Windows客户端程序员，自己也在时刻地警醒着：要抛弃传统软件开发思维，努力学习互联网思维。互联网+，这一个充满着机遇的经济新形态，让所有传统企业都感觉到挑战和希望。而最后能否突围成功，则在于是否能用互联网思维去解决问题。         好的，大层面讲完，该聚焦到具体的细节上
客户端架构设计的过程
chuyouyinghe的专栏
12-15 417
总的来说，架构设计需要经过需求分析，梳理业务流程，寻找模式，架构验证和架构演进等过程。为了设计好的、简洁的、可理解、可扩展的架构，每个过程都至关重要。这里总结几点：需求用例需要穷举场景关注核心业务流程，提炼重点问题；将大问题拆解成小问题，解决完再组合回来寻找模式来降低架构理解、使用成本；使用分层、模块化等方法明确职责和接口对架构进行验证，确保满足功能、易用性、可用性、性能等要求架构设计出来只是完成了10%，真正完成迁移才算做完了100%最后附上一段很棒的话，与诸君共勉。
【软件架构】软件的十二种架构简介
weixin_46453070的博客
03-26 1万+
微内核架构区分了基本的系统功能和可扩展的应用功能，核心系统提供最基本的操作，而其他功能则通过插件或模块的形式添加。这种架构的关键在于一个小型的内核负责提供最基础和通用的功能（如低级内存管理、设备驱动等），而更高级的功能（如用户界面、应用程序等）则作为独立的组件或服务存在，这些组件在运行时与微内核通信。在选择架构时，重要的是要根据项目的具体需求、团队的能力、预期的系统规模和性能要求来决定最适合的架构模式。每种架构风格都有其优势和局限性，选择哪一种架构取决于具体的项目需求、团队的技能以及系统未来的发展方向。
如何设计一个PC客户端的架构
MusicMan
08-20 862
UI和业务分离，这个主要指的是UI层和数据层，不能耦合在一块，这个看似简单，其实是客户端设计中比较难的一个点，大家可以通过这种方式来验证，就是比如说，你把下沉的sdk移除掉，这个软件如果还能正常打开使用，就说明了你的架构设计已经遵循了这个规则。插件化，这个指的是，假如一个特别大的软件，你需要和同事协同开发，这个时候，你就需要考虑使用插件化的方式，指的是在你的业务本身和他的耦合性不高的前提下，你可以直接创建自己自身的UI和处理相关业务，但是不影响到他本身业务的方式。
架构模式&开发模式
liyongtao524的博客
10-25 1528
架构模式和设计模式浅谈，欢迎评论，共同学习。
学习笔记二，vc++创建多线程服务器（四）
onesmiletogo的专栏
05-15 603
客户端类 // 客户端类 class CClient { public: CClient(const SOCKET sClient,const SOCKADDR_IN &addrClient); virtual ~CClient(); public: BOOL StartRuning(void); void HandleData(const char* pExpr); BOOL IsC
整理！这10款PC端软件，设计师必备！
weixin_58262980的博客
10-25 1087
相信有很多人都很羡慕那些设计大神能够做出杰出的设计，但你知不知道那些大神是用什么软件做出来的呢？下面介绍的这10款软件都是设计大神钟爱的，仔细看一看，总有一款适合你。 1.CorelDRAW CorelDRAW是一个矢量图形设计软件，对于设计师来说，矢量设计是不可缺少的基础功能。CorelDRAW推出年代较早，由于当时没有什么其他软件可以选择，所以它就成了设计行业唯一的选择。只需CorelDRAW一个软件即可解决图像处理、矢量绘制、平面排版的所有问题。 2.AffinityDesigner .
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值