Netty(二)客户端与服务端通信

最新推荐文章于 2024-05-06 20:43:41 发布
最新推荐文章于 2024-05-06 20:43:41 发布
阅读量187 收藏
点赞数
分类专栏： Netty 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ghost_B2/article/details/107030567
版权

客户端与服务端通信

简单示例代码：基于netty 4

服务端代码：
MyServer：

package secondexample;

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

public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerInit());

            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

MyServerInit：

package secondexample;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
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;

/**
 * 客户端跟服务端一旦进行连接MyServerInit就会被创建
 * initChannel 就会被调用
 *
 *
 */
public class MyServerInit extends ChannelInitializer<SocketChannel> {


    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {

        ChannelPipeline pipeline = socketChannel.pipeline();

        /**
         * netty提供的处理器
         *
         */
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0,
                4, 0, 4));
        pipeline.addLast(new LengthFieldPrepender(4));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));

        pipeline.addLast(new MyServerHandler());//自定义的处理器



    }
}

自定义处理器 MyServerHandler

package secondexample;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.util.UUID;

public class MyServerHandler extends SimpleChannelInboundHandler<String> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + "," + msg);
        ctx.channel().writeAndFlush("from server " + UUID.randomUUID().toString());

    }


    /**
     * 出现异常处理
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
        ctx.close();

    }
}

客户端代码：
MyClient：

package secondexample;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class MyClient {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new MyClientInit());

            ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

MyClientInit

package secondexample;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
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;

public class MyClientInit extends ChannelInitializer<SocketChannel> {


    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        /**
         * netty提供的处理器编解码
         *
         */
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0,
                4, 0, 4));
        pipeline.addLast(new LengthFieldPrepender(4));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
        pipeline.addLast(new MyClientHandler());

    }
}

MyClientHandler

package secondexample;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class MyClientHandler   extends SimpleChannelInboundHandler<String> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(ctx.channel().remoteAddress());
        System.out.println("client output" + msg);
        ctx.writeAndFlush("from client :" + System.currentTimeMillis());


    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端域服务端建立连接");
        ctx.writeAndFlush("from client hello world.....");

    }

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

多个客户端与服务端建立连接并实现简单聊天

简单示例代码：基于netty 4
场景：
1.多个客户端连接服务器
2.只要每一个客户端连接到了服务器，会通知到在线的客户端
3.只要每一个客户端断开连接，会通知到在线的客户端
4.实现简单聊天
服务端代码：
MyChatServer

package thirdexample;

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

public class MyChatServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new MyChatServerInit());
            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

MyChatServerInit

package thirdexample;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class MyChatServerInit extends ChannelInitializer<SocketChannel> {


    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
        pipeline.addLast(new MyChatServerHandler());




    }
}

自定义处理器MyChatServerHandler

package thirdexample;

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

public class MyChatServerHandler extends SimpleChannelInboundHandler<String> {

    //用于保存每一个建立连接的channel对象
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);



    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel channel = ctx.channel();//向服务器发送数据的连接（标识那个客户端发送的）
        channelGroup.forEach(ch -> {
            if (channel != ch) {
                ch.writeAndFlush(channel.remoteAddress() + "发送消息" + msg+"\n");
            }else{
                ch.writeAndFlush("【自己】" + msg + "\n");
            }
        });


    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println("谁谁与server建立连接");
        //底层会自动遍历每一个channel，会向每一个建立连接的channel发送信息（谁谁加入）
        channelGroup.writeAndFlush("【服务器】 -" + channel.remoteAddress() + "加入");
        channelGroup.add(channel);
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println("谁谁与server断开连接");
        channelGroup.writeAndFlush("【服务器】 -" + channel.remoteAddress() + "离开");
        System.out.println("数量：" + channelGroup.size());
        channelGroup.remove(channel);//也可以不写 会自动在channelGroup移除
        System.out.println("数量：" + channelGroup.size());

    }


    /**
     * 连接处于活动状态
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(channel.remoteAddress() + " 上线");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(channel.remoteAddress() + " 下线");

    }

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

    }
}

客户端代码：
MyChatClient

package thirdexample;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class MyChatClient {
    public static void main(String[] args) throws InterruptedException, IOException {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new MyChatClientInit());
            Channel channel = bootstrap.connect("localhost", 8899).sync().channel();

            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));//键盘输入
            for (; ; ) {
                channel.writeAndFlush(reader.readLine() + "\r\n");

            }
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

MyChatClientInit

package thirdexample;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class MyChatClientInit extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
        pipeline.addLast(new MyChatClientHandler());

    }
}

MyChatClientHandler

package thirdexample;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class MyChatClientHandler extends SimpleChannelInboundHandler<String> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {

    }
}

Netty提供的空闲检测机制

场景：
1.只要有连接进来提供netty的日志输出，使用handler，bossGroup进行处理

2.假如clien端连接后，5s之后客户端没有向服务器端发送任何数据，会触发读空闲机制。

3.假如服务器在7s之后没有向客户端发送任何数据，会触发写空闲机制。
4.要么没有读要么没有写都会触发机制
5.使用netty提供的IdleStateHandler处理器

服务端代码：
MyServer

package fourthexample;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); //handler
        EventLoopGroup workerGroup = new NioEventLoopGroup();//childHandler
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new MyServerInit());

            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

MyServerInit

package fourthexample;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

public class MyServerInit extends ChannelInitializer<SocketChannel> {


    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        //读空闲5秒(假如clien端连接后，5s之后客户端没有向服务器端发送任何数据，会触发读空闲机制)
        // 写空闲7（假如服务器在7s之后没有向客户端发送任何数据，会触发写空闲机制）
        // 读写空闲10s （要么没有读要么没有写都会触发机制）
        pipeline.addLast(new IdleStateHandler(5, 7, 10
                , TimeUnit.SECONDS));//IdleStateHandler 空闲状态监测处理器（在一定时间没有读或写或者没有读和写会触发）
        pipeline.addLast(new MyServerHandler());


    }
}

自定义处理器
MyServerHandler

package fourthexample;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;

public class MyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            String evenType = null;
            switch (event.state()) {
                case READER_IDLE:
                    evenType = "读空闲";
                    break;
                case WRITER_IDLE:
                    evenType = "写空闲";
                    break;
                case ALL_IDLE:
                    evenType = "读写空闲";
                    break;
            }
            System.out.println(ctx.channel().remoteAddress() + "超时事件" + evenType);
            ctx.channel().close();
        }


    }
}

客户端代码:
同上面简单聊天客户端代码。

三年级二班罗同学
关注
专栏目录
netty实现服务端与客户端通信
06-19
在本文中，我们将深入探讨如何使用 Netty 实现服务端与客户端之间的通信，以及涉及到的关键知识点。 首先，我们要理解 Netty 的核心概念。Netty 基于非阻塞 I/O 模型，利用 Java NIO（Non-blocking Input/Output）...
Netty自带的心跳机制——IdleStateHandler
moneywenxue的博客
10-20 1万+
一、前言 Netty提供了对心跳机制的天然支持，心跳可以检测远程端是否存活，或者活跃。 今天我们就一起初识一下Netty4的心跳机制。Netty4.0提供了一个类，名为IdleStateHandler，这个类可以对三种类型的心跳检测。 二、项目中的应用 上述是项目中应用到的心跳机制关键代码，主要步骤： 在pipeline中添加IdleStateHandler； 在IdleStateHandler后面再添加IdleHandler，这个handler是我们自定义的，后面会再分析...
IdleStateHandler 心跳机制源码详解
程序猿进阶
12-03 3195
也是一个，也需要被载入到中，加入我们在服务器端的中。我们在channel链中加入了，第一个参数是5，单位是秒，那么这样做的意思就是：在服务器端会每隔5秒来检查一下方法被调用的情况，如果在5秒内该链上的方法都没有被触发，就会调用//创建服务类//boss和workertry {//设置线程池//设置socket工厂,Channel 是对 Java 底层 Socket 连接的抽象//设置管道工厂@Override//设置后台转换器（二进制转换字符串）});并且还是个。
Netty源码解析-IdleStateHandler
恐龙弟旺仔的博客
12-30 2132
前言： 心跳机制广泛运用在我们的应用平台中。对于连接到应用服务的客户端，服务端有必要对长时间没有请求的客户端连接进行清理，以避免连接过多。这就需要服务端有空闲连接检测机制。 而针对客户端而言，如果长时间未请求数据，为避免被服务端清理连接，就需要间歇性的发送心跳请求。 在Netty中，针对以上需求，已经有现成的Handler可供使用，这就是本文要介绍的IdleStateHandler。 1.IdleStateHandler的使用 1.1 服务端检测长时间未请求的客户端 我们在服务端可以使用Id
IdleStateHandler
丶洗牙刷脸
12-05 2683
作用：用于空闲连接处理，当出现reader/writer空闲时，触发IdleStateEvent Netty事件，ChannelInboundHandler通过userEventTriggered来捕获这个事件，从而进行处理。 一、构造函数 一般我们使用的IdleStateHandler的构造函数有4个参数： long readerIdleTimeSeconds：Channel多久没有读取数...
2024年网络安全最全IdleStateHandler 心跳机制源码详解，2024年最新网络安全程序员必会
最新发布
2401_84281720的博客
05-06 1088
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。// 如果最后一次写的时间和上一次记录的时间不一样，说明写操作进行过了，则更新此值。
Netty实现简单的客户端服务端通信示例
12-12
在本文中，我们将深入探讨如何使用 Netty 实现简单的客户端-服务端通信，这对于初学者来说是一个很好的起点。 首先，理解 Netty 的核心概念至关重要。Netty 的设计基于 NIO（非阻塞 I/O），它利用了 Java 提供的 ...
Netty实现Java服务端和C#客户端联通
08-09
标题中的“Netty实现Java服务端和C#客户端联通”是指使用Netty作为Java服务器框架，与C#客户端（使用DotNetty库）进行通信的一种技术实现。这涉及到跨平台的网络通信，以及两个不同编程语言间的交互。 Netty是Java...
Android使用Netty网络框架实践（客户端、服务端）
10-21
在Android环境中，由于安全和权限限制，我们通常需要在后台服务中运行Netty服务器，而在Activity或Service中创建Netty客户端。通过Handler进行主线程和网络线程之间的数据交互，确保UI更新的及时性和线程安全性。 ...
Netty心跳检测之IdleStateHandler
qq_36851469的博客
08-24 509
protected void initChannel(SocketChannel ch) throws Exception { // 初始化时，IdleStateHandler 加入到pipeline时，会初始化一个任务加入到队列中，并且记录当前时间微妙 // 线程遍历队列，当执行到的该IdleStateHandler对应的任务时，通过当前时间与过期时间比较，如果小于0说明超时，会调用ServerIdleStateTrigger // 执行相应的逻辑，比如断开客户端连接 ch.pipeli
netty的读写空闲检测-IdleStateHandler
流火
04-28 1511
netty的读写空闲检测-IdleStateHandler
Netty学习（五）—IdleStateHandler心跳机制
热门推荐
tuzhenyu的博客
11-21 7万+
Netty学习（五）—IdleStateHandler心跳机制 Netty的IdleStateHandler心跳机制主要是用来检测远端是否存活，如果不存活或活跃则对空闲Socket连接进行处理避免资源的浪费； 个人主页：tuzhenyu’s page 原文地址：Netty学习（五）—IdleStateHandler心跳机制 (0)基础 心跳机制 心跳是在
【Netty】高阶使用：IdleStateHandler 心跳检测，实现超时断开连接
A minor
01-01 1万+
通过前面几篇博客的各种代码示例，就算别的没记住，也应该对实验后 Client 不会自动断开连接，等手动关闭时会报错的情况应该印象很深把。因为 Netty 建立的是长连接，也就是说只要不在 Client 的代码中手动 channel.close(); 那该连接就会一直保持着，直到客户端或者服务器一方关闭。 也不是说长连接它就不好，但大家想想，每一个客户端都一直占着一个连接，即使它后面已经用不到服务器了，而服务器能承受的连接数是有限的，后面再来了真正有需求的用户，它也进不来了，而且长时间的高并发也可能导致服务
[Netty] Netty自带的心跳机制 (十五)
959
04-20 1053
[Netty] Netty自带的心跳机制 (十五)
IdleStateHandler 心跳检测，实现超时断开连接
小猴子的博客
04-20 1438
目录 1.IdleStateHandler 原理 2.心跳检测 2.1.channel初始化时加入心跳超时处理事件 2.2 继承ChannelInboundHandlerAdapter ，重写超时事件 有没有一种办法，如果我一段时间用不到服务器，就把这个连接给关掉？答：心跳机制。所谓心跳，即在 TCP 长连接中，客户端和服务器之间定期发送的一种特殊的数据包（比如消息内容是某种要求格式、内容），通知对方自己还在线，以确保 TCP 连接的有效性。 在 Netty 中，实现心跳...
IdleStateHandler源码分析
qq_35142561的博客
09-08 5775
** IdleStateHandler构造器 ** readerIdleTime读空闲超时时间设定，如果channelRead()方法超过readerIdleTime时间未被调用则会触发超时事件调用userEventTrigger()方法； writerIdleTime写空闲超时时间设定，如果write()方法超过writerIdleTime时间未被调用则会触发超时事件调用userEventTrigger()方法； allIdleTime所有类型的空闲超时时间设定，包括读空闲和写空闲； unit时间单位，包
Netty复习：（2）IdleStateHandler的用法
amadeus_liu2的博客
10-30 372
当客户端连接之后，如果一段时间不发送数据，则服务器端会触发IdleStateEvent并被处理。三、定义server启动类，在pipeline中添加IdleStateHandler。二、定义Initializer。
Spring Boot整合Netty实现客户端-服务端通信教程
"Spring Boot集成netty实现客户端服务端交互示例详解" 在现代软件开发中，Spring Boot 和 Netty 都扮演着重要的角色。Spring Boot 是一个基于 Spring 框架的快速启动工具，简化了配置和应用部署，而 Netty 是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值