P2P直连？经服务器中转？

      当同一个系统的两个客户端A、B相互发送消息给对方时，如果它们之间存在P2P通道，那么消息传送的路径就有两种：直接经P2P通道传送、或者经服务器中转。如下图所示：

     

      通常就一般应用而言，如果P2P通道能够成功创建（即所谓的打洞成功），A和B之间的所有消息将直接走P2P通道，这样可以有效节省服务器的带宽和降低服务器的负载。这种模型即是所谓的“P2P通道优先”模型，也是最简单的通道选择模型。

一.通道质量优先模型

      然而，有些系统可能不能就如此简单的处理，最简单的例子，如果A和B之间传递的某些类型的消息必需让服务器监控到，那么，这样的消息就必需经过服务器中转。接下来，我们讨论一种较为复杂的情况。比如，在网络语音对话系统中，通道的质量直接决定着用户体验的好坏。我们希望，在这种系统中，语音数据需要始终经由两条通道中的那个质量较高的通道进行传送。这种策略就是所谓的“通道质量优先”模型。

      “通道质量优先”模型理解起来很简单，但是在实际中实现时，却还是很有难度的。通常有两种实现方式：

（1）定时检测、比较通道延时，并自动切换通道。

（2）由上层应用决定何时切换通道。一般而言，是当应用发现当前使用的通道不满足要求时，就主动要求切换到另外一条通道。

二.模型实现

      下面，我们就基于ESFramework提供的通信功能，来实现这两种方式。我们使用AgileP2PCustomizeOutter类来封装它，并可通过属性控制来启用哪种方式。 

public class AgileP2PCustomizeOutter:IEngineActor
    {
        //字典。userID - 当前选择的通道（如果为true，表示P2P通道；否则是经服务器中转）？
        private ObjectManager<string, bool> channelStateManager = new ObjectManager<string, bool>(); 
       private ICustomizeOutter customizeOutter; //消息发送器
        private IP2PController p2PController;//P2P控制器
        private IBasicOutter basicOutter; //心跳发送器
        private AgileCycleEngine agileCycleEngine; //定时检测引擎

        #region PingTestSpanInSecs
        private int pingTestSpanInSecs = 60;
        /// <summary>
        /// 定时进行ping测试以及自动切换通道的时间间隔，单位：秒。默认值为60。
        /// 如果设置为小于等于0，则表示不进行定时ping测试，也不会自动切换通道。
        /// </summary>
        public int PingTestSpanInSecs
        {
            get { return pingTestSpanInSecs; }
            set { pingTestSpanInSecs = value; }
        }    
        #endregion   

        #region Initialize
        public void Initialize(ICustomizeOutter _customizeOutter, IP2PController _p2PController, IBasicOutter _basicOutter)
        {
            this.customizeOutter = _customizeOutter;
            this.p2PController = _p2PController;
            this.basicOutter = _basicOutter;

            this.p2PController.P2PChannelOpened += new ESBasic.CbGeneric<P2PChannelState>(p2PController_P2PChannelOpened);
            this.p2PController.P2PChannelClosed += new ESBasic.CbGeneric<P2PChannelState>(p2PController_P2PChannelClosed);
            this.p2PController.AllP2PChannelClosed += new ESBasic.CbGeneric(p2PController_AllP2PChannelClosed);
            Dictionary<string, P2PChannelState> dic = this.p2PController.GetP2PChannelState();
            foreach (P2PChannelState state in dic.Values)
            {
                bool p2pFaster = this.TestSpeed(state.DestUserID);
                this.channelStateManager.Add(state.DestUserID, p2pFaster);
            }

            if (this.pingTestSpanInSecs > 0)
            {
                this.agileCycleEngine = new AgileCycleEngine(this);
                this.agileCycleEngine.DetectSpanInSecs = this.pingTestSpanInSecs;
                this.agileCycleEngine.Start();
            }
        }

        //定时执行，当前客户端到其它客户端之间的通道选择
        public bool EngineAction()
        {
            foreach (string userID in this.channelStateManager.GetKeyList())
            {
                bool p2pFaster = this.TestSpeed(userID);
                this.channelStateManager.Add(userID, p2pFaster);
            }

            return true;
        }

        void p2PController_AllP2PChannelClosed()
        {
            this.channelStateManager.Clear();
        }

        void p2PController_P2PChannelClosed(P2PChannelState state)
        {
            this.channelStateManager.Remove(state.DestUserID);
        }

        void p2PController_P2PChannelOpened(P2PChannelState state)
        {
            bool p2pFaster = this.TestSpeed(state.DestUserID);
            this.channelStateManager.Add(state.DestUserID, p2pFaster);
        }
        #endregion

        #region TestSpeed
        /// <summary>
        /// 定时测试
        /// </summary>     
        private bool TestSpeed(string userID)
        {
            try
            {
                int transfer = this.basicOutter.PingByServer(userID);
                int p2p = this.basicOutter.PingByP2PChannel(userID);
                return p2p <= transfer;
            }
            catch (Exception ee)
            {
                return false;
            }
        }
        #endregion

        /// <summary>
        /// 手动切换通道。
        /// </summary>        
        public void SwitchChannel(string destUserID)
        {
            if (this.channelStateManager.Contains(destUserID))
            {
                bool p2p = this.channelStateManager.Get(destUserID);
                this.channelStateManager.Add(destUserID, !p2p);
            }
        }

        /// <summary>
        /// 到目标用户是否使用的是P2P通道。
        /// </summary>        
        public bool IsUsingP2PChannel(string destUserID)
        {
            return this.channelStateManager.Get(destUserID);
        }

        public bool IsExistP2PChannel(string destUserID)
        {
            return this.channelStateManager.Contains(destUserID);
        }

        /// <summary>
        /// 向在线用户发送信息。
        /// </summary>
        /// <param name="targetUserID">接收消息的目标用户ID。</param>
        /// <param name="informationType">自定义信息类型</param>
        /// <param name="post">是否采用Post模式发送消息</param>  
        /// <param name="action">当通道繁忙时所采取的动作</param>  
        public void Send(string targetUserID, int informationType, byte[] info, bool post, ActionTypeOnChannelIsBusy action)
        {
            bool p2pFaster = this.channelStateManager.Get(targetUserID);
            ChannelMode mode = p2pFaster ? ChannelMode.ByP2PChannel : ChannelMode.TransferByServer;
            this.customizeOutter.Send(targetUserID, informationType, info, post, action, mode);
        }

        /// <summary>
        /// 向在线用户或服务器发送大的数据块信息。直到数据发送完毕，该方法才会返回。如果担心长时间阻塞调用线程，可考虑异步调用本方法。
        /// </summary>
        /// <param name="targetUserID">接收消息的目标用户ID。如果为null，表示接收者为服务器。</param>
        /// <param name="informationType">自定义信息类型</param>
        /// <param name="blobInfo">大的数据块信息</param>  
        /// <param name="fragmentSize">分片传递时，片段的大小</param>  
        public void SendBlob(string targetUserID, int informationType, byte[] blobInfo, int fragmentSize)
        {
            bool p2pFaster = this.channelStateManager.Get(targetUserID);
            ChannelMode mode = p2pFaster ? ChannelMode.ByP2PChannel : ChannelMode.TransferByServer;
            this.customizeOutter.SendBlob(targetUserID, informationType, blobInfo, fragmentSize, mode);
        }       
    }

       现在，我们对上面的实现简单解释一下。

（1）由于当前客户端可能会与多个其它的客户端进行通信，而与每一个其它的客户端之间的通信都有通道选择的问题，所以需要一个字典ObjectManager将它们管理起来。

（2）当某个P2P通道创建成功时，将进行首次ping比较，并将结果记录到字典中。

（3）定时引擎每隔60秒，分别针对每个其它客户端进行通道检测比较，自动选择ping值小的那个通道。

（4）当我们将PingTestSpanInSecs设为0时，就可以使用SwitchChannel方法来手动切换通道，即实现了上述的方式2。

（5）我们最终的目的是实现Send方法和SendBlob方法，之后，就可以使用AgileP2PCustomizeOutter类来替换ICustomizeOutter发送消息。

三.方式选择

      上面讲到“通道质量优先”模型的两种实现方式，那么在实际的应用中，如何进行选择了？

1.ping检测比较，自动切换     

      就这种方式而言，其缺陷在于，在客户端之间需要进行高频通信的系统中，ping检测可能是非常不准确的，甚至是错误的。

      比如，在实时视频对话系统中，其对带宽的要求是比较高的，假设，现在所有的视频数据走的都是P2P通道，那么P2P通道就非常忙碌，而经服务器中转的通道几乎就是空闲的。所以，当下一次定时ping检测到来时，P2P通道的ping值就会比实际的大。从而导致判断失误，而发生错误的自动切换。

2.手动切换

      对于刚才视频对话的例子，使用手动切换可能是更好的选择，由应用根据上层的实际效果来决定是否需要切换通道。比如，还以视频对话系统为例，应用可以根据信息接收方的定时反馈（在一段时间内，缺少音/视频包的个数，音/视频包的总延时等统计信息）来决定是否要切换到另外一个通道。这种方式更简洁描述可以表达为：如果当前通道质量已达到应用需求，即使另一个通道更快更稳定，也不进行切换；如果当前通道质量达不到应用需求，则切换到另一个通道（有可能另一个通道的质量更糟糕）。 

      本文只是简单地引出通道选择模型的问题，实际上，这个问题是相当复杂的，特别是在一些通信要求很高的项目中，而且，如果将广播消息的通道模型考虑进来就更麻烦了，有兴趣的朋友可以留言进行更深入的讨论。