<一起学netty>第一章：用netty开发多人聊天

<文章内容如有错误，烦请不吝赐教>

代码链接：https://github.com/levyc/NettyDemo/tree/master/src/chat

文章目录

关于netty框架
项目结构
代码分析
- 服务端代码分析
- 客户端代码分析

为什么使用netty框架

netty是一个基于NIO，异步的，事件驱动的网络通信框架。由于使用Java提供的NIO包中的API开发网络服务器代码量大，复杂，难保证稳定性。netty这类的网络框架应运而生。通过使用netty框架可以快速开发网络通信服务端，客户端。

项目结构

简单介绍一下项目。通过使用netty框架快速开发出简易多人聊天室，学会初步使用neety进行简单服务端与客户端的开发。

项目结构

Server端：

ServerMain:服务器启动类，负责服务器的绑定与启动
ServerChatHandler：核心类。负责连接消息的处理，数据的读写。
ServerIniterHandler：负责将多个Handlers组织进ChannelPipeline中。

Client端：

ClientMain：客户端启动类，负责客户端与服务器的连接，启动。
ClientChatHandler：核心类。负责连接消息的处理，数据读写。
ClientIniterHandler：负责将多个Handlers组织进ChannelPipeline中。

代码分析

服务端代码分析

ServerMain类

package chat.server;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;  
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class ServerMain {

private int port;

public ServerMain(int port) {
    this.port = port;
}

public static void main(String[] args) {
    new ServerMain(Integer.parseInt(args[0])).run();
}

public void run() {
    EventLoopGroup acceptor = new NioEventLoopGroup();
    EventLoopGroup worker = new NioEventLoopGroup();
    ServerBootstrap bootstrap = new ServerBootstrap();
    bootstrap.option(ChannelOption.SO_BACKLOG, 1024);
    bootstrap.group(acceptor, worker);//设置循环线程组，前者用于处理客户端连接事件，后者用于处理网络IO
    bootstrap.channel(NioServerSocketChannel.class);//用于构造socketchannel工厂
    bootstrap.childHandler(new ServerIniterHandler());//为处理accept客户端的channel中的pipeline添加自定义处理函数
    try {
        Channel channel = bootstrap.bind(port).sync().channel();//绑定端口（实际上是创建serversocketchannnel，并注册到eventloop上），同步等待完成，返回相应channel
        System.out.println("server strart running in port:" + port);
        channel.closeFuture().sync();//在这里阻塞，等待关闭
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        //优雅退出
        acceptor.shutdownGracefully();
        worker.shutdownGracefully();
        }
    }
}

EventLoopGroup：顾名思义，事件，循环，组，说白了即是用于管理多个channel的线程组。就好比一组进行循环使用的线程池中管理的线程。但是为什么分别有acceptor和worker2个呢？前者线程组负责连接的处理，即是用于接受客户端的连接，后者线程组负责handler消息数据的处理，即是用于处理SocketChannel网络读写
ServerBootstrap:简言之就是为服务器启动进行一些配置。调用的一些方法用处请看注释。

ServerChatHandler类

package chat.server;

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;

public class ChatServerHandler extends SimpleChannelInboundHandler {

public static final ChannelGroup group = new DefaultChannelGroup(
        GlobalEventExecutor.INSTANCE);

@Override
protected void channelRead0(ChannelHandlerContext arg0, String arg1)
        throws Exception {
    Channel channel = arg0.channel();
    for (Channel ch : group) {
        if (ch == channel) {
            ch.writeAndFlush("[you]：" + arg1 + "\n");
        } else {
            ch.writeAndFlush(
                    "[" + channel.remoteAddress() + "]: " + arg1 + "\n");
        }
    }

}

@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    for (Channel ch : group) {
        ch.writeAndFlush(
                "[" + channel.remoteAddress() + "] " + "is comming");
    }
    group.add(channel);
}

@Override
public voiced handlerRemoved(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    for (Channel ch : group) {
        ch.writeAndFlush(
                "[" + channel.remoteAddress() + "] " + "is comming");
    }
    group.remove(channel);
}

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    System.out.println("[" + channel.remoteAddress() + "] " + "online");
}

@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    System.out.println("[" + channel.remoteAddress() + "] " + "offline");
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
        throws Exception {
    System.out.println(
            "[" + ctx.channel().remoteAddress() + "]" + "exit the room");
    ctx.close().sync();
}
}

自定义的处理函类需要继承ChannelHandlerAdapter，我这里就直接继承SimpleChannelInboundHandler，后面的泛型代表接受的消息的类型。
因为多人聊天会有多个客户端连接进来，所以定义了一个ChannelGroup group去存储连接进来的channel当作在线用户。
下面介绍一下各方法的作用

channelRead0：当channel的可读就绪时，该方法被调用，即是接收到客户端发过来的消息时被调用。方法逻辑：遍历group，将当前发送信息的channel发送‘you say：＋消息体’，其余的channel则发送‘channle.remoteAdress＋消息体’

handlerAdded：当有客户端channel被连接进来时，该方法被调用。向在线的每个channel发送［IP］is comming

handlerRemoved:当有客户端channeld断开网络io，该方法被调用。向在线的每个channel发送［IP］is leaving

channelActive:当有客户端channeld活跃时，该方法被调用。向在线的每个channel发送［IP］online

channelInactive：当有客户端channeld不活跃时，该方法被调用。向在线的每个channel发送［IP］offline

exceptionCaught：当连接和网络io发生异常时被调用。

那么，大家一定有疑惑，网络通信中，消息有很多种载体，例如文件，图片，字符串，那么在我的客户端发送一个图片给你服务器，服务器又怎样知道你发的是图片呢？里面就涉及到两项技术，协议和编解码。图片和文件的传输后续再说，先从当前项目多人聊天说协议和编解码。

假定我们简易多人聊天只允许发送字符串聊天，那么客户端发送的字符串不可能直接就是字符串发送出去的，电路只能识别0和1，因此我们发送出去的字符串需要按某种编码格式编码成字节数组再发送出去，服务器接受到我们的字节数组后，再按某个解码格式解码成字符串。如果自己去实现这样的编码解码器，无疑加重开发工作量。neety已经提供很多种解码器给我们使用，而Stringencoder和StringDecoder就是neety提供的编解码器。下面说说怎样使用。

ServerIniterHandler类

    package chat.server;

    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelPipeline;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.handler.codec.string.StringDecoder;
    import io.netty.handler.codec.string.StringEncoder;

    public class ServerIniterHandler extends  ChannelInitializer {

@Override
protected void initChannel(SocketChannel arg0) throws Exception {
    ChannelPipeline pipeline = arg0.pipeline();
    pipeline.addLast("docode",new StringDecoder());
    pipeline.addLast("encode",new StringEncoder());
    pipeline.addLast("chat",new ChatServerHandler());
    
}

}

通过ChannelInitializer去给channel的pipelie添加上字符串编解码器。即可在网络io中收发字符串。

客户端代码分析

ClientMain类

package chat.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class ClientMain {
private String host;
private int port;
private boolean stop = false;

public ClientMain(String host, int port) {
    this.host = host;
    this.port = port;
}

public static void main(String[] args) throws IOException {
    new ClientMain(args[0], Integer.parseInt(args[1])).run();
}

public void run() throws IOException {
    EventLoopGroup worker = new NioEventLoopGroup();
    Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(worker);
    bootstrap.channel(NioSocketChannel.class);
    bootstrap.handler(new ClientIniter());

    try {
        Channel channel = bootstrap.connect(host, port).sync().channel();
        while (true) {
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(System.in));
            String input = reader.readLine();
            if (input != null) {
                if ("quit".equals(input)) {
                    System.exit(1);
                }
                channel.writeAndFlush(input);
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
        System.exit(1);
    }
}

public boolean isStop() {
    return stop;
}

public void setStop(boolean stop) {
    this.stop = stop;
}

}

客户端的启动比服务端简单一点，只使用到一个eventloopgroup，用于处理网络io。
注意：客户端用的是bootstrap类
逻辑：当connect方法调用后调用sync方法阻塞到连接成功，然后进行死循环——通过system.in去读取输入的文本字符串，当输入‘quit’就结束进程，否则就发送输入的字符串给服务器。

ChatClientHandler类

package chat.client;

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

public class ChatClientHandler extends SimpleChannelInboundHandler {

@Override
protected void channelRead0(ChannelHandlerContext arg0, String arg1)
        throws Exception {
    System.out.println(arg1);
}

}

打印服务器发送回来的数据

ClientIniter类

package chat.client;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class ClientIniter extends ChannelInitializer {

@Override
protected void initChannel(SocketChannel arg0) throws Exception {
    ChannelPipeline pipeline = arg0.pipeline();
    pipeline.addLast("stringD", new StringDecoder());
    pipeline.addLast("stringC", new StringEncoder());
    pipeline.addLast("http", new HttpClientCodec());
    pipeline.addLast("chat", new ChatClientHandler());
}

}

在channel的pipeline中添加编解码器和自定义消息处理器。

运行结果：
server的窗口：
server strart running in port:8888
[/127.0.0.1:49635] online
[/127.0.0.1:49648] online

client1的窗口
[/127.0.0.1:49648] is comming
[you]：49648，hi

client2的窗口
[/127.0.0.1:49635] 49648，hi

总结：
经过上面的分析，可以得出其实用netty框架开发网络应用，相比Java原生NIO的API简单快捷，代码量少。实际上用netty开发核心两点就是启动类和编写自定义处理类。

**下一章预告：使用netty框架开发单对单聊天 **

<一起学netty>第一章：用netty开发多人聊天

为什么使用netty框架

项目结构

代码分析

服务端代码分析

客户端代码分析

你可能感兴趣的:(<一起学netty>第一章：用netty开发多人聊天)