Netty学习篇②

Channel、ChannelPipeline、ChannelHandlerContent发送数据的不同

// channel往回写数据
Channel channel = ctx.channel();
channel.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

// pipeline写回数据
ChannelPipeline pipeline = ctx.pipeline();
pipeline.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

// ctx写回数据
ctx.writeAndFlush(Unpooled.copiedBuffer(new String("123").toCharArray(), CharsetUtil.UTF_8));

三种方式的区别

前2种影响channel整个通道的channelHandler的事件
ctx.writeAndFlush只影响当前handler

netty入站出站handler执行顺序问题

总结：
1. InboundHandler顺序执行，OutboundHandler逆序执行

2. InboundHandler通过write方法与OutboundHandler进行交互

3. InboundHandler想要传递消息到OutboundHandler，OutboundHandler需要在InboundHandler之前添加到管道中，否则在InboundHandler中write(msg)的时候OutboundHandler可能还没注册到管道中（前提是用ChannelHandlerContent进行回写数据）

4. InboundHandler和OutBoundHandler角色的不同顺序不同；针对客户端而言，客户端是先发起请求在接收数据，所以是OutboundHandler > InboundHandler；针对服务端则反之

netty异步操作

netty中所有的IO操作都是异步的，意味着任何IO调用都会立即返回，通过ChannelFuture获得IO操作的结果和状态

ChannelFuture

ChannelFuture提供了IO操作的结果和状态
它继承了io.netty.util.concurrent包下的Future 
间接继承了并发包下的Future

ChannelFuture的类图

avatar

注意：
不要在IO线程内调用future对象的sync/await方法，不能再ChannelHandler中调用sync/await方法，可能导致死锁问题

ChannelPromise

继承ChannelFuture，进一步拓展用于设置IO操作结果

TCP粘包拆包

TCP拆包

所谓拆包就是一个数据包拆分成多个包进行发送，就好比咱们在同一家店购买东西过多会拆成多个包裹进去发货类似，一个完成的数据包可能会被TCP拆分成多个包进行传输发送

TCP粘包

粘包则和拆包相反，将多个小包封装成一个大的数据包，就好比快递站收到包裹不会立马运输派送，会等到一定的量才会运输派送；客户端发送若干的数据包，服务端接收的时候粘合成一个包接收

// 客户端
public class HtNettyClient {

    private String ip;

    private int port;

    HtNettyClient(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public void start() {
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(workGroup)
                    .channel(NioSocketChannel.class)
                    .remoteAddress(new InetSocketAddress(ip, port))
                    .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new HtNettyClientHandler());
                }
            });
            ChannelFuture future = bootstrap.connect().sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {

        } finally {
            workGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        HtNettyClient client = new HtNettyClient("127.0.0.1", 9000);
        client.start();
    }
}

// 客户端发送数据handler
public class HtNettyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 数据缓冲区
        ByteBuf byteBuf = null;
        byte[] req = ("hetangyuese" +System.getProperty("line.separator")).getBytes();
        for (int i= 0; i<10; i++) {
            byteBuf = Unpooled.buffer(req.length);
            byteBuf.writeBytes(req);
            ctx.writeAndFlush(byteBuf);
        }
 }

    
// 服务端
public class HtNettyServer {

    private int port;

    HtNettyServer(int port) {
        this.port = port;
    }

    public void start() {
        // 定义一个boss来处理请求
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
//                                    .addLast(new LineBasedFrameDecoder(3))
                                    .addLast(new HtNettyHandler());
                        }
                    });
            // 绑定端口
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            // 阻塞至直至关闭通道
            channelFuture.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        HtNettyServer server = new HtNettyServer(9000);
        server.start();
    }
}
    
// 服务端handler
public class HtNettyHandler extends ChannelInboundHandlerAdapter {


    private int count;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 如果没有定义解码器的话 默认转byteBuf
        ByteBuf byteBuf = (ByteBuf)msg;
        byte[] params = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(params);
        String body = new String(params, CharsetUtil.UTF_8);
        System.out.println("收到了请求，请求内容：" + body + ", 收到请求次数：" + ++count);
    }

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

// 结果
收到了请求，请求内容：hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
hetangyuese
, 收到请求次数：1

粘、拆包

avatar

为何TCP会导致粘包和拆包？

TCP每次在发送数据时都是以流的形式进行传输，底层有一个缓冲区来存储发送的字节流，

1.当发送数据小于缓冲区的饱和的大小时，会发生粘包，粘成一个包发送至服务端（每个包之间的间隔时间短，包数据很小）；

2.当发送的数据大于缓冲区的阈值，则会拆分成多个包进行发送

3.服务端没及时读取缓冲区的数据，导致数据堆积，可能导致服务端粘包

4.发送方由于Nagle算法机制

Nagle算法

TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。

粘包、拆包解决方法

1. 设置定长消息（根据业务设置足够长）
2. 设置消息的边界（设置分隔符）
3. 使用带消息头的协议，消息头存储消息开始标识及消息的长度信息
4. 发送端关闭Nagle算法

Netty编、解码器

Decoder解码

主要对应的是ChannelInboundHandler，主要作用将字节数组转换成对象消息

Decoder解码常用抽象类

ByteToMessageDecoder

字节码转消息对象时需要检查缓冲区是否有足够的字节

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in,List<Object> out) throws Exception {
    // 假使消息为int字节 则需要判断bytebuf字节是否大于等于4
    if (in.readableBytes() >= 4) {
        // 符合的话就add到list对象中（解析对象）
        out.add(in.readInt());
    }
}

ReplayingDecoder

继承了ByteToMessageDecoder，不需要检查缓冲区是否有足够多的数据，速度略慢于ByteToMessageDecoder；
tips: 根据项目的复杂程度合理选择，常用ByteToMessageDecoder

MessageToMessageDecoder

用于从一种消息解码到另外一种消息

解码器的具体实现（主要解决TCP底层的粘包和拆包问题）

DelimiterBasedFrameDecoder

指定消息分隔符的解码器（客户端发送数据所有的数据末尾都需要增加分隔符，否则服务端接收不到）

// 定义最大长度及需要的切割符
public DelimiterBasedFrameDecoder(int maxFrameLength, ByteBuf delimiter) {
    this(maxFrameLength, true, delimiter);
}
// 定义切割符
ByteBuf delimiter = Unpooled.copiedBuffer("自定义分隔符".getBytes());

/**
* maxFrameLength：解析分隔符最大长度
* stripDelimiter：true表示解析数据隐藏分隔符，反之解析数据末尾都会带上分隔符
* failFast： true表示超出maxLength立刻抛出异常，false则会解析完在抛出异常
* delimiter: 分隔符
*/
public DelimiterBasedFrameDecoder(
            int maxFrameLength, boolean stripDelimiter, boolean failFast,
            ByteBuf delimiter) {
    this(maxFrameLength, stripDelimiter, failFast, new ByteBuf[] {
        delimiter.slice(delimiter.readerIndex(), delimiter.readableBytes())});
}

// 客户端请求体
reqStr = "hello!_" +
                "My name is hanleilei !_" +
                "What is your name !_" +
                "How are you? !_"
        ;

// 服务端增加解析 以!_为分隔符
.addLast(new DelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("!_".getBytes())))
    
// 结果
收到了请求，请求内容：hello, 收到请求次数：1
收到了请求，请求内容：My name is hanleilei , 收到请求次数：2
收到了请求，请求内容：What is your name , 收到请求次数：3
收到了请求，请求内容：How are you? , 收到请求次数：4

// 服务端设置stripDelimiter为false
addLast(new DelimiterBasedFrameDecoder(1024, false, Unpooled.copiedBuffer("!_".getBytes())));

//结果
收到了请求，请求内容：hello!_, 收到请求次数：1
收到了请求，请求内容：My name is hanleilei !_, 收到请求次数：2
收到了请求，请求内容：What is your name !_, 收到请求次数：3
收到了请求，请求内容：How are you? !_, 收到请求次数：4

LineBasedFrameDecoder

以换行符为结束标志的解码器

// 如果发送的数据超过了maxLength还未解析到换行符则抛出TooLongFrameException异常
public LineBasedFrameDecoder(final int maxLength) {
	this(maxLength, true, false);
}

// 服务端定义最大长度为3的换行解码器
public void start() {
        // 定义一个boss来处理请求
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new LineBasedFrameDecoder(3))
                                    .addLast(new HtNettyHandler());
                        }
                    });
            // 绑定端口
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            // 阻塞至直至关闭通道
            channelFuture.channel().closeFuture().sync();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }


// 客户端发送
public class HtNettyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 客户端注册是发送数据至服务端
        ByteBuf byteBuf = null;
        byte[] req = ("hetangyuese" +System.getProperty("line.separator")).getBytes();
        for (int i= 0; i<10; i++) {
            byteBuf = Unpooled.buffer(req.length);
            byteBuf.writeBytes(req);
            ctx.writeAndFlush(byteBuf);
        }
    }
}

// 异常
io.netty.handler.codec.TooLongFrameException: frame length (11) exceeds the allowed maximum (3)
	at io.netty.handler.codec.LineBasedFrameDecoder.fail(LineBasedFrameDecoder.java:146)
	at io.netty.handler.codec.LineBasedFrameDecoder.fail(LineBasedFrameDecoder.java:142)
	at io.netty.handler.codec.LineBasedFrameDecoder.decode(LineBasedFrameDecoder.java:99)
	at io.netty.handler.codec.LineBasedFrameDecoder.decode(LineBasedFrameDecoder.java:75)
	at io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:489)
	at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:428)
	at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:265)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:362)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:348)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:340)
	at io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1359)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:362)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:348)
	at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:935)
	at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:134)
	at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:645)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:580)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:497)
	at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:459)
	at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:858)
	at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run(DefaultThreadFactory.java:138)
	at java.lang.Thread.run(Thread.java:748)
    
// 修改长度
addLast(new LineBasedFrameDecoder(1024))
    
// 结果
收到了请求，请求内容：hetangyuese, 收到请求次数：1
收到了请求，请求内容：hetangyuese, 收到请求次数：2
收到了请求，请求内容：hetangyuese, 收到请求次数：3
收到了请求，请求内容：hetangyuese, 收到请求次数：4
收到了请求，请求内容：hetangyuese, 收到请求次数：5
收到了请求，请求内容：hetangyuese, 收到请求次数：6
收到了请求，请求内容：hetangyuese, 收到请求次数：7
收到了请求，请求内容：hetangyuese, 收到请求次数：8
收到了请求，请求内容：hetangyuese, 收到请求次数：9
收到了请求，请求内容：hetangyuese, 收到请求次数：10

FixedLengthFrameDecoder

固定长度的解码器

/**
* frameLength：解析的消息体长度，每次直解析frameLength长度字节消息
*/
public FixedLengthFrameDecoder(int frameLength) {
        if (frameLength <= 0) {
            throw new IllegalArgumentException(
                    "frameLength must be a positive integer: " + frameLength);
        }
        this.frameLength = frameLength;
    }

// 客户端
package com.hetangyuese.netty.client.handler;

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

/**
 * @program: netty-root
 * @description: 客户端逻辑类
 * @author: hewen
 * @create: 2019-10-22 17:15
 **/
public class HtNettyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        String reqStr = "";
        // 数据缓冲区
        ByteBuf byteBuf = null;
//        reqStr = "hetangyuese" + System.getProperty("line.separator");
        reqStr = "hello!_" +
                "My name is hanleilei !_" +
                "What is your name !_" +
                "How are you? !_"
        ;
        byte[] req = (reqStr).getBytes();
//        for (int i= 0; i<10; i++) {
        byteBuf = Unpooled.buffer(req.length);
        byteBuf.writeBytes(req);
        ctx.writeAndFlush(byteBuf);
//        }
    }
}

// 服务端解析（直接解析3个字节）
ch.pipeline().addLast(new FixedLengthFrameDecoder(3))
.addLast(new HtNettyHandler());

// 结果
收到了请求，请求内容：hel, 收到请求次数：1
收到了请求，请求内容：lo!, 收到请求次数：2
收到了请求，请求内容：_My, 收到请求次数：3
收到了请求，请求内容： na, 收到请求次数：4
收到了请求，请求内容：me , 收到请求次数：5
收到了请求，请求内容：is , 收到请求次数：6
收到了请求，请求内容：han, 收到请求次数：7
收到了请求，请求内容：lei, 收到请求次数：8
收到了请求，请求内容：lei, 收到请求次数：9
收到了请求，请求内容： !_, 收到请求次数：10
收到了请求，请求内容：Wha, 收到请求次数：11
收到了请求，请求内容：t i, 收到请求次数：12
收到了请求，请求内容：s y, 收到请求次数：13
收到了请求，请求内容：our, 收到请求次数：14
收到了请求，请求内容： na, 收到请求次数：15
收到了请求，请求内容：me , 收到请求次数：16
收到了请求，请求内容：!_H, 收到请求次数：17
收到了请求，请求内容：ow , 收到请求次数：18
收到了请求，请求内容：are, 收到请求次数：19
收到了请求，请求内容： yo, 收到请求次数：20
收到了请求，请求内容：u? , 收到请求次数：21

LengthFieldBasedFrameDecoder

消息包括 ：消息头 + 消息体，基于长度通用的解码器

/**
* maxFrameLength: 消息数据最大长度
*
* lengthFieldOffset：长度字段偏移位，长度字段开始的地方，跳过指定长度字节之后的消 * 息才是消息体字段，一般设置为0，从头部开始
*
* lengthFieldLength：消息头长度字段占的字节数，如果设为2则表示在     
* lengthFieldOffset开始往后的2个字节存储消息体长度
*
* lengthAdjustment：调整消息体长度字段，如果消息包括消息头（即长度字段），如果需要* 去掉消息头则需要对应设置为负数（长度字段的字节长度），netty解析要减去对应的数值获取* 消息体
*
* initialBytesToStrip：是否需要剔除消息头，在获取到一个完整的数据包之后，去除长度 * 字节，直接拿到消息体的数据,为0代表不去除消息头
*
* failFast：是否快速失败，true代表在数据长度超出最大长度则立刻抛出异常
*/
public LengthFieldBasedFrameDecoder(
            int maxFrameLength, int lengthFieldOffset, int lengthFieldLength,
            int lengthAdjustment, int initialBytesToStrip, boolean failFast) {
        this(
                ByteOrder.BIG_ENDIAN, maxFrameLength, lengthFieldOffset, lengthFieldLength,
                lengthAdjustment, initialBytesToStrip, failFast);
    }

StringDecoder

文本解码器，将接收到的消息解码成字符串，一般与上述搭配使用，然后在后面加业务的handler

Encoder编码器

主要对应的是ChannelOutboundHandler，将消息对象转换为字节数组

Encoder解码常用的抽象解码类

MessageToByteEncoder

消息转为字节数组，write方法会判断是否支持消息类型，如果不支持则通过context传递到下一个ChannelOutboundHandler,自定义需要重写encode方法

@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ByteBuf buf = null;
        try {
            // 判断是否支持的消息类型
            if (acceptOutboundMessage(msg)) {
                @SuppressWarnings("unchecked")
                I cast = (I) msg;
                buf = allocateBuffer(ctx, cast, preferDirect);
                try {
                    encode(ctx, cast, buf);
                } finally {
                    ReferenceCountUtil.release(cast);
                }

                if (buf.isReadable()) {
                    ctx.write(buf, promise);
                } else {
                    buf.release();
                    ctx.write(Unpooled.EMPTY_BUFFER, promise);
                }
                buf = null;
            } else {
                // 如果不支持则通过context传递到下一个ChannelOutboundHandler
                ctx.write(msg, promise);
            }
        } catch (EncoderException e) {
            throw e;
        } catch (Throwable e) {
            throw new EncoderException(e);
        } finally {
            if (buf != null) {
                buf.release();
            }
        }
    }

MessageToMessageEncoder：将一种消息编码为另外一种消息

ChannelOption常用的参数

SO_BACKLOG

用来设置服务端可连接的数量，当大量客户端连接时，服务端处理不过来的连接会等待，so_backlog的值可以用来控制等待连接的队列的大小

// 应用
.option(ChannelOption.SO_BACKLOG, 1024)

SO_KEEPALIVE

用来设置TCP连接检测连接状态，如果客户端和服务端长时间（2小时）未有数据传输，则会自动发送一个检测是否连接是否还活动的报文

// 应用
.option(ChannelOption.SO_KEEPALIVE, true)

SO_REUSEADDR

重复使用本地端口，某个端口被占用后设置这个属性则可以共同使用该端口

.option(ChannelOption.SO_REUSEADDR, true)

TCP_NODELAY

发送方由于Nagle算法，会把小数据包包装成更大的数据包一起发送，虽然有效的提高了网络的负载，但是却造成了延时，tcp_nodelay的作用就是禁用Nagle算法，nodelay非延迟即即时传输

.option(ChannelOption.TCP_NODELAY, true)

posted @ 2019-10-26 13:47 荷塘月色0519 阅读(384) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

荷塘月色0519