首页 > 编程语言 >[转] C# SuperSocket 手把手教你入门 傻瓜教程 5~6

[转] C# SuperSocket 手把手教你入门 傻瓜教程 5~6

时间：2023-07-19 09:55:51浏览次数：45  
标签：Console SuperSocket 自定义 C# 手把手 System using 客户端

5（探索自定义AppServer、AppSession，Conmmand，用配置文件App.comfig启动服务器）

 

目录

一、为什么要使用自定义类AppServer、AppSession，Conmmand

二、为什么要通过配置文件App.comfig启动服务器

三、创建工程项目

四、下载SuperSocket动态库

1、安装SuperSocket组件

2、安装SuperSocket.Engine组件

3、log4net.config的【复制到输出目录】组态为“如果较新则复制”

五、自定义AppSession类

1、工程项目中添加一个自定义类SocketSession类

2、SocketSession类完整的代码如下：

六、自定义AppServer类

1、工程项目中添加一个自定义类SocketServer

2、SocketServer类完整的代码如下：

七、使用Command

（一）、定义一个名为"Hello "的类去处理Key为"Hello"的请求。

（二）、定义一个名为"ADD"的类去处理Key为"ADD"的请求:

（三）、定义一个名为"MULT"的类去处理Key为"MULT"的请求:

（四）、定义一个名为"Echo"的类去处理Key为"Echo"的请求:

八、program.cs

九、配置App.config使用BootStrap启动SuperSocket

1、SuperSocket配置section 。

2、Server实例的配置     

十、完整的工程项目

十一、验证

        在前几篇文章中，我们已经了解到了如何在SuperSocket处理客户端请求。之前我们借助SuperSocket实现了一个简易版的服务器，但是不管是Server还是Session都是使用SuperSocket框架提供的Server和Session（即框架内置的Server类和Session类）。

一、为什么要使用自定义类AppServer、AppSession，Conmmand

        我们可能会发现一个问题，如果我们的服务器端包含有很多复杂的业务逻辑，这样的话如果仍然SuperSocket框架提供的内置的Server类和Session类，在编程时使用switch/case代码将会很长而且非常难看，并且没有遵循面向对象设计的原则（OOD）。

        因此本篇博客我们要实现自己定义的Server类和Session类，来重写SuperSocket​​​​​​​框架原生的Server类或Session类的方法，通过添加自己所需的属性，来实现自己的业务逻辑，并且也不在使用事件来绑定接收，连接，或关闭事件，全部交给Bootstrap来执行，（这个Bootstrap并不是指前端框架的Bootstrap，而是指的SuperSocket框架的一个引导程序或说是辅助程序），就是这里我们使用Bootstrap 来配置启动SuperSocket服务器程序。

二、为什么要通过配置文件App.comfig启动服务器

  1. 避免硬编码
  2. SuperSocket提供了很多有用的配置选项
  3. 可以充分利用SuperSocket提供的工具

        前面几篇文章，我们都使用如下方法启动服务器

  1.             var appServer = new AppServer();
  2.  
  3.             if (!appServer.Setup(2017)) // Setup with listening port
  4.             {
  5.                 Console.WriteLine("Failed to Setup!");
  6.                 Console.ReadKey();
  7.                 return;
  8.             }

         有没有更好的方法，不需要修改任何源程序就可以完成服务器的启动呢？答案就是使用APP.config配置文件启动服务器。我们可以在配置文件中方便的修改服务器的端口号和IP地址，而不需要修改源程序。

         下面我们就创建自定义AppSession类，自定义AppServer类，自定义Command类以及通过APP.config配置文件启动服务器。

三、创建工程项目

        创建控制台项目：打开visual Studio 2017程序，文件--->新建--->项目

        创建一个项目名称为：SuperSocketClass 的工程项目。

         SuperSocketClass就是APP.config配置文件中的实例名称。

四、下载SuperSocket动态库

        最好通过Visual Stuido 2017程序的NuGet来获取，本人也比较喜欢这种方式，可以更新组件版本。

 1、安装SuperSocket组件

点击浏览，输入SuperSocket，选中SuperSocket组件安装SuperSocket组件。

2、安装SuperSocket.Engine组件

 

3、log4net.config的【复制到输出目录】组态为“如果较新则复制”

添加完成组件后需要注意将config文件进行编译成内容，log4net需要使用config文件

将Config文件夹中的log4net.config的【复制到输出目录】组态为“如果较新则复制”

4、查看引入后的项目整体目录，框红线的为引入supersocket组件和log4net文件 

五、自定义AppSession类

        AppSession 代表一个和客户端的逻辑连接，基于连接的操作应该放在该类之中。你可以用该类的实例发送数据到客户端，接收客户端发送的数据或者关闭连接。

     使用方法：创建自定义类SocketSession，继承AppSession类并重写AppSession类的方法（注意：一个AppSession对象对应一个连接）

1、工程项目中添加一个自定义类SocketSession类

2、SocketSession类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketBase.Config;
  12. using SuperSocket.SocketEngine;
  13.  
  14.  
  15.  
  16. namespace SuperSocketClass.Config
  17. {
  18.     /// <summary>  
  19.     /// 自定义连接类SocketSession，继承AppSession，并传入到AppSession  
  20.     /// </summary>  
  21.     public class SocketSession : AppSession<SocketSession>
  22.     {
  23.         public override void Send(string message)
  24.         {
  25.             Console.WriteLine("发送消息:" + message);
  26.             base.Send(message);
  27.         }
  28.  
  29.  
  30.         protected override void OnSessionStarted()
  31.         {
  32.             //输出客户端IP地址  
  33.             Console.WriteLine(this.LocalEndPoint.Address.ToString());
  34.             this.Send("Hello User,Welcome to SuperSocket Telnet Server!");
  35.         }
  36.  
  37.  
  38.         /// <summary>  
  39.         /// 连接关闭  
  40.         /// </summary>  
  41.         /// <param name="reason"></param>  
  42.         protected override void OnSessionClosed(CloseReason reason)
  43.         {
  44.             base.OnSessionClosed(reason);
  45.         }
  46.  
  47.  
  48.         protected override void HandleUnknownRequest(StringRequestInfo requestInfo)
  49.         {
  50.             Console.WriteLine($"遇到未知的请求 Key:" + requestInfo.Key + $" Body:" + requestInfo.Body);
  51.             base.HandleUnknownRequest(requestInfo);
  52.         }
  53.  
  54.         /// <summary>  
  55.         /// 捕捉异常并输出  
  56.         /// </summary>  
  57.         /// <param name="e"></param>  
  58.         protected override void HandleException(Exception e)
  59.         {
  60.             this.Send("error: {0}", e.Message);
  61.         }
  62.     }
  63. }

六、自定义AppServer类

        AppServer 代表了监听客户端连接，承载TCP连接的服务器实例。理想情况下，我们可以通过AppServer实例获取任何你想要的客户端连接，服务器级别的操作和逻辑应该定义在此类之中。

        使用方法：创建自定义类SocketServer，继承AppServer类并重写AppServer类的方法

1、工程项目中添加一个自定义类SocketServer

2、SocketServer类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8.  
  9. using SuperSocket.Common;
  10. using SuperSocket.SocketBase;
  11. using SuperSocket.SocketBase.Protocol;
  12. using SuperSocket.SocketBase.Config;
  13. using SuperSocket.SocketEngine;
  14.  
  15.  
  16. namespace SuperSocketClass.Config
  17. {
  18.  
  19.     public class SocketServer : AppServer<SocketSession>
  20.     {
  21.         protected override bool Setup(IRootConfig rootConfig, IServerConfig config)
  22.         {
  23.             Console.WriteLine("正在准备配置文件");
  24.             return base.Setup(rootConfig, config);
  25.         }
  26.  
  27.         protected override void OnStarted()
  28.         {
  29.             Console.WriteLine("服务已开始");
  30.             base.OnStarted();
  31.         }
  32.  
  33.         protected override void OnStopped()
  34.         {
  35.             Console.WriteLine("服务已停止");
  36.             base.OnStopped();
  37.         }
  38.  
  39.  
  40.         /// <summary>  
  41.         /// 输出新连接信息  
  42.         /// </summary>  
  43.         /// <param name="session"></param>  
  44.         protected override void OnNewSessionConnected(SocketSession session)
  45.         {
  46.             base.OnNewSessionConnected(session);
  47.             //输出客户端IP地址  
  48.             Console.Write("\r\n" + session.LocalEndPoint.Address.ToString() + ":连接");
  49.         }
  50.  
  51.  
  52.         /// <summary>  
  53.         /// 输出断开连接信息  
  54.         /// </summary>  
  55.         /// <param name="session"></param>  
  56.         /// <param name="reason"></param>  
  57.         protected override void OnSessionClosed(SocketSession session, CloseReason reason)
  58.         {
  59.             base.OnSessionClosed(session, reason);
  60.             Console.Write("\r\n" + session.LocalEndPoint.Address.ToString() + ":断开连接");
  61.         }
  62.     }
  63. }

        警告： 自定义类SocketServer创建在Config文件夹下，因此【实例运行的AppServer类型】完整的路径是： 

SuperSocketClass.Config.SocketServer

         下图中SuperSocketClass.Config.SocketServer就是APP.config配置文件中的实例运行的AppServer类型的完整路径。

七、使用Command

         在SuperSocket中的Command让我们进行扩展，使用方法也极其简单。只需要继承一个CommandBase<AppSession, StringRequestInfo>类。（注意：如果使用了自定义的Session，需要修改此处，如ADD类下的ADD:CommandBase<SocketSession, StringRequestInfo>)类），并override这个类ExecuteCommand方法。

          同时我们要移除请求处理方法的注册，因为它和命令不能同时被支持，注释下面代码即可

    //appServer.NewRequestReceived += new RequestHandler<SocketSession, StringRequestInfo>(appServer_NewRequestReceived);

        现在我们来修改C# SuperSocket 手把手教你入门 傻瓜教程---3（Telnet服务器和客户端请求处理）这篇文章中的示例，先取消Telnet示例中的 appServer.NewRequestReceived 事件处理。这样我们就可以编写大量的命令让我们的Socket更灵活。

        例如，我们可以定义一个名为"Hello "的类去处理Key为"Hello"的请求。

                                 定义一个名为"ADD"的类去处理Key为"ADD"的请求:

                                 定义一个名为"MULT"的类去处理Key为"MULT"的请求:

                                 定义一个名为"Echo"的类去处理Key为"Echo"的请求:

（一）、定义一个名为"Hello "的类去处理Key为"Hello"的请求。

1、工程项目中添加一个自定义类Hello

  2、Hello类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8.  
  9. using SuperSocket.Common;
  10. using SuperSocket.SocketBase;
  11. using SuperSocket.SocketBase.Protocol;
  12. using SuperSocket.SocketBase.Command;
  13.  
  14.  
  15.  
  16. namespace SuperSocketClass.Config
  17. {
  18.     public class Hello : CommandBase<SocketSession, StringRequestInfo>
  19.     {
  20.         /// <summary>  
  21.         /// 自定义执行命令方法，注意传入的变量session类型为MySession  
  22.         /// </summary>  
  23.         /// <param name="session">会话</param>  
  24.         /// <param name="requestInfo">请求数据信息</param>  
  25.         public override void ExecuteCommand(SocketSession session, StringRequestInfo requestInfo)
  26.         {
  27.             session.Send(string.Format("Hello {0}:{1}   {2}", session.Config.Ip, session.Config.Port, requestInfo.Body));
  28.         }
  29.     }
  30. }

（二）、定义一个名为"ADD"的类去处理Key为"ADD"的请求:

1、工程项目中添加一个自定义类ADD

   2、ADD类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8.  
  9. using SuperSocket.Common;
  10. using SuperSocket.SocketBase;
  11. using SuperSocket.SocketBase.Protocol;
  12. using SuperSocket.SocketBase.Command;
  13.  
  14.  
  15.  
  16. namespace SuperSocketClass.Config
  17. {
  18.     public class ADD : CommandBase<SocketSession, StringRequestInfo>
  19.     {
  20.         public override void ExecuteCommand(SocketSession session, StringRequestInfo requestInfo)
  21.         {
  22.             session.Send(requestInfo.Parameters.Select(p => Convert.ToInt32(p)).Sum().ToString());
  23.         }
  24.  
  25.     }
  26. }

（三）、定义一个名为"MULT"的类去处理Key为"MULT"的请求:

1、工程项目中添加一个自定义类MULT

    2、MULT类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketBase.Command;
  12.  
  13.  
  14.  
  15. namespace SuperSocketClass.Config
  16. {
  17.     public class MULT : CommandBase<SocketSession, StringRequestInfo>
  18.     {
  19.         public override void ExecuteCommand(SocketSession session, StringRequestInfo requestInfo)
  20.         {
  21.             var result = 1;
  22.  
  23.             foreach (var factor in requestInfo.Parameters.Select(p => Convert.ToInt32(p)))
  24.             {
  25.                 result *= factor;
  26.             }
  27.  
  28.             session.Send(result.ToString());
  29.         }
  30.     }
  31. }

（四）、定义一个名为"Echo"的类去处理Key为"Echo"的请求:

1、工程项目中添加一个自定义类Echo

     2、Echo类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketBase.Command;
  12.  
  13.  
  14.  
  15. namespace SuperSocketClass.Config
  16. {
  17.     public class Echo : CommandBase<SocketSession, StringRequestInfo>
  18.     {
  19.         public override void ExecuteCommand(SocketSession session, StringRequestInfo requestInfo)
  20.         {
  21.             session.Send(requestInfo.Body);
  22.         }
  23.  
  24.     }
  25. }

八、program.cs

        需要修改program.cs。

        将原有【C# SuperSocket 手把手教你入门 傻瓜教程---3（Telnet服务器和客户端请求处理）】program.cs中定义的端口信息以及方法注释掉，只保留服务器启动和停止的代码。然后引入using SuperSocket.SocketEngine;     使用BootStrap启动服务器。

        在program.cs类中先要删除原先启动服务器方式的代码，然后改为使用App.config文件配置，用BootStrap启动服务器。

        警告：要想使用BootStrap启动服务器，必须引用

using SuperSocket.SocketEngine;

     1、program类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketEngine;
  12.  
  13.  
  14.  
  15. /****************************************************************
  16. *   作者:霸王猫
  17. *   创建时间：2022-01-19 00:02:17
  18. *   2022
  19. *   描述说明：自定义连接类SocketSession，继承AppSession，并传入到AppSession  
  20. *****************************************************************/
  21.  
  22.  
  23. namespace SuperSocketClass
  24. {
  25.     class Program
  26.     {
  27.         /// <summary>
  28.         /// SuperSocket服务启动或停止
  29.         /// </summary>
  30.         /// <param name="args"></param>
  31.         static void Main(string[] args)
  32.         {
  33.             //var appServer = new AppServer();
  34.             //启动应用服务端口
  35.             //if (!appServer.Setup(2017)) //启动时监听端口2017
  36.             //{
  37.             //Console.WriteLine("服务端口启动失败!");
  38.             //Console.ReadKey();
  39.             //return;
  40.             //}
  41.  
  42.             //Console.WriteLine();
  43.  
  44.             //尝试启动应用服务
  45.             //if (!appServer.Start())
  46.             //{
  47.             //Console.WriteLine("服务启动失败!");
  48.             //Console.ReadKey();
  49.             //return;
  50.             //}
  51.  
  52.             //Console.WriteLine("服务启动成功，请按'q'停止服务!");
  53.  
  54.             //appServer.NewSessionConnected += appServer_NewSessionConnected;
  55.             //appServer.NewRequestReceived += appServer_NewRequestReceived;
  56.  
  57.  
  58.             //while (Console.ReadKey().KeyChar != 'q')
  59.             //{
  60.             //Console.WriteLine();
  61.             //continue;
  62.             //}
  63.  
  64.             //停止服务
  65.             //appServer.Stop();
  66.  
  67.             //Console.WriteLine("服务已停止!");
  68.             //Console.ReadKey();
  69.  
  70.             // }
  71.  
  72.             //static void appServer_NewSessionConnected(AppSession session)
  73.             //{
  74.             //session.Send("Welcome to SuperSocket Telnet Server!");
  75.             //}
  76.  
  77.  
  78.             /// <summary>
  79.             ///客户端请求处理
  80.             /// </summary>
  81.             /// <param name="session">会话</param>
  82.             /// <param name="requestInfo">请求信息</param>
  83.  
  84.             //static void appServer_NewRequestReceived(AppSession session, StringRequestInfo requestInfo)
  85.             //{
  86.             //switch (requestInfo.Key.ToUpper())
  87.             //{
  88.             //  case ("ECHO"):
  89.             //session.Send(requestInfo.Body);
  90.             //break;
  91.  
  92.             //   case ("ADD"):
  93.             //session.Send(requestInfo.Parameters.Select(p => Convert.ToInt32(p)).Sum().ToString());
  94.             //break;
  95.  
  96.             //    case ("MULT"):
  97.  
  98.             //var result = 1;
  99.  
  100.             //foreach (var factor in requestInfo.Parameters.Select(p => Convert.ToInt32(p)))
  101.             //{
  102.             //result *= factor;
  103.             //}
  104.  
  105.             //session.Send(result.ToString());
  106.             //break;
  107.             //}
  108.  
  109.  
  110.  
  111.                 Console.WriteLine("请按任何键进行启动SuperSocket服务!");
  112.                 Console.ReadKey();
  113.                 Console.WriteLine();
  114.                 var bootstrap = BootstrapFactory.CreateBootstrap();
  115.  
  116.                 if (!bootstrap.Initialize())
  117.                 {
  118.                     Console.WriteLine("初始化失败!");
  119.                     Console.ReadKey();
  120.                     return;
  121.                 }
  122.  
  123.                 var result = bootstrap.Start();
  124.  
  125.                 Console.WriteLine("服务正在启动: {0}!", result);
  126.  
  127.                 if (result == StartResult.Failed)
  128.                 {
  129.                     Console.WriteLine("服务启动失败!");
  130.                     Console.ReadKey();
  131.                     return;
  132.                 }
  133.                 Console.WriteLine("服务启动成功，请按'q'停止服务!");
  134.  
  135.                 while (Console.ReadKey().KeyChar != 'q')
  136.                 {
  137.                     Console.WriteLine();
  138.                     continue;
  139.                 }
  140.  
  141.                 //停止服务
  142.                 // appServer.Stop();
  143.                 bootstrap.Stop();
  144.                 Console.WriteLine("服务已停止!");
  145.                 Console.ReadKey();
  146.  
  147.  
  148.             }
  149.         }
  150.  
  151. }

九、配置App.config使用BootStrap启动SuperSocket

1、SuperSocket配置section 。

        SuperSocket使用.NET自带的配置技术，SuperSocket有一个专门的配置Section，使用配置启动SuperSocket可以灵活配置选项。

  1.  <configSections>
  2.     <!--log 日志记录-->
  3.     <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
  4.     <!--SocketEngine-->
  5.     <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
  6.   </configSections>

2、Server实例的配置     

  1.   <!--SuperSocket服务配置信息 serverType是项目的服务如我自定义的Socketserver-->
  2.   <!--name: 实例名称
  3.       serverType: 实例运行的AppServer类型
  4.       ip: 侦听ip
  5.       port: 侦听端口-->
  6.   <superSocket>
  7.     <servers>
  8.       <!--textEncoding 编码方式"gb2312","utf-8" 默认是acii-->
  9.       <server name="SuperSocketClass" 
  10.        textEncoding="gb2312" 
  11.        serverType="SuperSocketClass.Config.SocketServer,SuperSocketClass"
  12.        ip="Any"
  13.        port="2017"
  14.        maxConnectionNumber="100">
  15.       </server>
  16.     </servers>
  17.   </superSocket>

         这里解释一下配置的服务器节点：

name: 实例名称（就是：工程项目的解决方案名称：SuperSocketClass）

serverType: 实例运行的AppServer类型（就是之前我们创建的自定义AppServer类【SocketServer】，它创建在Config文件夹下，因此它的全称为：SuperSocketClass.Config.SocketServer）

ip: 侦听ip

port: 侦听端口

name: 实例名称                                          --->   SuperSocketClass
serverType: 实例运行的AppServer类型     --->  SuperSocketClass.Config.SocketServer
ip: 侦听ip                                                     --->  Any
port: 侦听端口                                             ---> 2017

完整的App.config配置文件如下所示：

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.  
  4.   <configSections>
  5.     <!--log 日志记录-->
  6.     <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
  7.     <!--SocketEngine-->
  8.     <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
  9.   </configSections>
  10.  
  11.  
  12.   <!--服务信息描述，在window服务模式下的名称标识-->
  13.   <appSettings>
  14.     <add key="ServiceName" value="SupperSocketClass"/>
  15.     <add key="ServiceDescription" value="霸王猫"/>
  16.   </appSettings>
  17.  
  18.  
  19.   <!--SuperSocket服务配置信息 serverType是项目的服务如我自定义的Socketserver-->
  20.   <!--name: 实例名称
  21.       serverType: 实例运行的AppServer类型
  22.       ip: 侦听ip
  23.       port: 侦听端口-->
  24.   <superSocket>
  25.     <servers>
  26.       <!--textEncoding 编码方式"gb2312","utf-8" 默认是acii-->
  27.       <server name="SuperSocketClass" 
  28.        textEncoding="gb2312" 
  29.        serverType="SuperSocketClass.Config.SocketServer,SuperSocketClass"
  30.        ip="Any"
  31.        port="2017"
  32.        maxConnectionNumber="100">
  33.       </server>
  34.     </servers>
  35.   </superSocket>
  36.  
  37.  
  38.   <startup> 
  39.         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
  40.     </startup>
  41. </configuration>

十、完整的工程项目

        从下图可以观察到，工程项目的解决方案名为：SuperSocketClass，即为实例名称。

        从下图可以观察到，实例运行的AppServer类型为：SocketServer，它的全称为：SuperSocketClass.Config.SocketServer。（因为自定义类SocketServer创建在Config文件夹下，因此它的全称为SuperSocketClass.Config.SocketServer）

十一、验证

1、启动服务器，创建客户端

2、连接客户端

 3、验证Hello类

客户端输入字符串"Hello C# SuperSocket Very Good!!!"。

警告：在客户端输入字符串，一定要按下回车键后才能点【发送数据】按钮，因为SuperSocket规定客户端给服务器发送的报文必须以"\r\n"为结束符，否则服务器会认为是非法报文不预处理。

 4、验证ADD类

客户端输入字符串"ADD 2 3 5"。

警告：在客户端输入字符串，一定要按下回车键后才能点【发送数据】按钮，因为SuperSocket规定客户端给服务器发送的报文必须以"\r\n"为结束符，否则服务器会认为是非法报文不预处理。

  5、验证MULT类

客户端输入字符串"MULT 2 3 5"。

警告：在客户端输入字符串，一定要按下回车键后才能点【发送数据】按钮，因为SuperSocket规定客户端给服务器发送的报文必须以"\r\n"为结束符，否则服务器会认为是非法报文不预处理。

6、验证Echo类

客户端输入字符串"Echo hello world!"。

警告：在客户端输入字符串，一定要按下回车键后才能点【发送数据】按钮，因为SuperSocket规定客户端给服务器发送的报文必须以"\r\n"为结束符，否则服务器会认为是非法报文不预处理。

 

注意事项：

  （1）、SocketServer、自定义命令和ScoketSession的访问权限必须设置为public

  （2）、 SocketServerr父类为AppServer<ScoketSession>

  （3）、 SocketSession父类为AppSession<ScoketSession>

  （4）、Hello父类为CommandBase<ScoketSession,StringRequestInfo>，ExecueteCommand方法传入值类型分别为ScoketSession和StringRequestInfo

  （5）、多服务器中需注意AppSession、AppServer、自定义命令中的AppSession不要搞错

总结：

        通过自定义Session和Server，可以实现我们自己的AppSession和AppServer允许你根据你业务的需求来方便的扩展SuperSocket，你可以绑定session的连接和断开事件，服务器实例的启动和停止事件。你还可以在AppServer的Setup方法中读取你的自定义配置信息。总而言之，这些功能让你方便的创建一个你所需要的socket服务器成为可能。

转自https://blog.csdn.net/ba_wang_mao/article/details/128145746

6（CommandLineProtocol---命令行协议）

 

目录

一、 SuperSocket提供的通信协议

二、命令行协议CommandLineProtocol

        1、SuperSocket命令行协议定义了每个请求必须以回车换行符（ "\r\n"）结尾。

        2、SuperSocket命令行协议将接收到的数据翻译成StringRequestInfo 实例。

        3、SuperSocket 内置的命令行协议用空格来分割请求的Key和参数部分。

        4、SuperSocket 内置的命令行协议的参数部分用空格来分割。

三、创建一个支持命令行协议的工程项目

四、安装SuperSocket和SuperSocket.Engine 

1、进入【管理NuGet程序包】

2、安装SuperSocket

3、安装SuperSocket.Engine

 五、自定义AppSession类

1、工程项目中添加一个自定义类SocketSession类

​编辑

2、SocketSession类完整的代码如下：

六、自定义AppServer类

1、工程项目中添加一个自定义类SocketServer

 2、SocketServer类完整的代码如下：

七、使用Command

1、工程项目中添加一个自定义类LOGIN，处理Key为"LOGIN"的请求。

  2、LOGIN类完整的代码如下：

八、program.cs

九、配置App.config使用BootStrap启动SuperSocket

1、SuperSocket配置section 。

2、Server实例的配置     

十、验证

        构建一个网络应用程序, 仅仅使用 TCP 还是 UDP 是远远不够的。 因为TCP 和 UDP 是传输层协议。定义了传输层协议是不能让网络的两端进行通信的。需要定义应用层通信协议把接收到的二进制数据转化成你程序能理解的请求。

        Socket里面的协议解析是Socket通讯程序设计中最复杂的地方，如果你的应用层协议设计或实现不佳，Socket通讯中常见的粘包和分包就难以避免，而用SuperSocket提供的通信协议就完美的避免了上述情况的发生。

一、 SuperSocket提供的通信协议

        SuperSocket提供以了下几种应用层通信协议。 

  • CommandLineProtocol---命令行协议（默认内置）
  • TerminatorReceiveFilter (SuperSocket.SocketBase.Protocol.TerminatorReceiveFilter, SuperSocket.SocketBase) ---结束符协议
  • CountSpliterReceiveFilter (SuperSocket.Facility.Protocol.CountSpliterReceiveFilter, SuperSocket.Facility)---固定数量分隔符协议
  • FixedSizeReceiveFilter (SuperSocket.Facility.Protocol.FixedSizeReceiveFilter, SuperSocket.Facility)---固定请求大小协议
  • BeginEndMarkReceiveFilter (SuperSocket.Facility.Protocol.BeginEndMarkReceiveFilter, SuperSocket.Facility)---带起止符协议
  • FixedHeaderReceiveFilter (SuperSocket.Facility.Protocol.FixedHeaderReceiveFilter, SuperSocket.Facility)---头部格式固定并包含内容长度协议

        什么是默认内置？当你不定义应用层通信协议，直接用AppSession.Send()方法发送字符串进行服务器和客户端双向通信，SuperSocket就默认启用命令行协议CommandLineProtocol。

       下图的代码，你不定义应用层通信协议，直接用AppSession.Send()方法发送字符串进行服务器和客户端双向通信，SuperSocket就默认启用命令行格式的协议CommandLineProtocol进行通信。

  1. static void appServer_NewSessionConnected(AppSession session)
  2. {
  3.     session.Send("Welcome to SuperSocket Telnet Server!");
  4. }

二、命令行协议CommandLineProtocol

        命令行协议是一种被广泛应用的协议。一些成熟的协议如 Telnet, SMTP, POP3 和 FTP 都是基于命令行协议的。

        在SuperSocket 中，如果我们没有自定义应用层协议的话，SuperSocket默认的协议就是命令行协议 ，这样就极大的简化了基于此类协议的开发。

        1、SuperSocket命令行协议定义了每个请求必须以回车换行符（ "\r\n"）结尾。

        2、SuperSocket命令行协议将接收到的数据翻译成StringRequestInfo 实例。

        SuperSocket设计了两个RequestInfo类：StringRequestInfo 和BinaryRequestInfo。其中StringRequestInfo用于字符串实例，BinaryRequestInfo用于二进制实例。如果我们在SuperSocket中使用命令行协议，所有接收到的数据都会翻译成 StringRequestInfo实例（字符串实例）。我们来看一下StringRequestInfo的定义：

  1. public class StringRequestInfo 
  2. {
  3.      public string Key { get; }
  4.      public string Body { get; }
  5.      public string[] Parameters { get; }
  6. /* Other properties and methods */
  7. }

        StringRequestInfo有三个属性， Key是这个命令行协议的命令名，用于关联Command的字符串；Body是一个命令的参数部分；Parameters是一个命令的参数列表。

        3、SuperSocket 内置的命令行协议用空格来分割请求的Key和参数部分。

        SuperSocket内置的命令行协议用空格来分割请求的Key和参数部分，因此当客户端发送如下数据到服务器端时

"LOGIN kerry 123456" + 回车换行符

        服务器将会收到一个StringRequestInfo 实例，这个实例的属性为：

Key: "LOGIN"
Body: "kerry 123456";
Parameters: ["kerry", "123456"]

        同时定义 "LOGIN" 的命令，这个命令的 ExecuteCommand 方法将会被执行，服务器所接收到的StringRequestInfo实例也将作为参数传给这个方法。

  1. public class LOGIN : CommandBase<AppSession, StringRequestInfo>
  2. {
  3.     public override void ExecuteCommand(AppSession session, StringRequestInfo requestInfo)
  4.     {
  5.       
  6.     }
  7. }

         4、SuperSocket 内置的命令行协议的参数部分用空格来分割。

        SuperSocket内置的命令行协议的参数部分用空格来分割，因此当客户端发送如下数据到服务器端时:

"LOGIN kerry 123 456 789" + 回车换行符

         服务器将会收到一个StringRequestInfo 实例，这个实例的属性为：

Key: "LOGIN"
Body: "kerry 123 456 789";
Parameters: ["kerry", "123", "456", "789"]

其中:Parameters[0]="kerry"，Parameters[1]="123"，Parameters[2]="456"，Parameters[3]="789"

       

下面我们创建一个命令行协议的项目验证SuperSocket 内置的命令行协议CommandLineProtocol

三、创建一个支持命令行协议的工程项目

         新建一个SuperSocket服务器项目SuperSocketCommandLineProtocol，参见下图。

 

四、安装SuperSocket和SuperSocket.Engine 

1、进入【管理NuGet程序包】

鼠标右键单击【引用】，弹出下拉菜单，在下拉菜单中选中【管理NuGet程序包（N）】

 2、安装SuperSocket

（1）、【浏览】选项卡下面的输入框中输入SuperSocket

（2）、过一会下面会出现"SuperSocket  ......下载 v1.6.6.1"

（3）、鼠标点击"SuperSocket  ......下载 v1.6.6.1"，右边会出现"版本：最新稳定版1.6.6.1"

（4）、点击"版本：最新稳定版1.6.6.1"右边的【安装】按钮

 3、安装SuperSocket.Engine

（1）、鼠标点击"SuperSocket.Engine "，右边会出现"版本：1.6.6.1"

（2）、点击"版本：1.6.6.1"右边的【安装】按钮

 五、自定义AppSession类

AppSession 代表一个和客户端的逻辑连接，基于连接的操作应该放在该类之中。你可以用该类的实例发送数据到客户端，接收客户端发送的数据或者关闭连接。

     使用方法：创建自定义类SocketSession，继承AppSession类并重写AppSession类的方法（注意：一个AppSession对象对应一个连接）

1、工程项目中添加一个自定义类SocketSession类

2、SocketSession类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. using SuperSocket.Common;
  8. using SuperSocket.SocketBase;
  9. using SuperSocket.SocketBase.Protocol;
  10. using SuperSocket.SocketBase.Config;
  11. using SuperSocket.SocketEngine;
  12.  
  13. namespace SuperSocketCommandLineProtocol
  14. {
  15.     /// <summary>  
  16.     /// 自定义连接类SocketSession，继承AppSession，并传入到AppSession  
  17.     /// </summary>  
  18.     public class SocketSession : AppSession<SocketSession>
  19.     {
  20.         public override void Send(string message)
  21.         {
  22.             Console.WriteLine("发送消息:" + message);
  23.             base.Send(message);
  24.         }
  25.  
  26.  
  27.         protected override void OnSessionStarted()
  28.         {
  29.             //输出客户端IP地址  
  30.             Console.WriteLine(this.LocalEndPoint.Address.ToString());
  31.             this.Send("Hello User,Welcome to SuperSocket Telnet Server!");
  32.         }
  33.  
  34.  
  35.         /// <summary>  
  36.         /// 连接关闭  
  37.         /// </summary>  
  38.         /// <param name="reason"></param>  
  39.         protected override void OnSessionClosed(CloseReason reason)
  40.         {
  41.             base.OnSessionClosed(reason);
  42.         }
  43.  
  44.  
  45.         protected override void HandleUnknownRequest(StringRequestInfo requestInfo)
  46.         {
  47.             Console.WriteLine($"遇到未知的请求 Key:" + requestInfo.Key + $" Body:" + requestInfo.Body);
  48.             base.HandleUnknownRequest(requestInfo);
  49.         }
  50.  
  51.         /// <summary>  
  52.         /// 捕捉异常并输出  
  53.         /// </summary>  
  54.         /// <param name="e"></param>  
  55.         protected override void HandleException(Exception e)
  56.         {
  57.             this.Send("error: {0}", e.Message);
  58.         }
  59.     }
  60. }

六、自定义AppServer类

        AppServer 代表了监听客户端连接，承载TCP连接的服务器实例。理想情况下，我们可以通过AppServer实例获取任何你想要的客户端连接，服务器级别的操作和逻辑应该定义在此类之中。

        使用方法：创建自定义类SocketServer，继承AppServer类并重写AppServer类的方法

1、工程项目中添加一个自定义类SocketServer

 2、SocketServer类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. using SuperSocket.Common;
  8. using SuperSocket.SocketBase;
  9. using SuperSocket.SocketBase.Protocol;
  10. using SuperSocket.SocketBase.Config;
  11. using SuperSocket.SocketEngine;
  12.  
  13.  
  14. namespace SuperSocketCommandLineProtocol.Config
  15. {
  16.     public class SocketServer : AppServer<SocketSession>
  17.     {
  18.         protected override bool Setup(IRootConfig rootConfig, IServerConfig config)
  19.         {
  20.             Console.WriteLine("正在准备配置文件");
  21.             return base.Setup(rootConfig, config);
  22.         }
  23.  
  24.         protected override void OnStarted()
  25.         {
  26.             Console.WriteLine("服务已开始");
  27.             base.OnStarted();
  28.         }
  29.  
  30.         protected override void OnStopped()
  31.         {
  32.             Console.WriteLine("服务已停止");
  33.             base.OnStopped();
  34.         }
  35.  
  36.         /// <summary>  
  37.         /// 输出新连接信息  
  38.         /// </summary>  
  39.         /// <param name="session"></param>  
  40.         protected override void OnNewSessionConnected(SocketSession session)
  41.         {
  42.             base.OnNewSessionConnected(session);
  43.             //输出客户端IP地址  
  44.             Console.Write("\r\n" + session.LocalEndPoint.Address.ToString() + ":连接");
  45.         }
  46.  
  47.  
  48.         /// <summary>  
  49.         /// 输出断开连接信息  
  50.         /// </summary>  
  51.         /// <param name="session"></param>  
  52.         /// <param name="reason"></param>  
  53.         protected override void OnSessionClosed(SocketSession session, CloseReason reason)
  54.         {
  55.             base.OnSessionClosed(session, reason);
  56.             Console.Write("\r\n" + session.LocalEndPoint.Address.ToString() + ":断开连接");
  57.         }
  58.     }
  59.  
  60. }

警告： 自定义类SocketServer创建在文件夹Config下，因此完整的路径是：

SuperSocketCommandLineProtocol.Config

七、使用Command

         在SuperSocket中的Command让我们进行扩展，使用方法也极其简单。只需要继承一个CommandBase<AppSession, StringRequestInfo>类。（注意：如果使用了自定义的Session，需要修改此处，如LOGIN类下的LOGIN:CommandBase<SocketSession, StringRequestInfo>)类），并override这个类ExecuteCommand方法。

1、工程项目中添加一个自定义类LOGIN，处理Key为"LOGIN"的请求。

  2、LOGIN类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketBase.Command;
  12.  
  13.  
  14. namespace SuperSocketCommandLineProtocol
  15. {
  16.     public class LOGIN : CommandBase<SocketSession, StringRequestInfo>
  17.     {
  18.         /// <summary>  
  19.         /// 自定义执行命令方法，注意传入的变量session类型为MySession  
  20.         /// </summary>  
  21.         /// <param name="session">会话</param>  
  22.         /// <param name="requestInfo">请求数据信息</param>  
  23.         public override void ExecuteCommand(SocketSession session, StringRequestInfo requestInfo)
  24.         {
  25.             session.Send(string.Format("LOGIN {0}:{1}   {2}", session.Config.Ip, session.Config.Port, requestInfo.Body));
  26.         }
  27.     }
  28. }

八、program.cs

        在program.cs类中改为使用App.config文件配置，用BootStrap启动服务器。

        警告：要想使用BootStrap启动服务器，必须引用

using SuperSocket.SocketEngine;

program类完整的代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. using SuperSocket.Common;
  9. using SuperSocket.SocketBase;
  10. using SuperSocket.SocketBase.Protocol;
  11. using SuperSocket.SocketEngine;
  12.  
  13.  
  14.  
  15. namespace SuperSocketCommandLineProtocol
  16. {
  17.     class Program
  18.     {
  19.         static void Main(string[] args)
  20.         {
  21.             Console.WriteLine("请按任何键进行启动SuperSocket服务!");
  22.             Console.ReadKey();
  23.             Console.WriteLine();
  24.             var bootstrap = BootstrapFactory.CreateBootstrap();
  25.  
  26.             if (!bootstrap.Initialize())
  27.             {
  28.                 Console.WriteLine("初始化失败!");
  29.                 Console.ReadKey();
  30.                 return;
  31.             }
  32.  
  33.             var result = bootstrap.Start();
  34.  
  35.             Console.WriteLine("服务正在启动: {0}!", result);
  36.  
  37.             if (result == StartResult.Failed)
  38.             {
  39.                 Console.WriteLine("服务启动失败!");
  40.                 Console.ReadKey();
  41.                 return;
  42.             }
  43.             Console.WriteLine("服务启动成功，请按'q'停止服务!");
  44.  
  45.             while (Console.ReadKey().KeyChar != 'q')
  46.             {
  47.                 Console.WriteLine();
  48.                 continue;
  49.             }
  50.  
  51.             //停止服务
  52.             bootstrap.Stop();
  53.             Console.WriteLine("服务已停止!");
  54.             Console.ReadKey();
  55.         }
  56.     }
  57. }

九、配置App.config使用BootStrap启动SuperSocket

1、SuperSocket配置section 。

              SuperSocket使用.NET自带的配置技术，SuperSocket有一个专门的配置Section，使用配置启动SuperSocket可以灵活配置选项。

  1.  <configSections>
  2.     <!--log 日志记录-->
  3.     <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
  4.     <!--SocketEngine-->
  5.     <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
  6.   </configSections>

2、Server实例的配置     

  1.   <!--SuperSocket服务配置信息 serverType是项目的服务如我自定义的Socketserver-->
  2.   <!--name: 实例名称
  3.       serverType: 实例运行的AppServer类型
  4.       ip: 侦听ip
  5.       port: 侦听端口-->
  6.   <superSocket>
  7.     <servers>
  8.       <!--textEncoding 编码方式"gb2312","utf-8" 默认是acii-->
  9.       <server name="SuperSocketCommandLineProtocol" 
  10.        textEncoding="gb2312" 
  11.        serverType="SuperSocketCommandLineProtocol.Config.SocketServer,SuperSocketCommandLineProtocol"
  12.        ip="Any"
  13.        port="2017"
  14.        maxConnectionNumber="100">
  15.       </server>
  16.     </servers>
  17.   </superSocket>

这里解释一下配置的服务器节点：

name: 实例名称（就是：工程项目的解决方案名称：SuperSocketCommandLineProtocol）

serverType: 实例运行的AppServer类型（就是之前我们创建的自定义AppServer类【SocketServer】，它创建在Config文件夹下，因此的完整路径为：SuperSocketCommandLineProtocol.Config.SocketServer）

ip: 侦听ip

port: 侦听端口

name: 实例名称  --->  SuperSocketCommandLineProtocol
serverType:         --->  SuperSocketCommandLineProtocol.Config.SocketServer
ip: 侦听ip             --->  Any
port: 侦听端口     ---> 2017

完整的App.config配置文件如下所示：

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.  
  4.   <configSections>
  5.     <!--log 日志记录-->
  6.     <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
  7.     <!--SocketEngine-->
  8.     <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
  9.   </configSections>
  10.  
  11.  
  12.   <!--服务信息描述，在window服务模式下的名称标识-->
  13.   <appSettings>
  14.     <add key="ServiceName" value="SuperSocketCommandLineProtocol"/>
  15.     <add key="ServiceDescription" value="霸王猫"/>
  16.   </appSettings>
  17.  
  18.  
  19.   <!--SuperSocket服务配置信息 serverType是项目的服务如我自定义的Socketserver-->
  20.   <!--name: 实例名称
  21.       serverType: 实例运行的AppServer类型
  22.       ip: 侦听ip
  23.       port: 侦听端口-->
  24.   <superSocket>
  25.     <servers>
  26.       <!--textEncoding 编码方式"gb2312","utf-8" 默认是acii-->
  27.       <server name="SuperSocketCommandLineProtocol"
  28.        textEncoding="gb2312"
  29.        serverType="SuperSocketCommandLineProtocol.Config.SocketServer,SuperSocketCommandLineProtocol"
  30.        ip="Any"
  31.        port="2017"
  32.        maxConnectionNumber="100">
  33.       </server>
  34.     </servers>
  35.   </superSocket>
  36.  
  37.  
  38.   <startup>
  39.     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
  40.   </startup>
  41. </configuration>

十、验证

1、启动服务器

        服务器启动成功。

2、启动客户端

 3、连接客户端

        连接客户端后，客户端收到服务器发送的信息：“Hello User,Welcome to SuperSocket Telnet Server!”

 4、客户端发送字符串“LOGIN kerry 123 456 789”+回车换行符

        为了更好理解和明白，我们看一下调试的参数：

         服务器收到一个StringRequestInfo 实例，这个实例的属性为：

Key: "LOGIN"
Body: "kerry 123 456 789";
Parameters: ["kerry", "123", "456", "789"]

其中:

        Parameters[0]="kerry"，

        Parameters[1]="123"，

        Parameters[2]="456"，

        Parameters[3]="789"

转自https://blog.csdn.net/ba_wang_mao/article/details/128220289

标签：Console,SuperSocket,自定义,C#,手把手,System,using,客户端
From： https://www.cnblogs.com/castlewu/p/17564759.html

相关文章

  • 浪潮服务器安装centos系统
    文章来源:https://blog.csdn.net/tianmingqing0806/article/details/123107548给物理服务器装系统总结大全我这里一开始需求是装ubuntu系统的，后来需求改了就换成centos系统的拉。步骤一：首先你要制作一个启动盘，不能是大白菜的，系统不能识别pe的启动盘步骤二：做完启动盘，可能你的......
  • docker-compose使用踩坑
    之前在cm311-1a机顶盒上刷了armbian,开始把之前n5100x86小主机上的服务往上迁移,之前一直用docker,但是docker-compose没用过,正好部署rustdesk官网有docker-compose的示例,就顺便学习了一下,过程中遇到一些问题,特此记录:1.没有docker-compose命令,只有dockercompose(两个单词......
  • 【嵌入式面经专题】4-IIC协议
    1.概述I2C(Inter-IntegratedCircuitBUS)集成电路总线，该总线由NXP（原PHILIPS）公司设计，多用于主控制器和从器件间的主从通信，在小数据量场合使用，传输距离短，任意时刻只能有一个主机等特性。2.物理层只要求两条总线线路，一条是串行数据线SDA，一条是串行时钟线SCL。（IIC是半双工，而不是......
  • jdbc-plus是一款基于JdbcTemplate增强工具包，基于JdbcTemplate已实现分页、多租户、动
    ......
  • GDI+画刷(HatchBrush)
    HatchBrush在构造过程中需要指定画刷类型、前景色、后景色三项内容，其中画刷类型在官方文档中给出的枚举类型如下所示：1typedefenumHatchStyle{2HatchStyleHorizontal,3HatchStyleVertical,4HatchStyleForwardDiagonal,5HatchStyleBackwardDiagonal,6Hatc......
  • CORS常用解决跨域的方法
    浏览器先询问服务器，当前网页所在的域名是否在服务器的许可名单之中，以及可以使用哪些HTTP动词和头信息字段。只有得到肯定答复，浏览器才会发出正式的XMLHttpRequest请求，否则就报错 前端发送Ajax请求$("#test").click(function(){$.ajax({url:"http://localhost......
  • [转] SuperSocket 手把手教你入门 傻瓜教程
    1（服务器单向接收客户端发送数据）  目录一、SuperSocket 简介二、Socket调试工具 SocketTool三、移植C#SuperSocket 简介四、移植五、验证致谢：    我是一名单片机嵌入式软件开发工程师，之前从来没有接触过PC端的编程工作，只是这二年由于工程项目有需求，因此匆......
  • PerfView专题 (第十四篇)： 洞察那些 C# 代码中的短命线程
    一：背景1.讲故事这篇文章源自于分析一些疑难dump的思考而产生的灵感，在dump分析中经常要寻找的一个答案就是如何找到死亡线程的生前都做了一些什么？参考如下输出：0:001>!tThreadCount:22UnstartedThread:0BackgroundThread:1PendingThread:0DeadThread:......
  • Docker被墙了怎么办？换源处理！
    Docker被墙了怎么办？换源处理！命令行输入以下命令换源，按提示进行操作（推荐南京大学和微软云的源）bash<(curl-sSLhttps://ghproxy.com/https://github.com/SuperManito/LinuxMirrors/raw/main/DockerInstallation.sh)命令行代码来自于镜像中国......
  • GitLab + Jenkins + Docker 本地自动化部署
    GitLab+Jenkins+Docker本地自动化部署原创 贺大官人 猿起猿进 2023-07-1215:51 发表于浙江 GitLab+ Jenkins+ Docker+ Nginx 前端自动化部署 注GitLab 本地化部署——前端代码版本管理Docker+ Nginx 本地容器化部署前端项目——需手动上传......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99