Netty学习第四章 spring boot整合netty的使用

　　现在大多数项目都是基于spring boot进行开发，所以我们以spring boot作为开发框架来使用netty。使用spring boot的一个好处就是能给将netty的业务拆分出来，并通过spring cloud整合到项目中。

　　我们以一个简单的客户端发送消息到服务的场景编写一个实例。

一、服务端模块

　　netty中服务端一般分为两个类，一个是启动配置类，另一个是消息的逻辑处理类，但是首先我们要配置spring boot的启动类，启动netty

　　

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    NettyServer nettyServer;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        nettyServer.startServer();
    }
}

　　1.启动配置类

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

/**
 * Netty
 * 服务端
 */
@Configuration
public class NettyServer {

    //四个处理请求的逻辑类
    @Autowired
    ServerInboundHandler serverInboundHandler;

    @Autowired
    ServerInboundGetTimeHandler serverInboundGetTimeHandler;

    @Autowired
    ServerLastOutboundHandler serverLastOutboundHandler;

    @Autowired
    ServerOutboundHandler serverOutboundHandler;

    public void startServer() {
        System.out.println("服务端启动成功");
        //创建两个线程组，用于接收客户端的请求任务,创建两个线程组是因为netty采用的是反应器设计模式
        //反应器设计模式中bossGroup线程组用于接收
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //workerGroup线程组用于处理任务
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //创建netty的启动类
        ServerBootstrap bootstrap = new ServerBootstrap();
        //创建一个通道
        ChannelFuture f = null;
        try {
            bootstrap.group(bossGroup, workerGroup) //设置线程组
                    .channel(NioServerSocketChannel.class) //设置通道为非阻塞IO
                    .option(ChannelOption.SO_BACKLOG, 128) //设置日志
                    .option(ChannelOption.SO_RCVBUF, 32 * 1024)  //接收缓存
                    .childOption(ChannelOption.SO_KEEPALIVE, true)//是否保持连接
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        //设置处理请求的逻辑处理类
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //ChannelPipeline是handler的任务组，里面有多个handler
                            ChannelPipeline pipeline = ch.pipeline();
                            //逻辑处理类
                            pipeline.addLast(serverLastOutboundHandler);
                            pipeline.addLast(serverOutboundHandler);
                            pipeline.addLast(serverInboundHandler);
                            pipeline.addLast(serverInboundGetTimeHandler);
                        }
                    });

            f = bootstrap.bind(84).sync();//阻塞端口号，以及同步策略
            f.channel().closeFuture().sync();//关闭通道
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //优雅退出
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }

}

　　2.启动配置类中的各个组件

　　1)EventLoop 与 EventLoopGroup

　　EventLoop 好比一个线程，1个EventLoop 可以服务多个channel，而一个channel只会有一个EventLoop 。EventLoop 在netty中就是负责整个IO操作，包括从消息的读取、编码以及后续 ChannelHandler 的执行，这样做的好处就是避免了线程中的上下文切换时，大量浪费资源情况。

　　EventLoopGroup 是负责分配EventLoop到新创建的channel，EventLoopGroup 就好比线程池，它里面包含多个EventLoop。

　　2）BootStrap

　　BootStrap 是netty中的引导启动类也就是一个工厂配置类，可以通过它来完成 Netty 的客户端或服务器端的 Netty 初始化，所以我们主要来看它的几个常用的配置方法。

　　① gruop() 方法

　　gruop()方法用于配置netty中的线程组，也就是我们的EventLoopGroup ，在服务端中需要配置两个线程组，这是因为netty中采用的是反应器设计模式（reactor ），我们知道反应器设计模式中是需要两个线程组，一个用于接收用户的请求，另一个用于处理请求的内容。

　　② channel() 方法

　　channel()方法用于配置通道的IO类型，IO类型有两个：阻塞IO（BIO）OioServerSocketChannel；非阻塞IO（NIO）NioServerSocketChannel。

　　③ childHandler () 方法

　　用于设置处理请求的适配器，这个在下面详细介绍。

　　④ childOption() 方法

　　给每条child channel连接设置一些TCP底层相关的属性，比如上面，我们设置了两种TCP属性，其中 ChannelOption.SO_KEEPALIVE表示是否开启TCP底层心跳机制，true为开

　　⑤ option

　　给每条parent channel 连接设置一些TCP底层相关的属性。

　　关于option的属性有：

　　SO_RCVBUF ，SO_SNDBUF：用于设置TCP连接中使用的两个缓存区。

　　TCP_NODELAY：立即发送数据，采用的是Nagle算法。Nagle算法是当小数据过多时，就会将这些小数据碎片连接成更大的报文，从而保证发送的报文数量最小。所以如果数据量小就要禁用这个算法，netty默认是禁用的值为true。

　　通俗地说，如果要求高实时性，有数据发送时就马上发送，就关闭，如果需要减少发送次数减少网络交互，就开启。

　　SO_KEEPALIVE：底层TCP协议的心跳机制。Socket参数，连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。

　　SO_REUSEADDR：Socket参数，地址复用，默认值False

　　SO_LINGER：Socket参数，关闭Socket的延迟时间，默认值为-1，表示禁用该功能。

　　SO_BACKLOG：Socket参数，服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝。默认值，Windows为200，其他为128。

　　SO_BROADCAST：Socket参数，设置广播模式。

　　3）ChannelFuture

　　我们知道netty中的所有IO操作都是异步的，这意味着任何IO调用都会立即返回，不管结果如果状态如果。而ChannelFuture 的存在就是为了解决这一问题，它会提供IO操作中有关的信息、结果或状态。

　　ChannelFuture 一共有两个状态：

　　未完成状态：当IO操作开始时，将创建一个新的ChannelFuture 对象，此时这个对象既没有操作成功也没有失败，那么就说这个对象就是未完成的状态。简单来说未完成指创建了对象且没有完成IO操作。

　　已完成状态：当IO操作完成后，不管操作是成功还是失败，future都是标记已完成的，失败时也会有对应的具体失败信息。

3.消息逻辑处理类　　

　　可以看到我一共在pipeline里面配置了4个handler，这是为了查看inboundhandler和outboundhandler的数据传递方式，以及每个handler的执行顺序

　  ServerInboundGetTimeHandler:

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.springframework.context.annotation.Configuration;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Inbound处理类
 * 给客户端返回一个时间戳
 */
@Configuration
public class ServerInboundGetTimeHandler  extends ChannelInboundHandlerAdapter {

    /**
     * 获取客户端的内容类
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //将传递过来的内容转换为ByteBuf对象
        ByteBuf buf = (ByteBuf) msg;
        //和文件IO一样，用一个字节数组读数据
        byte[] reg = new byte[buf.readableBytes()];
        buf.readBytes(reg);
        //将读取的数据转换为字符串
        String body = new String(reg, "UTF-8");
        //给客户端传递的内容，同样也要转换成ByteBuf对象
        Date dNow = new Date( );
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
        String respMsg = body+ft.format(dNow);
        System.out.println("服务器当前时间是："+ft.format(dNow));
        ByteBuf respByteBuf = Unpooled.copiedBuffer(respMsg.getBytes());
        //调用write方法，通知并将数据传给outboundHand
        ctx.write(respByteBuf);

    }

    /**
     * 刷新后才将数据发出到SocketChannel
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    /**
     * 关闭
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

　　ServerInboundHandler:

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.springframework.context.annotation.Configuration;

/**
 * Inbound处理类，是用来处理客户端发送过来的信息
 * Sharable 所有通道都能使用的handler
 */
@Configuration
@ChannelHandler.Sharable
public class ServerInboundHandler extends ChannelInboundHandlerAdapter {

    /**
     * 获取客户端的内容类
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //将传递过来的内容转换为ByteBuf对象
        ByteBuf buf = (ByteBuf) msg;
        //和文件IO一样，用一个字节数组读数据
        byte[] reg = new byte[buf.readableBytes()];
        buf.readBytes(reg);
        //将读取的数据转换为字符串
        String body = new String(reg, "UTF-8");
        System.out.println( "服务端接收的信息是: " + body);
        //给客户端传递的内容，同样也要转换成ByteBuf对象
        String respMsg = "你好我是服务端,当前时间是:";
        ByteBuf respByteBuf = Unpooled.copiedBuffer(respMsg.getBytes());
        //调用fireChannelRead方法，通知并将数据传给下一个handler
        ctx.fireChannelRead(respByteBuf);

    }

    /**
     * 刷新后才将数据发出到SocketChannel
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    /**
     * 关闭
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

　　ServerLastOutboundHandler:

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import org.springframework.context.annotation.Configuration;

/**
 * Outbound表示服务器发送的handler
 */
@Configuration
public class ServerLastOutboundHandler extends ChannelOutboundHandlerAdapter {

    /**
     * 服务端要传递消息的方法
     * @param ctx
     * @param msg
     * @param promise
     * @throws Exception
     */
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        //将传递过来的内容转换为ByteBuf对象
        ByteBuf buf = (ByteBuf) msg;
        //和文件IO一样，用一个字节数组读数据
        byte[] reg = new byte[buf.readableBytes()];
        buf.readBytes(reg);
        String body=new String(reg,"UTF-8");
        String respMsg = body+"\n1.吃饭 2.睡觉";
        System.out.println("服务端要发送的消息是：\n"+respMsg);
        ByteBuf respByteBuf = Unpooled.copiedBuffer(respMsg.getBytes());
        ctx.write(respByteBuf);
        ctx.flush(); //ctx.write()方法执行后，需要调用flush()方法才能令它立即执行
    }
}

　　ServerOutboundHandler:

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import org.springframework.context.annotation.Configuration;

/**
 * Outbound表示服务器发送的handler
 */
@Configuration
public class ServerOutboundHandler extends ChannelOutboundHandlerAdapter{

    /**
     * 服务端要传递消息的方法
     * @param ctx
     * @param msg
     * @param promise
     * @throws Exception
     */
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        //将传递过来的内容转换为ByteBuf对象
        ByteBuf buf = (ByteBuf) msg;
        //和文件IO一样，用一个字节数组读数据
        byte[] reg = new byte[buf.readableBytes()];
        buf.readBytes(reg);
        String body=new String(reg,"UTF-8");
        System.out.println("serverOutbound的内容:\n"+body);
        String respMsg = body+"\n请问你需要操作什么任务";
        ByteBuf respByteBuf = Unpooled.copiedBuffer(respMsg.getBytes());
        ctx.write(respByteBuf);
        ctx.flush(); //ctx.write()方法执行后，需要调用flush()方法才能令它立即执行
    }
}

4.channelHandler中的各个组件

　　1）channel

　　channel的本质就是一个socket连接，是服务端与客户端连接的通道。channel除了连接客户端与服务端外，还能监控通道的状态，如：什么时候传输、传输完成情况都能监控到。

　　channel的一个有四个状态：

　　channelReistered：channel注册到一个EventLoop，此时为注册状态

　　channelUnregistered：channel已经创建好了还未进行注册，此时为未注册状态

　　channelActive：客户端与服务端连接后，channel会变为活跃状态，此时可以接收和发送数据

　　channelInactive：非活跃状态，没有连接远程主机的时候。

　　channel的生命周期状态变化大致如图：

　　

　　 2）channelHandler

　　channelHandler就是我们处理数据逻辑的地方，它一共分为两大类：InboundHandler和呕Outboundhandler。InboundHandler用于处理输入的数据和改变channel状态类型，OutboundHandler用于回写给外界的数据。

　　channelHandler的执行顺序：

　　InboundHandler：顺序执行

　　OutboundHandler：逆序执行

　　在channelHandler的执行过程中，InboundHandler会覆盖后面的OutboundHandler，所以在开发中应该先执行OutboundHandler再执行InboundHandler

　　3）channelPipeline

　　管理channelHandler的有序容器，它里面可以有多个channelHandler。

　　channel、channelHandler、channelPipeline三者的关系：

　　一个channel有一个容器channelPipeline,容器中有多个channelHandler。创建channel时会自动创建一个channelPipeline，每个channel都有一个管理它的channelPipeline，这个关联是永久的。

二、客户端代码

　　netty中客户端的各个组件都是和服务端一样的，所以不用再介绍客户端的组件

　　1.配置类代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import org.springframework.context.annotation.Configuration;

import java.net.InetSocketAddress;

/**
 * netty 客户端类
 */
@Configuration
public class NettyClient {

    public static void main(String[] args) {
        //客户端只需要创建一个线程就足够了
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //客户端启动类
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)//设置线程组
                    .channel(NioSocketChannel.class)//设置通道类型
                    .remoteAddress(new InetSocketAddress("127.0.0.1", 84))//设置IP和端口
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new ClientHandler());
                        }
                    });
            //阻塞通道
            ChannelFuture channelFuture = bootstrap.connect().sync();
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {

        } finally {
            group.shutdownGracefully();
        }
    }

}

　　2.逻辑处理类代码

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

/**
 * 客户端逻辑处理类
 */
public class ClientHandler  extends SimpleChannelInboundHandler<ByteBuf> {

    /**
     * 发送给服务器消息的方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好，我是客户端", CharsetUtil.UTF_8));
    }

    /**
     * 回调方法，接收服务器发送的消息
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println( msg.toString(CharsetUtil.UTF_8));
    }

    /**
     * 在处理过程中引发异常时被调用
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

测试结果，先启动服务端：

　

然后启动客户端：

　

最后再来看看服务端：