SuperSocket源码解析之消息处理

一 简述

　　Tcp消息的处理本身是与Tcp消息传输过程独立的，是消息的两个不同阶段，从前面的会话生命周期我们已经知道消息的传输主要有SocketSession实现，而真正处理则交由AppSession实现，SuperSocket的层次划分也是非常清晰明了。

　　SuperSocket消息处理主要流程：接收=》原始过滤=》协议解析=》命令路由并执行=》找不到命令则直接一分不动发给客户端

二 消息接收

1 开始接收

代码位置：AsyncSocketSession=》StartReceive

 private void StartReceive(SocketAsyncEventArgs e)
        {
            StartReceive(e, 0);
        }

        private void StartReceive(SocketAsyncEventArgs e, int offsetDelta)
        {
            bool willRaiseEvent = false;

            try
            {
                if (offsetDelta < 0 || offsetDelta >= Config.ReceiveBufferSize)
                    throw new ArgumentException(string.Format("Illigal offsetDelta: {0}", offsetDelta), "offsetDelta");

                var predictOffset = SocketAsyncProxy.OrigOffset + offsetDelta;

                if (e.Offset != predictOffset)
                {
                    e.SetBuffer(predictOffset, Config.ReceiveBufferSize - offsetDelta);
                }

                if (IsInClosingOrClosed)
                    return;

                OnReceiveStarted();
                willRaiseEvent = Client.ReceiveAsync(e);
            }
            catch (Exception exc)
            {
                LogError(exc);

                OnReceiveError(CloseReason.SocketError);
                return;
            }

            if (!willRaiseEvent)
            {
                ProcessReceive(e);
            }
        }

在接收数据前后触发ReceiveStarted，ReceiveEnd事件

2 接收有消息处理并转入处理

public void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (!ProcessCompleted(e))
            {
                OnReceiveError(CloseReason.ClientClosing);
                return;
            }

            OnReceiveEnded();

            int offsetDelta;

            try
            {
                //交给app会话处理接收到的数据，而appsession又交给接收请求处理器处理
                offsetDelta = this.AppSession.ProcessRequest(e.Buffer, e.Offset, e.BytesTransferred, true);
            }
            catch (Exception exc)
            {
                LogError("Protocol error", exc);
                this.Close(CloseReason.ProtocolError);
                return;
            }

            //read the next block of data sent from the client
            StartReceive(e, offsetDelta);
        }

三 消息处理

1 入口：按照协议解析，每次只处理一个数据包，因此便有了如下的入口代码

int IAppSession.ProcessRequest(byte[] readBuffer, int offset, int length, bool toBeCopied)
        {
            int rest, offsetDelta;

            while (true)
            {
                var requestInfo = FilterRequest(readBuffer, offset, length, toBeCopied, out rest, out offsetDelta);

                if (requestInfo != null)
                {
                    try
                    {
                        AppServer.ExecuteCommand(this, requestInfo);
                    }
                    catch (Exception e)
                    {
                        HandleException(e);
                    }
                }

                if (rest <= 0)
                {
                    return offsetDelta;
                }

                //Still have data has not been processed
                offset = offset + length - rest;
                length = rest;
            }
        }

2 原始过滤

 此处以原始数据接收事件方式，预留给AppServer子类处理该原始数据包，意味着可以对原始数据包执行一次拦截处理，如果经过一些逻辑处理后不能满足，则将终止该数据包继续传播

3 协议解析

协议解析由AppSession的m_ReceiveFilter成员完成，该成员的实例化有2种实现方式

默认实例化 ：默认命令行协议，该协议举例

下面是2行命令，行使用 作为结束标识，也就是回车换行，命令行内部使用空格分隔，第一个控制之前 如echo 为消息头也就是key，其后的字符串也使用空格分隔，作为参数，其整体=body

echo cc xxd    
cdc ds mmm

解析后为2个StringRequestInfo对象

 

 默认的协议解析工厂

 

 实例化默认协议解析对象

 通过AppServer构造函数传递解析工厂

 4 命令路由

上面我们已经解析到客户端发来的2条命令分别为echo 参数为cc xxd；cdc ds mmm；

其中key分别为echo和cdc，对于命令模式来说命令本身使用name字段进行标识，如果我们的key与name匹配那么我们即可路由到一个已有的命令，进而执行该命令，来看代码

 对于能够路由到的命令我们执行命令

 对于路由失败来说SuperSocket又是怎么做的呢？

找不到命令来处理该消息，将该命令名字发送会客户端，意思说明服务器没有实现该命令，那么命令从何而来？

5  命令

这还的从CommandLoader说起，CommandLoader又追溯到AppServer的构建过程

 

在没有显示配置CommandLoader的情况下默认为ReflectCommandLoader

 ReflectCommandLoader创建命令

  ReflectCommandLoader将扫描应用程序根目录下所有程序，并将实现了命令接口的实例通过反射创建出来

public override bool TryLoadCommands(out IEnumerable<TCommand> commands)
        {
            commands = null;

            var commandAssemblies = new List<Assembly>();

            if (m_AppServer.GetType().Assembly != this.GetType().Assembly)
                commandAssemblies.Add(m_AppServer.GetType().Assembly);

            string commandAssembly = m_AppServer.Config.Options.GetValue("commandAssembly");

            if (!string.IsNullOrEmpty(commandAssembly))
            {
                OnError("The configuration attribute 'commandAssembly' is not in used, please try to use the child node 'commandAssemblies' instead!");
                return false;
            }


            if (m_AppServer.Config.CommandAssemblies != null && m_AppServer.Config.CommandAssemblies.Any())
            {
                try
                {
                    var definedAssemblies = AssemblyUtil.GetAssembliesFromStrings(m_AppServer.Config.CommandAssemblies.Select(a => a.Assembly).ToArray());

                    if (definedAssemblies.Any())
                        commandAssemblies.AddRange(definedAssemblies);
                }
                catch (Exception e)
                {
                    OnError(new Exception("Failed to load defined command assemblies!", e));
                    return false;
                }
            }

            if (!commandAssemblies.Any())
            {
                commandAssemblies.Add(Assembly.GetEntryAssembly());
            }

            var outputCommands = new List<TCommand>();

            foreach (var assembly in commandAssemblies)
            {
                try
                {
                    outputCommands.AddRange(assembly.GetImplementedObjectsByInterface<TCommand>());
                }
                catch (Exception exc)
                {
                    OnError(new Exception(string.Format("Failed to get commands from the assembly {0}!", assembly.FullName), exc));
                    return false;
                }
            }

            commands = outputCommands;

            return true;
        }

因此默认的我们只需要定义一些实现命令接口ICommand<TAppSession, TRequestInfo>的命令出来，

6 自定义命令

 直接继承CommandBase抽象类即可

 到此SuperSocket对消息的处理流程差不多就是这样了，SuperSocket的框架的使用 我们只需要自定义自己的AppServer，以及AppServer配套的AppSession，ReciverFilter，以及命令等即可，这些在官方提供的例子中已经很清晰