netty编程

最新推荐文章于 2024-06-25 17:48:46 发布

losemyfuture

最新推荐文章于 2024-06-25 17:48:46 发布

阅读量393

点赞数

分类专栏： Java json xml 网络 NIO netty losemyfuture的博客文章标签： netty

本文链接：https://blog.csdn.net/qq_37049496/article/details/81380281

版权

Java 同时被 3 个专栏收录

42 篇文章 3 订阅

订阅专栏

losemyfuture的博客

25 篇文章 0 订阅

订阅专栏

网络

3 篇文章 0 订阅

订阅专栏

1 netty概述

一个基于Java NIO类库的异步通信框架，他的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性，常用在dubbo、Zookeeper、RocketMQ底层RPC通讯机制，游戏开发等

为什么使用netty？

1）NIO的类库和API繁杂，使用麻烦，你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等

2）需要具备其它的额外技能做铺垫，例如熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网路编程非常熟悉，才能编写出高质量的NIO程序；

3）可靠性能力补齐，工作量和难度都非常大。例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等等，NIO编程的特点是功能开发相对容易，但是可靠性能力补齐工作量和难度都非常大；

4） JDK NIO的BUG，例如臭名昭著的epoll bug，它会导致Selector空轮询，最终导致CPU 100%。官方声称在JDK1.6版本的update18修复了该问题，但是直到JDK1.7版本该问题仍旧存在，只不过该bug发生概率降低了一些而已，它并没有被根本解决。

2 Netty服务端

//Netty服务器端

class ServerHandler extends SimpleChannelHandler{
    //通道关闭时触发
    @Override
    public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelClosed(ctx, e);
        System.out.println("channelClosed");
    }

    //必须是连接已经建立，关闭通道时才会触发
    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelConnected(ctx, e);
        System.out.println("channelDisconnected");
    }

    //捕获异常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
        super.exceptionCaught(ctx, e);
        System.out.println("exceptionCaught");

    }

    //接受消息
    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        super.messageReceived(ctx, e);
        System.out.println("服务端收到客户端消息:"+e.getMessage());
    }
}
public class NettyServer {
    public static void main(String[] args) {
        //1、创建服务对象
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        //2、创建两个线程池 一个监听端口号 一个NIO监听
        ExecutorService boos = Executors.newCachedThreadPool();
        ExecutorService works = Executors.newCachedThreadPool();
        //3、设置工厂 并将两个线程池放入其中
        serverBootstrap.setFactory(new NioServerSocketChannelFactory(boos,works));
        //4、设置管道工厂
        serverBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() throws Exception {
                ChannelPipeline pipeline= Channels.pipeline();
                //将数据转换为String类型
                pipeline.addLast("decoder",new StringDecoder());
                pipeline.addLast("encoder",new StringEncoder());
                pipeline.addLast("serverHandler",new ServerHandler());
                return pipeline;
            }
        });
        //绑定端口号
        serverBootstrap.bind(new InetSocketAddress(8080));
        System.out.println("netty服务端启动。。。。");
        while(true){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("周期运行服务端自己的东西。。。");
        }
    }
}

3 Netty客户端

class ClientHandler extends SimpleChannelHandler{
    /**
     * 通道关闭的时候触发
     */
    @Override
    public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelClosed(ctx, e);
        System.out.println("channelClosed");
    }

    /**
     * 必须是连接已经建立,关闭通道的时候才会触发.
     */
    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelDisconnected(ctx, e);
        System.out.println("channelDisconnected");
    }

    /**
     * 捕获异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
        super.exceptionCaught(ctx, e);
        System.out.println("exceptionCaught");

    }

    /**
     * 接受消息
     */
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        super.messageReceived(ctx, e);
//		System.out.println("messageReceived");
        System.out.println("服务器端向客户端回复内容:"+e.getMessage());
        //回复内容
//		ctx.getChannel().write("好的");
    }

}
public class NettyClient {
    public static void main(String[] args) {
        //1、创建服务对象
        ClientBootstrap clientBootstrap = new ClientBootstrap();
        //2、创建两个线程池 一个监听端口号 一个NIO监听
        ExecutorService boos = Executors.newCachedThreadPool();
        ExecutorService works = Executors.newCachedThreadPool();
        //3、设置工厂 并将两个线程池放入其中
        clientBootstrap.setFactory(new NioClientSocketChannelFactory(boos,works));
        //4、设置管道工厂
        clientBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() throws Exception {
                ChannelPipeline pipeline= Channels.pipeline();
                //将数据转换为String类型
                pipeline.addLast("decoder",new StringDecoder());
                pipeline.addLast("encoder",new StringEncoder());
                pipeline.addLast("serverHandler",new ClientHandler());
                return pipeline;
            }
        });
        //连接服务器
        ChannelFuture connect=clientBootstrap.connect(new InetSocketAddress("127.0.0.1",8080));
        Channel channel = connect.getChannel();
        System.out.println("Clinet start.....");
        Scanner scanner=new Scanner(System.in);
        while (true){
            System.out.println("请输入内容。。。。。");
            channel.write(scanner.next());
        }

    }
}

4 长连接和短连接区别

短连接：客户端与服务端连接成功发送数据后就立即断开（比如http协议）。

长连接：客户端与服务端连接成功一次后，会一直保持连接状态，不会立即断开（所以netty客户端和服务端启动后，如果你直接停掉客户端就会报错，因为你没有正常关闭、四次挥手！！！！），常用于移动端消息推送、MQ等。直接上代码：

//服务端
class ServerHandler extends ChannelHandlerAdapter {
    /**
     * 当通道被调用,执行该方法
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 接收数据
        String value = (String) msg;
        System.out.println("Server msg:" + value);
        // 回复给客户端 “您好!”
        String res = "好的...";
        ctx.writeAndFlush(Unpooled.copiedBuffer(res.getBytes()));
    }

}

public class NettyServer {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("服务器端已经启动....");
        // 1.创建2个线程池,一个负责接收客户端连接， 一个负责进行 传输数据
        NioEventLoopGroup pGroup = new NioEventLoopGroup();
        NioEventLoopGroup cGroup = new NioEventLoopGroup();
        // 2. 创建服务器辅助类
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, cGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 1024)
                // 3.设置缓冲区与发送区大小
                .option(ChannelOption.SO_SNDBUF, 32 * 1024).option(ChannelOption.SO_RCVBUF, 32 * 1024)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        //设置消息为string类型
                        sc.pipeline().addLast(new StringDecoder());
                        sc.pipeline().addLast(new ServerHandler());
                    }
                });
        //启动
        ChannelFuture cf = b.bind(8080).sync();
        //关闭
        cf.channel().closeFuture().sync();
        pGroup.shutdownGracefully();
        cGroup.shutdownGracefully();

    }

}


//客户端
class ClientHandler extends ChannelHandlerAdapter {

    /**
     * 当通道被调用,执行该方法
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 接收数据
        String value = (String) msg;
        System.out.println("服务端数据:" + value);
    }


}

public class NettyClient {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("客户端已经启动....");
        // 创建负责接收客户端连接
        NioEventLoopGroup pGroup = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap();
        b.group(pGroup).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(new StringDecoder());
                sc.pipeline().addLast(new ClientHandler());
            }
        });
        ChannelFuture cf = b.connect("127.0.0.1", 8080).sync();
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端001".getBytes()));
        // 等待客户端端口号关闭
        cf.channel().closeFuture().sync();
        pGroup.shutdownGracefully();

    }

}

以上代码启动后，如果直接停掉客户端就会报错（长连接）：

警告: 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.
java.io.IOException: 远程主机强迫关闭了一个现有的连接。
	at sun.nio.ch.SocketDispatcher.read0(Native Method)
	at sun.nio.ch.SocketDispatcher.read(SocketDispatcher.java:43)

5 粘包/拆包

        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端001".getBytes()));
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端002".getBytes()));
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端003".getBytes()));
        Thread.sleep(1000);
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端004".getBytes()));
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("我是客户端005".getBytes()));

如果客户端按照以上这种发送则服务端响应如下（注意这个运行结果可能因设备不同而不同）：

Server msg:我是客户端001我是客户端002我是客户端003
Server msg:我是客户端004
Server msg:我是客户端005

为什么会有以上结果呢？也就是三次请求，如下图，客户端发送的5个数据包，由于TCP发送数据时做了优化（为什么？比如上面的将123三个包合在一起发送。。因为不做优化那岂不是发送一小点数据也要请求一次？这效率不用说吧），所以sleep导致通道的阻塞后，客户端会把123这三个已经准备好的数据包先发送到服务端，而由于TCP的优化导致这三个本来要独立发送的包粘在一起了，这便是粘包（把多个小的包封装成一个大的数据包发送），sleep休眠之后再发送其他（45）数据包。如果将sleep去掉呢？道理也是一样，此处不做分析。。

假如我按照下面这种方式发送数据呢，服务端会是怎么响应？

        for (int i = 0; i < 101; i++) {
            cf.channel().write(Unpooled.wrappedBuffer(new String("我是消息"+i).getBytes()));
        }
        cf.channel().flush();

Server msg:我是消息0我是消息1我是消息2我是消息3我是消息4我是消息5我是消息6我是消息7我是消息8我是消息9我是消息10我是消息11我是消息12我是消息13我是消息14我是消息15
Server msg:我是消息16我是消息17我是消息18我是消息19我是消息20我是消息21我是消息22我是消息23我是消息24我是消息25我是消息26我是消息27我是消息28我是消息29我是消息30我是消息31我是消息32我是消息33我是消息34我是消息35我是消息36我是消息37我是消息38我是消息39我是消息40我是消息41我是消息42我是消息43我是消息44我是消息45我是消息46我是消息47我是消息48我是消息49我是消息50我是消息51我是消息52我是消息53我是消息54我是消息55我是消息56我是消息57我是消息58我是消息59我是消息60我是消息61我是消息62我是消息63我是消息64我是消息65我是消息66我是消息67我是消息68我是消息69我是消息70我是消息71我是消息72我是消息73我是消息74我是消息75我是消息76我是消息77我是消息78我是消息79我是消息80我是消息81我是消息82我是消息83我是消息84我是消息85我是消息86我是消息87我是消息88�
Server msg:�是消息89我是消息90我是消息91我是消息92我是消息93我是消息94我是消息95我是消息96我是消息97我是消息98我是消息99我是消息100

明显看到客户端明明只发送了一个数据包，但是服务端却响应了三次。也就是将一个数据包拆分成多个数据包发送，这便是拆包（一个完整的业务可能会被TCP拆分成多个包进行发送）。

1. 第一种情况，Data1和Data2都分开发送到了Server端，没有产生粘包和拆包的情况。

2. 第二种情况，Data1和Data2数据粘在了一起，打成了一个大的包发送到Server端，这个情况就是粘包。

3. 第三种情况，Data2被分离成Data2_1和Data2_2，并且Data2_1在Data1之前到达了服务端，这种情况就产生了拆包。

由于网络的复杂性，可能数据会被分离成N多个复杂的拆包/粘包的情况，所以在做TCP服务器的时候就需要首先解决拆包

怎么解决呢？

一般有以下几种解决方式：

1、消息定长，报文固定大小，不够空格不全，发送和接收方遵循相同的约定，这样即使粘包了通过接收方编程实现获取定长报文也能区分

sc.pipeline().addLast(new FixedLengthFrameDecoder(10));

2、包尾添加特殊分隔符，例如每条结束都添加回车换行符（例如FTP协议）或者指定特殊操作字符作为报文分隔符，接收方通过特殊分隔符切分报文区分。

ByteBuf buf = Unpooled.copiedBuffer("^".getBytes());
sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));

3、将消息分为消息头后消息体，消息头中包含表示信息的总长度（或者消息体长度）的字段

6 序列化与自定义序列化协议

序列化（serialization）就是讲对象序列化为二进制形式（字节数组），主要用于网络传输、数据持久化等

反序列化（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，主要用于网络传输对象的解码，以便完成远程调用。

比如是Java默认提供的序列化机制，需要序列化的Java对象只需要实现 Serializable / Externalizable 接口并生成序列化ID，这个类就能够通过 ObjectInput 和 ObjectOutput 序列化和反序列化。但是Java默认提供的序列化有很多问题，主要有以下几个缺点：

无法跨语言：我认为这对于Java序列化的发展是致命的“失误”，因为Java序列化后的字节数组，其它语言无法进行反序列化。；

序列化后的码流太大:：相对于目前主流的序列化协议，Java序列化后的码流太大；

序列化的性能差：由于Java序列化采用同步阻塞IO，相对于目前主流的序列化协议，它的效率非常差。

影响序列化性能的关键因素

序列化后的码流大小（网络带宽的占用）；

序列化的性能（CPU资源占用）；

是否支持跨语言（异构系统的对接和开发语言切换）。

这里以一个netty5+Jboss来测试一个简单的序列化对象

Maven：

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha2</version>
        </dependency>
        <dependency>
            <groupId>org.jboss.marshalling</groupId>
            <artifactId>jboss-marshalling-serial</artifactId>
            <version>2.0.0.Beta2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>

消息体：

@Data
public class UserEntity implements Serializable {
    private static final long SerialVersionUID=1L;
    private Integer id;
    private String username;
}

服务端：

class SubReqServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        UserEntity user= (UserEntity) msg;
        System.out.println("服务器端收到的:"+user.getUsername()+"----"+user.getId());
        ctx.writeAndFlush(getUser(2));
    }
    private UserEntity getUser(Integer id){
        UserEntity userEntity = new UserEntity();
        userEntity.setId(id);
        userEntity.setUsername("itlose");
        return userEntity;
    }
}
public class NettyServer {
    public static void main(String[] args) {
        //配置服务端的NIO线程组
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,100)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(MarshallingCodeFactory.buildMarshallingDecoder());
                            socketChannel.pipeline().addLast(MarshallingCodeFactory.buildMarshallingEncoder());
                            socketChannel.pipeline().addLast(new SubReqServerHandler());
                        }
                    });
            //绑定端口，同步等待成功
            ChannelFuture c = bootstrap.bind(8080).sync();
            //等待服务端监听端口关闭
            c.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

客户端：

class SubReqClientHandler extends ChannelHandlerAdapter {
    /**
     * 客户端与服务端进行连接 可以发送数据
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端与服务端进行连接成功。。。");
        ctx.write(getUser(1));
        ctx.flush();
    }
    private UserEntity getUser(Integer id){
        UserEntity userEntity = new UserEntity();
        userEntity.setId(id);
        userEntity.setUsername("itlose");
        return userEntity;
    }

    /**
     * 当Channel上的某个读操作完成时被调用
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        UserEntity userEntity= (UserEntity) msg;
        System.out.println("客户端收到:"+userEntity.getUsername()+"----"+userEntity.getId());
        ctx.writeAndFlush(getUser(userEntity.getId()));
    }
}
public class NettyClient {
    private static UserEntity getUser(Integer id){
        UserEntity userEntity = new UserEntity();
        userEntity.setId(id);
        userEntity.setUsername("itlose");
        return userEntity;
    }
    public static void main(String[] args) {
        NioEventLoopGroup g = new NioEventLoopGroup();
        try{
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(g).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(MarshallingCodeFactory.buildMarshallingEncoder());
                            socketChannel.pipeline().addLast(MarshallingCodeFactory.buildMarshallingDecoder());
                            socketChannel.pipeline().addLast(new SubReqClientHandler());
                        }
                    });
            ChannelFuture connect = bootstrap.connect("127.0.0.1", 8080);
            connect.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            g.shutdownGracefully();
        }
    }
}

IO处理类：

//final表示该类不可继承，主要是序列化以后的字节数组（文件）不能被改变，保证反序列化成功
public final class MarshallingCodeFactory {
    /**
     * 创建Jboss Marshalling解码器
     * @return
     */
    public static MarshallingDecoder buildMarshallingDecoder(){
       final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
       final MarshallingConfiguration configuration = new MarshallingConfiguration();
       configuration.setVersion(5);
        DefaultUnmarshallerProvider defaultUnmarshallerProvider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
        MarshallingDecoder marshallingDecoder = new MarshallingDecoder(defaultUnmarshallerProvider, 1024);
        return marshallingDecoder;
    }
    public static MarshallingEncoder buildMarshallingEncoder(){
        final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        final MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);
        MarshallerProvider defaultUnmarshallerProvider = new DefaultMarshallerProvider(marshallerFactory, configuration);
        MarshallingEncoder marshallingEncoder = new MarshallingEncoder(defaultUnmarshallerProvider);
        return marshallingEncoder;
    }
}

8 几种流行的序列化协议比较

8.1XML

（1）定义：

XML（Extensible Markup Language）是一种常用的序列化和反序列化协议，它历史悠久，从1998年的1.0版本被广泛使用至今。

（2）优点

人机可读性好

可指定元素或特性的名称

（3）缺点

序列化数据只包含数据本身以及类的结构，不包括类型标识和程序集信息。

类必须有一个将由XmlSerializer 序列化的默认构造函数。

只能序列化公共属性和字段

不能序列化方法

文件庞大，文件格式复杂，传输占带宽

（4）使用场景

当做配置文件存储数据

实时数据转换

8.2 JSON

（1）定义：

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript (w3c制定的js规范)的一个子集， JSON采用与编程语言无关的文本格式，但是也使用了类C语言（包括C， C++， C#， Java， JavaScript， Perl， Python等）的习惯，简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

（2）优点

前后兼容性高

数据格式比较简单，易于读写

序列化后数据较小，可扩展性好，兼容性好

与XML相比，其协议比较简单，解析速度比较快

（3）缺点

数据的描述性比XML差

不适合性能要求为ms级别的情况

额外空间开销比较大

（4）适用场景（可替代ＸＭＬ）

跨防火墙访问

可调式性要求高的情况

基于Web browser的Ajax请求

传输数据量相对小，实时性要求相对低（例如秒级别）的服务

8.3 Fastjson

（1）定义

Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致。

（2）优点

接口简单易用

目前java语言中最快的json库

（3）缺点

过于注重快，而偏离了“标准”及功能性

代码质量不高，文档不全

（4）适用场景

协议交互

Web输出

Android客户端

8.4 Thrift

（1）定义：

Thrift并不仅仅是序列化协议，而是一个RPC框架。它可以让你选择客户端与服务端之间传输通信协议的类别，即文本(text)和二进制(binary)传输协议, 为节约带宽，提供传输效率，一般情况下使用二进制类型的传输协议。

（2）优点

序列化后的体积小, 速度快

支持多种语言和丰富的数据类型

对于数据字段的增删具有较强的兼容性

支持二进制压缩编码

（3）缺点

使用者较少

跨防火墙访问时，不安全

不具有可读性，调试代码时相对困难

不能与其他传输层协议共同使用（例如HTTP）

无法支持向持久层直接读写数据，即不适合做数据持久化序列化协议

（4）适用场景

分布式系统的RPC解决方案

8.5 Avro

（1）定义：

Avro属于Apache Hadoop的一个子项目。 Avro提供两种序列化格式：JSON格式或者Binary格式。Binary格式在空间开销和解析性能方面可以和Protobuf媲美，Avro的产生解决了JSON的冗长和没有IDL的问题

（2）优点

支持丰富的数据类型

简单的动态语言结合功能

具有自我描述属性

提高了数据解析速度

快速可压缩的二进制数据形式

可以实现远程过程调用RPC

支持跨编程语言实现

（3）缺点

对于习惯于静态类型语言的用户不直观

（4）适用场景

在Hadoop中做Hive、Pig和MapReduce的持久化数据格式

8.6 Protobuf

（1）定义

protocol buffers 由谷歌开源而来，在谷歌内部久经考验。它将数据结构以.proto文件进行描述，通过代码生成工具可以生成对应数据结构的POJO对象和Protobuf相关的方法和属性。

（2）优点

序列化后码流小，性能高

结构化数据存储格式（XML JSON等）

通过标识字段的顺序，可以实现协议的前向兼容

结构化的文档更容易管理和维护

（3）缺点

需要依赖于工具生成代码

支持的语言相对较少，官方只支持Java 、C++ 、Python

（4）适用场景

对性能要求高的RPC调用

具有良好的跨防火墙的访问属性

适合应用层对象的持久化

8.7 其它

protostuff 基于protobuf协议，但不需要配置proto文件，直接导包即

Jboss marshaling 可以直接序列化java类，无须实java.io.Serializable接口

Message pack 一个高效的二进制序列化格式

Hessian 采用二进制协议的轻量级remoting onhttp工具

kryo 基于protobuf协议，只支持java语言,需要注册（Registration），然后序列化（Output），反序列化（Input）

8.8 性能对比图解

时间

空间

分析上图知：

XML序列化（Xstream）无论在性能和简洁性上比较差。

Thrift与Protobuf相比在时空开销方面都有一定的劣势。

Protobuf和Avro在两方面表现都非常优越。

选型建议

不同的场景适用的序列化协议：

对于公司间的系统调用，如果性能要求在100ms以上的服务，基于XML的SOAP协议是一个值得考虑的方案。

基于Web browser的Ajax，以及Mobile app与服务端之间的通讯，JSON协议是首选。对于性能要求不太高，或者以动态类型语言为主，或者传输数据载荷很小的的运用场景，JSON也是非常不错的选择。

对于调试环境比较恶劣的场景，采用JSON或XML能够极大的提高调试效率，降低系统开发成本。

当对性能和简洁性有极高要求的场景，Protobuf，Thrift，Avro之间具有一定的竞争关系。

对于T级别的数据的持久化应用场景，Protobuf和Avro是首要选择。如果持久化后的数据存储在Hadoop子项目里，Avro会是更好的选择。

由于Avro的设计理念偏向于动态类型语言，对于动态语言为主的应用场景，Avro是更好的选择。

对于持久层非Hadoop项目，以静态类型语言为主的应用场景，Protobuf会更符合静态类型语言工程师的开发习惯。

如果需要提供一个完整的RPC解决方案，Thrift是一个好的选择。

如果序列化之后需要支持不同的传输层协议，或者需要跨防火墙访问的高性能场景，Protobuf可以优先考虑。

losemyfuture

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
netty编程

目录1 netty概述2 Netty服务端3 Netty客户端4 长连接和短连接区别5 粘包/拆包怎么解决呢？6 序列化与自定义序列化协议8 几种流行的序列化协议比较8.1XML8.2 JSON8.3 Fastjson8.4 Thrift8.5 Avro8.6 Protobuf8.7 其它8.8 性能对比图解选型建议1 net...
复制链接

扫一扫

专栏目录