SuperSocket笔记
https://note.youdao.com/share/?id=eec22facef3d915b5efb258a715ad882&type=note#/
SuperSocket是一款优秀的SOCKET框架，功能强大，以下是我的学习笔记。
一、官网
主页： http://www.supersocket.net
官网文档： http://docs.supersocket.net
二、源码浅析
Socket通讯不管怎么封装，其核心必然是Listen、Accept、Receive、Send等关键，因此从最底层开始往上抽丝剥茧，解读SuperSocket的逻辑。
项目SuperSocket.SocketEngine.Net45 实现对Socket链接、收发数据的封装。
项目SuperSocket.SocketBase.Net45实现对AppServer AppSession等业务逻辑的抽象封装。
整个SuperSocket是基于.net SocketAsyncEventArgs实现的，相关介绍请参考：http://www.cnblogs.com/smark/p/3573107.html
http://blog.****.net/zhangjunjian127/article/details/7067797
1、SocketServerBase：一个SocketServer可以监听多个端口
public SocketServerBase(IAppServer appServer, ListenerInfo[] listeners)
{....} //ListenerInfo[]表示多个端口
public virtual bool Start()
{
......
//创建多个监听
for (var i = 0; i < ListenerInfos.Length; i++)
{
var listener = CreateListener(ListenerInfos[i]); //创建一个Socket监听
listener.Error += new ErrorHandler(OnListenerError);
listener.Stopped += new EventHandler(OnListenerStopped);
listener.NewClientAccepted += new NewClientAcceptHandler(OnNewClientAccepted); //OnNewClientAccepted是抽象方法，在AsyncSocketServer中实现；
if (listener.Start(AppServer.Config))
{
Listeners.Add(listener);
........
}
}
......
}
//子类TcpSocketServerBase实现抽象方法创建监听
protected override ISocketListener CreateListener(ListenerInfo listenerInfo)
{
return new TcpAsyncSocketListener(listenerInfo);
}
2、SocketListenerBase，抽象类，实现接口ISocketListener，定义基础的start stop error等事件；TcpAsyncSocketListener ，SocketListenerBase子类，封装了socket监听：
public override bool Start(IServerConfig config)
{
m_ListenSocket = new Socket(this.Info.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); //创建socket;
......
ProcessAccept(acceptEventArg);//处理accept
}
void ProcessAccept(SocketAsyncEventArgs e)
{
......
if (socket != null)
OnNewClientAccepted(socket, null);//触发OnNewClientAccepted,通过这个事件，又回到了AsyncSocketServer.OnNewClientAccepted
........
}
3. AsyncSocketServer , TcpSocketServerBase的子类，是获取新连接，监听收数据的关键
public override bool Start()
{
m_BufferManager = new BufferManager(bufferSize * AppServer.Config.MaxConnectionNumber, bufferSize); //预生成了一块缓冲区，根据ServerConfig的最大链接数预生成
//预创建MaxConnectionNumber个SocketAsyncEventArgsProxy
var socketArgsProxyList = new List<SocketAsyncEventArgsProxy>(AppServer.Config.MaxConnectionNumber);
for (int i = 0; i < AppServer.Config.MaxConnectionNumber; i++)
{
//Pre-allocate a set of reusable SocketAsyncEventArgs
socketEventArg = new SocketAsyncEventArgs();
m_BufferManager.SetBuffer(socketEventArg);
socketArgsProxyList.Add(new SocketAsyncEventArgsProxy(socketEventArg));
}
//创建了读写时的队列，基于ConcurrentStack，是.net 并行框架的一个库，是无锁的，提高效率；参考资料：http://www.cnblogs.com/zw369/p/3990908.html
m_ReadWritePool = new ConcurrentStack<SocketAsyncEventArgsProxy>(socketArgsProxyList);
......
}
//接着分析NewClientAccepted事件
protected override void OnNewClientAccepted(ISocketListener listener, Socket client, object state)
{
........
ProcessNewClient(client, listener.Info.Security);
}
//处理新的Seesion接入（新的客户端Socket接入）
private IAppSession ProcessNewClient(Socket client, SslProtocols security)
{
if (!m_ReadWritePool.TryPop(out socketEventArgsProxy)).....
//AsyncSocketSession封装了处理某一个client Socket数据收发的类
socketSession = new AsyncSocketSession(client, socketEventArgsProxy);
//创建了一个AppSession对象，CreateSession在TcpSocketServerBase中实现；主要是对clientSocket进行设置缓冲区大小，超时时间等；
AppSession代表一个和客户端的逻辑连接，官方说明：http://docs.supersocket.net/v1-6/zh-CN/Implement-your-AppServer-and-AppSession
通过AppSession，将AsyncSocketServer 与AppServer关联起来了;
最终是调用了AppServerBase.CreateAppSession，并执行了ExecuteConnectionFilters，ConnectionFilter的目的是对客户端的请求进行验证，更多ConnectionFilter参考官网说明：http://docs.supersocket.net/v1-6/zh-CN/Connection-Filter；
返回的AppSession是什么类型？后面继续讲
var session = CreateSession(client, socketSession);
......
//AsyncStreamSocketSession继承了INegotiateSocketSession，用于处理SSL加密；
var negotiateSession = socketSession as INegotiateSocketSession;
if (negotiateSession == null) //一般情况是AsyncSocketSession
{
//AppServer注册了session的Closed事件并绑到了SessionClosed事件上，同时触发了NewSessionConnected事件;
if (RegisterSession(session))
{
AppServer.AsyncRun(() => socketSession.Start());//异步启动接收数据；这里是最重点的部分；
}
return session;
}
negotiateSession.NegotiateCompleted += OnSocketSessionNegotiateCompleted;
negotiateSession.Negotiate();
}
从上面部分代码的解读，可以清楚了解到SuperSocket是如何监听一个端口的，如何响应一个客户端Socket的链接请求的（NewSessionConnected），以及如何响应客户端Socket的关闭事件的（SessionClosed）。
4、接下来解读如何处理收数据、解析数据
AsyncSocketSession:
//开始接收数据
public override void Start()
{
StartReceive(SocketAsyncProxy.SocketEventArgs);
if (!m_IsReset)
StartSession();
}
private void StartReceive(SocketAsyncEventArgs e, int offsetDelta)
{......
// the connection is closing or closed
if (!OnReceiveStarted())
return;
willRaiseEvent = Client.ReceiveAsync(e);
......
ProcessReceive(e)
}
public void ProcessReceive(SocketAsyncEventArgs e)
{
......
//由AppSession进行进一步的数据处理；
offsetDelta = this.AppSession.ProcessRequest(e.Buffer, e.Offset, e.BytesTransferred, true);
......
//read the next block of data sent from the client
StartReceive(e, offsetDelta);
}
AppSession :
int IAppSession.ProcessRequest(byte[] readBuffer, int offset, int length, bool toBeCopied)
{
int rest, offsetDelta;
while (true)
{
//解析数据，FilterRequest的解读在下一段；
var requestInfo = FilterRequest(readBuffer, offset, length, toBeCopied, out rest, out offsetDelta);
if (requestInfo != null)
{
try
{
//执行指令，将解析出来的数据进一步进行业务逻辑处理；解读在后面...
AppServer.ExecuteCommand(this, requestInfo);
}
........
}
if (rest <= 0)
{
return offsetDelta;
}
//Still have data has not been processed
offset = offset + length - rest;
length = rest;
}//循环进行数据解析，直到缓冲区的数据全部解析完，目的是为了防止有粘包...
}
////解析数据
TRequestInfo FilterRequest(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest, out int offsetDelta)
{
//触发AppServer的RawDataReceived事件；从这里可以看出来，RawDataReceived是原始的数据包，如果返回false则不会继续往下执行。
if (!AppServer.OnRawDataReceived(this, readBuffer, offset, length))
{
rest = 0;
offsetDelta = 0;
return null;
}
var currentRequestLength = m_ReceiveFilter.LeftBufferSize;
//调用ReceiveFilter处理接收到的数据,ReceiveFilter的官网说明：http://docs.supersocket.net/v1-6/zh-CN/Implement-Your-Own-Communication-Protocol-with-IRequestInfo,-IReceiveFilter-and-etc
官方内置了一些常用的Filter，http://docs.supersocket.net/v1-6/zh-CN/The-Built-in-Common-Format-Protocol-Implementation-Templates
利用自定义的Filter可以实现自己业务数据的解析；
var requestInfo = m_ReceiveFilter.Filter(readBuffer, offset, length, toBeCopied, out rest);
if (m_ReceiveFilter.State == FilterState.Error)
{
rest = 0;
offsetDelta = 0;
Close(CloseReason.ProtocolError);
return null;
}
var offsetAdapter = m_ReceiveFilter as IOffsetAdapter;
offsetDelta = offsetAdapter != null ? offsetAdapter.OffsetDelta : 0;
.......
return requestInfo;
}
//执行指令。AppServerBase类中。
protected virtual void ExecuteCommand(TAppSession session, TRequestInfo requestInfo)
{
if (m_RequestHandler == null)
{
//从命令加载器获取对应命令，参考官网说明：http://docs.supersocket.net/v1-6/zh-CN/Command-and-Command-Loader
var commandProxy = GetCommandByName(requestInfo.Key);
if (commandProxy != null)
{
var command = commandProxy.Command;
var commandFilters = commandProxy.Filters;
session.CurrentCommand = requestInfo.Key;
var cancelled = false;
if (commandFilters == null)
{
//执行命令
command.ExecuteCommand(session, requestInfo);
}
else
{
//如果有命令过滤器，参考官网说明：http://docs.supersocket.net/v1-6/zh-CN/Command-Filter，命令过滤器的作用是可以在执行前，执行后进行进一步的业务处理，用Attribute实现的，类似一种AOP的作用；
var commandContext = new CommandExecutingContext();
commandContext.Initialize(session, requestInfo, command);
for (var i = 0; i < commandFilters.Length; i++)
{
var filter = commandFilters[i];
//命令执行前
filter.OnCommandExecuting(commandContext);
if (commandContext.Cancel)
{
cancelled = true;
if(Logger.IsInfoEnabled)
Logger.Info(session, string.Format("The executing of the command {0} was cancelled by the command filter {1}.", command.Name, filter.GetType().ToString()));
break;
}
}
if (!cancelled)
{
try
{
//执行命令
command.ExecuteCommand(session, requestInfo);
}
catch (Exception exc)
{
commandContext.Exception = exc;
}
for (var i = 0; i < commandFilters.Length; i++)
{
var filter = commandFilters[i];
//命令执行后
filter.OnCommandExecuted(commandContext);
}
if (commandContext.Exception != null && !commandContext.ExceptionHandled)
{
try
{
session.InternalHandleExcetion(commandContext.Exception);
}
catch
{
}
}
}
}
if(!cancelled)
{
session.PrevCommand = requestInfo.Key;
if (Config.LogCommand && Logger.IsInfoEnabled)
Logger.Info(session, string.Format("Command - {0}", requestInfo.Key));
}
}
else
{
session.InternalHandleUnknownRequest(requestInfo);
}
session.LastActiveTime = DateTime.Now;
}
else
{
session.CurrentCommand = requestInfo.Key;
try
{
//触发NewRequestReceived事件，由事件响应处理指令；
m_RequestHandler(session, requestInfo);
}
catch (Exception e)
{
session.InternalHandleExcetion(e);
}
......
}
.......
}
5 发数据
官网资料：http://docs.supersocket.net/v1-6/zh-CN/Push-Data-to-Clients-from-Server-Initiatively
发数据逻辑相对要简单多了，通过AppSession发送数据，AppSession通过内部的SocketSession发送数据。
三、小结
通过上述代码解读后，对SuperSocket的结构有了一个清晰的概念，对照官网这张结构图，会更直观：
但是从代码中可以看出来，在Command执行期间，如果存在大运算或CPU密集型计算，仍然有可能造成阻塞，因为指令执行这一部分并没有用到线程池，所以在处理业务逻辑时要着重注意！