Netty 快速入门系列 - Chapter 3 Netty5.x【第九讲】 - 单客户多Client 重连

最新推荐文章于 2025-08-20 09:15:47 发布

原创最新推荐文章于 2025-08-20 09:15:47 发布 · 274 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Netty

Netty框架同时被 3 个专栏收录

22 篇文章

订阅专栏

RPC 框架

22 篇文章

订阅专栏

Netty 快速入门系列

22 篇文章

订阅专栏

本文介绍了一个使用Netty实现的多客户端连接管理方案。该方案通过递归方式获取可用Channel，并在Channel失效时尝试重新建立连接。文章还提供了一个控制台输入功能，允许用户向任一活动连接发送消息。

MultipleNetty5Client ：学习getFirstChannel 通过递归，获取一个可用Channel

public Channel nextChannel() throws InterruptedException {
return getFirstChannel(0);

}

private Channel getFirstChannel(int tryCount) throws InterruptedException；

private List<Channel> channels; 保存单个客户，多个Client 连接

package com.john.netty.learn.ch05;


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoop;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;


public class MultipleNetty5Client {


  private String ip;


  private int port;


  private int count;


  private Bootstrap bootstrap;


  private List<Channel> channels;


  private EventLoopGroup workers = new NioEventLoopGroup();


  private AtomicLong index = new AtomicLong();


  public MultipleNetty5Client(String ip, int port, int count) {


     this.ip = ip;
     this.port = port;
     this.count = count;


     channels = new ArrayList<>(count);
  }


  public void connect() {


     this.bootstrap = new Bootstrap();


     this.bootstrap.group(this.workers);


     bootstrap.channel(NioSocketChannel.class);


     bootstrap.handler(new ChannelInitializer<Channel>() {


       @Override
       protected void initChannel(Channel ch) throws Exception {


          ch.pipeline().addLast(new StringDecoder());
          ch.pipeline().addLast(new StringEncoder());
          ch.pipeline().addLast(new MultClientHandler());
       }
     });


     for (int i = 0; i < this.count; i++) {


       channels.add(bootstrap.connect(this.ip, this.port).channel());


     }


  }


  public Channel nextChannel() throws InterruptedException {


     return getFirstChannel(0);
  }


  private Channel getFirstChannel(int tryCount) throws InterruptedException {


     Channel channel = channels.get((int) Math.abs(index.incrementAndGet() % channels.size()));


     if (!channel.isActive()) {


       reconnect(channel);


       // 重连
       if (tryCount >= channels.size()) {


          throw new IllegalAccessError("No Available Connection Channel!");
       }


       return getFirstChannel(++tryCount);
     }


     return channel;
  }


  private void reconnect(Channel channel) throws InterruptedException {


     synchronized (channel) {


       if (channel.isActive()) {
          return;
       }


       int indexOf = this.channels.indexOf(channel);


       if (indexOf == -1) {
          return;
       }


       channels.set(indexOf, bootstrap.connect(this.ip, this.port).sync().channel());


     }
  }


  public void console() throws Exception {


     BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in, "GBK"));


     while (true) {


       try {


          System.out.println("请输入:");


          String line = bufferedReader.readLine();


          this.send(line);


          if ("quit".equalsIgnoreCase(line)) {


            break;
          }


       } catch (Throwable e) {


       }
     }
  }


  private void send(String message) throws InterruptedException {


     this.nextChannel().writeAndFlush(message);


  }


  public static void main(String[] args) throws Exception {


     MultipleNetty5Client multipleNetty5Client = new MultipleNetty5Client("127.0.0.1", 23, 3);
     multipleNetty5Client.connect();
     multipleNetty5Client.console();
  }
}

MultClientHandler

package com.john.netty.learn.ch05;


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;


public class MultClientHandler extends SimpleChannelInboundHandler<String> {


  public MultClientHandler() {
  }


  @Override
  protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {

     System.out.println("Client Read message " + msg);
  }


  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {

     System.out.println("channelActive(ChannelHandlerContext " + ctx + ")");

  }


  @Override
  public void channelInactive(ChannelHandlerContext ctx) throws Exception {

     System.out.println("channelInactive(ChannelHandlerContext " + ctx + ")");

  }


}

所有源码下载：https://download.youkuaiyun.com/download/netcobol/10308871