Netty入门(二)-------HelloWord

Netty入门（一）——为什么使用Netty

上篇简单介绍了下为什么使用Netty,这篇我们将简单的搭个HelloWord。
在Netty使用手册中说了世界上最简单的协议不是”Hello,World!”，是DISCARD，他是一种丢弃了所有接受到的数据，并不做有任何的响应的协议，本文中就不已抛弃协议为蓝本了，我们就简单搭个服务端、客户端。
客户端发送信息、服务端接收处理并返回给客户端结果。
整个demo有四个类：

当然netty的maven依赖也要加入：

<!--netty-->
 <dependency>
     <groupId>io.netty</groupId>
     <artifactId>netty-all</artifactId>
     <version>5.0.0.Alpha2</version>
 </dependency>

整个准备情况基本完成。
服务器端代码：

package com.herman.helloWord;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author hsh
 * @create 2018-05-08 18:12
 **/
public class Service {
    public static final int port = 888;
    public static final String ip = "localhost";

    public static void main(String[] args) throws InterruptedException {
        System.out.println("服务端启动...");
        //1 初始化两个线程组
        //一个是用于处理服务器端接收客户端连接的
        //一个是进行网络通信的（网络读写的）
        NioEventLoopGroup pGroup = new NioEventLoopGroup();
        NioEventLoopGroup cGroup = new NioEventLoopGroup();

        //2 创建辅助工具类 用于服务器通道的一系列配置
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(pGroup, cGroup)//绑定两个线程组
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)//设置TCP缓存大小
                .option(ChannelOption.SO_SNDBUF, 32 * 1024)//设置发送缓存大小
                .option(ChannelOption.SO_RCVBUF, 32 * 1024)//设置接收缓存大小
                .option(ChannelOption.SO_KEEPALIVE, true)//保持连接
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //3 配置具体业务处理逻辑(可多个)
                        socketChannel.pipeline().addLast(new ServerHanler());
                    }
                });
        //绑定
        ChannelFuture future = bootstrap.bind(port).sync();
        //等待关闭
        future.channel().closeFuture().sync();
        //释放管道
        pGroup.shutdownGracefully();
        cGroup.shutdownGracefully();
    }
}

服务端中对应的业务逻辑处理ServerHanler代码：

package com.herman.helloWord;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

/**
 * @author hsh
 * @create 2018-05-08 18:39
 **/
public class ServerHanler extends ChannelHandlerAdapter {

    //激活时调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active...");
    }

    //读取
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //从内存中获取消息引用地址
        ByteBuf byteBuf = (ByteBuf) msg;
        //生成内存数组
        byte[] req = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(req);//copy数据到内存
        String body = new String(req, "UTF-8");
        System.out.println("Server:" + body);
        String response = "服务器返回给客户端:" + body;
        //返回给客户端
        ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
    }

    //读取完成
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("服务端读完了");
        ctx.flush();
    }

    //出现异常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        System.out.println("出现了异常");
        throw new RuntimeException("出现了错误:", cause);
    }
}

以上服务端搭建完成，定义了两个NioEventLoopGroup 并使用辅助工具ServerBootstrap来初始化了一个服务端，并通过childHandler方法定义了处理业务的ServerHanler 。
在ServerHanler 中继承了ChannelHandlerAdapter 并重写了其中几个主要的方法。
客户端代码：

package com.herman.helloWord;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @author hsh
 * @create 2018-05-09 9:25
 **/
public class Client {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new ClientHandler());
                    }
                });
        ChannelFuture future = bootstrap.connect(Service.ip, Service.port).sync();
        Thread.sleep(1000);
        future.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes()));
        future.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
        Thread.sleep(2000);
        future.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));

        future.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

客户端的业务处理类

package com.herman.helloWord;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.ReferenceCountUtil;

/**
 * @author hsh
 * @create 2018-05-09 9:27
 **/
public class ClientHandler extends ChannelHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client channel active...");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
        ByteBuf byteBuf = (ByteBuf) msg;
        byte[] req = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("Client :" + body );
        String response="收到服务端返回的信息:"+body;
        }finally {
            ReferenceCountUtil.release(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端读完了");
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        throw new RuntimeException("客户端出现了异常:", cause);
    }
}

客户端的代码基本与服务端一致，主要区别是服务端初始化时指定的是NioServerSocketChannel，客户端是NioSocketChannel。服务端辅助类是调用bind、客户端是connect。
业务逻辑是客户端向服务端发送三次数据，服务端接收之后会返回给客户端相应，客户端输出服务器返回的数据。
启动先启动服务端，再启动客户端，运行效果如下：
服务端：

客户端：