基于javaNIO的封装框架 Netty简单入门

Netty服务器与客户端实现及核心机制解析
最新推荐文章于 2025-09-02 23:22:42 发布
原创 最新推荐文章于 2025-09-02 23:22:42 发布 · 372 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文通过一个完整的Netty服务器和客户端示例，展示了如何配置和启动Netty服务，包括BossGroup和WorkerGroup的使用，以及如何处理连接和数据传输。同时，代码中使用了LengthFieldBasedFrameDecoder解决粘包半包问题，确保数据正确解码。此外，还涉及了ChannelPipeline和ChannelHandler在处理业务逻辑中的应用。

先提出三个问题：

1.默认情况下，netty服务端启多少个线程？
2. netty是如何解决 jdk空轮询的bug?
3.netty是如何保证异步串行化？
答案
1.
优秀的博文地址1：此博主还有另一篇优秀博文【netty搭建socket客户端,断线重连,发送数据,接收服务端数据,spring注入service】
2.
Netty框架学习之(一）：Netty框架简介
3.
Netty学习（五）—IdleStateHandler心跳机制
4.
Netty学习（六）—WebSocket通信
5
netty事件
netty的 bund 和 outbund
6.
channel讲解

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

基于上图，第一个代码演示 Netty

服务端代码：

package com.jidongcloud;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 * ClassName：Server
 * Package:com.jidongcloud
 *
 * @DATE:2020/11/14 0014 21:09
 * @Author:robin
 */
public class Server {
    //IP地址
    private static final String ip = "127.0.0.1";
    //核心线程数 (一般为cpu的2倍)
    private static final int BIZGROUPSIZE = Runtime.getRuntime().availableProcessors() * 2;
    //定义一个线程的大小
    private static final int BIZTHREADSIZE = 100;
    //端口
    private int port;


    public Server(int port) {
        this.port = port;
    }

    public static void main(String[] args) {
        System.out.println("启动Server..........");
        new Server(8379).start();
    }

    /**
     * @return void
     * @Author robin
     * @Description 启动服务的方法：
     * 如何去连接，以及连接好了如何去处理 IO事件
     * @Date 21:35 2020/11/14 0014
     * @Param
     **/
    //定义 boss线程：管理各种事件的一个组
    EventLoopGroup bossGroup = new NioEventLoopGroup(BIZGROUPSIZE); //用于处理服务器端接收客户端连接
    //定义worker线程
    EventLoopGroup workerGroup = new NioEventLoopGroup(BIZTHREADSIZE); //进行网络通信（读写）
    public void start() {

        try {
            //辅助工具类，用于服务器通道的一系列配置
            ServerBootstrap bootstrap = new ServerBootstrap();
            //绑定两个线程组
            bootstrap.group(bossGroup, workerGroup)
                    //NioServerSocketChannel
                    .channel(NioServerSocketChannel.class) //指定NIO的模式
                    // .handler("");处理服务端的逻辑，比如我的channel被注册上了。
                    //传入  ChannelInitializer 类的抽象方法 initChannel  java8新特性
                    .childHandler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception { //childHandler是对连接 的处理 handler 父子关系
                            //比如设置 TCP的属性、发送缓冲区、接收缓冲区。
                            //channel核心的初始化流程
                            //  ChannelPipeline不是单独存在,
                            //  它肯定会和Channel、ChannelHandler、ChannelHandlerContext关联在一起,
                            //  所以有关概念这里一起讲。
                            ChannelPipeline pipeline = ch.pipeline();//业务逻辑是由ChannelHandler类去做的。 pipeline是管理ChannelHandler的一个容器。
                            //这里加 ChannelHandler
                            //解码器来解决粘包与半包问题
                            // maxFrameLength：单个包最大的长度;这个值根据实际场景而定，我设置的是1024，固然我的心跳包不大，但是其他包可能比较大
                            //lengthFieldOffset：表示数据长度字段开始的偏移量，比如上面的协议,lengthFieldOffset应该取值为5，
                            // 因为数据长度之前有2个字节的包头，1个字节的功能
                            //lengthFieldLength：数据长度字段的所占的字节数，上面的协议中写的是2个字节，所以取值为2
                            //lengthAdjustment：这里取值为10=7(系统时间) + 1（校验码）+ 2 (包尾)，如果这个值取值为0，试想一下，
                            // 解码器跟数据长度字段的取值（这里数据长度内容肯定是1），只向后取一个字节，肯定不对。（lengthAdjustment + 数据长度取值 = 数据长度字段之后剩下包的字节数）
                            //initialBytesToStrip：表示从整个包第一个字节开始，向后忽略的字节数，我设置为0，
                            // 本来可以忽略掉包头的两个字节（即设置为2），但是，实际项目中，需要校验包头取值是否为AA55，来判断包的合法性。

                            pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                            //字符串类型解码器和编码器
                            pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
                            pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));

                            //加一个TCP方式的处理类
                            pipeline.addLast(new ServerHandler());

                        }
                    });
            /**
             * 对于ChannelOption.SO_BACKLOG的解释：
             * 服务器端TCP内核维护有两个队列，我们称之为A、B队列。客户端向服务器端connect时，会发送带有SYN标志的包（第一次握手），服务器端
             * 接收到客户端发送的SYN时，向客户端发送SYN ACK确认（第二次握手），此时TCP内核模块把客户端连接加入到A队列中，然后服务器接收到
             * 客户端发送的ACK时（第三次握手），TCP内核模块把客户端连接从A队列移动到B队列，连接完成，应用程序的accept会返回。也就是说accept
             * 从B队列中取出完成了三次握手的连接。
             * A队列和B队列的长度之和就是backlog。当A、B队列的长度之和大于ChannelOption.SO_BACKLOG时，新的连接将会被TCP内核拒绝。
             * 所以，如果backlog过小，可能会出现accept速度跟不上，A、B队列满了，导致新的客户端无法连接。要注意的是，backlog对程序支持的
             * 连接数并无影响，backlog影响的只是还没有被accept取出的连接
             */
//                    .option(ChannelOption.SO_BACKLOG, 128) //设置TCP缓冲区
//                    .option(ChannelOption.SO_SNDBUF, 32 * 1024) //设置发送数据缓冲大小
//                    .option(ChannelOption.SO_RCVBUF, 32 * 1024) //设置接受数据缓冲大小
//                    .childOption(ChannelOption.SO_KEEPALIVE, true); //保持连接
            //绑定端口，因为比较耗时，所以同步阻塞。sync ，如果进程不在，会绑定端口失败。
            //第一步：  监听
            ChannelFuture future = bootstrap.bind(ip, port).sync();
            //ChannelFuture关闭的时候需要提示一些信息，所以要注册一个监听器 ，sync，因为关闭也是一个阻塞事件。
            future.channel().closeFuture().sync();
            System.out.println("Server start: ");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //优雅的关闭线程
            shutDown();
        }
    }
    private void shutDown() {
        //优雅的关闭线程
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
        System.out.println("已完成优雅关闭Server。。。");
    }
}

  
package com.jidongcloud;

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

/**
 * ClassName：ServerHandler
 * Package:com.jidongcloud
 *
 * @DATE:2020/11/14 0014 21:11
 * @Author:robin TODO: ChannelHandlerAdapter 这个类不行
 */
public class ServerHandler  extends ChannelInboundHandlerAdapter {
    //传播事件，或者说是激活的状态
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
//        super.channelActive(ctx);
        System.out.println("channel active ...");
    }
//一个消息可读了，channelRead就可以被回调。
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server receive message : "+msg);
        //do something msg
//        ByteBuf buf = (ByteBuf)msg;
//        byte[] data = new byte[buf.readableBytes()];
//        buf.readBytes(data);
//        String request = new String(data, "utf-8");
//        System.out.println("Server: " + request);
//        //写给客户端
//        String response = "我是反馈的信息";
        Channel channel = ctx.channel();
//        channel.writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
        channel.writeAndFlush ("accept message"+msg);
        //.addListener(ChannelFutureListener.CLOSE);
        //关闭channel上下文资源
        ctx.close();

    }
//捕捉异常的方法
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        String message = cause.getMessage();
        System.out.println("异常信息----->"+message);
//        ctx.close();
    }

}

测试网络连接状态：
在这里插入图片描述
回车后出现下面信息说明成功启动服务端

在这里插入图片描述
在这里插入图片描述

客户端代码 ：

package com.jidongcloud;

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 io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;


/**
 * ClassName：Client
 * Package:com.jidongcloud
 *
 * @DATE:2020/11/14 0014 21:12
 * @Author:robin TODO:
 */
public class Client  implements  Runnable{
    //定义worker线程，进行网络通讯，比如 读写操作
  public  static   EventLoopGroup workerGroup = new NioEventLoopGroup();
    @Override
    public void run() {
       try {

           //  辅助工具类，用于服务器通道的一系列配置
           Bootstrap bootstrap = new Bootstrap();
           bootstrap.group(workerGroup)
                   .channel(NioSocketChannel.class)
                   .option(ChannelOption.TCP_NODELAY,true)
                   .handler(new ChannelInitializer<SocketChannel>() {
                       @Override
                       protected void initChannel(SocketChannel socketChannel) throws Exception {
                           socketChannel.pipeline()
                         .addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4))
                         .addLast("frameEncoder",new LengthFieldPrepender(4))
                         .addLast("decoder",new StringDecoder(CharsetUtil.UTF_8))
                         .addLast("encoder",new StringEncoder(CharsetUtil.UTF_8))
                         .addLast("handler",new ClientHandler());
                       }
                   });
           for (int i = 0; i <10 ; i++) {
               ChannelFuture future = bootstrap.connect("127.0.0.1", 8379).sync();
               future.channel().writeAndFlush("hello,Server"+Thread.currentThread().getName()+"------>"+i);
               // 闭的时候需要提示一些信息，所以要注册一个监听器 ，sync，因为关闭也是一个阻塞事件。
               future.channel().closeFuture().sync();
           }

       }catch (Exception e){
           System.out.println("客户端异常------>"+e.getMessage());
       }finally {
           System.out.println("优雅关闭client。。。");
           workerGroup.shutdownGracefully();
       }
    }



    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <3 ; i++) {
          new Thread(new Client(),">>>>>this thread"+i).start();
        }
    }

}

package com.jidongcloud;

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

/**
 * ClassName：ClientHandler
 * Package:com.jidongcloud
 *
 * @DATE:2020/11/14 0014 21:12
 * @Author:robin TODO:
 */
public class ClientHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            System.out.println("client receive msg: "+msg);
//            ByteBuf buf = (ByteBuf) msg;
//            byte[] data = new byte[buf.readableBytes()];
//            buf.readBytes(data);
//            System.out.println("Client：" + new String(data).trim());
        } finally {
//            ReferenceCountUtil.release(msg);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        String message = cause.getMessage();
        System.out.println("Client 异常信息----->"+message);
//        ctx.close();
    }

}

测试结果：
在这里插入图片描述

channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread1------>0
server receive message : hello,Server>>>>>this thread0------>0
server receive message : hello,Server>>>>>this thread2------>0
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread1------>1
server receive message : hello,Server>>>>>this thread2------>1
server receive message : hello,Server>>>>>this thread0------>1
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread2------>2
server receive message : hello,Server>>>>>this thread0------>2
server receive message : hello,Server>>>>>this thread1------>2
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread2------>3
server receive message : hello,Server>>>>>this thread1------>3
server receive message : hello,Server>>>>>this thread0------>3
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread2------>4
server receive message : hello,Server>>>>>this thread1------>4
channel active ...
server receive message : hello,Server>>>>>this thread0------>4
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread0------>5
channel active ...
server receive message : hello,Server>>>>>this thread1------>5
server receive message : hello,Server>>>>>this thread2------>5
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread0------>6
server receive message : hello,Server>>>>>this thread2------>6
server receive message : hello,Server>>>>>this thread1------>6
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread1------>7
server receive message : hello,Server>>>>>this thread0------>7
server receive message : hello,Server>>>>>this thread2------>7
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread2------>8
server receive message : hello,Server>>>>>this thread0------>8
server receive message : hello,Server>>>>>this thread1------>8
channel active ...
channel active ...
channel active ...
server receive message : hello,Server>>>>>this thread2------>9
server receive message : hello,Server>>>>>this thread1------>9
server receive message : hello,Server>>>>>this thread0------>9

在这里插入图片描述
完整的demo完成。

分析以上代码流程：
在这里插入图片描述
需求：做一个类似饿了么的业务推送平台。
消费者------>商家（饿了么）----->骑手
在这里插入图片描述
1. 整体架构
业务推送最终是把消费者下单信息推送到骑手手机上。

在这里插入图片描述
2.系统架构：
在这里插入图片描述
3.逻辑架构：微观的架构，具体用到组件
在这里插入图片描述
4.模块划分：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
八.消息推送流程：
在这里插入图片描述
最后一个是客户端 client
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
项目结构：

在这里插入图片描述
在这里插入图片描述
首先是开发core代码：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
参考 git

Netty完整框架

Netty使用详解
rimua的博客
04-11 897
netty是一个高性能的NIO网络通信框架,是对NIO网络模型的封装，提供了一些简单，易用的Api，并且进行了许多优化操作，如零拷贝机制，高性能无所队列，内存池等优化策略。netty支持多种通信协议，如HTTP，webSoket等，并且针对数据通信拆包黏包的一些问题，netty也进行了许多拆包策略。在网络应用编程中netty可以使得服务器可以获得更高的吞吐量，帮助解决网络通信中黏包/拆包问题，支持多种协议开发，以较少的代码实现网络通信开发。
Netty的简单使用和理解
white_bird_shit的博客
01-04 905
Netty 学习笔记 1.Netty 介绍和应用场景 1.1 介绍 Netty 是jboss的一个开源框架 Netty是一个异步的,基于事件驱动的网络应用框架 基于nio 1.2 应用场景 Rpc 例如dubbo 游戏 大数据 涉及到网络通信的应用都可以使用netty 2. i/o模型 2.1 介绍 bio 同步并阻塞 一个连接对应服务器一个线程 适用于连接数较少的架构 jdk1.4 nio 同步非阻塞 服务器一个线程处理多个连接 适用于连接数较多连接时间短 jdk1.4 aio(nio.
Netty从0到1系列之NIO
最新发布
生菜园子
09-02 1181
NIO核心思想与组件摘要 传统BIO采用阻塞式流模型，存在线程资源浪费问题。NIO通过三大核心组件实现高效I/O处理： Channel：双向通信通道（文件/网络），支持非阻塞模式 Buffer：数据容器，通过position/limit/capacity机制实现灵活读写 Selector：多路复用器，单线程可监控数千通道的IO事件
基于netty封装的快速分布式任务开发框架
09-16
一个基于netty封装的快速分布式任务开发框架，目标：简单，简单，再简单！ easynetty-demo是用spring-boot，spring-shell实现的示例
Netty——基本使用介绍
热门推荐
隔壁老王的专栏
11-20 12万+
1.为什么选择Netty 上一篇文章我们已经了解了Socket通信（IO/NIO/AIO）编程，对于通信模型已经有了一个基本的认识。其实上一篇文章中，我们学习的仅仅是一个模型，如果想把这些真正的用于实际工作中，那么还需要不断的完善、扩展和优化。比如经典的TCP读包写包问题，或者是数据接收的大小，实际的通信处理与应答的处理逻辑等等一些细节问题需要认真的去思考，而这些都需要大量的时间和经历，以及丰富
Netty基础入门（二）
青鸟飞鱼
01-13 1556
原文：http://blog.csdn.net/haoyuyang/article/details/53243785参考：http://wiki.jikexueyuan.com/project/netty-4-user-guide/1.为什么选择Netty上一篇文章我们已经了解了Socket通信（IO/NIO/AIO）编程，对于通信模型已经有了一个基本的认识。其实上一篇文章中，我们学习的仅仅是一个...
【Java进阶营】Java异步NIO框架Netty实现高性能高并发
hong7888888的博客
04-30 833
1. 背景 1.1. 惊人的性能数据 最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨节点远程服务调用。相比于传统基于Java序列化+BIO（同步阻塞IO）的通信框架，性能提升了8倍多。 事实上，我对这个数据并不感到惊讶，根据我5年多的NIO编程经验，通过选择合适的NIO框架，加上高性能的压缩二进制编解码技术，精心的设计Reactor线程模型，达到上述性能指标是完全有可能的。 下面我们就一起来看下Netty是如
Java异步NIO框架Netty实现高性能高并发
mt77666的博客
06-10 2132
1. 背景1.1. 惊人的性能数据最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨节点远程服务调用。相比于传统基于Java序列化+BIO（同步阻塞IO）的通信框架，性能提升了8倍多。事实上，我对这个数据并不感到惊讶，根据我5年多的NIO编程经验，通过选择合适的NIO框架，加上高性能的压缩二进制编解码技术，精心的设计Reactor线程模型，达到上述性能指标是完全有可能的。下面我们就一起来看下Netty是如何支持1
第38讲 | 对比Java标准NIO类库，你知道Netty是如何实现更高性能的吗？
qq_37756660的博客
05-21 972
今天会对 NIO 进行一些补充，在专栏第 11 讲中，我们初步接触了 Java 提供的几种 IO 机制，作为语言基础类库，Java 自身的 NIO 设计更偏底层，这本无可厚非，但是对于一线的应用开发者，其复杂性、扩展性等方面，就存在一定的局限了。在基础 NIO 之上，Netty 构建了更加易用、高性能的网络框架，广泛应用于互联网、游戏、电信等各种领域。今天要问你的问题是，对比 Java 标准 NIO 类库，你知道 Netty 是如何实现更高性能的吗？
Netty入门：基于JavaNIO的高性能网络框架解析
它基于Java NIO（非阻塞I/O）设计，使得网络编程变得更加简单且高效。在描述中提到的“13.4 编写广播器”，这部分内容可能涵盖了如何使用Netty来实现UDP广播功能，即向网络中的所有设备发送数据包。 Netty的核心...
Netty入门：Java NIO框架解析
它基于Java NIO（非阻塞I/O）构建，使得网络编程变得更加简单且高效。Netty的核心优势在于其异步事件驱动的网络通信模型，这极大地提高了系统的并发处理能力。 在传统的阻塞I/O模型中，当一个线程发起读写操作时，...
Netty基本使用(一)
cfy137000的博客
04-10 1485
Netty基本使用(一) 1. 概述 Netty是什么 Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端, 引用官网的自述: Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. 简单的说, Netty就是一个 网络框架 ,可
Netty基本使用
熊浪的博客
07-03 1695
1、使用Netty自带的解码器2.自定义序列化规则在 Java 中自带的有实现 Serializable 接口来实现序列化，但由于它性能、安全性等原因一般情况下是不会被使用到的。通常情况下，我们使用Protostuff、Hessian2、json 序列方式比较多，另外还有一些序列化性能非常好的序列化方式也是很好的选择： 专门针对Java 语言的：Kryo，FST 等等 跨语言的：Protostuff（基于 protobuf。
netty基本使用
qq_20004115的博客
11-27 1563
客户端： 1、创建一个发送请求工作线程组 EventLoopGroup workerGroup = new NioEventLoopGroup(); 2、创建客户端启动器 Bootstrap b = new Bootstrap(); 3、启动器绑定线程组 b.group(workerGroup) 4、启动器绑定NIO通道 b.channel(NioSocketChannel.class) 5、构建请求发送处理器 b.handler(new ChannelInitializer<..
Netty使用篇
七叔的博客
10-30 2万+
Netty使用篇
Netty的简单使用
weixin_42679286的博客
05-17 1436
户空间切换到内核空间（ 此时调用进程挂起，阻塞等待，称之为阻塞 ）。用户空间切换到内核空间（ 此时调用进程立即返回，称之为非阻塞，然后不断轮询 ）。一个线程可以监视多个文件描述符。在使用信号驱动 I/O 时，当数据准备就绪后，内核通过发送一个 SIGIO 信号通知应用进程，应用进程就可以开始读取数据了。从内核缓冲区拷贝数据到用户态缓冲区的过程由OS异步完成，应用进程只需要在指定的数组中引用数据即可。
Netty使用教程（一）
qq_25212845的博客
08-11 8629
1.传输一个字符串 1. netty开发基本流程 基本流程 - 详细流程 标红的位置为客户端和服务端不同的地方 创建的工程名称，用驼峰命名法 内部jar包名称全部小写 创建类 - 创建类 2.分别实现客户端和服务器端 2.1 实现客户端 （1）增加Sharable注解，为了线程安全 客户端消息接收和异常处理 package com.xc.helloworld; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHand
Netty入门使用
Charge8的博客
04-27 1267
Netty入门使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值