（请移步到）
image.png
https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&album_id=1539935825956798467&__biz=MzU5NzcwMjI2Mw==#wechat_redirect
前面两章已经介绍了Socket和SocketAsyncEventArgs两个关于通讯操作的基础对象，接下来要做的工作是如何实现服务；在做之前都需要总结一下要做什么功能，然后针对功能进行相应接口行为定义。而在这里的设计更多是依据于数看在这方面的工作经验，而接下来要详细讲述的组件的服务端行为接口是如何设计。
在做之前要归纳服务端总体上需要些什么，然后再针对功能制定接口和类行为信息。作为一个服务端组件它应该具备以下基础功能: 服务配置, 会话管理, 协议分析器, 日志,和基础数据统计.针对以上的功能制定服务基础接口规范：

  1.     public interface IServer : IDisposable
  2.     {
  3.         //当前在线数
  4.         int Count
  5.         { get; }
  6.         //服务配置
  7.         ServerOptions Options
  8.         { get; }
  9.         //接收数据的缓冲池
  10.         Buffers.BufferPoolGroup ReceiveBufferPool { get; }
  11.         //发送数据的缓冲池
  12.         Buffers.BufferPoolGroup SendBufferPool { get; }
  13.         //配置的委托
  14.         IServer Setting(Action<ServerOptions> handler);
  15.         //版本号
  16.         long Version { get; }
  17.         //获取当前在线的所有会话
  18.         ISession[] GetOnlines();
  19.         //打开服务
  20.         bool Open();
  21.         //启动时输出的Logo
  22.         Action WriteLogo { get; set; }
  23.         //暂停
  24.         bool Pause();
  25.         //恢复服务
  26.         void Resume();
  27.         //获取服务运行时长（毫秒）
  28.         long GetRunTime();
  29.         //服务名称
  30.         string Name { get; set; }
  31.         //服务处理相关事件行为
  32.         IServerHandler Handler {  get; set;}
  33.         //协议分析器
  34.         IPacket Packet { get; set;}
  35.         //判断日志等级
  36.         bool EnableLog(EventArgs.LogType logType);
  37.         //获取指定ID的会话
  38.         ISession GetSession(long id);
  39.         //获取服务状态
  40.         ServerStatus Status { get; set; }
  41.         //更新会话活跃时间
  42.         void UpdateSession(ISession session);
  43.         //记录日志
  44.         void Log(EventArgs.LogType type, ISession session, string message);
  45.         //记录日志
  46.         void Log(EventArgs.LogType type, ISession session, string message, params object[] parameters);
  47.         //记录错误
  48.         void Error(Exception error, ISession session, string message);
  49.         //记录错误
  50.         void Error(Exception error, ISession session, string message, params object[] parameters);
  51.         //触发会话接收数据事件
  52.         void SessionReceive(EventArgs.SessionReceiveEventArgs e);
  53.         //关闭会话
  54.         void CloseSession(ISession session);
  55.         //向指定会话发送消息
  56.         bool Send(object message, ISession session);
  57.         //向指定会话发送消息
  58.         bool[] Send(object message, params ISession[] sessions);
  59.         //向指定会话发送消息
  60.         bool[] Send(object message, System.ArraySegment<ISession> sessions);
  61.         //发送IO总量
  62.         long SendQuantity { get; }
  63.         //接收IO总量
  64.         long ReceiveQuantity { get; }
  65.         //接收数据总量
  66.         long ReceivBytes {get;}
  67.         //发送数据总量
  68.         long SendBytes { get; }
  70.     }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/IServer.cs)
接下来详细介绍每个功能涉及到具体设计和定义

服务配置

配置是服务的基础信息，它主要包括有：服务地址，缓冲区大小了，可接管的最大连接数，超时时间，字符编码和加密方式等等。组件设计了一个ServerOptions类结构用于描述这些信息：

  1.     public class ServerOptions
  2.     {
  3.         //会话发送队列最大等待值，超过则关闭会话
  4.         public int MaxWaitMessages { get; set; } = 0;
  5.         //队列数，主要用于发送和接收消息处理
  6.         public int IOQueues { get; set; }
  7.         //是否同步Accept连接
  8.         public bool SyncAccept { get; set; } = true;
  9.         //会话活跃超时时间,为零是不处理，当大于零的情况会检会话活跃时间是否超时，超时则关闭
  10.         public int SessionTimeOut { get; set; }
  11.         //是否启用IPv6
  12.         public bool UseIPv6 { get; set; }
  13.         //日志输出级别
  14.         public EventArgs.LogType LogLevel { get; set; }
  15.         //是否记录统计信息
  16.         public bool Statistical { get; set; }
  17.         //是否合并序列化消息,为0不处理;当同时发送消息给多个会话时进行一次序列化处理。
  18.         public int Combined{ get; set;}
  19.         //返回第一个监听信息配置
  20.         public ListenHandler DefaultListen => Listens[0];
  21.         //配置多个监听列表
  22.         public IList<ListenHandler> Listens { get; private set; }
  23.         //添加监听
  24.         public ServerOptions AddListen(int port)
  25.         {
  26.             return AddListen(null, port);
  27.         }
  28.         //添加监听
  29.         public ServerOptions AddListen(string host, int port)
  30.         {
  31.             ListenHandler listenOptions = new ListenHandler
  32.             {
  33.                 Host = host,
  34.                 Port = port
  35.             };
  36.             Listens.Add(listenOptions);
  37.             return this;
  38.         }
  39.         //添加SSL监听
  40.         public ServerOptions AddListenSSL(string certificateFile, string password, int port = 443)
  41.         {
  42.             return AddListenSSL(certificateFile, password, null, port);
  43.         }
  44.         //添加SSL监听
  45.         public ServerOptions AddListenSSL(string certificateFile, string password, string host, int port = 443)
  46.         {
  47.             ListenHandler listenOptions = new ListenHandler
  48.             {
  49.                 Host = host,
  50.                 Port = port,
  51.                 SSL = true,
  52.                 CertificateFile = certificateFile,
  53.                 CertificatePassword = password
  54.             };
  55.             Listens.Add(listenOptions);
  56.             return this;
  57.         }
  58.         //配置最大可用缓冲区大小(单位MB)
  59.         public int BufferPoolMaxMemory { get; set; }
  60.         //单个缓冲池大小
  61.         public int BufferPoolSize { get; set; }
  62.         //配置有多少个缓冲池
  63.         public int BufferPoolGroups { get; set; }
  64.         //配置大小节序，默认是小
  65.         public bool LittleEndian{ get; set;}
  66.         //配置字符编码
  67.         public System.Text.Encoding Encoding{get; set;}
  68.         //是否启动单独的队列来进行接收消息处理
  69.         public bool IOQueueEnabled { get; set; }
  70.         //单个缓存大小
  71.         public int BufferSize { get; set; }
  72.         //最大支持在线会话数
  73.         public int MaxConnections { get; set; }
  74.         //接入队列最大数量，超过直接拒绝
  75.         public int MaxAcceptQueue { get; set; }
  77.     }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/ServerOptions.cs)
以上是组件的基础配置信息，在这里需要进行一说明的是监听列表属性Listens，组件的设计是允许服务同时监听多个地址，每个地址都可以开启不同的TLS选项,具体会在后面的《监听》章节详细说明。

会话管理

作为服务端它需要同时应用对不同的请求处理，针对这些管理同样也非常重要。服务端一般提供会话管理功能有：会话创建，释放，发送消息，接收消息和简单查询功能。在上面描述的服务接口中有几个成员用于提供这些功能的支持。

基础属性方法

  • Handler

设置服务相关处理事件对象，对象实现IServerHandler接口用于接管处理服务相关事件逻辑处理。

  • Send

向指定的会话发送消息，并返回是否已经写入到相应的会话队列

  1. bool Send(object message, ISession session);
  2. bool[] Send(object message, params ISession[] sessions);
  3. bool[] Send(object message, System.ArraySegment<ISession> sessions);
  • Log

记录日志方法

  1. void Log(EventArgs.LogType type, ISession session, string message);
  2. void Log(EventArgs.LogType type, ISession session, string message, params object[] parameters);

大部分日志信息都需要用于字符串拼接，字符拼接对服务性能有比较大的影响，在记录日志的前最好判断当前日志级别。

  1.     if (EnableLog(LogType.Debug))
  2.     {
  3.         Log(LogType.Debug, session, "{0} update active time", session.RemoteEndPoint);
  4.     }
  • GetOnlines

获取当前服务在线的所有会话

  1. ISession[] GetOnlines();
  • GetSession

获取指定ID的会话信息

  1. ISession GetSession(long id);
  • UpdateSession

更新会话最新活跃时间，它是配合Options.SessionTimeOut来使用，当SessionTimeOut设置了值后服务会定时检测会话的最新活跃时间，如果超出配置的值则会关闭会话。

  1. void UpdateSession(ISession session);
  • Version

当前服务在线会话变更版本号，由于服务存储会话用于Dictionary，如果每次获取列表都从新获取会比较损耗资源；服务引入了一个版本号只要缓存中的版本号一致即直接从已有缓存列表中获取所有会话。

  1. public ISession[] GetOnlines()
  2. {
  3.     if (mOnlines.Version != this.Version)
  4.     {
  5.         //元子状态操作判断
  6.         if (System.Threading.Interlocked.CompareExchange(ref mGetOnlinesStatus, 1, 0) == 0)
  7.         {
  8.             try
  9.             {
  10.                 if (mOnlines.Version != this.Version)
  11.                 {
  12.                     mOnlines.Arrays = mSessions.Values.ToArray();
  13.                     mOnlines.Version = this.Version;
  14.                 }
  15.             }
  16.             finally
  17.             {
  18.                 System.Threading.Interlocked.Exchange(ref mGetOnlinesStatus, 0);
  19.             }
  20.         }
  21.     }
  22.     return mOnlines.Arrays;
  23. }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/TcpServer.cs)

会话事件

组件通过IServerHandler接口用于描述针对会话的一些事件行为处理，通过实现这接口可以定义会话创建，释放和消息接等环节的逻辑处理。

  1.     public interface IServerHandler
  2.     {
  3.         //对应的服务信息
  4.         IServer Server { get; set; }
  5.         //会话创建前事件，可以根据情况取消会话
  6.         void Connecting(IServer server, EventArgs.ConnectingEventArgs e);
  7.         //会话创建完成事件
  8.         void Connected(IServer server, EventArgs.ConnectedEventArgs e);
  9.         //记录日志方法
  10.         void Log(IServer server, EventArgs.ServerLogEventArgs e);
  11.         //记录错误日志方法
  12.         void Error(IServer server, EventArgs.ServerErrorEventArgs e);
  13.         //会话接收网络流事件
  14.         void SessionReceive(IServer server, SessionReceiveEventArgs e);
  15.         //会话接收消息，前提是服务定义了IPacket协议分析器
  16.         void SessionPacketDecodeCompleted(IServer server, EventArgs.PacketDecodeCompletedEventArgs e);
  17.         //会话断开事件
  18.         void Disconnect(IServer server, EventArgs.SessionEventArgs e);
  19.         //检测会话超时事件，只有设置了SessionTimeOut才会触发
  20.         void SessionDetection(IServer server, SessionDetectionEventArgs e);
  21.         //初始化服务完成事件
  22.         void Opened(IServer server);
  24.     }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/IServerHandler.cs)
以上接口行为必须由使用者实现并设置到对应的服务中，服务会根据情况进行调用。在这里需要关注的是SessionReceive和SessionPacketDecodeCompleted,前者是会话接收到数据时候触发处理，而后者则是协议分析后转换成对象触处理；当服务配置了协议分析器后IPacket后才会触，一旦配置了IPacket那对应的SessionReceive则无效。

日志

网络服务涉及到很多异步或多线程处理的环节，这些应用在问题排查上非常困难；还有就是在高并发吞吐在处理日志上也要有所注意，处理不当还是对性能影响比较大的。服务提供了Log和Error方法来记录日志，为了在不同情况下对性能和输出带来的影响还制定了LogLevel用于定义不同情况的输出。

LogLevel定义

  1.     public enum LogType : int
  2.     {
  3.         All = 0,
  4.         Trace = 1,
  5.         Debug = 2,
  6.         Info = 4,
  7.         Warring = 8,
  8.         Error = 16,
  9.         Fatal = 32,
  10.         Off = 64
  11.     }

对于值的定义为什么是2的次方呢，主要是方便合混定义合用如:Trace|Info|Error,以上定义就是可以同时输出以上几种日志内容。

日志输出

组件在很多过程处理都添加了日志记录，但记录日志涉及到一个问题就是当吞吐比较大的情况记录这些日志都会带来极大的损耗问题；所以在记录日志的时候时还是有所不同，代码如下:

  1. if (Server.EnableLog(EventArgs.LogType.Warring))
  2. {
  3.     Server.Log(EventArgs.LogType.Warring, null,
  4.         $"{RemoteEndPoint} sync SslStream date error {error.Message}@{error.StackTrace}");
  5. }

为什么每次记录日志都需要判断一下呢，统一在下层过虑不更方便？主要原因是日志信息过程存在大量合并字符串，而这个过程又非常损耗资源；如果上层不判断下层过虑那就意味着不过日志记不记录都存在合并字符串的损耗，而这种损耗一旦在高吞吐的情况下会给GC带的了巨大的压力(毕竟在日志全开高压下可以达到每秒数十万条或更多)！

创建服务

由于服务是基于接口的方式提供使用，使用者无法直接创建；需要通过SocketFactory对象相关静态方法来创实服务实例。

  1.     public class SocketFactory
  2.     {
  3.         //创建一个TCP服务并设置处理的事件和协议分析器
  4.         public static IServer CreateTcpServer(IServerHandler handler, IPacket packet, ServerOptions options = null)
  5.         {
  6.             TcpServer server = new TcpServer(options);
  7.             server.Handler = handler;
  8.             server.Packet = packet;
  9.             return server;
  10.         }
  11.         //创建一个TCP服务并设置处理的事件和协议分析器
  12.         public static IServer CreateTcpServer<HANDLER, IPACKET>(ServerOptions options = null)
  13.             where HANDLER : IServerHandler, new()
  14.             where IPACKET : IPacket, new()
  15.         {
  16.             return CreateTcpServer(new HANDLER(), new IPACKET(), options);
  17.         }
  18.         //创建一个TCP服务并设置处理的事件，无协议分析器
  19.         public static IServer CreateTcpServer<HANDLER>(ServerOptions options = null) where HANDLER : IServerHandler, new()
  20.         {
  21.             return CreateTcpServer(new HANDLER(), null, options);
  22.         }
  23.         //创建一个指向服务地址的Client,host可以是域名
  24.         public static CLIENT CreateClient<CLIENT>(string host, int port)
  25.            where CLIENT : IClient, new()
  26.         {
  27.             CLIENT client = new CLIENT();
  28.             client.Init(host, port, null);
  30.             return client;
  31.         }
  32.         //创建一个指向服务地址的Client并指定协议分析器,host可以是域名
  33.         public static CLIENT CreateClient<CLIENT, PACKET>(string host, int port)
  34.             where PACKET : Clients.IClientPacket, new()
  35.             where CLIENT : IClient, new()
  36.         {
  37.             CLIENT client = new CLIENT();
  38.             client.Init(host, port, new PACKET());
  40.             return client;
  41.         }
  42.         //创建一个指向服务地址的Client并指定协议分析器,host可以是域名
  43.         public static CLIENT CreateClient<CLIENT>(IClientPacket packet, string host, int port) where CLIENT : IClient, new()
  44.         {
  45.             CLIENT client = new CLIENT();
  46.             client.Init(host, port, packet);
  48.             return client;
  49.         }
  51.         //创建一个指向服务地址的Ssl Client,host可以是域名，serviceName为证书的服务名称
  52.         public static CLIENT CreateSslClient<CLIENT>(string host, int port, string serviceName)
  53.           where CLIENT : IClient, new()
  54.         {
  55.             CLIENT client = new CLIENT();
  56.             client.Init(host, port, null);
  57.             client.SSL = true;
  58.             client.SslServiceName = serviceName;
  59.             return client;
  60.         }
  61.         //创建一个指向服务地址的Ssl Client并指定协议分析器,host可以是域名，serviceName为证书的服务名称
  62.         public static CLIENT CreateSslClient<CLIENT, PACKET>(string host, int port, string serviceName)
  63.             where PACKET : Clients.IClientPacket, new()
  64.             where CLIENT : IClient, new()
  65.         {
  66.             CLIENT client = new CLIENT();
  67.             client.Init(host, port, new PACKET());
  68.             client.SSL = true;
  69.             client.SslServiceName = serviceName;
  70.             return client;
  71.         }
  72.     //创建一个指向服务地址的Ssl Client并指定协议分析器,host可以是域名,serviceName为证书的服务名称
  73.         public static CLIENT CreateSslClient<CLIENT>(IClientPacket packet, string host, int port, string serviceName) where CLIENT : IClient, new()
  74.         {
  75.             CLIENT client = new CLIENT();
  76.             client.Init(host, port, packet);
  77.             client.SSL = true;
  78.             client.SslServiceName = serviceName;
  79.             return client;
  80.         }
  81.     }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/ServerFactory.cs)
以上是服务最基础的功能，实际还有很多细节的东西需要实现，如连接监听，接收，发送信息等；这些都会在后面的章节来讲述如何实现。

启动

IServer提供了一个Open方法来启动服务，这个方法的过程主要是对配置进行一个初始化，和调用相关的ListenHandler(《监听》章节会讲述)。

  1.         public bool Open()
  2.         {
  3.             bool result = false;
  4.             try
  5.             {
  6.                 //初始化
  7.                 ToInitialize();
  8.                 Status = ServerStatus.Start;
  9.                 //运行相关地址监听
  10.                 foreach (ListenHandler item in this.Options.Listens)
  11.                 {
  12.                     item.SyncAccept = Options.SyncAccept;
  13.                     item.Run(this, OnListenAcceptCallBack);
  14.                 }
  15.                 //打印当前GC是否ServerGC，在多核发CPU中开启这个配置可以更好地提升GC处理能力
  16.                 if (!GCSettings.IsServerGC)
  17.                 {
  18.                     if (EnableLog(LogType.Warring))
  19.                         Log(LogType.Warring, null, "no serverGC mode,please enable serverGC mode!");
  20.                 }
  21.                 if (Handler != null)
  22.                     Handler.Server = this;
  23.                 if (WriteLogo != null)
  24.                     WriteLogo();
  25.                 else
  26.                     OnWriteLogo();
  27.                 Handler?.Opened(this);
  28.                 //获取监听是所有成功
  29.                 foreach (ListenHandler item in this.Options.Listens)
  30.                 {
  31.                     result |= (item.Error == null);
  32.                 }
  33.             }
  34.             catch (Exception e_)
  35.             {
  36.                 Status = ServerStatus.Error;
  37.                 if (EnableLog(LogType.Error))
  38.                     Error(e_, null, "server start error!");
  39.                 result = false;
  40.             }
  41.             if (result)
  42.             {
  43.                 Status = ServerStatus.Start;
  44.             }
  45.             else
  46.             {
  47.                 Status = ServerStatus.Error;
  48.             }
  49.             return result;
  50.         }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/TcpServer.cs)

在启动过程中有个比较重要的环节是内部初始化，这个工作主要把服务的缓冲区和线程队列等对象过行实例化。

  1.         private void ToInitialize()
  2.         {
  3.             if (!mInitialized)
  4.             {
  5.                 //初始化接收线程队列
  6.                 mReceiveDispatchCenter = new Dispatchs.DispatchCenter<SocketAsyncEventArgsX>(ProcessReceiveArgs, Options.IOQueues);
  7.                 int maxBufferSize;
  8.                 if (Options.BufferPoolMaxMemory == 0)
  9.                 {
  10.                     Options.BufferPoolMaxMemory = 500;
  11.                 }
  12.                 //计算最大可用缓冲区内存
  13.                 maxBufferSize = (int)(((long)Options.BufferPoolMaxMemory * 1024 * 1024) / Options.BufferSize / Options.BufferPoolGroups);
  14.                 if (maxBufferSize < Options.BufferPoolSize)
  15.                     maxBufferSize = Options.BufferPoolSize;
  16.                 //初始化接收缓冲池
  17.                 mReceiveBufferPoolGroup = new BufferPoolGroup(Options.BufferSize, Options.BufferPoolSize, maxBufferSize, Options.BufferPoolGroups);
  18.                 //初始化发送缓冲池
  19.                 mSendBufferPoolGroup = new BufferPoolGroup(Options.BufferSize, Options.BufferPoolSize, maxBufferSize, Options.BufferPoolGroups);
  20.                 //创建会话列表
  21.                 mSessions = new ConcurrentDictionary<long, ISession>();
  22.                 mInitialized = true;
  23.                 //初始化接入处理线程队列
  24.                 mAcceptDispatcher = new Dispatchs.DispatchCenter<AcceptSocketInfo>(AcceptProcess, Math.Min(Environment.ProcessorCount, 16));
  25.                 //配置会话超时
  26.                 if (Options.SessionTimeOut > 0)
  27.                 {
  28.                     //计算设置超时时间 
  29.                     if (Options.SessionTimeOut * 1000 < mTimeOutCheckTime)
  30.                         mTimeOutCheckTime = Options.SessionTimeOut * 1000;
  31.                     else
  32.                         mTimeOutCheckTime = Options.SessionTimeOut * 1000;
  34.                     if (mDetectionTimer != null)
  35.                         mDetectionTimer.Dispose();
  36.                     //启动定时器
  37.                     mDetectionTimer = new System.Threading.Timer(OnDetectionHandler, null,
  38.                         mTimeOutCheckTime, mTimeOutCheckTime);
  39.                     if (EnableLog(LogType.Info))
  40.                         Log(LogType.Info, null, "detection sessions timeout with {0}s", Options.SessionTimeOut);
  41.                 }
  42.             }
  43.         }

(https://github.com/IKende/BeetleX/blob/master/src/BeetleX/TcpServer.cs)