`

Netty4.0学习笔记系列之六：多种通讯协议支持

Netty多种通讯协议 
阅读更多

        上文介绍了如何应用Netty开发自定义通讯协议，本文在此基础上进一步深化，研究如何同时支持不同的通讯协议。

        此处所谓的通讯协议，指的是把Netty通讯管道中的二进制流转换为对象、把对象转换成二进制流的过程。转换过程追根究底还是ChannelInboundHandler、ChannelOutboundHandler的实现类在进行处理。ChannelInboundHandler负责把二进制流转换为对象，ChannelOutboundHandler负责把对象转换为二进制流。

        接下来要构建一个Server，同时支持Person通讯协议和String通讯协议。

        Person通讯协议：二进制流与Person对象间的互相转换。

        String通讯协议：二进制流与有固定格式要求的String的相互转换。String格式表示的也是一个Person对象，格式规定为：name:xx;age:xx;sex:xx;

        这时候，来自客户端的请求，会依次传递给两个通讯解析接口进行解析，每个通讯接口判断是否是匹配的协议，如果是则进行解析，如果不是则传递给其它通讯接口进行解析。

实体类Person.java

package com.bijian.netty.dto;

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private String sex;
    private int age;

    public String toString() {
        return "name:" + name + " sex:" + sex + " age:" + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Server端的类为：Server.java、PersonDecoder.java、StringDecoder.java、BusinessHandler.java

1.Server.java开启Netty服务

package com.bijian.netty.server;

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

// 测试coder 和 handler 的混合使用  
public class Server {
    public void start(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new PersonDecoder());
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new BusinessHandler());
                        }
                    }).option(ChannelOption.SO_BACKLOG, 128).childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture f = b.bind(port).sync();

            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        Server server = new Server();
        server.start(8000);
    }
}

2.PersonDecoder.java把二进制流转换成Person对象

package com.bijian.netty.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

import com.bijian.netty.util.ByteBufToBytes;
import com.bijian.netty.util.ByteObjConverter;

public class PersonDecoder extends ByteToMessageDecoder {
    
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        byte n = "n".getBytes()[0];
        byte p = in.readByte();
        in.resetReaderIndex();
        if (n != p) {
            // 把读取的起始位置重置
            ByteBufToBytes reader = new ByteBufToBytes();
            out.add(ByteObjConverter.ByteToObject(reader.read(in)));
        } else {
            // 执行其它的decode
            ctx.fireChannelRead(in);
        }
    }
}

3.StringDecoder.java把满足条件的字符串转换成Person对象

package com.bijian.netty.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

import com.bijian.netty.dto.Person;
import com.bijian.netty.util.ByteBufToBytes;

public class StringDecoder extends ByteToMessageDecoder {
    
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        
        // 判断是否是String协议
        byte n = "n".getBytes()[0];
        byte p = in.readByte();
        // 把读取的起始位置重置
        in.resetReaderIndex();
        if (n == p) {
            ByteBufToBytes reader = new ByteBufToBytes();
            String msg = new String(reader.read(in));
            Person person = buildPerson(msg);
            out.add(person);
            //in.release();
        } else {
            ctx.fireChannelRead(in);
        }
    }

    private Person buildPerson(String msg) {
        
        Person person = new Person();
        String[] msgArray = msg.split(";|:");
        person.setName(msgArray[1]);
        person.setAge(Integer.parseInt(msgArray[3]));
        person.setSex(msgArray[5]);
        return person;
    }
}

4.BusinessHandler.java展现客户端请求的内容

package com.bijian.netty.server;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.bijian.netty.dto.Person;

public class BusinessHandler extends ChannelInboundHandlerAdapter {
    
    private Logger logger = LoggerFactory.getLogger(BusinessHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Person person = (Person) msg;
        logger.info("BusinessHandler read msg from client :" + person);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

客户端1发送Person格式的协议：Client.java、ClientInitHandler.java、PersonEncoder.java

1.Client.java

package com.bijian.netty.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 com.bijian.netty.dto.Person;

public class Client {
    
    public void connect(String host, int port) throws Exception {
        
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new PersonEncoder());
                    Person person = new Person();
                    person.setName("test");
                    person.setSex("man");
                    person.setAge(30);
                    ch.pipeline().addLast(new ClientInitHandler(person));
                }
            });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }

    }

    public static void main(String[] args) throws Exception {
        Client client = new Client();
        client.connect("127.0.0.1", 8000);
    }
}

2.ClientInitHandler.java向服务端发送Person对象

package com.bijian.netty.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.bijian.netty.dto.Person;

public class ClientInitHandler extends ChannelInboundHandlerAdapter {
    
    private static Logger logger = LoggerFactory.getLogger(ClientInitHandler.class);
    private Person person;

    public ClientInitHandler(Person person) {
        this.person = person;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        logger.info("ClientInitHandler.channelActive");
        ctx.write(person);
        ctx.flush();
    }
}

3.PersonEncoder.java把Person对象转换成二进制进行传送

package com.bijian.netty.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

import com.bijian.netty.dto.Person;
import com.bijian.netty.util.ByteObjConverter;

public class PersonEncoder extends MessageToByteEncoder<Person> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
        out.writeBytes(ByteObjConverter.ObjectToByte(msg));
    }
}

客户端2发送String格式的协议：Client2.java、StringEncoder.java同样使用了客户端1中定义的ClientInitHandler 进行数据发送操作。

1.Client2.java

package com.bijian.netty.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 com.bijian.netty.dto.Person;

public class Client2 {
    
    public void connect(String host, int port) throws Exception {
        
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new StringEncoder());
                    Person person = new Person();
                    person.setName("test2");
                    person.setSex("girl");
                    person.setAge(4);
                    ch.pipeline().addLast(new ClientInitHandler(person));
                }
            });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        Client2 client = new Client2();
        client.connect("127.0.0.1", 8000);
    }
}

2.StringEncoder.java把Person对象转换成固定格式的String的二进制流进行传送

package com.bijian.netty.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

import com.bijian.netty.dto.Person;

public class StringEncoder extends MessageToByteEncoder<Person> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
        // 转成字符串：name:xx;age:xx;sex:xx;
        StringBuffer sb = new StringBuffer();
        sb.append("name:").append(msg.getName()).append(";");
        sb.append("age:").append(msg.getAge()).append(";");
        sb.append("sex:").append(msg.getSex()).append(";");
        out.writeBytes(sb.toString().getBytes());
    }
}

        其它：工具类ByteBufToBytes（读取ByteBuf数据的工具类）、ByteObjConverter（Object与byte互转的工具类）在以前的文章中已经存在，在此省略。

注意事项：

        1.该段代码能运行出结果，但是运行的时候会报 io.netty.util.IllegalReferenceCountException: refCnt: 0, decrement: 1 异常，已经解决。日志中的提示信息为：

An exceptionCaught() event was fired, and it reached at the tail of the pipeline. It usually means the last handler in the pipeline did not handle the exception

说明缺少exceptionCaught方法，在server端最后一个Handler中增加这个方法即可。

        2.PersonDecoder和StringDecoder中有一个if判断，是为了判断消息究竟是什么协议。如果是String协议的话，格式是【name:xx;age:xx;sex:xx;】，第一个字母是英文字母n，所以判断协议类型时候是读取二进制流的第一个字符进行判断，当然这种判断方式非常幼稚，以后有机会可以进行改善。

 

文章来源：http://blog.csdn.net/u013252773/article/details/22108385

分享到：
| Netty4.0学习笔记系列之五：自定义通讯协议
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Netty4.0学习笔记系列之五：自定义通讯协议

    在本篇“Netty4.0学习笔记系列之五：自定义通讯协议”中，我们将深入探讨如何在Netty框架下构建和实现自己的通信协议。Netty是一个高性能、异步事件驱动的网络应用框架，广泛应用于Java领域的服务器开发，如网络游戏...

    Netty4.0学习笔记系列之四：混合使用coder和handler

    在本篇Netty4.0学习笔记中，我们将聚焦于如何在实际应用中混合使用`coder`和`handler`，这是Netty框架中非常关键的一部分，对于构建高性能、低延迟的网络应用程序至关重要。Netty是一个用Java编写的异步事件驱动的...

    Netty4.0学习笔记系列之二：Handler的执行顺序

    在本篇“Netty4.0学习笔记系列之二：Handler的执行顺序”中，我们将深入探讨Netty中的Handler处理链以及它们的执行流程。 首先，Netty 中的 ChannelHandler 是处理 I/O 事件或拦截 I/O 操作的核心组件。每个 ...

    Netty4.0学习笔记系列之三：构建简单的http服务

    Netty4.0学习笔记系列之三是关于构建简单的HTTP服务的教程，这主要涉及网络编程、服务器开发以及Java NIO（非阻塞I/O）的相关知识。Netty是一个高性能、异步事件驱动的网络应用程序框架，它使得开发可伸缩且稳定的...

    Netty4.0学习笔记系列之一：Server与Client的通讯

    在本文中，我们将深入探讨Netty 4.0的学习笔记，特别是关于Server与Client之间的通信机制。 首先，我们要理解Netty的核心概念——NIO（非阻塞I/O）。Netty基于Java NIO库构建，它提供了更高级别的API，简化了多路...

    Netty4.0 jar包 及 源代码 和 例子

    Netty4.0全部jar包.开发时候只需要倒入总的哪一个netty4.0.jar就行了 后缀为resources.jar的全部是源码。 简单的代码例子在netty-example-resources.jar里面。

    Netty4.0 官网例子（免费）

    7. **协议支持**：Netty 内置了对 HTTP、HTTPS、WebSocket、FTP、SMTP 等多种协议的支持，使得开发网络应用更加便捷。 8. **线程模型**：Netty 采用 NIO（非阻塞 I/O）模型，结合 Epoll（在 Linux 下）和 Kqueue...

    netty4.0文件分片上传+断点续传+权限校验

    Netty 是一个高性能、异步事件驱动...rrkd-file-client和rrkd-file-server这两个文件可能包含了实现上述功能的客户端和服务端代码示例，通过分析和学习这些代码，开发者可以更好地理解和应用Netty进行文件上传的实践。

    Netty4.0 http案例

    此外，Netty支持多种协议，如TCP、UDP、WebSocket、FTP等，使其成为一个非常灵活且强大的网络编程框架。 总的来说，这个"Netty4.0 http案例"涵盖了如何使用Netty构建高效、可扩展的HTTP服务器和客户端，以及如何...

    netty4.0工具包

    NIO socket开发，netty4.0工具包。

    Springboot 2.0 整合 Netty 4.0 实现IO异步通讯架构

    Springboot2.0.8集成 netty4 ，使用protobuf作为ping的数据交换，比json更加的小巧,占用数据量更小，可用于任何第三方应用做心跳监控。 已完成功能： - 客户端授权验证(基于protoBuff) - 心跳检测(基于protoBuff) ...

    netty4.0源码，netty例子，netty api文档

    5. **丰富的协议支持**：Netty内置了对多种常见网络协议的支持，如TCP、UDP、HTTP、FTP、SMTP、IMAP等，同时也支持自定义协议。 6. **易用性与灵活性**：Netty提供了许多便捷的API和工具，使得开发者可以快速构建...

    netty4.0.45jar包socket和http工具包

    Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在本文中，我们将深入探讨Netty 4.0.45版本在Socket和HTTP开发中的应用，以及它如何在实际的保险项目中提供...

    netty4.0 demo

    通过对"Netty4.0 demo"的学习，我们可以掌握Netty的基本用法，理解其异步事件驱动模型，以及如何构建和配置处理器链来处理网络通信。这些示例代码对于初学者来说是很好的实践材料，有助于快速上手Netty并应用于实际...

    netty-all-4.0.50.Final-API文档-中文版.zip

    赠送jar包：netty-all-4.0.50.Final.jar； 赠送原API文档：netty-all-4.0.50.Final-javadoc.jar； 赠送源代码：netty-all-4.0.50.Final-sources.jar； 赠送Maven依赖信息文件：netty-all-4.0.50.Final.pom； 包含...

    netty4.0中的新变化和注意点鸟窝.pdf

    在 Netty 4.0 中，引入了一系列重大改进和变化，旨在提高性能、可维护性和易用性。以下是这些变化的详细说明： 1. **工程结构的改变**： - 包名从 org.jboss.netty 更改为 io.netty，反映了项目的独立性。 - ...

    Netty4.0.54英文版API文档

    Netty4.0.54英文版API文档,与官网中文档内容一致，方便用户在离线环境下，开发Netty

    netty-4.0.28.Final

    Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序dsf。...netty, 4.0.28, Final, jar包， 含源码

    Netty进阶之路：跟着案例学Netty 完整版.pdf

    《Netty进阶之路：跟着案例学Netty》中的案例涵盖了Netty的启动和停止、内存、并发多线程、性能、可靠性、安全等方面，囊括了Netty绝大多数常用的功能及容易让人犯错的地方。在案例的分析过程中，还穿插讲解了Netty...

Magicbox
Global site tag (gtag.js) - Google Analytics