init

simples/JT808.DotNetty.SimpleServer/Program.cs

@@ -36,8 +36,6 @@ namespace JT808.DotNetty.SimpleServer
                 services.AddJT808Configure()
                         .AddJT808NettyCore(hostContext.Configuration)
                         .AddJT808TcpNettyHost()
-                        // 自定义Tcp消息处理业务
-                        .ReplaceMsgIdHandler<JT808MsgIdTcpSimpleHandler>()
                         .Builder();
             });
 

src/JT808.DotNetty.Abstractions/Dtos/JT808SystemCollectInfoDto.cs

@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Abstractions.Dtos
-{
-    public class JT808SystemCollectInfoDto
-    {
-        /// <summary>
-        /// 进程Id
-        /// </summary>
-        public int ProcessId { get; set; }
-        /// <summary>
-        /// 进程分配内存
-        /// 单位MB
-        /// </summary>
-        public double WorkingSet64 { get; set; }
-        /// <summary>
-        /// 进程分配内存峰值
-        /// 单位MB
-        /// </summary>
-        public double PeakWorkingSet64 { get; set; }
-        /// <summary>
-        /// 进程分配私有内存
-        /// 单位MB
-        /// </summary>
-        public double PrivateMemorySize64 { get; set; }
-        /// <summary>
-        /// 进程执行CPU总处理时间
-        /// </summary>
-        public TimeSpan CPUTotalProcessorTime { get; set; }
-    }
-}

src/JT808.DotNetty.Abstractions/Dtos/JT808TrafficInfoDto.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Abstractions.Dtos
-{
-    public  class JT808TrafficInfoDto
-    {
-        /// <summary>
-        /// 总接收大小 
-        /// 单位KB
-        /// </summary>
-        public double TotalReceiveSize { get; set; }
-        /// <summary>
-        /// 总发送大小 
-        /// 单位KB
-        /// </summary>
-        public double TotalSendSize { get; set; }
-    }
-}

src/JT808.DotNetty.Abstractions/JT808Constants.cs

@@ -12,32 +12,10 @@
 
             public const string SessionPrefix = "Session";
 
-            public const string TransmitPrefix = "Transmit";
-
-            public const string SystemCollectPrefix = "SystemCollect";
-
-            public const string TrafficPrefix = "Traffic";
-
             public const string TcpPrefix = "Tcp";
 
             public const string UdpPrefix = "Udp";
 
-            /// <summary>
-            ///获取当前系统进程使用率
-            /// </summary>
-            public static string SystemCollectGet = $"{RouteTablePrefix}/{SystemCollectPrefix}/Get";
-            /// <summary>
-            ///基于Tcp的添加转发过滤地址
-            /// </summary>
-            public static string TransmitAdd = $"{RouteTablePrefix}/{TcpPrefix}/{TransmitPrefix}/Add";
-            /// <summary>
-            /// 基于Tcp的删除转发过滤地址（不能删除在网关服务器配置文件配的地址）
-            /// </summary>
-            public static string TransmitRemove = $"{RouteTablePrefix}/{TcpPrefix}/{TransmitPrefix}/Remove";
-            /// <summary>
-            ///基于Tcp的获取转发过滤地址信息集合
-            /// </summary>
-            public static string TransmitGetAll = $"{RouteTablePrefix}/{TcpPrefix}/{TransmitPrefix}/GetAll";
             /// <summary>
             /// 基于Tcp的包计数器
             /// </summary>
@@ -54,11 +32,6 @@
             /// 基于Tcp的统一下发信息
             /// </summary>
             public static string UnificationTcpSend = $"{RouteTablePrefix}/{TcpPrefix}/UnificationSend";
-            /// <summary>
-            /// 基于Tcp的流量服务获取
-            /// </summary>
-            public static string TrafficTcpGet = $"{RouteTablePrefix}/{TcpPrefix}/{TrafficPrefix}/Get";
-
             /// <summary>
             /// 获取Udp包计数器
             /// </summary>
@@ -75,10 +48,6 @@
             /// 基于Udp的会话服务-通过设备终端号移除对应会话
             /// </summary>
             public static string SessionUdpRemoveByTerminalPhoneNo = $"{RouteTablePrefix}/{UdpPrefix}/{SessionPrefix}/RemoveByTerminalPhoneNo";
-            /// <summary>
-            /// 基于Udp的流量服务获取
-            /// </summary
-            public static string TrafficUdpGet = $"{RouteTablePrefix}/{UdpPrefix}/{TrafficPrefix}/Get";
         }
     }
 }

src/JT808.DotNetty.Core/Codecs/JT808TcpEncoder.cs

@@ -4,9 +4,6 @@ using JT808.Protocol;
 using DotNetty.Transport.Channels;
 using JT808.DotNetty.Core.Interfaces;
 using Microsoft.Extensions.Logging;
-using JT808.DotNetty.Core.Services;
-using JT808.DotNetty.Abstractions;
-using JT808.DotNetty.Abstractions.Enums;
 using JT808.Protocol.Interfaces;
 
 namespace JT808.DotNetty.Core.Codecs
@@ -18,21 +15,13 @@ namespace JT808.DotNetty.Core.Codecs
     {
         private readonly ILogger<JT808TcpEncoder> logger;
 
-        private readonly JT808TrafficService jT808TrafficService;
-
-        private readonly IJT808DownlinkPacket jT808DownlinkPacket;
-
         private readonly JT808Serializer JT808Serializer;
 
         public JT808TcpEncoder(
             IJT808Config jT808Config,
-            ILoggerFactory loggerFactory, 
-            JT808TrafficServiceFactory jT808TrafficServiceFactory,
-            IJT808DownlinkPacket jT808DownlinkPacket)
+            ILoggerFactory loggerFactory)
         {
             logger = loggerFactory.CreateLogger<JT808TcpEncoder>();
-            this.jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.tcp);
-            this.jT808DownlinkPacket = jT808DownlinkPacket;
             this.JT808Serializer = jT808Config.GetSerializer();
         }
 
@@ -43,8 +32,6 @@ namespace JT808.DotNetty.Core.Codecs
                 try
                 {
                     var sendData = JT808Serializer.Serialize(message.Package, message.MinBufferSize);
-                    jT808TrafficService.SendSize(sendData.Length);
-                    jT808DownlinkPacket.ProcessorAsync(sendData, JT808TransportProtocolType.tcp);
                     output.WriteBytes(Unpooled.WrappedBuffer(sendData));
                 }
                 catch (JT808.Protocol.Exceptions.JT808Exception ex)
@@ -58,8 +45,6 @@ namespace JT808.DotNetty.Core.Codecs
             }
             else if (message.HexData != null)
             {
-                jT808TrafficService.SendSize(message.HexData.Length);
-                jT808DownlinkPacket.ProcessorAsync(message.HexData, JT808TransportProtocolType.tcp);
                 output.WriteBytes(Unpooled.WrappedBuffer(message.HexData));
             }
         }

src/JT808.DotNetty.Core/Impls/JT808DatagramPacketImpl.cs

@@ -13,19 +13,15 @@ namespace JT808.DotNetty.Core.Impls
 {
     class JT808DatagramPacketImpl : IJT808DatagramPacket
     {
-        private readonly JT808TrafficService jT808TrafficService;
         private readonly IJT808DownlinkPacket jT808DownlinkPacket;
         public JT808DatagramPacketImpl(
-            JT808TrafficServiceFactory jT808TrafficServiceFactory,
             IJT808DownlinkPacket jT808DownlinkPacket)
         {
             this.jT808DownlinkPacket = jT808DownlinkPacket;
-            this.jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.udp);
         }
 
         public DatagramPacket Create(byte[] message, EndPoint recipient)
         {
-            jT808TrafficService.SendSize(message.Length);
             jT808DownlinkPacket.ProcessorAsync(message, JT808TransportProtocolType.udp);
             return new DatagramPacket(Unpooled.WrappedBuffer(message), recipient);
         }

src/JT808.DotNetty.Core/Impls/JT808DownlinkPacketEmptyImpl.cs

@@ -1,17 +0,0 @@
-using JT808.DotNetty.Abstractions;
-using JT808.DotNetty.Abstractions.Enums;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Impls
-{
-    class JT808DownlinkPacketEmptyImpl : IJT808DownlinkPacket
-    {
-        public Task ProcessorAsync(byte[] data, JT808TransportProtocolType transportProtocolType)
-        {
-            return Task.CompletedTask;
-        }
-    }
-}

src/JT808.DotNetty.Core/Impls/JT808SourcePackageDispatcherEmptyImpl.cs

@@ -1,16 +0,0 @@
-using JT808.DotNetty.Abstractions;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Impls
-{
-    /// <summary>
-    /// 原包分发器默认空实现
-    /// </summary>
-    public class JT808SourcePackageDispatcherEmptyImpl : IJT808SourcePackageDispatcher
-    {
-        public  Task SendAsync(byte[] data)
-        {
-            return Task.CompletedTask;
-        }
-    }
-}

src/JT808.DotNetty.Core/Impls/JT808UplinkPacketEmptyImpl.cs

@@ -1,17 +0,0 @@
-using JT808.DotNetty.Abstractions;
-using JT808.DotNetty.Abstractions.Enums;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Impls
-{
-    class JT808UplinkPacketEmptyImpl : IJT808UplinkPacket
-    {
-        public Task ProcessorAsync(byte[] data, JT808TransportProtocolType transportProtocolType)
-        {
-            return Task.CompletedTask;
-        }
-    }
-}

src/JT808.DotNetty.Core/Interfaces/IJT808NettyBuilder.cs

@@ -10,9 +10,6 @@ namespace JT808.DotNetty.Core.Interfaces
     public interface IJT808NettyBuilder
     {
         IJT808Builder JT808Builder { get; }
-        IJT808NettyBuilder ReplaceSourcePackageDispatcher<T>() where T : IJT808SourcePackageDispatcher;
-        IJT808NettyBuilder ReplaceDownlinkPacket<T>() where T: IJT808DownlinkPacket;
-        IJT808NettyBuilder ReplaceUplinkPacket<T>() where T : IJT808UplinkPacket;
         IJT808NettyBuilder ReplaceSessionPublishing<T>() where T : IJT808SessionPublishing;
         IJT808Builder Builder();
     }

src/JT808.DotNetty.Core/Interfaces/IJT808Session.cs

@@ -0,0 +1,20 @@
+using DotNetty.Transport.Channels;
+using JT808.DotNetty.Abstractions.Enums;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace JT808.DotNetty.Core.Interfaces
+{
+    public interface IJT808Session
+    {
+        /// <summary>
+        /// 终端手机号
+        /// </summary>
+        string TerminalPhoneNo { get; set; }
+        IChannel Channel { get; set; }
+        DateTime LastActiveTime { get; set; }
+        DateTime StartTime { get; set; }
+        JT808TransportProtocolType TransportProtocolType { get; set; }
+    }
+}

src/JT808.DotNetty.Core/Interfaces/IJT808TcpCustomMsgIdHandler.cs

@@ -1,20 +0,0 @@
-using JT808.DotNetty.Core.Metadata;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Core.Interfaces
-{
-    public interface IJT808TcpCustomMsgIdHandler
-    {
-        IJT808Reply Proccesser(JT808Request request);
-    }
-
-    public class JT808TcpCustomMsgIdHandlerEmpty : IJT808TcpCustomMsgIdHandler
-    {
-        public IJT808Reply Proccesser(JT808Request request)
-        {
-            return default;
-        }
-    }
-}

src/JT808.DotNetty.Core/Interfaces/IJT808TcpNettyBuilder.cs

@@ -9,8 +9,6 @@ namespace JT808.DotNetty.Core.Interfaces
     {
         IJT808NettyBuilder Instance { get; }
         IJT808NettyBuilder Builder();
-        IJT808TcpNettyBuilder ReplaceCustomMsgIdHandler<T>() where T : IJT808TcpCustomMsgIdHandler;
-        IJT808TcpNettyBuilder ReplaceMsgIdHandler<T>() where T : JT808MsgIdTcpHandlerBase;
         IJT808TcpNettyBuilder ReplaceSessionService<T>() where T : IJT808TcpSessionService;
         IJT808TcpNettyBuilder ReplaceUnificationSendService<T>() where T : IJT808UnificationTcpSendService;
     }

src/JT808.DotNetty.Core/Interfaces/IJT808UdpCustomMsgIdHandler.cs

@@ -1,20 +0,0 @@
-using JT808.DotNetty.Core.Metadata;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Core.Interfaces
-{
-    public interface IJT808UdpCustomMsgIdHandler
-    {
-        IJT808Reply Proccesser(JT808Request request);
-    }
-
-    public class JT808UdpCustomMsgIdHandlerEmpty : IJT808UdpCustomMsgIdHandler
-    {
-        public IJT808Reply Proccesser(JT808Request request)
-        {
-            return default;
-        }
-    }
-}

src/JT808.DotNetty.Core/Interfaces/IJT808UdpNettyBuilder.cs

@@ -9,8 +9,6 @@ namespace JT808.DotNetty.Core.Interfaces
     {
         IJT808NettyBuilder Instance { get; }
         IJT808NettyBuilder Builder();
-        IJT808UdpNettyBuilder ReplaceCustomMsgIdHandler<T>() where T : IJT808UdpCustomMsgIdHandler;
-        IJT808UdpNettyBuilder ReplaceMsgIdHandler<T>() where T : JT808MsgIdUdpHandlerBase;
         IJT808UdpNettyBuilder ReplaceSessionService<T>() where T : IJT808UdpSessionService;
         IJT808UdpNettyBuilder ReplaceUnificationSendService<T>() where T : IJT808UnificationUdpSendService;
     }

src/JT808.DotNetty.Core/JT808.DotNetty.Core.csproj

@@ -7,10 +7,6 @@
     <PackageReleaseNotes>基于DotNetty实现的JT808DotNetty的核心库</PackageReleaseNotes>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Compile Remove="Jobs\JT808UdpMaintainSessionJob.cs" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="DotNetty.Handlers" Version="0.6.0" />
     <PackageReference Include="DotNetty.Transport.Libuv" Version="0.6.0" />

src/JT808.DotNetty.Core/JT808BackgroundService.cs

@@ -1,74 +0,0 @@
-using Microsoft.Extensions.Hosting;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core
-{
-    /// <summary>
-    /// 
-    /// <see cref="https://blogs.msdn.microsoft.com/cesardelatorre/2017/11/18/implementing-background-tasks-in-microservices-with-ihostedservice-and-the-backgroundservice-class-net-core-2-x/"/>
-    /// </summary>
-    public abstract class JT808BackgroundService : IHostedService, IDisposable
-    {
-        /// <summary>
-        /// 默认次日过期
-        /// </summary>
-        public virtual TimeSpan DelayTimeSpan
-        {
-            get
-            {
-                DateTime current = DateTime.Now;
-                DateTime tmp = current.Date.AddDays(1).AddSeconds(-1);
-                return tmp.Subtract(current);
-            }
-            set { }
-        }
-
-        private Task _executingTask;
-
-        public abstract string ServiceName { get; }
-
-        private readonly CancellationTokenSource _stoppingCts = new CancellationTokenSource();
-
-        protected abstract Task ExecuteAsync(CancellationToken stoppingToken);
-
-        public void Dispose()
-        {
-            _stoppingCts.Cancel();
-        }
-
-        public virtual Task StartAsync(CancellationToken cancellationToken)
-        {
-            // Store the task we're executing
-            _executingTask = ExecuteAsync(_stoppingCts.Token);
-            // If the task is completed then return it,
-            // this will bubble cancellation and failure to the caller
-            if (_executingTask.IsCompleted)
-            {
-                return _executingTask;
-            }
-            // Otherwise it's running
-            return Task.CompletedTask;
-        }
-
-        public virtual async Task StopAsync(CancellationToken cancellationToken)
-        {
-            // Stop called without start
-            if (_executingTask == null)
-            {
-                return;
-            }
-            try
-            {
-                // Signal cancellation to the executing method
-                _stoppingCts.Cancel();
-            }
-            finally
-            {
-                // Wait until the task completes or the stop token triggers
-                await Task.WhenAny(_executingTask, Task.Delay(Timeout.Infinite,cancellationToken));
-            }
-        }
-    }
-}

src/JT808.DotNetty.Core/JT808CoreDotnettyExtensions.cs

@@ -58,13 +58,7 @@ namespace JT808.DotNetty.Core
             }
             IJT808NettyBuilder nettyBuilder = new JT808NettyBuilderDefault(jt808Builder);
             nettyBuilder.JT808Builder.Services.Configure<JT808Configuration>(configuration.GetSection("JT808Configuration"));
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808SessionPublishing, JT808SessionPublishingEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808DownlinkPacket, JT808DownlinkPacketEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UplinkPacket, JT808UplinkPacketEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808SourcePackageDispatcher, JT808SourcePackageDispatcherEmptyImpl>();
             nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808AtomicCounterServiceFactory>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808TrafficServiceFactory>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808SimpleSystemCollectService>();
             return nettyBuilder;
         }
 
@@ -83,13 +77,7 @@ namespace JT808.DotNetty.Core
             }
             IJT808NettyBuilder nettyBuilder = new JT808NettyBuilderDefault(jt808Builder);
             nettyBuilder.JT808Builder.Services.Configure(jt808Options);
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808SessionPublishing, JT808SessionPublishingEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808DownlinkPacket, JT808DownlinkPacketEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UplinkPacket, JT808UplinkPacketEmptyImpl>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808SourcePackageDispatcher, JT808SourcePackageDispatcherEmptyImpl>();
             nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808AtomicCounterServiceFactory>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808TrafficServiceFactory>();
-            nettyBuilder.JT808Builder.Services.TryAddSingleton<JT808SimpleSystemCollectService>();
             return nettyBuilder;
         }
     }

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

@@ -1,38 +0,0 @@
-using JT808.DotNetty.Abstractions.Enums;
-using JT808.DotNetty.Core.Services;
-using Microsoft.Extensions.Logging;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Jobs
-{
-    internal class JT808TcpAtomicCouterResetDailyJob : JT808BackgroundService
-    {
-        private readonly ILogger<JT808TcpAtomicCouterResetDailyJob> _logger;
-
-        private readonly JT808AtomicCounterService _jT808AtomicCounterService;
-
-        public JT808TcpAtomicCouterResetDailyJob(
-            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
-            ILoggerFactory loggerFactory)
-        {
-            _jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.tcp);
-            _logger =loggerFactory.CreateLogger<JT808TcpAtomicCouterResetDailyJob>();
-        }
-
-        public override string ServiceName => nameof(JT808TcpAtomicCouterResetDailyJob);
-
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            _logger.LogInformation($"{ServiceName} is starting.");
-            stoppingToken.Register(() => _logger.LogInformation($"{ServiceName} background task is stopping."));
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808AtomicCounterService.Reset();
-                await Task.Delay(DelayTimeSpan, stoppingToken);
-            }
-            _logger.LogInformation($"{ServiceName} background task is stopping.");
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-using JT808.DotNetty.Abstractions.Enums;
-using JT808.DotNetty.Core.Services;
-using Microsoft.Extensions.Logging;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Jobs
-{
-    internal class JT808TcpTrafficResetDailyJob : JT808BackgroundService
-    {
-        private readonly ILogger<JT808TcpTrafficResetDailyJob> _logger;
-
-        private readonly JT808TrafficService _jT808TrafficService;
-
-        public JT808TcpTrafficResetDailyJob(
-            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
-            ILoggerFactory loggerFactory)
-        {
-            _jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.tcp);
-            _logger =loggerFactory.CreateLogger<JT808TcpTrafficResetDailyJob>();
-        }
-
-        public override string ServiceName => nameof(JT808TcpTrafficResetDailyJob);
-
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            _logger.LogInformation($"{ServiceName} is starting.");
-            stoppingToken.Register(() => _logger.LogInformation($"{ServiceName} background task is stopping."));
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808TrafficService.ResetSize();
-                await Task.Delay(DelayTimeSpan, stoppingToken);
-            }
-            _logger.LogInformation($"{ServiceName} background task is stopping.");
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-using JT808.DotNetty.Abstractions.Enums;
-using JT808.DotNetty.Core.Services;
-using Microsoft.Extensions.Logging;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Jobs
-{
-    internal class JT808UdpAtomicCouterResetDailyJob : JT808BackgroundService
-    {
-        private readonly ILogger<JT808UdpAtomicCouterResetDailyJob> _logger;
-
-        private readonly JT808AtomicCounterService _jT808AtomicCounterService;
-
-        public JT808UdpAtomicCouterResetDailyJob(
-            JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
-            ILoggerFactory loggerFactory)
-        {
-            _jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.udp);
-            _logger =loggerFactory.CreateLogger<JT808UdpAtomicCouterResetDailyJob>();
-        }
-
-        public override string ServiceName => nameof(JT808UdpAtomicCouterResetDailyJob);
-
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            _logger.LogInformation($"{ServiceName} is starting.");
-            stoppingToken.Register(() => _logger.LogInformation($"{ServiceName} background task is stopping."));
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808AtomicCounterService.Reset();
-                await Task.Delay(DelayTimeSpan, stoppingToken);
-            }
-            _logger.LogInformation($"{ServiceName} background task is stopping.");
-        }
-    }
-}

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

@@ -1,38 +0,0 @@
-using JT808.DotNetty.Abstractions.Enums;
-using JT808.DotNetty.Core.Services;
-using Microsoft.Extensions.Logging;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace JT808.DotNetty.Core.Jobs
-{
-    internal class JT808UdpTrafficResetDailyJob : JT808BackgroundService
-    {
-        private readonly ILogger<JT808UdpTrafficResetDailyJob> _logger;
-
-        private readonly JT808TrafficService _jT808TrafficService;
-
-        public JT808UdpTrafficResetDailyJob(
-            JT808TrafficServiceFactory jT808TrafficServiceFactory,
-            ILoggerFactory loggerFactory)
-        {
-            _jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.udp);
-            _logger =loggerFactory.CreateLogger<JT808UdpTrafficResetDailyJob>();
-        }
-
-        public override string ServiceName => nameof(JT808UdpTrafficResetDailyJob);
-
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            _logger.LogInformation($"{ServiceName} is starting.");
-            stoppingToken.Register(() => _logger.LogInformation($"{ServiceName} background task is stopping."));
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                _logger.LogInformation($"{ServiceName} task doing background work.");
-                _jT808TrafficService.ResetSize();
-                await Task.Delay(DelayTimeSpan, stoppingToken);
-            }
-            _logger.LogInformation($"{ServiceName} background task is stopping.");
-        }
-    }
-}

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

@@ -1,9 +1,11 @@
 using DotNetty.Transport.Channels;
+using JT808.DotNetty.Abstractions.Enums;
+using JT808.DotNetty.Core.Interfaces;
 using System;
 
 namespace JT808.DotNetty.Core.Metadata
 {
-    public class JT808TcpSession
+    public class JT808TcpSession: IJT808Session
     {
         public JT808TcpSession(IChannel channel, string terminalPhoneNo)
         {
@@ -25,5 +27,6 @@ namespace JT808.DotNetty.Core.Metadata
         public DateTime LastActiveTime { get; set; }
 
         public DateTime StartTime { get; set; }
+        public JT808TransportProtocolType TransportProtocolType { get; set; } = JT808TransportProtocolType.tcp;
     }
 }

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

@@ -1,10 +1,12 @@
 using DotNetty.Transport.Channels;
+using JT808.DotNetty.Abstractions.Enums;
+using JT808.DotNetty.Core.Interfaces;
 using System;
 using System.Net;
 
 namespace JT808.DotNetty.Core.Metadata
 {
-    public class JT808UdpSession
+    public class JT808UdpSession: IJT808Session
     {
         public JT808UdpSession(IChannel channel,
             EndPoint sender,
@@ -31,5 +33,6 @@ namespace JT808.DotNetty.Core.Metadata
         public DateTime LastActiveTime { get; set; }
 
         public DateTime StartTime { get; set; }
+        public JT808TransportProtocolType TransportProtocolType { get; set; } = JT808TransportProtocolType.udp;
     }
 }

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

@@ -1,30 +0,0 @@
-using JT808.DotNetty.Abstractions.Dtos;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
-
-namespace JT808.DotNetty.Core.Services
-{
-    /// <summary>
-    /// 简单系统收集服务
-    /// </summary>
-    public  class JT808SimpleSystemCollectService
-    {
-        /// <summary>
-        /// 获取系统当前进程使用情况
-        /// </summary>
-        /// <returns></returns>
-        public JT808SystemCollectInfoDto Get()
-        {
-            JT808SystemCollectInfoDto jT808SystemCollectInfoDto = new JT808SystemCollectInfoDto();
-            var proc = Process.GetCurrentProcess();
-            jT808SystemCollectInfoDto.ProcessId = proc.Id;
-            jT808SystemCollectInfoDto.WorkingSet64 = proc.WorkingSet64 / 1024.0 / 1024.0;
-            jT808SystemCollectInfoDto.PeakWorkingSet64 = proc.PeakWorkingSet64 / 1024.0 / 1024.0;
-            jT808SystemCollectInfoDto.PrivateMemorySize64 = proc.PrivateMemorySize64 / 1024.0 / 1024.0;
-            jT808SystemCollectInfoDto.CPUTotalProcessorTime = proc.TotalProcessorTime;
-            return jT808SystemCollectInfoDto;
-        }
-    }
-}

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

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

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

@@ -1,33 +0,0 @@
-using JT808.DotNetty.Abstractions.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<JT808TransportProtocolType, JT808TrafficService> cache;
-
-        public JT808TrafficServiceFactory()
-        {
-            cache = new ConcurrentDictionary<JT808TransportProtocolType, JT808TrafficService>();
-        }
-
-        public JT808TrafficService Create(JT808TransportProtocolType 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/JT808TransmitAddressFilterService.cs

@@ -1,102 +0,0 @@
-using JT808.DotNetty.Abstractions.Dtos;
-using Microsoft.Extensions.Options;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using JT808.DotNetty.Core.Configurations;
-
-namespace JT808.DotNetty.Core.Services
-{
-    /// <summary>
-    /// JT808转发地址过滤服务
-    /// 按照808的消息，有些请求必须要应答，但是转发可以不需要有应答可以节省部分资源包括：
-    //  1.消息的序列化
-    //  2.消息的下发
-    //  都有一定的性能损耗，那么不需要判断写超时 IdleState.WriterIdle 
-    //  就跟神兽貔貅一样。。。
-    /// </summary>
-    public class JT808TransmitAddressFilterService : IDisposable
-    {
-        private readonly IOptionsMonitor<JT808Configuration> jT808ConfigurationOptionsMonitor;
-
-        private ConcurrentDictionary<string,byte> ForwardingRemoteAddresssDict;
-
-        private IDisposable jT808ConfigurationOptionsMonitorDisposable;
-
-        public JT808TransmitAddressFilterService(
-            IOptionsMonitor<JT808Configuration> jT808ConfigurationOptionsMonitor)
-        {
-            this.jT808ConfigurationOptionsMonitor = jT808ConfigurationOptionsMonitor;
-            ForwardingRemoteAddresssDict = new ConcurrentDictionary<string, byte>();
-            InitForwardingRemoteAddress(jT808ConfigurationOptionsMonitor.CurrentValue.ForwardingRemoteIPAddress);
-            //OnChange 源码多播委托
-            jT808ConfigurationOptionsMonitorDisposable = this.jT808ConfigurationOptionsMonitor.OnChange(options =>
-            {
-                ChangeForwardingRemoteAddress(options.ForwardingRemoteIPAddress);
-            });
-        }
-
-        private void InitForwardingRemoteAddress(List<string> jT808ClientConfigurations)
-        {
-            if (jT808ClientConfigurations != null && jT808ClientConfigurations.Count > 0)
-            {
-                foreach (var item in jT808ClientConfigurations)
-                {
-                    ForwardingRemoteAddresssDict.TryAdd(item, 0);
-                }
-            }
-        }
-
-        private void ChangeForwardingRemoteAddress(List<string> jT808ClientConfigurations)
-        {
-            if (jT808ClientConfigurations != null && jT808ClientConfigurations.Count > 0)
-            {
-                ForwardingRemoteAddresssDict.Clear();
-                foreach (var item in jT808ClientConfigurations)
-                {             
-                    ForwardingRemoteAddresssDict.TryAdd(item, 0);
-                }
-            }
-            else
-            {
-                ForwardingRemoteAddresssDict.Clear();
-            }
-        }
-
-        public bool ContainsKey(EndPoint endPoint)
-        {
-            IPAddress ip = ((IPEndPoint)endPoint).Address;
-            return ForwardingRemoteAddresssDict.ContainsKey(ip.ToString());
-        }
-
-        public JT808ResultDto<bool> Add(string host)
-        {
-            return new JT808ResultDto<bool>() { Code = JT808ResultCode.Ok, Data = ForwardingRemoteAddresssDict.TryAdd(host,0) };
-        }
-
-        public JT808ResultDto<bool> Remove(string host)
-        {
-            if(jT808ConfigurationOptionsMonitor.CurrentValue.ForwardingRemoteIPAddress!=null &&
-                jT808ConfigurationOptionsMonitor.CurrentValue.ForwardingRemoteIPAddress.Any(w=>w== host))
-            {
-                return new JT808ResultDto<bool>() { Code = JT808ResultCode.Ok, Data = false,Message="不能删除服务器配置的地址" };
-            }
-            else
-            {
-                return new JT808ResultDto<bool>() { Code = JT808ResultCode.Ok, Data = ForwardingRemoteAddresssDict.TryRemove(host,out var temp) };
-            }
-        }
-
-        public JT808ResultDto<List<string>> GetAll()
-        {
-            return new JT808ResultDto<List<string>>(){ Code = JT808ResultCode.Ok, Data = ForwardingRemoteAddresssDict.Select(s=>s.Key).ToList() };
-        }
-
-        public void Dispose()
-        {
-            jT808ConfigurationOptionsMonitorDisposable.Dispose();
-        }
-    }
-}

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

@@ -1,18 +0,0 @@
-using JT808.DotNetty.Core;
-using JT808.DotNetty.Core.Handlers;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace JT808.DotNetty.Tcp.Handlers
-{
-    /// <summary>
-    /// 默认消息处理业务实现
-    /// </summary>
-    internal class JT808MsgIdDefaultTcpHandler : JT808MsgIdTcpHandlerBase
-    {
-        public JT808MsgIdDefaultTcpHandler(JT808TcpSessionManager sessionManager) : base(sessionManager)
-        {
-        }
-    }
-}

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

@@ -3,14 +3,11 @@ using DotNetty.Transport.Channels;
 using JT808.Protocol;
 using System;
 using JT808.DotNetty.Core;
-using JT808.DotNetty.Abstractions;
 using Microsoft.Extensions.Logging;
-using JT808.DotNetty.Core.Handlers;
 using JT808.DotNetty.Core.Services;
-using JT808.DotNetty.Core.Metadata;
-using JT808.DotNetty.Core.Interfaces;
 using JT808.DotNetty.Abstractions.Enums;
 using JT808.Protocol.Interfaces;
+using JT808.Protocol.Exceptions;
 
 namespace JT808.DotNetty.Tcp.Handlers
 {
@@ -18,111 +15,48 @@ namespace JT808.DotNetty.Tcp.Handlers
     /// JT808服务端处理程序
     /// </summary>
     internal class JT808TcpServerHandler : SimpleChannelInboundHandler<byte[]>
-    {
-        private readonly JT808MsgIdTcpHandlerBase handler;
-        
+    {       
         private readonly JT808TcpSessionManager jT808SessionManager;
 
-        private readonly JT808TransmitAddressFilterService jT808TransmitAddressFilterService;
-
-        private readonly IJT808SourcePackageDispatcher jT808SourcePackageDispatcher;
-
         private readonly JT808AtomicCounterService jT808AtomicCounterService;
 
-        private readonly JT808TrafficService jT808TrafficService;
-
-        private readonly IJT808UplinkPacket  jT808UplinkPacket;
-
-        private readonly IJT808TcpCustomMsgIdHandler jT808TcpCustomMsgIdHandler;
-
         private readonly ILogger<JT808TcpServerHandler> logger;
 
-        private readonly ILogger unknownLogger;
-
         private readonly JT808Serializer JT808Serializer;
 
         public JT808TcpServerHandler(
             IJT808Config jT808Config,
-            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory,
-            JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
-            IJT808SourcePackageDispatcher jT808SourcePackageDispatcher,
-            IJT808UplinkPacket jT808UplinkPacket,
-            JT808MsgIdTcpHandlerBase handler,
             JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
-            IJT808TcpCustomMsgIdHandler jT808TcpCustomMsgIdHandler,
             JT808TcpSessionManager jT808SessionManager)
         {
-            this.jT808TcpCustomMsgIdHandler = jT808TcpCustomMsgIdHandler;
-            this.jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.tcp);
-            this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
-            this.handler = handler;
             this.jT808SessionManager = jT808SessionManager;
-            this.jT808SourcePackageDispatcher = jT808SourcePackageDispatcher;
-            this.jT808UplinkPacket = jT808UplinkPacket;
             this.jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.tcp);
             this.JT808Serializer = jT808Config.GetSerializer();
             logger = loggerFactory.CreateLogger<JT808TcpServerHandler>();
-            unknownLogger = loggerFactory.CreateLogger("tcp_unknown_msgid");
         }
 
-
         protected override void ChannelRead0(IChannelHandlerContext ctx, byte[] msg)
         {
             try
             {
-                jT808SourcePackageDispatcher.SendAsync(msg);
-                jT808UplinkPacket.ProcessorAsync(msg, JT808TransportProtocolType.tcp);
                 //解析到头部,然后根据具体的消息Id通过队列去进行消费
                 //要是一定要解析到数据体可以在JT808MsgIdHandlerBase类中根据具体的消息，
                 //解析具体的消息体，具体调用JT808Serializer.Deserialize<T>
                 JT808HeaderPackage jT808HeaderPackage = JT808Serializer.Deserialize<JT808HeaderPackage>(msg);
                 jT808AtomicCounterService.MsgSuccessIncrement();
-                jT808TrafficService.ReceiveSize(msg.Length);
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
-                    logger.LogTrace("accept package success count<<<" + jT808AtomicCounterService.MsgSuccessCount.ToString());
-                    logger.LogTrace("accept msg <<< " + ByteBufferUtil.HexDump(msg));
+                    logger.LogTrace($"accept package success count=>{jT808AtomicCounterService.MsgSuccessCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg)}");
                 }
                 jT808SessionManager.TryAdd(jT808HeaderPackage.Header.TerminalPhoneNo,ctx.Channel);
-                if (handler.HandlerDict.TryGetValue(jT808HeaderPackage.Header.MsgId, out var handlerFunc))
-                {
-                    IJT808Reply jT808Response = handlerFunc(new JT808Request(jT808HeaderPackage, msg));
-                    if (jT808Response != null)
-                    {
-                        if (!jT808TransmitAddressFilterService.ContainsKey(ctx.Channel.RemoteAddress))
-                        {
-                            ctx.WriteAndFlushAsync(jT808Response);
-                        }
-                    }
-                }
-                else
-                {
-                    IJT808Reply jT808CustomMsgIdResponse = jT808TcpCustomMsgIdHandler.Proccesser(new JT808Request(jT808HeaderPackage, msg));
-                    if (jT808CustomMsgIdResponse != null)
-                    {
-                        if (!jT808TransmitAddressFilterService.ContainsKey(ctx.Channel.RemoteAddress))
-                        {
-                            ctx.WriteAndFlushAsync(jT808CustomMsgIdResponse);
-                        }
-                    }
-                    else
-                    {
-                        //未知的消息类型已日志形式输出
-                        if (unknownLogger.IsEnabled(LogLevel.Debug))
-                        {
-                            unknownLogger.LogDebug(ByteBufferUtil.HexDump(msg));
-                        }
-                    }
-                }
             }
-            catch (JT808.Protocol.Exceptions.JT808Exception ex)
+            catch (JT808Exception ex)
             {
                 jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
-                    logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg));
+                    logger.LogError(ex,$"accept package fail count=>{jT808AtomicCounterService.MsgFailCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg)}");
                 }
             }
             catch (Exception ex)
@@ -130,8 +64,7 @@ namespace JT808.DotNetty.Tcp.Handlers
                 jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
-                    logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg));
+                    logger.LogError(ex, $"accept package fail count=>{jT808AtomicCounterService.MsgFailCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg)}");
                 }
             }
         }

src/JT808.DotNetty.Tcp/JT808TcpBuilderDefault.cs

@@ -22,17 +22,6 @@ namespace JT808.DotNetty.Tcp
             return Instance;
         }
 
-        public IJT808TcpNettyBuilder ReplaceCustomMsgIdHandler<T>() where T : IJT808TcpCustomMsgIdHandler
-        {
-            Instance.JT808Builder.Services.Replace(new ServiceDescriptor(typeof(IJT808TcpCustomMsgIdHandler), typeof(T), ServiceLifetime.Singleton));
-            return this;
-        }
-
-        public IJT808TcpNettyBuilder ReplaceMsgIdHandler<T>() where T : JT808MsgIdTcpHandlerBase
-        {
-            Instance.JT808Builder.Services.Replace(new ServiceDescriptor(typeof(JT808MsgIdTcpHandlerBase), typeof(T), ServiceLifetime.Singleton));
-            return this;
-        }
 
         public IJT808TcpNettyBuilder ReplaceSessionService<T>() where T : IJT808TcpSessionService
         {

src/JT808.DotNetty.Tcp/JT808TcpDotnettyExtensions.cs

@@ -10,7 +10,6 @@ using Newtonsoft.Json;
 using System;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using JT808.DotNetty.Core.Jobs;
 using JT808.DotNetty.Core.Interfaces;
 using JT808.DotNetty.Internal;
 
@@ -22,18 +21,13 @@ namespace JT808.DotNetty.Tcp
     {
         public static IJT808TcpNettyBuilder AddJT808TcpNettyHost(this IJT808NettyBuilder jT808NettyBuilder)
         {
-            jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808TcpCustomMsgIdHandler, JT808TcpCustomMsgIdHandlerEmpty>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808TcpSessionService, JT808TcpSessionService>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UnificationTcpSendService, JT808UnificationTcpSendService>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<JT808TcpSessionManager>();
-            jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<JT808TransmitAddressFilterService>();
-            jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<JT808MsgIdTcpHandlerBase, JT808MsgIdDefaultTcpHandler>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808TcpConnectionHandler>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808TcpEncoder>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808TcpDecoder>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808TcpServerHandler>();
-            jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808TcpAtomicCouterResetDailyJob>();
-            jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808TcpTrafficResetDailyJob>();
             jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808TcpServerHost>();
             return new JT808TcpBuilderDefault(jT808NettyBuilder);
         }

src/JT808.DotNetty.Tests/JT808.DotNetty.Core.Test/JT808TransmitAddressFilterServiceTest.cs

@@ -1,75 +0,0 @@
-using JT808.DotNetty.Abstractions.Dtos;
-using JT808.DotNetty.Core.Configurations;
-using JT808.DotNetty.Core.Services;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-
-namespace JT808.DotNetty.Core.Test
-{
-    [TestClass]
-    public class JT808TransmitAddressFilterServiceTest
-    {
-        private JT808TransmitAddressFilterService jT808TransmitAddressFilterService;
-
-        public JT808TransmitAddressFilterServiceTest()
-        {
-            var serverHostBuilder = new HostBuilder()
-            .ConfigureAppConfiguration((hostingContext, config) =>
-            {
-                config.SetBasePath(AppDomain.CurrentDomain.BaseDirectory);
-                config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
-            })
-            .ConfigureServices((hostContext, services) =>
-            {
-                services.AddSingleton<ILoggerFactory, LoggerFactory>();
-                services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
-                services.Configure<JT808Configuration>(hostContext.Configuration.GetSection("JT808Configuration"));
-                services.AddSingleton<JT808TransmitAddressFilterService>();
-            });
-            var serviceProvider = serverHostBuilder.Build().Services;
-            jT808TransmitAddressFilterService = serviceProvider.GetService<JT808TransmitAddressFilterService>();
-            jT808TransmitAddressFilterService.Add("127.0.0.1");
-        }
-
-        [TestMethod]
-        public void Test1()
-        {
-            Assert.IsTrue(jT808TransmitAddressFilterService.ContainsKey(new JT808IPAddressDto
-            {
-                Host = "127.0.0.1",
-                Port = 12348
-            }.EndPoint));
-        }
-
-        [TestMethod]
-        public void Test2()
-        {
-            var result = jT808TransmitAddressFilterService.GetAll();
-        }
-
-        [TestMethod]
-        public void Test3()
-        {
-            var result1= jT808TransmitAddressFilterService.Add("127.0.0.1");
-            Assert.AreEqual(JT808ResultCode.Ok, result1.Code);
-            Assert.IsTrue(result1.Data);
-            var result2 = jT808TransmitAddressFilterService.Remove("127.0.0.1");
-            Assert.AreEqual(JT808ResultCode.Ok, result2.Code);
-            Assert.IsTrue(result2.Data);
-        }
-
-        [TestMethod]
-        public void Test4()
-        {
-            var result2 = jT808TransmitAddressFilterService.Remove("127.0.0.1");
-            Assert.AreEqual(JT808ResultCode.Ok, result2.Code);
-            Assert.IsFalse(result2.Data);
-            Assert.AreEqual("不能删除服务器配置的地址", result2.Message);
-        }
-    }
-}

src/JT808.DotNetty.Tests/JT808.DotNetty.Hosting/Program.cs

@@ -54,19 +54,9 @@ namespace JT808.DotNetty.Hosting
                     services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
                     services.AddJT808Configure()
                             .AddJT808NettyCore(hostContext.Configuration)
-                            //自定义日志下发包
-                            .ReplaceDownlinkPacket<JT808DownlinkPacketLogging>()
-                            //自定义会话通知（在线/离线）使用异步方式
-                            //.ReplaceSessionPublishing<CustomJT808SessionPublishing>()
-                            //自定义原包转发 使用异步方式
-                            //.ReplaceSourcePackageDispatcher<CustomJT808SourcePackageDispatcher>
                             .AddJT808TcpNettyHost()
-                            // 自定义Tcp消息处理业务
-                            .ReplaceMsgIdHandler<JT808MsgIdTcpCustomHandler>()
                             .Builder()
                             .AddJT808UdpNettyHost()
-                            // 自定义Udp消息处理业务
-                            .ReplaceMsgIdHandler<JT808MsgIdUdpCustomHandler>()
                             .Builder()
                             .AddJT808WebApiNettyHost()
                             .Builder();

src/JT808.DotNetty.Tests/JT808.DotNetty.WebApi.Test/JT808DotNettyWebApiTest.cs

@@ -22,24 +22,12 @@ namespace JT808.DotNetty.WebApi.Test
             var api = HttpApi.Resolve<IJT808DotNettyWebApi>();
         }
 
-        [TestMethod]
-        public void GetSystemCollectTest()
-        {
-            var result = jT808DotNettyWebApi.GetSystemCollect().GetAwaiter().GetResult();
-        }
-
         [TestMethod]
         public void GetUdpAtomicCounterTest()
         {
             var result = jT808DotNettyWebApi.GetUdpAtomicCounter().GetAwaiter().GetResult();
         }
 
-        [TestMethod]
-        public void GetUdpTrafficTest()
-        {
-            var result = jT808DotNettyWebApi.GetUdpTraffic().GetAwaiter().GetResult();
-        }
-
         [TestMethod]
         public void UnificationUdpSendTest()
         {
@@ -61,44 +49,12 @@ namespace JT808.DotNetty.WebApi.Test
             var result = jT808DotNettyWebApi.GetUdpSessionAll().GetAwaiter().GetResult();  
         }
 
-        [TestMethod]
-        public void GetTcpTrafficTest()
-        {
-            var result = jT808DotNettyWebApi.GetTcpTraffic().GetAwaiter().GetResult();
-        }
-
         [TestMethod]
         public void GetTcpAtomicCounterTest()
         {
             var result = jT808DotNettyWebApi.GetTcpAtomicCounter().GetAwaiter().GetResult();
         }
 
-        [TestMethod]
-        public void GetTransmitAllTest()
-        {
-            var result = jT808DotNettyWebApi.GetTransmitAll().GetAwaiter().GetResult();
-        }
-
-        [TestMethod]
-        public void RemoveTransmitAddressTest()
-        {
-            var result = jT808DotNettyWebApi.RemoveTransmitAddress(new Abstractions.Dtos.JT808IPAddressDto
-            {
-                Host = "127.0.0.1",
-                Port = 6561
-            }).GetAwaiter().GetResult();
-        }
-
-        [TestMethod]
-        public void AddTransmitAddressTest()
-        {
-            var result = jT808DotNettyWebApi.AddTransmitAddress(new Abstractions.Dtos.JT808IPAddressDto
-            {
-                Host = "127.0.0.1",
-                Port = 6553
-            }).GetAwaiter().GetResult();
-        }
-
         [TestMethod]
         public void UnificationTcpSendTest()
         {

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

@@ -1,15 +0,0 @@
-using JT808.DotNetty.Core;
-using JT808.DotNetty.Core.Handlers;
-
-namespace JT808.DotNetty.Udp.Handlers
-{
-    /// <summary>
-    /// 默认消息处理业务实现
-    /// </summary>
-    internal class JT808MsgIdDefaultUdpHandler : JT808MsgIdUdpHandlerBase
-    {
-        public JT808MsgIdDefaultUdpHandler(JT808UdpSessionManager sessionManager) : base(sessionManager)
-        {
-        }
-    }
-}

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

@@ -3,14 +3,9 @@ using DotNetty.Transport.Channels;
 using JT808.Protocol;
 using System;
 using Microsoft.Extensions.Logging;
-using DotNetty.Transport.Channels.Sockets;
 using JT808.DotNetty.Core.Metadata;
-using JT808.DotNetty.Abstractions;
 using JT808.DotNetty.Core.Services;
 using JT808.DotNetty.Core;
-using JT808.DotNetty.Core.Handlers;
-using System.Threading.Tasks;
-using JT808.DotNetty.Core.Interfaces;
 using JT808.DotNetty.Abstractions.Enums;
 using JT808.Protocol.Interfaces;
 
@@ -21,96 +16,39 @@ namespace JT808.DotNetty.Udp.Handlers
     /// </summary>
     internal class JT808UdpServerHandler : SimpleChannelInboundHandler<JT808UdpPackage>
     {
-        private readonly IJT808SourcePackageDispatcher jT808SourcePackageDispatcher;
-
         private readonly JT808AtomicCounterService jT808AtomicCounterService;
 
         private readonly ILogger<JT808UdpServerHandler> logger;
 
         private readonly JT808UdpSessionManager jT808UdpSessionManager;
 
-        private readonly JT808MsgIdUdpHandlerBase handler;
-
-        private readonly JT808TrafficService jT808TrafficService;
-
-        private readonly IJT808UplinkPacket jT808UplinkPacket;
-
-        private readonly IJT808UdpCustomMsgIdHandler jT808UdpCustomMsgIdHandler;
-
-        private readonly IJT808DatagramPacket jT808DatagramPacket;
-
-        private readonly ILogger unknownLogger;
-
         private readonly JT808Serializer JT808Serializer;
 
         public JT808UdpServerHandler(
             IJT808Config jT808Config,
-            IJT808DatagramPacket jT808DatagramPacket,
-            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             ILoggerFactory loggerFactory,
-            IJT808SourcePackageDispatcher jT808SourcePackageDispatcher,
-            IJT808UplinkPacket jT808UplinkPacket,
-            JT808MsgIdUdpHandlerBase handler,
             JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory,
-            IJT808UdpCustomMsgIdHandler jT808UdpCustomMsgIdHandler,
             JT808UdpSessionManager jT808UdpSessionManager)
         {
-            this.jT808UdpCustomMsgIdHandler = jT808UdpCustomMsgIdHandler;
-            this.jT808DatagramPacket = jT808DatagramPacket;
-            this.jT808TrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.udp);
-            this.handler = handler;
-            this.jT808SourcePackageDispatcher = jT808SourcePackageDispatcher;
             this.jT808AtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.udp);
-            this.jT808UplinkPacket = jT808UplinkPacket;
             this.jT808UdpSessionManager = jT808UdpSessionManager;
             logger = loggerFactory.CreateLogger<JT808UdpServerHandler>();
             JT808Serializer = jT808Config.GetSerializer();
-            unknownLogger = loggerFactory.CreateLogger("udp_unknown_msgid");
         }
 
         protected override void ChannelRead0(IChannelHandlerContext ctx, JT808UdpPackage msg)
         {
             try
             {
-                jT808SourcePackageDispatcher.SendAsync(msg.Buffer);
-                jT808UplinkPacket.ProcessorAsync(msg.Buffer, JT808TransportProtocolType.udp);
                 //解析到头部,然后根据具体的消息Id通过队列去进行消费
                 //要是一定要解析到数据体可以在JT808MsgIdHandlerBase类中根据具体的消息，
                 //解析具体的消息体，具体调用JT808Serializer.Deserialize<T>
                 JT808HeaderPackage jT808HeaderPackage = JT808Serializer.Deserialize<JT808HeaderPackage>(msg.Buffer);
                 jT808AtomicCounterService.MsgSuccessIncrement();
-                jT808TrafficService.ReceiveSize(msg.Buffer.Length);
                 jT808UdpSessionManager.TryAdd(ctx.Channel, msg.Sender, jT808HeaderPackage.Header.TerminalPhoneNo);
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
-                    logger.LogTrace("accept package success count<<<" + jT808AtomicCounterService.MsgSuccessCount.ToString());
-                    logger.LogTrace("accept msg <<< " + ByteBufferUtil.HexDump(msg.Buffer));
-                }
-                if (handler.HandlerDict.TryGetValue(jT808HeaderPackage.Header.MsgId, out var handlerFunc))
-                {
-                    IJT808Reply jT808Response = handlerFunc(new JT808Request(jT808HeaderPackage, msg.Buffer));
-                    if (jT808Response != null)
-                    {
-                        var sendData = JT808Serializer.Serialize(jT808Response.Package, jT808Response.MinBufferSize);
-                        ctx.WriteAndFlushAsync(jT808DatagramPacket.Create(sendData,msg.Sender));
-                    }
-                }
-                else
-                {
-                    IJT808Reply jT808CustomMsgIdResponse = jT808UdpCustomMsgIdHandler.Proccesser(new JT808Request(jT808HeaderPackage, msg.Buffer));
-                    if (jT808CustomMsgIdResponse != null)
-                    {
-                        var sendData = JT808Serializer.Serialize(jT808CustomMsgIdResponse.Package, jT808CustomMsgIdResponse.MinBufferSize);
-                        ctx.WriteAndFlushAsync(jT808DatagramPacket.Create(sendData, msg.Sender));
-                    }
-                    else
-                    {
-                        //未知的消息类型已日志形式输出
-                        if (unknownLogger.IsEnabled(LogLevel.Debug))
-                        {
-                            unknownLogger.LogDebug(ByteBufferUtil.HexDump(msg.Buffer));
-                        }
-                    }
+                    logger.LogTrace($"accept package success count=>{jT808AtomicCounterService.MsgFailCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg.Buffer)}");
                 }
             }
             catch (JT808.Protocol.Exceptions.JT808Exception ex)
@@ -118,8 +56,7 @@ namespace JT808.DotNetty.Udp.Handlers
                 jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
-                    logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg.Buffer));
+                    logger.LogError(ex, $"accept package fail count=>{jT808AtomicCounterService.MsgFailCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg.Buffer)}");
                 }
             }
             catch (Exception ex)
@@ -127,13 +64,11 @@ namespace JT808.DotNetty.Udp.Handlers
                 jT808AtomicCounterService.MsgFailIncrement();
                 if (logger.IsEnabled(LogLevel.Error))
                 {
-                    logger.LogError("accept package fail count<<<" + jT808AtomicCounterService.MsgFailCount.ToString());
-                    logger.LogError(ex, "accept msg<<<" + ByteBufferUtil.HexDump(msg.Buffer));
+                    logger.LogError(ex, $"accept package fail count=>{jT808AtomicCounterService.MsgFailCount.ToString()},accept msg=>{ByteBufferUtil.HexDump(msg.Buffer)}");
                 }
             }
         }
 
         public override void ChannelReadComplete(IChannelHandlerContext context) => context.Flush();
-
     }
 }

src/JT808.DotNetty.Udp/JT1078UdpBuilderDefault.cs

@@ -1,10 +1,6 @@
-using JT808.DotNetty.Core.Handlers;
-using JT808.DotNetty.Core.Interfaces;
+using JT808.DotNetty.Core.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace JT808.DotNetty.Udp
 {
@@ -22,18 +18,6 @@ namespace JT808.DotNetty.Udp
             return Instance;
         }
 
-        public IJT808UdpNettyBuilder ReplaceCustomMsgIdHandler<T>() where T : IJT808UdpCustomMsgIdHandler
-        {
-            Instance.JT808Builder.Services.Replace(new ServiceDescriptor(typeof(IJT808UdpCustomMsgIdHandler), typeof(T), ServiceLifetime.Singleton));
-            return this;
-        }
-
-        public IJT808UdpNettyBuilder ReplaceMsgIdHandler<T>() where T : JT808MsgIdUdpHandlerBase
-        {
-            Instance.JT808Builder.Services.Replace(new ServiceDescriptor(typeof(JT808MsgIdUdpHandlerBase), typeof(T), ServiceLifetime.Singleton));
-            return this;
-        }
-
         public IJT808UdpNettyBuilder ReplaceSessionService<T>() where T : IJT808UdpSessionService
         {
             Instance.JT808Builder.Services.Replace(new ServiceDescriptor(typeof(IJT808UdpSessionService), typeof(T), ServiceLifetime.Singleton));

src/JT808.DotNetty.Udp/JT808UdpDotnettyExtensions.cs

@@ -3,13 +3,11 @@ using JT808.DotNetty.Core.Codecs;
 using JT808.DotNetty.Core.Handlers;
 using JT808.DotNetty.Core.Impls;
 using JT808.DotNetty.Core.Interfaces;
-using JT808.DotNetty.Core.Jobs;
 using JT808.DotNetty.Core.Services;
 using JT808.DotNetty.Internal;
 using JT808.DotNetty.Udp.Handlers;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using Microsoft.Extensions.Internal;
 using System;
 using System.Runtime.CompilerServices;
 
@@ -21,16 +19,12 @@ namespace JT808.DotNetty.Udp
     {
         public static IJT808UdpNettyBuilder AddJT808UdpNettyHost(this IJT808NettyBuilder jT808NettyBuilder)
         {
-            jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UdpCustomMsgIdHandler, JT808UdpCustomMsgIdHandlerEmpty>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UdpSessionService, JT808UdpSessionService>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808DatagramPacket, JT808DatagramPacketImpl>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<IJT808UnificationUdpSendService, JT808UnificationUdpSendService>();
             jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<JT808UdpSessionManager>();
-            jT808NettyBuilder.JT808Builder.Services.TryAddSingleton<JT808MsgIdUdpHandlerBase, JT808MsgIdDefaultUdpHandler>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808UdpDecoder>();
             jT808NettyBuilder.JT808Builder.Services.TryAddScoped<JT808UdpServerHandler>();
-            jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808UdpAtomicCouterResetDailyJob>();
-            jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808UdpTrafficResetDailyJob>();
             jT808NettyBuilder.JT808Builder.Services.AddHostedService<JT808UdpServerHost>();
             return new JT1078UdpBuilderDefault(jT808NettyBuilder);
         }

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

@@ -18,8 +18,6 @@ namespace JT808.DotNetty.WebApi.Handlers
 
         private readonly JT808AtomicCounterService jT808UdpAtomicCounterService;
 
-        private readonly JT808TransmitAddressFilterService jT808TransmitAddressFilterService;
-
         private readonly IJT808TcpSessionService jT808TcpSessionService;
 
         private readonly IJT808UdpSessionService jT808UdpSessionService;
@@ -28,32 +26,19 @@ namespace JT808.DotNetty.WebApi.Handlers
 
         private readonly IJT808UnificationUdpSendService jT808UnificationUdpSendService;
 
-        private readonly JT808TrafficService jT808TcpTrafficService;
-
-        private readonly JT808TrafficService jT808UdpTrafficService;
-
-        private readonly JT808SimpleSystemCollectService jT808SimpleSystemCollectService;
-
         /// <summary>
         /// TCP一套注入
         /// </summary>
         /// <param name="jT808TcpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
-            JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-            JT808TrafficServiceFactory  jT808TrafficServiceFactory,
             IJT808UnificationTcpSendService jT808UnificationTcpSendService,
             IJT808TcpSessionService jT808TcpSessionService,
-            JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
             JT808AtomicCounterServiceFactory  jT808AtomicCounterServiceFactory
             )
         {
-            this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808TcpTrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.tcp);
             this.jT808UnificationTcpSendService = jT808UnificationTcpSendService;
-            this.jT808TcpSessionService = jT808TcpSessionService;
-            this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
+            this.jT808TcpSessionService = jT808TcpSessionService; 
             this.jT808TcpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.tcp);
-            InitCommonRoute();
             InitTcpRoute();
         }
 
@@ -62,19 +47,14 @@ namespace JT808.DotNetty.WebApi.Handlers
         /// </summary>
         /// <param name="jT808UdpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
-            JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-            JT808TrafficServiceFactory jT808TrafficServiceFactory,
             IJT808UdpSessionService jT808UdpSessionService,
             IJT808UnificationUdpSendService jT808UnificationUdpSendService,
             JT808AtomicCounterServiceFactory jT808AtomicCounterServiceFactory
             )
         {
-            this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808UdpTrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.udp);
             this.jT808UdpSessionService = jT808UdpSessionService;
             this.jT808UnificationUdpSendService = jT808UnificationUdpSendService;
             this.jT808UdpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.udp);
-            InitCommonRoute();
             InitUdpRoute();
         }
 
@@ -84,27 +64,19 @@ namespace JT808.DotNetty.WebApi.Handlers
         /// <param name="jT808TcpAtomicCounterService"></param>
         /// <param name="jT808UdpAtomicCounterService"></param>
         public JT808MsgIdDefaultWebApiHandler(
-             JT808SimpleSystemCollectService jT808SimpleSystemCollectService,
-             JT808TrafficServiceFactory jT808TrafficServiceFactory,
              IJT808UnificationTcpSendService jT808UnificationTcpSendService,
              IJT808UnificationUdpSendService jT808UnificationUdpSendService,
              IJT808TcpSessionService jT808TcpSessionService,
              IJT808UdpSessionService jT808UdpSessionService,
-             JT808TransmitAddressFilterService jT808TransmitAddressFilterService,
             JT808AtomicCounterServiceFactory jT808AtomicCounterServiceFactory
            )
         {
-            this.jT808SimpleSystemCollectService = jT808SimpleSystemCollectService;
-            this.jT808TcpTrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.tcp);
-            this.jT808UdpTrafficService = jT808TrafficServiceFactory.Create(JT808TransportProtocolType.udp);
             this.jT808UdpSessionService = jT808UdpSessionService;
             this.jT808UnificationTcpSendService = jT808UnificationTcpSendService;
             this.jT808UnificationUdpSendService = jT808UnificationUdpSendService;
             this.jT808TcpSessionService = jT808TcpSessionService;
-            this.jT808TransmitAddressFilterService = jT808TransmitAddressFilterService;
             this.jT808TcpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.tcp);
             this.jT808UdpAtomicCounterService = jT808AtomicCounterServiceFactory.Create(JT808TransportProtocolType.udp);
-            InitCommonRoute();
             InitTcpRoute();
             InitUdpRoute();
         }
@@ -161,44 +133,6 @@ namespace JT808.DotNetty.WebApi.Handlers
             return CreateJT808HttpResponse(result);
         }
 
-        /// <summary>
-        /// 添加转发过滤地址
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse AddTransmitAddress(JT808HttpRequest request)
-        {
-            if (string.IsNullOrEmpty(request.Json))
-            {
-                return EmptyHttpResponse();
-            } 
-            return CreateJT808HttpResponse(jT808TransmitAddressFilterService.Add(request.Json));
-        }
-
-        /// <summary>
-        /// 删除转发过滤地址（不能删除在网关服务器配置文件配的地址）
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse RemoveTransmitAddress(JT808HttpRequest request)
-        {
-            if (string.IsNullOrEmpty(request.Json))
-            {
-                return EmptyHttpResponse();
-            }
-            return CreateJT808HttpResponse(jT808TransmitAddressFilterService.Remove(request.Json));
-        }
-
-        /// <summary>
-        /// 获取转发过滤地址信息集合
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse GetTransmitAll(JT808HttpRequest request)
-        {
-            return CreateJT808HttpResponse(jT808TransmitAddressFilterService.GetAll());
-        }
-
         /// <summary>
         /// 获取Tcp包计数器
         /// </summary>
@@ -265,61 +199,12 @@ namespace JT808.DotNetty.WebApi.Handlers
             return CreateJT808HttpResponse(result);
         }
 
-        /// <summary>
-        /// 基于Tcp的流量获取
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse TrafficTcpGet(JT808HttpRequest request)
-        {
-            JT808ResultDto<JT808TrafficInfoDto> jT808ResultDto = new JT808ResultDto<JT808TrafficInfoDto>();
-            jT808ResultDto.Data = new JT808TrafficInfoDto();
-            jT808ResultDto.Data.TotalReceiveSize = (jT808TcpTrafficService.TotalReceiveSize * 1.0) / 1024;
-            jT808ResultDto.Data.TotalSendSize = (jT808TcpTrafficService.TotalSendSize * 1.0) / 1024;
-            return CreateJT808HttpResponse(jT808ResultDto);
-        }
-
-        /// <summary>
-        /// 基于Udp的流量获取
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse TrafficUdpGet(JT808HttpRequest request)
-        {
-            JT808ResultDto<JT808TrafficInfoDto> jT808ResultDto = new JT808ResultDto<JT808TrafficInfoDto>();
-            jT808ResultDto.Data = new JT808TrafficInfoDto();
-            jT808ResultDto.Data.TotalReceiveSize = (jT808UdpTrafficService.TotalReceiveSize * 1.0) / 1024;
-            jT808ResultDto.Data.TotalSendSize = (jT808UdpTrafficService.TotalSendSize * 1.0) / 1024;
-            return CreateJT808HttpResponse(jT808ResultDto);
-        }
-
-        /// <summary>
-        /// 获取当前系统进程使用率
-        /// </summary>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public JT808HttpResponse SystemCollectGet(JT808HttpRequest request)
-        {
-            JT808ResultDto<JT808SystemCollectInfoDto> jT808ResultDto = new JT808ResultDto<JT808SystemCollectInfoDto>();
-            jT808ResultDto.Data = jT808SimpleSystemCollectService.Get();
-            return CreateJT808HttpResponse(jT808ResultDto);
-        }
-
-        protected virtual void InitCommonRoute()
-        {
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.SystemCollectGet, SystemCollectGet);
-        }
-
         protected virtual void InitTcpRoute()
         {
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.TransmitAdd, AddTransmitAddress);
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.TransmitRemove, RemoveTransmitAddress);
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.TransmitGetAll, GetTransmitAll);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.GetTcpAtomicCounter, GetTcpAtomicCounter);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.SessionTcpGetAll, GetTcpSessionAll);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.SessionTcpRemoveByTerminalPhoneNo, RemoveTcpSessionByTerminalPhoneNo);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.UnificationTcpSend, UnificationTcpSend);
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.TrafficTcpGet, TrafficTcpGet);
         }
 
         protected virtual void InitUdpRoute()
@@ -328,7 +213,6 @@ namespace JT808.DotNetty.WebApi.Handlers
             CreateRoute(JT808Constants.JT808WebApiRouteTable.UnificationUdpSend, UnificationUdpSend);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.SessionUdpGetAll, GetUdpSessionAll);
             CreateRoute(JT808Constants.JT808WebApiRouteTable.SessionUdpRemoveByTerminalPhoneNo, RemoveUdpSessionByTerminalPhoneNo);
-            CreateRoute(JT808Constants.JT808WebApiRouteTable.TrafficUdpGet, TrafficUdpGet);
         }
     }
 }

src/JT808.DotNetty.WebApiClientTool/IJT808DotNettyWebApi.cs

@@ -29,38 +29,12 @@ namespace JT808.DotNetty.WebApiClientTool
         [HttpPost("Tcp/UnificationSend")]
         ITask<JT808ResultDto<bool>> UnificationTcpSend([JsonContent]JT808UnificationSendRequestDto jT808UnificationSendRequestDto);
         /// <summary>
-        /// 添加转发过滤地址
-        /// </summary>
-        /// <param name="jT808IPAddressDto"></param>
-        /// <returns></returns>
-        [HttpPost("Tcp/Transmit/Add")]
-        ITask<JT808ResultDto<bool>> AddTransmitAddress([JsonContent]JT808IPAddressDto jT808IPAddressDto);
-        /// <summary>
-        /// 删除转发过滤地址（不能删除在网关服务器配置文件配的地址）
-        /// </summary>
-        /// <param name="jT808IPAddressDto"></param>
-        /// <returns></returns>
-        [HttpPost("Tcp/Transmit/Remove")]
-        ITask<JT808ResultDto<bool>> RemoveTransmitAddress([JsonContent]JT808IPAddressDto jT808IPAddressDto);
-        /// <summary>
-        /// 获取转发过滤地址信息集合
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet("Tcp/Transmit/GetAll")]
-        ITask<JT808ResultDto<List<string>>> GetTransmitAll();
-        /// <summary>
         /// 获取Tcp包计数器
         /// </summary>
         /// <param name="uri"></param>
         /// <returns></returns>
         [HttpGet("Tcp/GetAtomicCounter")]
         ITask<JT808ResultDto<JT808AtomicCounterDto>> GetTcpAtomicCounter();
-        /// <summary>
-        /// 基于Tcp的流量获取
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet("Tcp/Traffic/Get")]
-        ITask<JT808ResultDto<JT808TrafficInfoDto>> GetTcpTraffic();
 
         #endregion
 
@@ -87,26 +61,11 @@ namespace JT808.DotNetty.WebApiClientTool
         [HttpPost("Udp/UnificationSend")]
         ITask<JT808ResultDto<bool>> UnificationUdpSend([JsonContent]JT808UnificationSendRequestDto jT808UnificationSendRequestDto);
         /// <summary>
-        /// 基于Udp的流量获取
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet("Udp/Traffic/Get")]
-        ITask<JT808ResultDto<JT808TrafficInfoDto>> GetUdpTraffic();
-        /// <summary>
         /// 获取Udp包计数器
         /// </summary>
         /// <returns></returns>
         [HttpGet("Udp/GetAtomicCounter")]
         ITask<JT808ResultDto<JT808AtomicCounterDto>> GetUdpAtomicCounter();
         #endregion
-
-        #region 公共部分
-        /// <summary>
-        /// 获取当前系统进程使用率
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet("SystemCollect/Get")]
-        ITask<JT808ResultDto<JT808SystemCollectInfoDto>> GetSystemCollect();
-        #endregion
     }
 }