Netty 进阶篇（待完成）

已于 2022-10-09 11:17:50 修改
阅读量331 收藏 1
点赞数 1
分类专栏： Netty 文章标签： java
于 2022-04-17 09:59:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43102784/article/details/123999220
版权

第 1 章 Google Protobuf

1.1 编码和解码的基本介绍

  1. 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码

  2. codec(编解码器) 的组成部分有两个：decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节 码数据，decoder 负责把字节码数据转换成业务数据
    在这里插入图片描述

1.2 Netty 本身的编码解码的机制和问题分析

  1. Netty 自身提供了一些 codec(编解码器)
  2. Netty 提供的编码器 StringEncoder，
    对字符串数据进行编码 ObjectEncoder，
    对 Java 对象进行编码
    …
  3. Netty 提供的解码器
    StringDecoder, 对字符串数据进行解码 ObjectDecoder，
    对 Java 对象进行解码
    …
  4. Netty 本身自带的 ObjectDecoder 和 ObjectEncoder 可以用来实现 POJO 对象或各种业务对象的编码和解码，底层使用的仍是 Java 序列化技术 , 而 Java 序列化技术本身效率就不高，存在如下问题
  • 无法跨语言
  • 序列化后的体积太大，是二进制编码的 5 倍多。
  • 序列化性能太低
  1. => 引出 新的解决方案 [Google 的 Protobuf]

1.3 Protobuf

  1. Protobuf 基本介绍和使用示意图
  2. Protobuf 是 Google 发布的开源项目，全称 Google Protocol Buffers，是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC[远程过程调用 remote procedure call ] 数据交换格式 。
    目前很多公司 http+json tcp+protobuf
  3. 参考文档 : https://developers.google.com/protocol-buffers/docs/proto 语言指南
  4. Protobuf 是以 message 的方式来管理数据的.
  5. 支持跨平台、跨语言，即[客户端和服务器端可以是不同的语言编写的] （支持目前绝大多数语言，例如 C++、 C#、Java、python 等）
  6. 高性能，高可靠性
  7. 使用 protobuf 编译器能自动生成代码，Protobuf 是将类的定义使用.proto 文件进行描述。说明，在 idea 中编写 .proto 文件时，会自动提示是否下载 .ptotot 编写插件. 可以让语法高亮。
  8. 然后通过 protoc.exe 编译器根据.proto 自动生成.java 文件
  9. protobuf 使用示意图
    在这里插入图片描述

1.4 Protobuf 快速入门实例

编写程序，使用 Protobuf 完成如下功能

  1. 客户端可以发送一个 Student PoJo 对象到服务器 (通过 Protobuf 编码)
  2. 服务端能接收 Student PoJo 对象，并显示信息(通过 Protobuf 解码)
  3. 代码
    在这里插入图片描述
  • 引入依赖
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.6.1</version>
        </dependency>
  • Student.proto
syntax = "proto3"; //版本
option java_outer_classname = "StudentPOJO";//生成的外部类名，同时也是文件名
//protobuf 使用message 管理数据
message Student { //会在 StudentPOJO 外部类生成一个内部类 Student， 他是真正发送的POJO对象
    int32 id = 1; // Student 类中有 一个属性 名字为 id 类型为int32(protobuf类型) 1表示属性序号，不是值
    string name = 2;
}
  • 编译执行生成文件
    把Student.proto拷贝到如图目录下
    在这里插入图片描述
    cmd 执行命令：protoc.exe --java_out=. Student.proto
    将会生成如图文件
    在这里插入图片描述
    将生成的 StudentPOJO 放入到项目使用
    在这里插入图片描述
  • 运行测试
    在这里插入图片描述

1.5 Protobuf 快速入门实例 2

  1. 编写程序，使用 Protobuf 完成如下功能
  2. 客户端可以随机发送 Student PoJo/ Worker PoJo 对象到服务器 (通过 Protobuf 编码)
  3. 服务端能接收 Student PoJo/ Worker PoJo 对象(需要判断是哪种类型)，并显示信息(通过 Protobuf 解码)
  4. 代码
    在这里插入图片描述
  • Student.proto
syntax = "proto3";
option optimize_for = SPEED; // 加快解析
option java_package="com.atguigu.netty.codec2";   //指定生成到哪个包下
option java_outer_classname="MyDataInfo"; // 外部类名, 文件名

//protobuf 可以使用message 管理其他的message
message MyMessage {

    //定义一个枚举类型
    enum DataType {
        StudentType = 0; //在proto3 要求enum的编号从0开始
        WorkerType = 1;
    }

    //用data_type 来标识传的是哪一个枚举类型
    DataType data_type = 1;

    //表示每次枚举类型最多只能出现其中的一个, 节省空间
    oneof dataBody {
        Student student = 2;
        Worker worker = 3;
    }

}

message Student {
    int32 id = 1;//Student类的属性
    string name = 2; //
}
message Worker {
    string name=1;
    int32 age=2;
}
  • 编译生成文件同实例1一样操作
    cmd 命令： protoc.exe --java_out=. Student.proto
    在这里插入图片描述
    执行完成后如图生成MyDataInfo
    在这里插入图片描述
    拷贝到对应IDE开发目录下：
    在这里插入图片描述
    生成的代码结构
    在这里插入图片描述
  • 运行测试
    在这里插入图片描述

感觉实际开发中应该用不到protobuf,上面的实例也是写得也是比较简单， 源码gitee

第 2 章 Netty 编解码器和 handler 的调用机制

2.1 基本说明

  1. netty 的组件设计：Netty 的主要组件有 Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe 等
  2. ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时 ，也可以从 ChannelInboundHandler 冲刷数据 。 业务逻辑通常写在一个或者多个 ChannelInboundHandler 中。ChannelOutboundHandler 原理一样，只不过它是用来处理出站数据的
  3. ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到 服务端的，那么我们称这些事件为出站的，即客户端发送给服务端的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之则称为入站的
    在这里插入图片描述
    出站，入站如果搞不清楚，看下面的Netty的handler链的调用机制，通过一个例子和图讲清楚

2.2 编码解码器

  1. 当 Netty 发送或者接受一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节转换为另一种 格式（比如 java 对象）；如果是出站消息，它会被编码成字节。
  2. Netty 提供一系列实用的编解码器，他们都实现了 ChannelInboundHadnler 或者 ChannelOutboundHandler 接口。 在这些类中，channelRead 方法已经被重写了。以入站为例，对于每个从入站 Channel 读取的消息，这个方法会 被调用。随后，它将调用由解码器所提供的 decode()方法进行解码，并将已经解码的字节转发给 ChannelPipeline 中的下一个 ChannelInboundHandler。

2.3 解码器-ByteToMessageDecoder

  1. 关系继承图
    在这里插入图片描述
  2. 由于不可能知道远程节点是否会一次性发送一个完整的信息，tcp 有可能出现粘包拆包的问题，这个类会对入 站数据进行缓冲，直到它准备好被处理.
  3. 一个关于 ByteToMessageDecoder 实例分析
    在这里插入图片描述

2.4 Netty 的 handler 链的调用机制

实例要求:

  1. 使用自定义的编码器和解码器来说明 Netty 的 handler 调用机制 客户端发送 long -> 服务器 服务端发送 long -> 客户端
  2. 案例演示
    在这里插入图片描述

第 11 章用 Netty 自己 实现 dubbo RPC

11.1 RPC 基本介绍

  1. RPC（Remote Procedure Call）— 远程过程调用，是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程

  2. 两个或多个应用程序都分布在不同的服务器上，它们之间的调用都像是本地方法调用一样(如图)
    在这里插入图片描述
    过程：

     1.调用者(Caller)，调用远程API(Remote API)
 2.调用远程API会通过一个RPC代理(RpcProxy)
 3.RPC代理再去调用RpcInvoker(这个是PRC的调用者)
 4.RpcInvoker通过RPC连接器(RpcConnector)
 5.RPC连接器用两台机器规定好的PRC协议(RpcProtocol)把数据进行编码
 6.接着RPC连接器通过RpcChannel通道发送到对方的PRC接收器(RpcAcceptor)
 7.PRC接收器通过PRC协议进行解码拿到数据
 8.然后将数据传给RpcProcessor
 9.RpcProcessor再传给RpcInvoker
 10.RpcInvoker调用Remote API
 11.最后推给被调用者(Callee)

  3. 常见的 RPC 框架有: 比较知名的如阿里的Dubbo、google的gRPC、Go语言的rpcx、Apache的thrift，Spring 旗下的 Spring Cloud。

11.2 RPC 调用流程图

在这里插入图片描述

11.3 PRC 调用流程说明

  1. 服务消费方(client)以本地调用方式调用服务
  2. client stub 接收到调用后负责将方法、参数等封装成能够进行网络传输的消息体
  3. client stub 将消息进行编码并发送到服务端
  4. server stub 收到消息后进行解码
  5. server stub 根据解码结果调用本地的服务
  6. 本地服务执行并将结果返回给 server stub
  7. server stub 将返回导入结果进行编码并发送至消费方
  8. client stub 接收到消息并进行解码
  9. 服务消费方(client)得到结果

小结：RPC 的目标就是将 2-8 这些步骤都封装起来，用户无需关心这些细节，可以像调用本地方法一样即可完成远程服务调用

11.4 自己实现 dubbo RPC(基于 Netty)

11.4.1 需求说明

  1. dubbo 底层使用了 Netty 作为网络通讯框架，要求用 Netty 实现一个简单的 RPC 框架
  2. 模仿 dubbo，消费者和提供者约定接口和协议，消费者远程调用提供者的服务，提供者返回一个字符串，消费者打印提供者返回的数据。底层网络通信使用 Netty 4.1.20

11.4.2 设计说明

  1. 创建一个接口，定义抽象方法。用于消费者和提供者之间的约定。
  2. 创建一个提供者，该类需要监听消费者的请求，并按照约定返回数据。
  3. 创建一个消费者，该类需要透明的调用自己不存在的方法，内部需要使用 Netty 请求提供者返回数据
  4. 开发的分析图
    在这里插入图片描述
  • 代码结构
    在这里插入图片描述
  • 封装的RPC

可以把这块代码理解成封装的dubbo

  1. NettyServer
package com.atguigu.netty.dubborpc.netty;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyServer {

    public static void startServer(String hostName, int port) {
        startServer0(hostName,port);
    }

    //编写一个方法，完成对NettyServer的初始化和启动
    private static void startServer0(String hostname, int port) {

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {

            ServerBootstrap serverBootstrap = new ServerBootstrap();

            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                                      @Override
                                      protected void initChannel(SocketChannel ch) throws Exception {
                                          ChannelPipeline pipeline = ch.pipeline();
                                          pipeline.addLast(new StringDecoder());
                                          pipeline.addLast(new StringEncoder());
                                          pipeline.addLast(new NettyServerHandler()); //业务处理器

                                      }
                                  }

                    );

            ChannelFuture channelFuture = serverBootstrap.bind(hostname, port).sync();
            System.out.println("服务提供方开始提供服务~~");
            channelFuture.channel().closeFuture().sync();

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

    }
}
  1. NettyServerHandler
package com.atguigu.netty.dubborpc.netty;


import com.atguigu.netty.dubborpc.customer.ClientBootstrap;
import com.atguigu.netty.dubborpc.provider.HelloServiceImpl;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

//服务器这边handler比较简单
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送的消息，并调用服务
        System.out.println("msg=" + msg);
        //客户端在调用服务器的api 时，我们需要定义一个协议
        //比如我们要求 每次发消息是都必须以某个字符串开头 "HelloService#hello#你好"
        if(msg.toString().startsWith(ClientBootstrap.providerName)) {

            String result = new HelloServiceImpl().hello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
            ctx.writeAndFlush(result);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}
  1. NettyClient
package com.atguigu.netty.dubborpc.netty;


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.lang.reflect.Proxy;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NettyClient {

    //创建线程池
    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    private static NettyClientHandler client;
    private int count = 0;

    //编写方法使用代理模式，获取一个代理对象
    public Object getBean(final Class<?> serivceClass, final String providerName) {

        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serivceClass}, (proxy, method, args) -> {

                    System.out.println("(proxy, method, args) 进入...." + (++count) + " 次");
                    //{}  部分的代码，客户端每调用一次 hello, 就会进入到该代码
                    if (client == null) {
                        initClient();
                    }

                    //设置要发给服务器端的信息
                    //providerName 协议头 args[0] 就是客户端调用api hello(???), 参数
                    client.setPara(providerName + args[0]);

                    //
                    return executor.submit(client).get();

                });
    }

    //初始化客户端
    private static void initClient() {
        client = new NettyClientHandler();
        //创建EventLoopGroup
        NioEventLoopGroup group = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(
                        new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline pipeline = ch.pipeline();
                                pipeline.addLast(new StringDecoder());
                                pipeline.addLast(new StringEncoder());
                                pipeline.addLast(client);
                            }
                        }
                );

        try {
            bootstrap.connect("127.0.0.1", 7000).sync();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. NettyClientHandler
package com.atguigu.netty.dubborpc.netty;

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

import java.util.concurrent.Callable;

public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {

    private ChannelHandlerContext context;//上下文
    private String result; //返回的结果
    private String para; //客户端调用方法时，传入的参数
    
    //与服务器的连接创建后，就会被调用, 这个方法是第一个被调用(1)
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(" channelActive 被调用  ");
        context = ctx; //因为我们在其它方法会使用到 ctx
    }

    //收到服务器的数据后，调用方法 (4)
    //
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println(" channelRead 被调用  ");
        result = msg.toString();
        notify(); //唤醒等待的线程
    }

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

    //被代理对象调用, 发送数据给服务器，-> wait -> 等待被唤醒(channelRead) -> 返回结果 (3)-》5
    @Override
    public synchronized Object call() throws Exception {
        System.out.println(" call1 被调用  ");
        context.writeAndFlush(para);
        //进行wait
        wait(); //等待channelRead 方法获取到服务器的结果后，唤醒
        System.out.println(" call2 被调用  ");
        return  result; //服务方返回的结果

    }
    //(2)
    void setPara(String para) {
        System.out.println(" setPara  ");
        this.para = para;
    }
}
  • 接口
package com.atguigu.netty.dubborpc.publicinterface;

/**
 * 这个是接口，是服务提供方和 服务消费方都需要
 * @author Administrator
 */
public interface HelloService {

    String hello(String mes);

}
  • 服务端(provider)
  1. HelloServiceImpl
package com.atguigu.netty.dubborpc.provider;

import com.atguigu.netty.dubborpc.publicinterface.HelloService;

public class HelloServiceImpl implements HelloService{

    private static int count = 0;
    //当有消费方调用该方法时， 就返回一个结果
    @Override
    public String hello(String mes) {
        System.out.println("收到客户端消息=" + mes);
        //根据mes 返回不同的结果
        if(mes != null) {
            return "你好客户端, 我已经收到你的消息 [" + mes + "] 第" + (++count) + " 次";
        } else {
            return "你好客户端, 我已经收到你的消息 ";
        }
    }
}
  1. ServerBootstrap
package com.atguigu.netty.dubborpc.provider;

import com.atguigu.netty.dubborpc.netty.NettyServer;

//ServerBootstrap 会启动一个服务提供者，就是 NettyServer
public class ServerBootstrap {
    public static void main(String[] args) {

        //代码代填..
        NettyServer.startServer("127.0.0.1", 7000);
    }
}
  • 客户端(消费者)
package com.atguigu.netty.dubborpc.customer;

import com.atguigu.netty.dubborpc.netty.NettyClient;
import com.atguigu.netty.dubborpc.publicinterface.HelloService;

public class ClientBootstrap {


    //这里定义协议头
    public static final String providerName = "HelloService#hello#";

    public static void main(String[] args) throws  Exception{

        //创建一个消费者
        NettyClient customer = new NettyClient();

        //创建代理对象
        HelloService service = (HelloService) customer.getBean(HelloService.class, providerName);

        for (;; ) {
            Thread.sleep(2 * 1000);
            //通过代理对象调用服务提供者的方法(服务)
            String res = service.hello("你好 dubbo~");
            System.out.println("调用的结果 res= " + res);
        }
    }
}

  • 启动测试，先启动ServerBootstrap后启动ClientBootstrap
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 调用过程

  1. ClientBootstrap#通过main发起调用

  2. 走到下面这一行代码后
    在这里插入图片描述

  3. 调用NettyClient#getBean，在此方法里与服务端建立链接获取一个代理对象。
    在这里插入图片描述

  4. 通过代理对象调用服务提供者的方法(服务)
    在这里插入图片描述

  5. 第一次执行时会进入initClient() 客户端和服务器获取联系
    在这里插入图片描述
    客户端和服务器获取联系
    在这里插入图片描述

  6. 与服务器的连接创建后执行NettyClientHandler中的channelActive方法（NettyClientHandler 是通过获取客户端联系时绑定的）
    在这里插入图片描述

  7. 接着回到NettyClient#getBean调用NettyClientHandler#setPara，调用完之后再回到NettyClient#getBean，用线程池提交任务；因为用线程池提交了任务，就准备执行NettyClientHandler#call线程任务
    在这里插入图片描述
    在这里插入图片描述

  8. 在NettyClientHandler#call中发送数据给服务提供者context.writeAndFlush(para);

  9. wait(); //等待channelRead 方法获取到服务器的结果后，唤醒，执行此方法后服务提供者才会获取数据
    在这里插入图片描述

  10. 获取服务方返回结果获取的函数是，获取后返回到客户端
    在这里插入图片描述
    在这里插入图片描述

MrJson-架构师
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty进阶
ARSCCC的博客
06-07 212
文章目录1. Netty的粘包与半包现象1.1 粘包现象 1. Netty的粘包与半包现象 1.1 粘包现象
《Netty进阶之路 跟着案例学Netty》.rar
11-22
Java进阶技术-netty进阶之路
Netty 学习和进阶策略
cpongo5
12-25 181
《Netty 进阶之路》、《分布式服务框架原理与实践》作者李林锋手把手教你Netty框架如何学习和进阶。李林锋此后还将在InfoQ上开设Netty专题持续出稿，感兴趣的同学可以持续关注。背景Netty框架的特点Netty的一个特点就是入门相对比较容易，但是真正掌握并精通是非常困难的，原因有如下几个：涉及的知识面比较广：Netty作为一个高性能的NIO通信框架，涉及到的知识点包括网络通信、多线程编程...
netty指南及进阶
anys0039的博客
12-05 89
　　Netty是一个高性能的，提供异步的、事件驱动，非堵塞的IO(NIO)框架，用以快速开发高性能、高可靠性的网络服务器和客户端dsf。用于建立TCP等底层的连接，基于Netty可以建立高性能的Http服务器。 堵塞与非堵塞原理 　　传统硬件的堵塞如下，从内存中读取数据，然后写到磁盘，而CPU一直等到磁盘写完成，磁盘的写操作是慢的，这段时间CPU被堵塞不能发挥效率。 图一、 ...
Netty进阶之路-跟着案例学Netty
05-16
Netty进阶之路，跟着案例学Netty，李林峰大神新作。值得一读。
《Netty进阶之路 跟着案例学Netty》_李林锋_
05-30
Netty进阶之路 跟着案例学Netty 整本书无密码，Netty进阶之路 跟着案例学Netty
《Netty进阶之路 跟着案例学Netty》_李林锋_2018-11-01
12-10
《Netty进阶之路 跟着案例学Netty》_李林锋_2018-11-01
Netty03-进阶
u011767319的博客
05-10 109
三. Netty 进阶 1. 粘包与半包 1.1 粘包现象 服务端代码 public class HelloWorldServer { static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class); void start() { NioEventLoopGroup boss = new NioEventLoopGroup(1); NioEventLoopGroup worke
C# Netty 客户端，服务器端包含接双向接收
02-12
C# Netty 客户端，服务器端 自己研究一才研究出来的与大家分享一下
netty的实用进阶
素剑步青尘
11-05 224
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Netty 框架文档
weixin_34151004的博客
05-14 1122
原文引自：github.com/netty/netty… 前言 问题 现在我们使用通用应用程序或库来相互通信。例如，我们经常使用HTTP客户端库从Web服务器检索信息并通过Web服务调用远程过程调用。但是，通用协议或其实现有时不能很好地扩展。这就像我们不使用通用HTTP服务器来交换大量文件，电子邮件和近实时消息（如财务信息和多人游戏数据）。所需要的是高度优化的协议实现，专用于特殊目的。例如，您可能...
使用Netty提供的解码器解决TCP粘包和拆包问题
男儿当自强
09-24 384
解决粘包和拆包问题： 发送端需要使用tcp_nodelay来关闭nagle算法，有数据就发送； 接收端，需要在应用层来解决问题，可用的方式： 固定消息长度，比如不足的位数补0,接收端使用FixedLengthFrameDecoder； 使用换行符、自定义分隔符给消息添加边界； 将消息拆分为消息头和消息体，消息头中指定了消息长度等信息,接收端使用LengthFieldBas...
基于TCP的网络应用程序的编写
欧特GO
06-14 1315
1、说明 这是一个最基本的实例，一个服务端，一个客户端；代码在vs2019下编译通过；服务端和客户端放在同一台机器上运行效果如下： 2、代码 1）服务端 // TCPSrv.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <Winsock2.h> #include <time.h> #include <stdio.h> #include <windows.h> #include <WS2tcpip.h
netty进阶
专栏
07-11 1038
Netty进阶 一、Netty 核心模块组件 (1) Bootstrap、ServerBootstrap Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类 常见的方法有 public ServerBootstrap group(EventLoopGroup parentGroup, Eve
三. Netty 进阶
weixin_46633487的博客
04-30 395
三. Netty 进阶 笔记源于视频:https://www.bilibili.com/video/BV1py4y1E7oA?p=54&spm_id_from=pageDriver 1. 粘包与半包 1.1 粘包现象 服务端代码 public class HelloWorldServer { static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class); void start() {
14.Netty框架的C#实战使用
热门推荐
大李出奇迹的博客
04-18 1万+
文章目录博客概述场景与实现C#服务器端实现C#客户端的写法 博客概述 我是java线的工程师，但是技术栈有点全栈的意思。在某次项目中需要用到c#的socket通讯，查询之后惊喜的发现c#也有netty框架。dotnetty，github托管地址：https://github.com/Azure/DotNetty/blob/dev/examples/SecureChat.Client/Program...
Netty进阶学习之原理解析
m0_37561303的博客
08-11 211
Netty的核心组件 1、Bootstrap、ServerBootstrap Bootstrap和ServerBootstrap是Netty提供的一个创建客户端和服务端的一个启动器，主要作用是配置整个Netty程序，串联各个组件。 EventLoopGroup bossGroup = new NioEventLoopGroup(1); EventLoopGroup workGroup = new NioEventLoopGroup(); ServerBootstrap serveBootstrap =
netty进阶之路 pdf
最新发布
07-08
《Netty进阶之路》是一本关于Netty网络编程框架的进阶指南，它主要介绍了如何在实际项目中应用Netty来构建高效、稳定的网络应用。 首先，该书从Netty的基础概念和核心组件开始介绍，如Channel、EventLoop、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值