Présentation de l'API Netty Core

ChannelHandler et sa classe d'implémentation

L'interface ChannelHandler définit de nombreuses méthodes de gestion des événements et nous pouvons implémenter une logique métier spécifique en réécrivant ces méthodes.

Parmi elles, ChannleInboundHandlerAdapter et ChannelOutboundHandlerAdapter sont les classes les plus couramment utilisées. Nous devons souvent personnaliser un gestionnaire pour hériter de ChannelInboundHandlerAdatper, puis réécrire la logique métier correspondante:

public void channelActive (ChannelHandlerContext ctx), événement channel ready
public void channelRead (ChannelHandlerContext ctx, Object msg), événement de données de lecture de canal
public void channelReadComplete (ChannelHandlerContext ctx), événement de lecture complète des données
public void exceptionCaught (ChannelHandlerContext ctx, Throwable cause), un événement d'exception se produit dans le canal

pipline 和 ChannelPipeline

ChannelPipeLine est une collection de Handlers, qui est responsable du traitement et de l'interception des événements et opérations entrants ou sortants, ce qui équivaut à une chaîne qui traverse Netty.

ChannelPipeline addFirst (ChannelHandler ... handlers ), ajoutez une classe de traitement métier (handler) à la première position de la chaîne .
ChannelPipeline addLast (ChannelHandler ... handlers ), ajoute une classe de traitement métier à la dernière position de la chaîne .

ChannelHandlerContext

Il s'agit de l'objet de contexte du gestionnaire d'événements, le nœud de traitement réel dans la chaîne Pipeline. Chaque nœud de traitement ChannelHandlerContext contient un processeur de temps spécifique ChannelHandler, et ChannelHandlerContext lie également les informations de pipeline et de canal correspondantes pour faciliter l'ajustement de ChannelHandler. Les méthodes couramment utilisées sont les suivantes:

ChannelFuture close (). Ferme la chaîne (chaîne associée)
ChannelOutboundInvoker flush (), actualiser
ChannelFuture writeAndFlush (Object msg), écrivez les données dans le ChannelHandler suivant du ChannelHandler actuel dans ChannelPipeline pour démarrer le traitement (sortant)

ChannelOption

Une fois que Netty a créé une instance Channel, il doit généralement définir le paramètre ChannelOption. ChannelOption est un paramètre standard de Socket, pas un original Netty. Les configurations de paramètres couramment utilisées sont:

1. ChannelOption.SO_BACKLOG définit la taille de la file d'attente

Correspondant au paramètre backlog dans la fonction d'écoute du protocole TCP / IP, il est utilisé pour initialiser la taille de la file d'attente connectable du serveur . Le serveur traite les demandes de connexion client dans l'ordre, de sorte qu'une seule connexion client peut être traitée en même temps. Lorsque plusieurs clients arrivent, le serveur place les demandes de connexion client qui ne peuvent pas être traitées dans la file d'attente pour traitement et le paramètre backlog spécifie la taille de la file d'attente.

2. ChannelOption.SO_KEEPLIVE, reste connecté tout le temps.

ChannelFuture

Toutes les opérations d'E / S dans Netty sont asynchrones. Les appels d'E / S seront retournés directement et l'appelant ne peut pas obtenir le résultat immédiatement, mais l'état de traitement des opérations d'E / S peut être obtenu via ChannelFuture, similaire à java.io .nio + java.util.Current.

Channel channel (), retourne le canal en cours d'opération IO
ChannelFuture sync (), attendez la fin de l'opération asynchrone

EventLoopGroup et sa classe d'implémentation NioEventLoopGroup [thread unique]

EventLoopGroup est une abstraction d'un groupe d'EventLoops. Afin de mieux utiliser les ressources du processeur multicœur, Netty dispose généralement de plusieurs EventLoops fonctionnant en même temps, et chaque EventLoop gère une instance de Selector.

EventLoopGroup fournit l'interface suivante, qui peut obtenir l'un des EventLoops du groupe selon certaines règles pour traiter les tâches. Dans la programmation côté serveur Netty, nous devons généralement fournir deux EventLoopGroup, par exemple: BossEventLoopGroup et WorkerEventLoopGroup.

Habituellement, un port de service, c'est-à-dire qu'un ServerSocketChannel correspond à un sélecteur et à un thread EventLoop. BossEventLoop est responsable de la réception des connexions client et de la transmission de SocketChannel à WorkerEventLoopGroup pour le traitement des E / S.

BossEventLoopGroup est généralement un EventLoop à thread unique . EventLoop gère une instance de Selector enregistrée auprès de ServerSocketChannel. BossEventLoop interroge en permanence le Selector pour séparer les événements de connexion, généralement l'événement OP_ACCEPT, puis transmet le SocketChannel reçu au WorkerEventLoopGroup, et
WorkerEventLoopGroup sera utilisé. par le suivant (Implémentation de l'interface Iterable) Sélectionnez l'un des EventLoopGroup pour enregistrer le SocketChannel dans le sélecteur qu'il gère et traiter ses événements IO ultérieurs.
Les méthodes courantes sont les suivantes:

public NioEventLoopGroup (), méthode de construction
public Future <?> shutownGracefully (), déconnectez, fermez le fil [appel à la fin]

ServerBootstrap et Bootstrap [configuration au démarrage]

serverBootstrap est l'assistant de démarrage côté serveur dans Netty, à travers lequel diverses configurations côté serveur peuvent être complétées; Bootstrap est l'assistant côté client dans Netty, à travers lequel diverses configurations du serveur peuvent être complétées; Bootstrap est le démarrage côté client assistant dans Netty, à travers Il peut compléter diverses configurations du client.

public ServerBootstrap group (EventLoopGroup parentGroup, EventLoopGroup childGroup (, cette méthode est utilisée côté serveur pour définir deux EventLoop
groupe public B (groupe EventLoopGroup), cette méthode est utilisée côté client pour mettre en place un EventLoop
canal B public (Class <? extend C> channelClass), cette méthode permet de définir la réalisation du canal d'un serveur
option public <T> B (option ChannelOption <T>, valeur T), utilisée pour ajouter la configuration à ServerChannel
public <T> ServerBootstrap childOption (ChannelOption <T> childOption, valeur T), utilisée pour ajouter la configuration au canal reçu
public ServerBootstrap childHandler (ChannelHandler childHandler), cette méthode est utilisée pour définir la classe de traitement métier (gestionnaire personnalisé
public ChannelFuture bind (int inetPort), cette méthode est utilisée côté serveur pour définir le numéro de port occupé
public ChannelFuture connect (String inetHost, int inetPort), cette méthode est utilisée côté client pour se connecter au serveur

Exemples:

Terminal de service

public class NettyServer {
    public static void main(String[] args) throws Exception{
        //1. 创建一个线程组：接收客户端连接
        EventLoopGroup bossGroup =new NioEventLoopGroup();
        //2. 创建一个线程组：处理网络操作
        EventLoopGroup workerGroup =new NioEventLoopGroup();
        //3. 创建服务器端启动助手来配置参数
        ServerBootstrap b=new ServerBootstrap();
        b.group(bossGroup,workerGroup) //4.设置两个线程组
         .channel(NioServerSocketChannel.class) //5.使用NioServerSocketChannel作为服务器端通道的实现
         .option(ChannelOption.SO_BACKLOG,128) //6.设置线程队列中等待连接的个数
         .childOption(ChannelOption.SO_KEEPALIVE,true) //7.保持活动连接状态
         .childHandler(new ChannelInitializer<SocketChannel>() {  //8. 创建一个通道初始化对象
             public void initChannel(SocketChannel sc){   //9. 往Pipeline链中添加自定义的handler类
                 sc.pipeline().addLast(new NettyServerHandler());
             }
         });
        System.out.println("......Server is ready......");
        ChannelFuture cf=b.bind(9999).sync();  //10. 绑定端口 bind方法是异步的  sync方法是同步阻塞的
        System.out.println("......Server is starting......");

        //11. 关闭通道，关闭线程组
        cf.channel().closeFuture().sync(); //异步
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

Client

//网络客户端
public class NettyClient {
    public static void main(String[] args) throws  Exception{

        //1. 创建一个线程组
        EventLoopGroup group=new NioEventLoopGroup();
        //2. 创建客户端的启动助手，完成相关配置
        Bootstrap b=new Bootstrap();
        b.group(group)  //3. 设置线程组
         .channel(NioSocketChannel.class)  //4. 设置客户端通道的实现类
         .handler(new ChannelInitializer<SocketChannel>() {  //5. 创建一个通道初始化对象
             @Override
             protected void initChannel(SocketChannel socketChannel) throws Exception {
                 socketChannel.pipeline().addLast(new NettyClientHandler()); //6.往Pipeline链中添加自定义的handler
             }
         });
        System.out.println("......Client is  ready......");

        //7.启动客户端去连接服务器端  connect方法是异步的   sync方法是同步阻塞的
        ChannelFuture cf=b.connect("127.0.0.1",9999).sync();

        //8.关闭连接(异步非阻塞)
        cf.channel().closeFuture().sync();

    }
}

Classe non groupée

Il s'agit d'une classe d'outils spécialement utilisée pour manipuler les tampons fournis par Netty. Les méthodes courantes sont les suivantes:

pulic static ByteBuf copiedBuffer (CharSequence string, Charset charsht), renvoie un objet ByteBuf avec les données et le codage de caractères donnés (similaire à l'objet ByteBuffer dans NIO)

 //数据读取完毕事件
    public void channelReadComplete(ChannelHandlerContext ctx){
        ctx.writeAndFlush(Unpooled.copiedBuffer("就是没钱",CharsetUtil.UTF_8));
    }
.