Netty 聊天小程序

　　这节讲解基于 Netty 快速实现一个聊天小程序。

一、服务端

1. SimpleChatServerHandler（处理器类）

　　该类主要实现了接收来自客户端的消息并转发给其他客户端。

/**
 * 服务端处理器
 */
public class SimpleChatServerHandler extends SimpleChannelInboundHandler<String> {
    public static ChannelGroup channels 
        = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    
    /**
     * 收到新的客户端连接时调用
     * 将客户端channel存入列表，并广播消息
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        // 广播加入消息
        channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 加入
");
        channels.add(incoming);        // 存入列表    
    }
    
    /**
     * 客户端连接断开时调用
     * 广播消息
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        // 广播离开消息
        channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 离开
");
        // channel会自动从ChannelGroup中删除 
    }
    
    /**
     * 收到消息时调用
     * 将消息转发给其他客户端
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel incoming = ctx.channel();
        for(Channel channel : channels) {        // 遍历所有连接的客户端
            if(channel != incoming) {            // 其他客户端
                channel.writeAndFlush("[" + incoming.remoteAddress() + "] " + msg + "
" );
            } else {                            // 自己
                channel.writeAndFlush("[you] " + msg + "
" );
            }
        }
    }
    
    /**
     * 监听到客户端活动时调用
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 在线");
    }
    
    /**
     * 监听到客户端不活动时调用
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 掉线");
    }
    
    /**
     * 当Netty由于IO错误或者处理器在处理事件抛出异常时调用
     * 关闭连接
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("SimpleChatClient: " + incoming.remoteAddress() + " 异常");
    }
}

2. SimpleChatServerInitializer（配置 Channel 类）

 　　该类添加分隔符协议处理类，解码、编码器还有自定义处理器。

/**
 * 服务器配置初始化
 * 添加多个处理器
 */
public class SimpleChatServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 添加处理类
        // 使用'
''
'分割帧
        pipeline.addLast("framer", 
                new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
        // 解码、编码器
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());
        // 处理器
        pipeline.addLast("handler", new SimpleChatServerHandler());
        
        System.out.println("SimpleChatClient: " + ch.remoteAddress() + "连接上");
    }

}

3. SimpleChatServer（服务端主程序）

　　启动服务端。

/**
 * 服务端 main 启动
 */
public class SimpleChatServer {
    private int port;        // 端口
    
    public SimpleChatServer(int port) {
        this.port = port;
    }
    
    // 配置并开启服务器
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();        // 用来接收进来的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();    // 用来处理已接收的连接
        
        try {
            ServerBootstrap sb = new ServerBootstrap();            // 启动NIO服务的辅助启动类
            sb.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)                // 设置如何接受连接
                .childHandler(new SimpleChatServerInitializer())    // 配置Channel
                .option(ChannelOption.SO_BACKLOG, 128)                // 设置缓冲区
                .childOption(ChannelOption.SO_KEEPALIVE, true);    // 启用心跳机制
            
            System.out.println("SimpleChatServer 启动了");
            ChannelFuture future = sb.bind(port).sync();        // 绑定端口，开始接收连接
            future.channel().closeFuture().sync();                // 等待关闭服务器（不会发生）
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
            System.out.println("SimpleChatServer 关闭了");
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new SimpleChatServer(port).run();     // 开启服务器
    }
}

 二、客户端

1. SimpleChatClientHandler（处理器类）

　　直接输出收到的消息。

/**
 * 客户端处理类
 * 直接输出收到的消息
 */
public class SimpleChatClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg);    // 直接输出消息        
    }

}

 2. SimpleChatClientInitializer（配置 Channel 类）

 　　与服务端类似。

/**
 * 客户端配置初始化
 * 与服务端类似
 */
public class SimpleChatClientInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 添加处理类
        // 使用'
''
'分割帧
        pipeline.addLast("framer", 
                new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
        // 解码、编码器
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());
        // 处理器
        pipeline.addLast("handler", new SimpleChatClientHandler());
    }

}

 3. SimpleChatClient（客户端主程序）

 　　接收来自控制台的消息，每帧以 " " 结尾，再发给服务端。

/**
 * 客户端
 * 开启客户端，接收控制台输入并发送给服务端
 */
public class SimpleChatClient {
    private final String host;        // IP
    private final int port;        // 端口
    
    public SimpleChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    
    // 配置并运行客户端
    public void run() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();        // 客户端辅助启动类
            b.group(group)                                    // 客户端只需要一个用来接收并处理连接
                .channel(NioSocketChannel.class)            // 设置如何接受连接
                .handler(new SimpleChatClientInitializer());// 配置 channel
            // 连接服务器
            Channel channel = b.connect(host, port).sync().channel();
            // 读取控制台输入字符
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            while(true) {
                // 每行成一帧输出，以"
"结尾
                channel.writeAndFlush(in.readLine() + "
");
            }
        } catch (Exception e) {
            e.printStackTrace();        // 输出异常
        } finally {
            group.shutdownGracefully();    // 关闭
        }
    }
    
    public static void main(String[] args) throws Exception {
        new SimpleChatClient("localhost", 8080).run();        // 启动客户端
    }

}

三、运行效果 

 　　先运行服务端程序，然后在运行两次客户端程序，如下：

　　服务端输出：

　　

　　首先连接的客户端输出：

　　

　　随便选个客户端在控制台输出信息并回车，如下：

　　 自身输出：

　　

　　另一客户端输出：

　　

　　以上……