nhet_cn_back_charger/HybirdFrameworkDriver/TcpServer/TcpServer.cs

using System.Reflection;
using Autofac;
using Autofac.Core;
using DotNetty.Codecs;
using DotNetty.Handlers.Logging;
using DotNetty.Handlers.Timeout;
using DotNetty.Transport.Bootstrapping;
using DotNetty.Transport.Channels;
using DotNetty.Transport.Channels.Sockets;
using HybirdFrameworkCore.Autofac;
using HybirdFrameworkCore.Autofac.Attribute;
using log4net;

namespace HybirdFrameworkDriver.TcpServer
{
    /// <summary>
    /// netty server
    /// </summary>
    public class TcpServer <TH, TD, TE> : IDisposable where TH : IChannelHandler where TD: ByteToMessageDecoder,new() where TE: ChannelHandlerAdapter, new()
    {
       private static readonly ILog Log = LogManager.GetLogger(typeof(TcpServer<TH, TD, TE>));

        static MultithreadEventLoopGroup? bossGroup;
        static MultithreadEventLoopGroup? workerGroup;
        static ServerBootstrap? bootstrap;

        private int _port = 9000;

        public TcpServer()
        {
            bossGroup = new MultithreadEventLoopGroup();
            workerGroup = new MultithreadEventLoopGroup();
            bootstrap = new ServerBootstrap();
            bootstrap
                .Group(bossGroup, workerGroup) // 设置主和工作线程组
                .Channel<TcpServerSocketChannel>() // 设置通道模式为TcpSocket
                .Option(ChannelOption.SoKeepalive, true) //保持连接
                .Handler(new LoggingHandler())
                .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel =>
                {
                    var serverListenerHandler = new ServerListenerHandler<TH, TD, TE>();
                    IChannelPipeline pipeline = channel.Pipeline;
                    pipeline.AddLast(new LoggingHandler(""));
                    pipeline.AddLast(serverListenerHandler);
                    pipeline.AddLast(new IdleStateHandler(0, 0, 180)); //检测空闲连接
                    //业务handler ，这里是实际处理业务的Handler

                    ResolveEncode(pipeline);
                    ResolveDecode(pipeline);
                    ResolveHandler(pipeline);
                }));
        }

        private void ResolveEncode(IChannelPipeline pipeline)
        {
            pipeline.AddLast(new TE());
        }
        
        private void ResolveDecode(IChannelPipeline pipeline)
        {
            pipeline.AddLast(new TD());
        }

        private void ResolveHandler(IChannelPipeline pipeline)
        {
            List<Type> list = new List<Type>();
        
            foreach (IComponentRegistration reg in AppInfo.Container.ComponentRegistry.Registrations)
            {
                foreach (Service service in reg.Services)
                {
                    if (service is TypedService ts)
                    {
                        if (MatchHandlers(ts))
                        {
                            list.Add(ts.ServiceType);
                        }
                    }
                }
            }

            List<TH> handlers = new List<TH>();
            foreach (var type in list)
            {
                object resolve = AppInfo.Container.Resolve(type);
                handlers.Add((TH) resolve);
            }
        
            handlers.Sort((handler, msgHandler) =>
            {
                OrderAttribute? orderAttribute1 = handler.GetType().GetCustomAttribute<OrderAttribute>();
                OrderAttribute? orderAttribute2 = msgHandler.GetType().GetCustomAttribute<OrderAttribute>();
                int h1Order = orderAttribute1?.Order ?? 0;
                int h2Order = orderAttribute2?.Order ?? 0;
                return h1Order.CompareTo(h2Order);
            });
            foreach (var msgHandler in handlers)
            {
                pipeline.AddLast((IChannelHandler)msgHandler);
            }
        }
        
        private bool MatchHandlers(TypedService ts)
        {
            Type[] interfaces = ts.ServiceType.GetInterfaces();
            if (interfaces.Length > 0)
            {
                foreach (Type type in interfaces)
                {
                    if (type == typeof(TH))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        public void Start(int port)
        {
            _port = port;
            Log.Info(" Start Listen");
            Task<IChannel>? channel = bootstrap?.BindAsync(_port);
            Log.Info($"netty success listen {_port}");
        }


        /// <summary>
        /// ??netty
        /// </summary>
        public void Dispose()
        {
            Log.Info(this + " Dispose");
            bossGroup?.ShutdownGracefullyAsync();
        }
    }
}