1.调整重复代码

2.修复设计模型
3.增加808客户端调用（待做）

src/JT808.DotNetty.Client/JT808.DotNetty.Client.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\JT808.DotNetty.Core\JT808.DotNetty.Core.csproj" />
+  </ItemGroup>
+
+</Project>

src/JT808.DotNetty.Client/JT808TcpClient.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JT808.DotNetty.Client
+{
+    public class JT808TcpClient
+    {
+
+    }
+}

src/JT808.DotNetty.Core/Enums/JT808ModeType.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JT808.DotNetty.Core.Enums
+{
+    /// <summary>
+    /// 模式类型
+    /// </summary>
+    public enum JT808ModeType
+    {
+        Tcp=1,
+        Udp = 2
+    }
+}

src/JT808.DotNetty.Core/Handlers/JT808MsgIdTcpHandlerBase.cs

@@ -43,8 +43,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// 平台无需回复
         /// 实现自己的业务
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0001(JT808Request request)
         {
@@ -53,8 +52,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端心跳
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0002(JT808Request request)
         {
@@ -69,8 +67,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端注销
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0003(JT808Request request)
         {
@@ -84,8 +81,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端注册
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0100(JT808Request request)
         {
@@ -99,8 +95,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端鉴权
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0102(JT808Request request)
         {
@@ -114,8 +109,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 位置信息汇报
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0200(JT808Request request)
         {
@@ -129,8 +123,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 定位数据批量上传
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0704(JT808Request request)
         {
@@ -144,8 +137,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 数据上行透传
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0900(JT808Request request)
         {

src/JT808.DotNetty.Core/Handlers/JT808MsgIdUdpHandlerBase.cs

@@ -43,8 +43,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// 平台无需回复
         /// 实现自己的业务
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0001(JT808Request request)
         {
@@ -53,8 +52,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端心跳
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0002(JT808Request request)
         {
@@ -69,8 +67,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端注销
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0003(JT808Request request)
         {
@@ -84,8 +81,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端注册
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0100(JT808Request request)
         {
@@ -99,8 +95,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 终端鉴权
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0102(JT808Request request)
         {
@@ -129,8 +124,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 定位数据批量上传
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0704(JT808Request request)
         {
@@ -144,8 +138,7 @@ namespace JT808.DotNetty.Core.Handlers
         /// <summary>
         /// 数据上行透传
         /// </summary>
-        /// <param name="reqJT808Package"></param>
-        /// <param name="ctx"></param>
+        /// <param name="request"></param>
         /// <returns></returns>
         public virtual JT808Response Msg0x0900(JT808Request request)
         {

src/JT808.DotNetty.Core/JT808CoreDotnettyExtensions.cs

@@ -8,6 +8,7 @@ using JT808.DotNetty.Internal;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using System;
 using System.Runtime.CompilerServices;
@@ -16,6 +17,9 @@ using System.Runtime.CompilerServices;
 [assembly: InternalsVisibleTo("JT808.DotNetty.Tcp.Test")]
 [assembly: InternalsVisibleTo("JT808.DotNetty.Udp.Test")]
 [assembly: InternalsVisibleTo("JT808.DotNetty.WebApi.Test")]
+[assembly: InternalsVisibleTo("JT808.DotNetty.Tcp")]
+[assembly: InternalsVisibleTo("JT808.DotNetty.Udp")]
+[assembly: InternalsVisibleTo("JT808.DotNetty.WebApi")]
 namespace JT808.DotNetty.Core
 {
     public static class JT808CoreDotnettyExtensions
@@ -52,6 +56,33 @@ namespace JT808.DotNetty.Core
             serviceDescriptors.Configure<JT808Configuration>(configuration.GetSection("JT808Configuration"));
             serviceDescriptors.TryAddSingleton<IJT808SessionPublishing, JT808SessionPublishingEmptyImpl>();
             serviceDescriptors.TryAddSingleton<IJT808SourcePackageDispatcher, JT808SourcePackageDispatcherEmptyImpl>();
+            serviceDescriptors.TryAddSingleton<JT808AtomicCounterServiceFactory>();
+            serviceDescriptors.TryAddSingleton<JT808TrafficServiceFactory>();
+            serviceDescriptors.TryAddSingleton<IJT808UnificationTcpSendService, JT808UnificationTcpSendService>();
+            serviceDescriptors.TryAddSingleton<IJT808UnificationUdpSendService, JT808UnificationUdpSendService>();
+            serviceDescriptors.TryAddSingleton<IJT808TcpSessionService, JT808TcpSessionService>();
+            serviceDescriptors.TryAddSingleton<IJT808UdpSessionService, JT808UdpSessionService>();
+            serviceDescriptors.TryAddSingleton<JT808SimpleSystemCollectService>();
+            return serviceDescriptors;
+        }
+
+        public static IServiceCollection AddJT808Core(this IServiceCollection serviceDescriptors, Action<JT808Configuration> jt808Options, Newtonsoft.Json.JsonSerializerSettings settings = null)
+        {
+            if (settings != null)
+            {
+                JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>
+                {
+                    settings.Converters.Add(new JsonIPAddressConverter());
+                    settings.Converters.Add(new JsonIPEndPointConverter());
+                    settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+                    return settings;
+                });
+            }
+            serviceDescriptors.Configure(jt808Options);
+            serviceDescriptors.TryAddSingleton<IJT808SessionPublishing, JT808SessionPublishingEmptyImpl>();
+            serviceDescriptors.TryAddSingleton<IJT808SourcePackageDispatcher, JT808SourcePackageDispatcherEmptyImpl>();
+            serviceDescriptors.TryAddSingleton<JT808AtomicCounterServiceFactory>();
+            serviceDescriptors.TryAddSingleton<JT808TrafficServiceFactory>();
             serviceDescriptors.TryAddSingleton<IJT808UnificationTcpSendService, JT808UnificationTcpSendService>();
             serviceDescriptors.TryAddSingleton<IJT808UnificationUdpSendService, JT808UnificationUdpSendService>();
             serviceDescriptors.TryAddSingleton<IJT808TcpSessionService, JT808TcpSessionService>();

src/JT808.DotNetty.Core/Jobs/JT808TcpAtomicCouterResetDailyJob.cs

@@ -5,17 +5,17 @@ using System.Threading.Tasks;
 
 namespace JT808.DotNetty.Core.Jobs
 {
-    public class JT808TcpAtomicCouterResetDailyJob : JT808BackgroundService
+    internal class JT808TcpAtomicCouterResetDailyJob : JT808BackgroundService
     {
         private readonly ILogger<JT808TcpAtomicCouterResetDailyJob> _logger;
 
-        private readonly JT808TcpAtomicCounterService _jT808TcpAtomicCounterService;
+        private readonly JT808AtomicCounterService _jT808AtomicCounterService;
 
         public JT808TcpAtomicCouterResetDailyJob(
-            JT808TcpAtomicCounterService jT808TcpAtomicCounterService,
+            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
             ILoggerFactory loggerFactory)
         {
-            _jT808TcpAtomicCounterService = jT808TcpAtomicCounterService;
+            _jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(Enums.JT808ModeType.Tcp);
             _logger =loggerFactory.CreateLogger<JT808TcpAtomicCouterResetDailyJob>();
         }
 
@@ -28,7 +28,7 @@ namespace JT808.DotNetty.Core.Jobs
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808TcpAtomicCounterService.Reset();
+                _jT808AtomicCounterService.Reset();
                 await Task.Delay(DelayTimeSpan, stoppingToken);
             }
             _logger.LogInformation($"{ServiceName} background task is stopping.");

src/JT808.DotNetty.Core/Jobs/JT808TcpTrafficResetDailyJob.cs

@@ -5,17 +5,17 @@ using System.Threading.Tasks;
 
 namespace JT808.DotNetty.Core.Jobs
 {
-    public class JT808TcpTrafficResetDailyJob : JT808BackgroundService
+    internal class JT808TcpTrafficResetDailyJob : JT808BackgroundService
     {
         private readonly ILogger<JT808TcpTrafficResetDailyJob> _logger;
 
-        private readonly JT808TcpTrafficService _jT808TcpTrafficService;
+        private readonly JT808TrafficService _jT808TrafficService;
 
         public JT808TcpTrafficResetDailyJob(
-            JT808TcpTrafficService jT808TcpTrafficService,
+            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory)
         {
-            _jT808TcpTrafficService = jT808TcpTrafficService;
+            _jT808TrafficService = jT808TrafficServiceFactory.Create( Enums.JT808ModeType.Tcp);
             _logger =loggerFactory.CreateLogger<JT808TcpTrafficResetDailyJob>();
         }
 
@@ -28,7 +28,7 @@ namespace JT808.DotNetty.Core.Jobs
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808TcpTrafficService.ResetSize();
+                _jT808TrafficService.ResetSize();
                 await Task.Delay(DelayTimeSpan, stoppingToken);
             }
             _logger.LogInformation($"{ServiceName} background task is stopping.");

src/JT808.DotNetty.Core/Jobs/JT808UdpAtomicCouterResetDailyJob.cs

@@ -5,17 +5,17 @@ using System.Threading.Tasks;
 
 namespace JT808.DotNetty.Core.Jobs
 {
-    public class JT808UdpAtomicCouterResetDailyJob : JT808BackgroundService
+    internal class JT808UdpAtomicCouterResetDailyJob : JT808BackgroundService
     {
         private readonly ILogger<JT808UdpAtomicCouterResetDailyJob> _logger;
 
-        private readonly JT808UdpAtomicCounterService _jT808UdpAtomicCounterService;
+        private readonly JT808AtomicCounterService _jT808AtomicCounterService;
 
         public JT808UdpAtomicCouterResetDailyJob(
-            JT808UdpAtomicCounterService jT808UdpAtomicCounterService,
+            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
             ILoggerFactory loggerFactory)
         {
-            _jT808UdpAtomicCounterService = jT808UdpAtomicCounterService;
+            _jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(Enums.JT808ModeType.Udp);
             _logger =loggerFactory.CreateLogger<JT808UdpAtomicCouterResetDailyJob>();
         }
 
@@ -28,7 +28,7 @@ namespace JT808.DotNetty.Core.Jobs
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808UdpAtomicCounterService.Reset();
+                _jT808AtomicCounterService.Reset();
                 await Task.Delay(DelayTimeSpan, stoppingToken);
             }
             _logger.LogInformation($"{ServiceName} background task is stopping.");

src/JT808.DotNetty.Core/Jobs/JT808UdpTrafficResetDailyJob.cs

@@ -5,17 +5,17 @@ using System.Threading.Tasks;
 
 namespace JT808.DotNetty.Core.Jobs
 {
-    public class JT808UdpTrafficResetDailyJob : JT808BackgroundService
+    internal class JT808UdpTrafficResetDailyJob : JT808BackgroundService
     {
         private readonly ILogger<JT808UdpTrafficResetDailyJob> _logger;
 
-        private readonly JT808UdpTrafficService _jT808UdpTrafficService;
+        private readonly JT808TrafficService _jT808TrafficService;
 
         public JT808UdpTrafficResetDailyJob(
-            JT808UdpTrafficService jT808UdpTrafficService,
+            JT808TrafficServiceFactory jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory)
         {
-            _jT808UdpTrafficService = jT808UdpTrafficService;
+            _jT808TrafficService = jT808TrafficServiceFactory.Create(Enums.JT808ModeType.Udp);
             _logger =loggerFactory.CreateLogger<JT808UdpTrafficResetDailyJob>();
         }
 
@@ -28,7 +28,7 @@ namespace JT808.DotNetty.Core.Jobs
             while (!stoppingToken.IsCancellationRequested)
             {
                 _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808UdpTrafficService.ResetSize();
+                _jT808TrafficService.ResetSize();
                 await Task.Delay(DelayTimeSpan, stoppingToken);
             }
             _logger.LogInformation($"{ServiceName} background task is stopping.");

src/JT808.DotNetty.Core/Metadata/JT808AtomicCounter.cs

@@ -9,7 +9,7 @@ namespace JT808.DotNetty.Core.Metadata
     /// 
     /// <see cref="Grpc.Core.Internal"/>
     /// </summary>
-    public class JT808AtomicCounter
+    internal class JT808AtomicCounter
     {
         long counter = 0;
 

src/JT808.DotNetty.Core/Services/JT808TcpAtomicCounterService.cs → src/JT808.DotNetty.Core/Services/JT808AtomicCounterService.cs

@@ -3,17 +3,18 @@
 namespace JT808.DotNetty.Core.Services
 {
     /// <summary>
-    /// Tcp计数包服务
+    /// 计数包服务
     /// </summary>
-    public class JT808TcpAtomicCounterService
+    public class JT808AtomicCounterService
     {
-        private readonly JT808AtomicCounter MsgSuccessCounter = new JT808AtomicCounter();
+        private readonly JT808AtomicCounter MsgSuccessCounter;
 
-        private readonly JT808AtomicCounter MsgFailCounter = new JT808AtomicCounter();
+        private readonly JT808AtomicCounter MsgFailCounter;
 
-        public JT808TcpAtomicCounterService()
+        public JT808AtomicCounterService()
         {
-
+            MsgSuccessCounter=new JT808AtomicCounter();
+            MsgFailCounter = new JT808AtomicCounter();
         }
 
         public void Reset()

src/JT808.DotNetty.Core/Services/JT808AtomicCounterServiceFactory.cs

@@ -0,0 +1,30 @@
+using JT808.DotNetty.Core.Enums;
+using System;
+using System.Collections.Concurrent;
+
+namespace JT808.DotNetty.Core.Services
+{
+    public class JT808AtomicCounterServiceFactory
+    {
+        private readonly ConcurrentDictionary<JT808ModeType, JT808AtomicCounterService> cache;
+
+        private JT808AtomicCounterServiceFactory()
+        {
+            cache = new ConcurrentDictionary<JT808ModeType, JT808AtomicCounterService>();
+        }
+
+        public JT808AtomicCounterService Create(JT808ModeType type)
+        {
+            if(cache.TryGetValue(type,out var service))
+            {
+                return service;
+            }
+            else
+            {
+                var serviceNew = new JT808AtomicCounterService();
+                cache.TryAdd(type, serviceNew);
+                return serviceNew;
+            }
+        }
+    }
+}

src/JT808.DotNetty.Core/Services/JT808TcpTrafficService.cs → src/JT808.DotNetty.Core/Services/JT808TrafficService.cs

@@ -5,11 +5,17 @@ using System.Text;
 
 namespace JT808.DotNetty.Core.Services
 {
-    public class JT808TcpTrafficService
+    public class JT808TrafficService
     {
-        private readonly JT808AtomicCounter receiveCounter = new JT808AtomicCounter();
+        public JT808TrafficService()
+        {
+            receiveCounter = new JT808AtomicCounter();
+            sendCounter = new JT808AtomicCounter();
+        }
+
+        private readonly JT808AtomicCounter receiveCounter;
 
-        private readonly JT808AtomicCounter sendCounter = new JT808AtomicCounter();
+        private readonly JT808AtomicCounter sendCounter;
 
         public void ReceiveSize(long size)
         {

src/JT808.DotNetty.Core/Services/JT808TrafficServiceFactory.cs

@@ -0,0 +1,33 @@
+using JT808.DotNetty.Core.Enums;
+using JT808.DotNetty.Core.Metadata;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JT808.DotNetty.Core.Services
+{
+    public class JT808TrafficServiceFactory
+    {
+        private readonly ConcurrentDictionary<JT808ModeType, JT808TrafficService> cache;
+
+        private JT808TrafficServiceFactory()
+        {
+            cache = new ConcurrentDictionary<JT808ModeType, JT808TrafficService>();
+        }
+
+        public JT808TrafficService Create(JT808ModeType type)
+        {
+            if (cache.TryGetValue(type, out var service))
+            {
+                return service;
+            }
+            else
+            {
+                var serviceNew = new JT808TrafficService();
+                cache.TryAdd(type, serviceNew);
+                return serviceNew;
+            }
+        }
+    }
+}

src/JT808.DotNetty.Core/Services/JT808UdpAtomicCounterService.cs

@@ -1,51 +0,0 @@
-using JT808.DotNetty.Core.Metadata;
-
-namespace JT808.DotNetty.Core.Services
-{
-    /// <summary>
-    /// Udp计数包服务
-    /// </summary>
-    public class JT808UdpAtomicCounterService
-    {
-        private readonly JT808AtomicCounter MsgSuccessCounter = new JT808AtomicCounter();
-
-        private readonly JT808AtomicCounter MsgFailCounter = new JT808AtomicCounter();
-
-        public JT808UdpAtomicCounterService()
-        {
-
-        }
-
-        public void Reset()
-        {
-            MsgSuccessCounter.Reset();
-            MsgFailCounter.Reset();
-        }
-
-        public long MsgSuccessIncrement()
-        {
-            return MsgSuccessCounter.Increment();
-        }
-
-        public long MsgSuccessCount
-        {
-            get
-            {
-                return MsgSuccessCounter.Count;
-            }
-        }
-
-        public long MsgFailIncrement()
-        {
-            return MsgFailCounter.Increment();
-        }
-
-        public long MsgFailCount
-        {
-            get
-            {
-                return MsgFailCounter.Count;
-            }
-        }
-    }
-}

src/JT808.DotNetty.Core/Services/JT808UdpTrafficService.cs

@@ -1,40 +0,0 @@
-using JT808.DotNetty.Core.Metadata;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Core.Services
-{
-    public class JT808UdpTrafficService
-    {
-        private readonly JT808AtomicCounter receiveCounter = new JT808AtomicCounter();
-
-        private readonly JT808AtomicCounter sendCounter = new JT808AtomicCounter();
-
-        public void ReceiveSize(long size)
-        {
-            receiveCounter.Add(size);
-        }
-
-        public long TotalReceiveSize
-        {
-            get { return receiveCounter.Count; }
-        }
-
-        public long TotalSendSize
-        {
-            get { return sendCounter.Count; }
-        }
-
-        public void SendSize(long size)
-        {
-            sendCounter.Add(size);
-        }
-
-        public void ResetSize()
-        {
-            receiveCounter.Reset();
-            sendCounter.Reset();
-        }
-    }
-}

src/JT808.DotNetty.Core/Services/JT808UnificationTcpSendService.cs

@@ -12,13 +12,13 @@ namespace JT808.DotNetty.Internal
     {
         private readonly JT808TcpSessionManager jT808SessionManager;
 
-        private readonly JT808TcpTrafficService  jT808TcpTrafficService;
+        private readonly JT808TrafficService jT808TrafficService;
 
         public JT808UnificationTcpSendService(
-            JT808TcpTrafficService jT808TcpTrafficService,
+            JT808TrafficServiceFactory jT808TrafficServiceFactory,
             JT808TcpSessionManager jT808SessionManager)
         {
-            this.jT808TcpTrafficService = jT808TcpTrafficService;
+            this.jT808TrafficService = jT808TrafficServiceFactory.Create(Core.Enums.JT808ModeType.Tcp);
             this.jT808SessionManager = jT808SessionManager;
         }
 
@@ -39,7 +39,7 @@ namespace JT808.DotNetty.Internal
                     }
                     else
                     {
-                        jT808TcpTrafficService.SendSize(data.Length);
+                        jT808TrafficService.SendSize(data.Length);
                         session.Channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(data));
                         resultDto.Code = JT808ResultCode.Ok;
                         resultDto.Data = true;

src/JT808.DotNetty.Core/Services/JT808UnificationUdpSendService.cs

@@ -12,13 +12,13 @@ namespace JT808.DotNetty.Internal
     {
         private readonly JT808UdpSessionManager jT808SessionManager;
 
-        private readonly JT808UdpTrafficService jT808UdpTrafficService;
+        private readonly JT808TrafficService jT808TrafficService;
 
         public JT808UnificationUdpSendService(
-            JT808UdpTrafficService jT808UdpTrafficService,
+            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             JT808UdpSessionManager jT808SessionManager)
         {
-            this.jT808UdpTrafficService = jT808UdpTrafficService;
+            this.jT808TrafficService = jT808TrafficServiceFactory.Create(Core.Enums.JT808ModeType.Udp);
             this.jT808SessionManager = jT808SessionManager;
         }
 
@@ -30,7 +30,7 @@ namespace JT808.DotNetty.Internal
                 var session = jT808SessionManager.GetSession(terminalPhoneNo);
                 if (session != null)
                 {
-                    jT808UdpTrafficService.SendSize(data.Length);
+                    jT808TrafficService.SendSize(data.Length);
                     session.Channel.WriteAndFlushAsync(new DatagramPacket(Unpooled.WrappedBuffer(data), session.Sender));
                     resultDto.Code = JT808ResultCode.Ok;
                     resultDto.Data = true;

src/JT808.DotNetty.Tcp/Handlers/JT808TcpServerHandler.cs

@@ -24,27 +24,27 @@ namespace JT808.DotNetty.Tcp.Handlers
 
         private readonly IJT808SourcePackageDispatcher jT808SourcePackageDispatcher;
 
-        private readonly JT808TcpAtomicCounterService jT808AtomicCounterService;
+        private readonly JT808AtomicCounterService jT808AtomicCounterService;
 
-        private readonly JT808TcpTrafficService jT808TcpTrafficService;
+        private readonly JT808TrafficService jT808TrafficService;
 
         private readonly ILogger<JT808TcpServerHandler> logger;
 
         public JT808TcpServerHandler(
-            JT808TcpTrafficService jT808TcpTrafficService,
+            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory,
             JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
             IJT808SourcePackageDispatcher jT808SourcePackageDispatcher,
             JT808MsgIdTcpHandlerBase handler,
-            JT808TcpAtomicCounterService jT808AtomicCounterService,
+            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
             JT808TcpSessionManager jT808SessionManager)
         {
-            this.jT808TcpTrafficService = jT808TcpTrafficService;
+            this.jT808TrafficService = jT808TrafficServiceFactory.Create(Core.Enums.JT808ModeType.Tcp);
             this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
             this.handler = handler;
             this.jT808SessionManager = jT808SessionManager;
             this.jT808SourcePackageDispatcher = jT808SourcePackageDispatcher;
-            this.jT808AtomicCounterService = jT808AtomicCounterService;
+            this.jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(Core.Enums.JT808ModeType.Tcp);
             logger = loggerFactory.CreateLogger<JT808TcpServerHandler>();
         }
 
@@ -59,7 +59,7 @@ namespace JT808.DotNetty.Tcp.Handlers
                 //解析具体的消息体，具体调用JT808Serializer.Deserialize<T>
                 JT808HeaderPackage jT808HeaderPackage = JT808Serializer.Deserialize<JT808HeaderPackage>(msg);
                 jT808AtomicCounterService.MsgSuccessIncrement();
-                jT808TcpTrafficService.ReceiveSize(msg.Length);
+                jT808TrafficService.ReceiveSize(msg.Length);
                 if (logger.IsEnabled(LogLevel.Debug))
                 {
                     logger.LogDebug("accept package success count<<<" + jT808AtomicCounterService.MsgSuccessCount.ToString());
@@ -74,7 +74,7 @@ namespace JT808.DotNetty.Tcp.Handlers
                         if (!jT808TransmitAddressFilterService.ContainsKey(ctx.Channel.RemoteAddress))
                         {
                             var sendData = JT808Serializer.Serialize(jT808Response.Package, jT808Response.MinBufferSize);
-                            jT808TcpTrafficService.SendSize(sendData.Length);
+                            jT808TrafficService.SendSize(sendData.Length);
                             ctx.WriteAndFlushAsync(Unpooled.WrappedBuffer(sendData));
                         }
                     }

src/JT808.DotNetty.Tcp/JT808TcpDotnettyExtensions.cs

@@ -21,9 +21,7 @@ namespace JT808.DotNetty.Tcp
         public static IServiceCollection AddJT808TcpHost(this IServiceCollection  serviceDescriptors)
         {
             serviceDescriptors.TryAddSingleton<JT808TcpSessionManager>();
-            serviceDescriptors.TryAddSingleton<JT808TcpAtomicCounterService>();
             serviceDescriptors.TryAddSingleton<JT808TransmitAddressFilterService>();
-            serviceDescriptors.TryAddSingleton<JT808TcpTrafficService>();
             serviceDescriptors.TryAddSingleton<JT808MsgIdTcpHandlerBase, JT808MsgIdDefaultTcpHandler>();
             serviceDescriptors.TryAddScoped<JT808TcpConnectionHandler>();
             serviceDescriptors.TryAddScoped<JT808TcpDecoder>();

src/JT808.DotNetty.Udp/Handlers/JT808UdpServerHandler.cs

@@ -20,7 +20,7 @@ namespace JT808.DotNetty.Udp.Handlers
     {
         private readonly IJT808SourcePackageDispatcher jT808SourcePackageDispatcher;
 
-        private readonly JT808UdpAtomicCounterService jT808UdpAtomicCounterService;
+        private readonly JT808AtomicCounterService jT808AtomicCounterService;
 
         private readonly ILogger<JT808UdpServerHandler> logger;
 
@@ -28,20 +28,20 @@ namespace JT808.DotNetty.Udp.Handlers
 
         private readonly JT808MsgIdUdpHandlerBase handler;
 
-        private readonly JT808UdpTrafficService jT808UdpTrafficService;
+        private readonly JT808TrafficService jT808TrafficService;
 
         public JT808UdpServerHandler(
-            JT808UdpTrafficService jT808UdpTrafficService,
+            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory,
             IJT808SourcePackageDispatcher jT808SourcePackageDispatcher,
             JT808MsgIdUdpHandlerBase handler,
-            JT808UdpAtomicCounterService jT808UdpAtomicCounterService,
+            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
             JT808UdpSessionManager jT808UdpSessionManager)
         {
-            this.jT808UdpTrafficService = jT808UdpTrafficService;
+            this.jT808TrafficService = jT808TrafficServiceFactory.Create(Core.Enums.JT808ModeType.Udp);
             this.handler = handler;
             this.jT808SourcePackageDispatcher = jT808SourcePackageDispatcher;
-            this.jT808UdpAtomicCounterService = jT808UdpAtomicCounterService;
+            this.jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(Core.Enums.JT808ModeType.Udp);
             this.jT808UdpSessionManager = jT808UdpSessionManager;
             logger = loggerFactory.CreateLogger<JT808UdpServerHandler>();
         }
@@ -51,16 +51,16 @@ namespace JT808.DotNetty.Udp.Handlers
             try
             {
                 jT808SourcePackageDispatcher?.SendAsync(msg.Buffer);
-                jT808UdpTrafficService.ReceiveSize(msg.Buffer.Length);
+                jT808TrafficService.ReceiveSize(msg.Buffer.Length);
                 //解析到头部,然后根据具体的消息Id通过队列去进行消费
                 //要是一定要解析到数据体可以在JT808MsgIdHandlerBase类中根据具体的消息，
                 //解析具体的消息体，具体调用JT808Serializer.Deserialize<T>
                 JT808HeaderPackage jT808HeaderPackage = JT808Serializer.Deserialize<JT808HeaderPackage>(msg.Buffer);
-                jT808UdpAtomicCounterService.MsgSuccessIncrement();
+                jT808AtomicCounterService.MsgSuccessIncrement();
                 jT808UdpSessionManager.TryAdd(ctx.Channel, msg.Sender, jT808HeaderPackage.Header.TerminalPhoneNo);
                 if (logger.IsEnabled(LogLevel.Debug))
                 {
-                    logger.LogDebug("accept package success count<<<" + jT808UdpAtomicCounterService.MsgSuccessCount.ToString());
+                    logger.LogDebug("accept package success count<<<" + jT808AtomicCounterService.MsgSuccessCount.ToString());
                 }
                 Func<JT808Request, JT808Response> handlerFunc;
                 if (handler.HandlerDict.TryGetValue(jT808HeaderPackage.Header.MsgId, out handlerFunc))
@@ -69,26 +69,26 @@ namespace JT808.DotNetty.Udp.Handlers
                     if (jT808Response != null)
                     {
                         var sendData = JT808Serializer.Serialize(jT808Response.Package, jT808Response.MinBufferSize);
-                        jT808UdpTrafficService.SendSize(sendData.Length);
+                        jT808TrafficService.SendSize(sendData.Length);
                         ctx.WriteAndFlushAsync(new DatagramPacket(Unpooled.WrappedBuffer(sendData), msg.Sender));
                     }
                 }
             }
             catch (JT808.Protocol.Exceptions.JT808Exception ex)
             {
-                jT808UdpAtomicCounterService.MsgFailIncrement();
+                jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808UdpAtomicCounterService.MsgFailCount.ToString());
+                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
                     logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg.Buffer));
                 }
             }
             catch (Exception ex)
             {
-                jT808UdpAtomicCounterService.MsgFailIncrement();
+                jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808UdpAtomicCounterService.MsgFailCount.ToString());
+                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
                     logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg.Buffer));
                 }
             }

src/JT808.DotNetty.Udp/JT808UdpDotnettyExtensions.cs

@@ -19,8 +19,6 @@ namespace JT808.DotNetty.Udp
         public static IServiceCollection AddJT808UdpHost(this IServiceCollection  serviceDescriptors)
         {
             serviceDescriptors.TryAddSingleton<JT808UdpSessionManager>();
-            serviceDescriptors.TryAddSingleton<JT808UdpAtomicCounterService>();
-            serviceDescriptors.TryAddSingleton<JT808UdpTrafficService>();
             serviceDescriptors.TryAddSingleton<JT808MsgIdUdpHandlerBase, JT808MsgIdDefaultUdpHandler>();
             serviceDescriptors.TryAddScoped<JT808UdpDecoder>();
             serviceDescriptors.TryAddScoped<JT808UdpServerHandler>();

src/JT808.DotNetty.WebApi/Handlers/JT808MsgIdDefaultWebApiHandler.cs

@@ -1,5 +1,6 @@
 using JT808.DotNetty.Abstractions;
 using JT808.DotNetty.Abstractions.Dtos;
+using JT808.DotNetty.Core.Enums;
 using JT808.DotNetty.Core.Handlers;
 using JT808.DotNetty.Core.Interfaces;
 using JT808.DotNetty.Core.Metadata;
@@ -13,9 +14,9 @@ namespace JT808.DotNetty.WebApi.Handlers
     /// </summary>
     public class JT808MsgIdDefaultWebApiHandler : JT808MsgIdHttpHandlerBase
     {
-        private readonly JT808TcpAtomicCounterService jT808TcpAtomicCounterService;
+        private readonly JT808AtomicCounterService jT808TcpAtomicCounterService;
 
-        private readonly JT808UdpAtomicCounterService jT808UdpAtomicCounterService;
+        private readonly JT808AtomicCounterService jT808UdpAtomicCounterService;
 
         private readonly JT808TransmitAddressFilterService jT808TransmitAddressFilterService;
 
@@ -27,9 +28,9 @@ namespace JT808.DotNetty.WebApi.Handlers
 
         private readonly IJT808UnificationUdpSendService jT808UnificationUdpSendService;
 
-        private readonly JT808TcpTrafficService jT808TcpTrafficService;
+        private readonly JT808TrafficService jT808TcpTrafficService;
 
-        private readonly JT808UdpTrafficService jT808UdpTrafficService;
+        private readonly JT808TrafficService jT808UdpTrafficService;
 
         private readonly JT808SimpleSystemCollectService jT808SimpleSystemCollectService;
 
@@ -39,19 +40,19 @@ namespace JT808.DotNetty.WebApi.Handlers
         /// <param name="jT808TcpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
             JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-            JT808TcpTrafficService jT808TcpTrafficService,
+            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             IJT808UnificationTcpSendService jT808UnificationTcpSendService,
             IJT808TcpSessionService jT808TcpSessionService,
             JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
-            JT808TcpAtomicCounterService jT808TcpAtomicCounterService
+            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory
             )
         {
             this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808TcpTrafficService = jT808TcpTrafficService;
+            this.jT808TcpTrafficService = jT808TrafficServiceFactory.Create(JT808ModeType.Tcp);
             this.jT808UnificationTcpSendService = jT808UnificationTcpSendService;
             this.jT808TcpSessionService = jT808TcpSessionService;
             this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
-            this.jT808TcpAtomicCounterService = jT808TcpAtomicCounterService;
+            this.jT808TcpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808ModeType.Tcp);
             InitCommonRoute();
             InitTcpRoute();
         }
@@ -62,17 +63,17 @@ namespace JT808.DotNetty.WebApi.Handlers
         /// <param name="jT808UdpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
             JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-            JT808UdpTrafficService jT808UdpTrafficService,
+            JT808TrafficServiceFactory jT808TrafficServiceFactory,
             IJT808UdpSessionService jT808UdpSessionService,
             IJT808UnificationUdpSendService jT808UnificationUdpSendService,
-            JT808UdpAtomicCounterService jT808UdpAtomicCounterService
+            JT808AtomicCounterServiceFactory jT808AtomicCounterServiceFactory
             )
         {
             this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808UdpTrafficService = jT808UdpTrafficService;
+            this.jT808UdpTrafficService = jT808TrafficServiceFactory.Create(JT808ModeType.Udp);
             this.jT808UdpSessionService = jT808UdpSessionService;
             this.jT808UnificationUdpSendService = jT808UnificationUdpSendService;
-            this.jT808UdpAtomicCounterService = jT808UdpAtomicCounterService;
+            this.jT808UdpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808ModeType.Udp);
             InitCommonRoute();
             InitUdpRoute();
         }
@@ -84,27 +85,25 @@ namespace JT808.DotNetty.WebApi.Handlers
         /// <param name="jT808UdpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
              JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-             JT808TcpTrafficService jT808TcpTrafficService,
-             JT808UdpTrafficService jT808UdpTrafficService,
+             JT808TrafficServiceFactory jT808TrafficServiceFactory,
              IJT808UnificationTcpSendService jT808UnificationTcpSendService,
              IJT808UnificationUdpSendService jT808UnificationUdpSendService,
              IJT808TcpSessionService jT808TcpSessionService,
              IJT808UdpSessionService jT808UdpSessionService,
              JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
-             JT808TcpAtomicCounterService jT808TcpAtomicCounterService,
-             JT808UdpAtomicCounterService jT808UdpAtomicCounterService
+            JT808AtomicCounterServiceFactory jT808AtomicCounterServiceFactory
            )
         {
             this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808TcpTrafficService = jT808TcpTrafficService;
-            this.jT808UdpTrafficService = jT808UdpTrafficService;
+            this.jT808TcpTrafficService = jT808TrafficServiceFactory.Create(JT808ModeType.Tcp);
+            this.jT808UdpTrafficService = jT808TrafficServiceFactory.Create(JT808ModeType.Udp);
             this.jT808UdpSessionService = jT808UdpSessionService;
             this.jT808UnificationTcpSendService = jT808UnificationTcpSendService;
             this.jT808UnificationUdpSendService = jT808UnificationUdpSendService;
             this.jT808TcpSessionService = jT808TcpSessionService;
             this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
-            this.jT808TcpAtomicCounterService = jT808TcpAtomicCounterService;
-            this.jT808UdpAtomicCounterService = jT808UdpAtomicCounterService;
+            this.jT808TcpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808ModeType.Tcp);
+            this.jT808UdpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808ModeType.Udp);
             InitCommonRoute();
             InitTcpRoute();
             InitUdpRoute();

src/JT808.DotNetty.WebApiClientTool/JT808.DotNetty.WebApiClientTool.csproj

@@ -18,7 +18,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="WebApiClient.JIT" Version="0.3.0" />
+    <PackageReference Include="WebApiClient.JIT" Version="0.3.4" />
   </ItemGroup>
 
   <ItemGroup>

src/JT808.DotNetty.sln

@@ -31,6 +31,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JT808.DotNetty.Hosting", "J
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JT808.DotNetty.WebApiClientTool", "JT808.DotNetty.WebApiClientTool\JT808.DotNetty.WebApiClientTool.csproj", "{9D86C951-94F2-4CBD-B177-8AF31DDB05D8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JT808.DotNetty.Client", "JT808.DotNetty.Client\JT808.DotNetty.Client.csproj", "{87C08239-C57F-4FC5-9579-05D0723AA4A0}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -85,6 +87,10 @@ Global
 		{9D86C951-94F2-4CBD-B177-8AF31DDB05D8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9D86C951-94F2-4CBD-B177-8AF31DDB05D8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9D86C951-94F2-4CBD-B177-8AF31DDB05D8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{87C08239-C57F-4FC5-9579-05D0723AA4A0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{87C08239-C57F-4FC5-9579-05D0723AA4A0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{87C08239-C57F-4FC5-9579-05D0723AA4A0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{87C08239-C57F-4FC5-9579-05D0723AA4A0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE