Netty入门案例编写

最新推荐文章于 2022-05-18 14:31:03 发布

柳柳柳柳丶

最新推荐文章于 2022-05-18 14:31:03 发布

阅读量251

点赞数

分类专栏： netty 文章标签： websocket netty 单元测试 java

原文链接：https://blog.csdn.net/shalldid/category_10167380.html

版权

netty 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一：单元测试

1.AbstractEmbeddedChannel提供的常用方法

名称	描述
writeInbound(…)	向Channel写入数据，模拟Channel收到数据，也就是说这些数据会经过ChannelPipeline的ChannelInboundHandler
readInbound(…)	从EmbeddedChannel中读数据，返回经过ChannelPipeline中的ChannelInboundHandler的数据，如果没有数据则返回null
writeOutbound(…)	向Channel写入数据，模拟Channel发送数据，也就是说这些数据会经过ChannelPipeline的ChannelOutboundHandler
readOutbound(…)	从EmbeddedChannel中读数据，返回经过ChannelPipeline中的ChannelOutboundHandler的数据，如果没有数据则返回null
finish()	结束EmbeddedChannel，如果里面有任何类型的可读数据都会返回true，它也会调用Channel的close方法

writeOutbound(…)会将数据写到Channel并经过OutboundHandler，然后通过readOutbound(…)方法就能读取到处理后的数据。模拟收到数据也是类似的，通过writeInbound(…)和readInbound(…)方法。收到的数据和发送的数据的逻辑基本是一样的，经过ChannelPipeline后到达终点后会存储在EmbeddedChannel中。

2.测试ChannelHandler

我们先实现一个简单的ByteToMessageDecoder，主要逻辑就是每次收到数据后将数据分成数量固定的组，如果数据不够就不分然后等到下次收到数据的时候再检查是否数据足够


import java.util.List;
 
public class FixedLengthFrameDecoder extends ByteToMessageDecoder {
 
    //每组数据的长度
    private final int frameLength;
 
    public FixedLengthFrameDecoder(int frameLength) {
        if (frameLength <= 0) {
            throw new IllegalArgumentException("frameLength must be a positive integer: " + frameLength);
        }
        this.frameLength = frameLength;
    }
 
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //检查数据是否足够
        while (in.readableBytes() >= frameLength) {
            //读取指定长度的数据
            ByteBuf buf = in.readBytes(frameLength);
            //添加到列表中
            out.add(buf);
        }
    }
}

下面我来测试一下实现的解码器

package com.nan.netty.test;
 
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Assert;
import org.junit.Test;
 
public class FixedLengthFrameDecoderTest {
 
    @Test
    public void testFramesDecoded() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 0; i < 9; i++) {
            buf.writeByte(i);
        }
        ByteBuf input = buf.duplicate();
        EmbeddedChannel channel = new EmbeddedChannel(new FixedLengthFrameDecoder(3));
 
        //验证写数据返回True
        Assert.assertTrue(channel.writeInbound(input.readBytes(9)));
        Assert.assertTrue(channel.finish());
        //每次读3个数据
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertNull(channel.readInbound());
    }
 
    @Test
    public void testFramesDecoded2() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 0; i < 9; i++) {
            buf.writeByte(i);
        }
        ByteBuf input = buf.duplicate();
        EmbeddedChannel channel = new EmbeddedChannel(new FixedLengthFrameDecoder(3));
        Assert.assertFalse(channel.writeInbound(input.readBytes(2)));
        Assert.assertTrue(channel.writeInbound(input.readBytes(7)));
        Assert.assertTrue(channel.finish());
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertEquals(buf.readBytes(3), channel.readInbound());
        Assert.assertNull(channel.readInbound());
    }
}

我们看看上边的单元测试的主要逻辑。 testFramesDecoded()方法主要逻辑是一个包含9个字节的ByteBuf，警告我们实现的解码器，变成了3个ByteBuf，每个ByteBuf包含3个字节。通过writeInbound(…)方法将9个字节写到EmbeddedByteChannel中，调用finish()方法标记EmbeddedByteChannel已经结束，然后使用readInbound()方法读出EmbeddedByteChannel中已经解码完成的数据。
testFramesDecoded2()方法的大致逻辑和前一个方法一样，唯一的区别就是写入数据的时候先写2个字节，因此导致我们实现的FixedLengthFrameDecoder没有解码输出，所以返回结果为false。

3.测试OutboundHandler

我们实现一个AbsIntegerEncoder，将负数变成正数，然后传递给下一个ChannelHandler，主要步骤如下：

收到ByteBuf后，调用Math.abs(…)将它们都转成正数
转换完成之后将数据传递给下一个ChannelHandler

package com.nan.netty.test;
 
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;
 
import java.util.List;
 
public class AbsIntegerEncoder extends MessageToMessageEncoder<ByteBuf> {
 
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext,
                          ByteBuf in, List<Object> out) throws Exception {
        while (in.readableBytes() >= 4) {
            int value = Math.abs(in.readInt());
            out.add(value);
        }
    }
}

测试代码

package com.nan.netty.test;
 
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Assert;
import org.junit.Test;
 
public class AbsIntegerEncoderTest {
    @Test
    public void testEncoded() {
        ByteBuf buf = Unpooled.buffer();
        for (int i = 1; i < 10; i++) {
            buf.writeInt(i * -1);
        }
        EmbeddedChannel channel = new EmbeddedChannel(new AbsIntegerEncoder());
        //模拟发送数据
        Assert.assertTrue(channel.writeOutbound(buf));
        Assert.assertTrue(channel.finish());
        //检查是否是正数
        for (int i = 1; i < 10; i++) {
            Assert.assertEquals(i, (int) channel.readOutbound());
        }
        //没有数据返回null
        Assert.assertNull(channel.readOutbound());
    }
}

4.总结

这一节主要学习了单元测试实现的ChannelHandler，单元测试框架使用的还是经典的JUnit。测试中使用的Channel类型是EmbeddedChannel，虽然它的实现很简单，但功能是很完善的，可以帮助我们测试自己的ChannelHandler。

二：websocket

1. 核心依赖

<dependencies>
    <!--netty的依赖集合，都整合在一个依赖里面了-->
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.6.Final</version>
    </dependency>
</dependencies>

2. 代码

2.1 启动项

public class NioWebSocketServer {
    private final Logger logger=Logger.getLogger(this.getClass());
    private void init(){
        logger.info("正在启动websocket服务器");
        NioEventLoopGroup boss=new NioEventLoopGroup();
        NioEventLoopGroup work=new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap=new ServerBootstrap();
            bootstrap.group(boss,work);
            bootstrap.channel(NioServerSocketChannel.class);
            bootstrap.childHandler(new NioWebSocketChannelInitializer());
            Channel channel = bootstrap.bind(8081).sync().channel();
            logger.info("webSocket服务器启动成功："+channel);
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
            logger.info("运行出错："+e);
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
            logger.info("websocket服务器已关闭");
        }
    }

    public static void main(String[] args) {
        new NioWebSocketServer().init();
    }
}

netty搭建的服务器基本上都是差不多的写法：

绑定主线程组和工作线程组，这部分对应架构图中的事件循环组
只有服务器才需要绑定端口，客户端是绑定一个地址
配置channel（数据通道）参数，重点就是ChannelInitializer的配置
以异步的方式启动，最后是结束关闭两个线程组

2.2 ChannelInitializer写法

public class NioWebSocketChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast("logging",new LoggingHandler("DEBUG"));//设置log监听器，并且日志级别为debug，方便观察运行流程
        ch.pipeline().addLast("http-codec",new HttpServerCodec());//设置解码器
        ch.pipeline().addLast("aggregator",new HttpObjectAggregator(65536));//聚合器，使用websocket会用到
        ch.pipeline().addLast("http-chunked",new ChunkedWriteHandler());//用于大数据的分区传输
        ch.pipeline().addLast("handler",new NioWebSocketHandler());//自定义的业务handler
    }
}

2.3 自定义的处理器NioWebSocketHandler

public class NioWebSocketHandler extends SimpleChannelInboundHandler<Object> {

    private final Logger logger=Logger.getLogger(this.getClass());

    private WebSocketServerHandshaker handshaker;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到消息："+msg);
        if (msg instanceof FullHttpRequest){
            //以http请求形式接入，但是走的是websocket
                handleHttpRequest(ctx, (FullHttpRequest) msg);
        }else if (msg instanceof  WebSocketFrame){
            //处理websocket客户端的消息
            handlerWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //添加连接
        logger.debug("客户端加入连接："+ctx.channel());
        ChannelSupervise.addChannel(ctx.channel());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        //断开连接
        logger.debug("客户端断开连接："+ctx.channel());
        ChannelSupervise.removeChannel(ctx.channel());
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
    private void handlerWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame){
        // 判断是否关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(
                    new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        // 本例程仅支持文本消息，不支持二进制消息
        if (!(frame instanceof TextWebSocketFrame)) {
            logger.debug("本例程仅支持文本消息，不支持二进制消息");
            throw new UnsupportedOperationException(String.format(
                    "%s frame types not supported", frame.getClass().getName()));
        }
        // 返回应答消息
        String request = ((TextWebSocketFrame) frame).text();
        logger.debug("服务端收到：" + request);
        TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
                + ctx.channel().id() + "：" + request);
        // 群发
        ChannelSupervise.send2All(tws);
        // 返回【谁发的发给谁】
        // ctx.channel().writeAndFlush(tws);
    }
    /**
     * 唯一的一次http请求，用于创建websocket
     * */
    private void handleHttpRequest(ChannelHandlerContext ctx,
                                   FullHttpRequest req) {
        //要求Upgrade为websocket，过滤掉get/Post
        if (!req.decoderResult().isSuccess()
                || (!"websocket".equals(req.headers().get("Upgrade")))) {
            //若不是websocket方式，则创建BAD_REQUEST的req，返回给客户端
            sendHttpResponse(ctx, req, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return;
        }
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                "ws://localhost:8081/websocket", null, false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory
                    .sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(), req);
        }
    }
    /**
     * 拒绝不合法的请求，并返回错误信息
     * */
    private static void sendHttpResponse(ChannelHandlerContext ctx,
                                         FullHttpRequest req, DefaultFullHttpResponse res) {
        // 返回应答给客户端
        if (res.status().code() != 200) {
            ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(),
                    CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
        }
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        // 如果是非Keep-Alive，关闭连接
        if (!isKeepAlive(req) || res.status().code() != 200) {
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }
}

执行流程是:

web发起一次类似是http的请求，并在channelRead0方法中进行处理，并通过instanceof去判断帧对象是FullHttpRequest还是WebSocketFrame，建立连接是时候会是FullHttpRequest
在handleHttpRequest方法中去创建websocket，首先是判断Upgrade是不是websocket协议，若不是则通过sendHttpResponse将错误信息返回给客户端，紧接着通过WebSocketServerHandshakerFactory创建socket对象并通过handshaker握手创建连接
在连接创建好后的所以消息流动都是以WebSocketFrame来体现
在handlerWebSocketFrame去处理消息，也可能是客户端发起的关闭指令，ping指令等等

2.4 保存客户端的信息

当有客户端连接时候会被channelActive监听到，当断开时会被channelInactive监听到，一般在这两个方法中去保存/移除客户端的通道信息，而通道信息保存在ChannelSupervise中：

public class ChannelSupervise {
    private   static ChannelGroup GlobalGroup=new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    private  static ConcurrentMap<String, ChannelId> ChannelMap=new ConcurrentHashMap();
    public  static void addChannel(Channel channel){
        GlobalGroup.add(channel);
        ChannelMap.put(channel.id().asShortText(),channel.id());
    }
    public static void removeChannel(Channel channel){
        GlobalGroup.remove(channel);
        ChannelMap.remove(channel.id().asShortText());
    }
    public static  Channel findChannel(String id){
        return GlobalGroup.find(ChannelMap.get(id));
    }
    public static void send2All(TextWebSocketFrame tws){
        GlobalGroup.writeAndFlush(tws);
    }
}

ChannelGroup是netty提供用于管理web于服务器建立的通道channel的，其本质是一个高度封装的set集合，在服务器广播消息时，可以直接通过它的writeAndFlush将消息发送给集合中的所有通道中去。但在查找某一个客户端的通道时候比较坑爹，必须通过channelId对象去查找，而channelId不能人为创建，所有必须通过map将channelId的字符串和channel保存起来。

柳柳柳柳丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Netty入门案例编写

一：单元测试1.AbstractEmbeddedChannel提供的常用方法名称描述 writeInbound(…) 向Channel写入数据，模拟Channel收到数据，也就是说这些数据会经过ChannelPipeline的ChannelInboundHandler readInbound(…) 从EmbeddedChann
复制链接

扫一扫