说明

Netty 的入门练习，使用 Netty 模拟多人聊天室的功能，不考虑高并发，只实现基础聊天功能和提示上下线。

交互逻辑

Client

• 连接服务端成功后，打印本客户端信息Ip:Port
• 读取用户客户端的键盘输入，发送给服务器，服务器转发给其他客户端

Server

• 服务端感知到某个客户端上线后，给其他所有客户端发消息提示上线
• 服务端感知到某个客户端下线后，给其他所有客户端发消息提示下线，统计当前活跃客户端
• 读取到客户端的消息后，转发给所有客户端

代码实现

1. 导包

		<dependency>
			<groupId>io.netty</groupId>
			<artifactId>netty-all</artifactId>
			<version>4.1.35.Final</version>
		</dependency>

2. 创建ChatServer，用于启动服务端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class ChatServer {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();

                            // 加入 编解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());

                            // 加入 自己的业务处理
                            pipeline.addLast(new ChatServerHandler());
                        }
                    });
            System.out.println("聊天室启动...");
            ChannelFuture channelFuture = serverBootstrap.bind(9000).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

3. 创建ChatServerHandler，实现具体业务

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.text.SimpleDateFormat;

/**
 * 用户上线时，打印  [ 客户端 ] xxx 上线了
 * 用户离线时，打印  [ 客户端 ] xxx 下线了
 * 用户发消息时
 *      如果不在自己的窗口，打印  [ 客户端 ] xxx 发送了消息 xxx
 *      如果在自己的窗口，打印   [ 自己 ] 发送了消息 xxx
 */
public class ChatServerHandler extends SimpleChannelInboundHandler<String> {

    //GlobalEventExecutor.INSTANCE 是全局的事件执行器，是一个单例，可以看做 所有客户端的集合
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


    /**
     * 功能：提示上线
     * 实现：当某个客户端上线时（channel 处于就绪状态），给其他所有客户端发送 该客户端上线消息
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        //将该客户加入聊天的信息推送给其它在线的客户端
        //该方法会将 channelGroup 中所有的 channel 遍历，并发送消息
        channelGroup.writeAndFlush("[ 客户端 ]" + channel.remoteAddress() + " 上线了 " + sdf.format(new
                java.util.Date()) + "\n");
        //将当前 channel 加入到 channelGroup
        channelGroup.add(channel);
        System.out.println("[ 客户端 ]" + ctx.channel().remoteAddress() + " 上线了 " + sdf.format(new java.util.Date()) + "\n");
    }

    /**
     * 功能：提示下线
     * 实现：当某个客户端下线时（channel 处于非就绪状态），给其他所有客户端发送 该客户端下线消息
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        //将客户离开信息推送给当前在线的客户
        channelGroup.writeAndFlush("[ 客户端 ]" + channel.remoteAddress() + " 下线了" + "\n");
        System.out.println("[ 客户端 ]" + channel.remoteAddress() + " 下线了");
        System.out.println("剩余客户端个数 = " + channelGroup.size() + "\n");
    }

    //读取某个客户端数据，转发给其他客户端
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        //获取到当前 channel
        Channel channel = ctx.channel();
        //这时我们遍历 channelGroup, 根据不同的情况， 回送不同的消息
        channelGroup.forEach(ch -> {
            if (channel != ch) { //不是当前的 channel,转发消息
                ch.writeAndFlush("[ 客户端 ]" + channel.remoteAddress() + " 发送了消息：" + msg + "\n");
            } else {//回显自己发送的消息给自己
                ch.writeAndFlush("[ 自己 ]发送了消息：" + msg + "\n");
            }
        });
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        //关闭通道
        ctx.close();
    }

}

4. 创建ChatClient，启动客户端

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

public class ChatClient {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();

                            // 添加编解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            // 添加自己的业务逻辑
                            pipeline.addLast(new ChatClientHandler());

                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9000).sync();
            Channel channel = channelFuture.channel();
            // 打印 当前客户端信息
            System.out.println("========" + channel.localAddress() + "========");
            // 从键盘读取 当前客户端 的消息，发给服务端
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                channel.writeAndFlush(msg);
            }
        } finally {
            group.shutdownGracefully();
        }
    }
}

5. 创建 ChatClientHandler，实现客户端业务逻辑

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

public class ChatClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // 客户端收到 服务端消息，去掉尾部回车 后，打印到屏幕
        System.out.println(msg.trim());
    }
}

运行

1. 先执行 ChatServer 的 main 方法，启动服务端，查看日志
2. 执行 ChatClient 的 main 方法，启动第一个客户端，查看日志
3. 执行 ChatClient 的 main 方法，启动第二个客户端，查看日志
4. 选择第一个客户端，发送消息，查看日志
5. 关闭第二个客户端，查看日志
   

注：如果不能开启多个客户端，可按如下设置