第 2 篇 : Netty客户端之间互发消息和服务端广播

最新推荐文章于 2024-06-08 22:45:27 发布
最新推荐文章于 2024-06-08 22:45:27 发布
阅读量461 收藏 1
点赞数 4
分类专栏： Netty 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiezi__/article/details/138183591
版权

1. 服务端改造

1.1 修改 Message类

package com.hahashou.netty.server.config;

import com.alibaba.fastjson.JSON;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
import lombok.Data;

/**
 * @description:
 * @author: 哼唧兽
 * @date: 9999/9/21
 **/
@Data
public class Message {

    /** 发送者用户code */
    private String userCode;

    /** 接收者用户code */
    private String friendUserCode;

    /** 连接时专用 */
    private String channelId;

    /** 文字 */
    private String text;

    public static ByteBuf transfer(Message message) {
        return Unpooled.copiedBuffer(JSON.toJSONString(message), CharsetUtil.UTF_8);
    }
}

1.2 修改 NettyServerHandler类

package com.hahashou.netty.server.config;

import com.alibaba.fastjson.JSON;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @description:
 * @author: 哼唧兽
 * @date: 9999/9/21
 **/
@Component
@ChannelHandler.Sharable
@Slf4j
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /** key: 用户code; value: channelId */
    public static Map<String, String> USER_CHANNEL = new ConcurrentHashMap<>(32);

    /** key: channelId; value: Channel */
    public static Map<String, Channel> CHANNEL = new ConcurrentHashMap<>(32);

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        String channelId = channel.id().asLongText();
        log.info("有客户端连接, channelId : " + channelId);
        CHANNEL.put(channelId, channel);
        Message message = new Message();
        message.setChannelId(channelId);
        channel.writeAndFlush(Message.transfer(message));
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        log.info("有客户端断开连接, channelId : {}", ctx.channel().id().asLongText());
        CHANNEL.remove(ctx.channel().id().asLongText());
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg != null) {
            Message message = JSON.parseObject(msg.toString(), Message.class);
            String userCode = message.getUserCode(),
                    channelId = message.getChannelId(),
                    text = message.getText();
            if (StringUtils.hasText(userCode) && StringUtils.hasText(channelId)) {
                log.info("客户端 " + userCode + " 连接");
                USER_CHANNEL.put(userCode, channelId);
            } else if (StringUtils.hasText(text)) {
                String friendUserCode = message.getFriendUserCode();
                if (StringUtils.hasText(friendUserCode)) {
                    // 向某客户端发送
                    String queryChannelId = USER_CHANNEL.get(friendUserCode);
                    if (StringUtils.hasText(queryChannelId)) {
                        Channel channel = CHANNEL.get(queryChannelId);
                        if (channel == null) {
                            log.error(friendUserCode + "已下线, 存储消息 :{}", text);
                            return;
                        }
                        channel.writeAndFlush(Message.transfer(message));
                    } else {
                        log.error("无此用户信息");
                    }
                } else {
                    // 向服务端发送时, 返回当前时间
                    message.setUserCode("ADMIN");
                    message.setText(LocalDateTime.now().toString());
                    ctx.channel().writeAndFlush(Message.transfer(message));
                }
            }
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        log.info("有客户端发生异常, channelId : {}", ctx.channel().id().asLongText());
    }
}

1.3 修改 ServerController类

package com.hahashou.netty.server.controller;

import com.hahashou.netty.server.config.Message;
import com.hahashou.netty.server.config.NettyServerHandler;
import io.netty.channel.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @description:
 * @author: 哼唧兽
 * @date: 9999/9/21
 **/
@RestController
@RequestMapping("/server")
@Slf4j
public class ServerController {

    @PostMapping("/send")
    public String send(@RequestBody Message dto) {
        String friendUserCode = dto.getFriendUserCode();
        if (StringUtils.hasText(friendUserCode)) {
            String channelId = NettyServerHandler.USER_CHANNEL.get(friendUserCode);
            if (StringUtils.hasText(channelId)) {
                Channel channel = NettyServerHandler.CHANNEL.get(channelId);
                if (channel == null) {
                    return "该客户端已下线, 需要存储相关信息";
                }
                channel.writeAndFlush(Message.transfer(dto));
            } else {
                log.error("无此用户信息");
            }
        } else {
            // 全体广播
            NettyServerHandler.USER_CHANNEL.forEach((userCode, channelId) -> {
                Channel channel = NettyServerHandler.CHANNEL.get(channelId);
                if (channel == null) {
                    log.error(userCode + "已下线, 需要存储相关信息");
                    return;
                }
                channel.writeAndFlush(Message.transfer(dto));
            });
        }
        return "success";
    }
}

1.4 启动服务端

2. 客户端改造

2.1 复制服务端的 Message类

2.2 修改 NettyClientHandler类

package com.hahashou.netty.client.config;

import com.alibaba.fastjson.JSON;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
 * @description:
 * @author: 哼唧兽
 * @date: 9999/9/21
 **/
@Component
@ChannelHandler.Sharable
@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    @Value("${userCode}")
    private String userCode;

    public static Channel CHANNEL;

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        CHANNEL = ctx.channel();
        log.info("客户端 " + userCode + " 上线");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        CHANNEL = null;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg != null) {
            Message message = JSON.parseObject(msg.toString(), Message.class);
            String channelId = message.getChannelId(),
                    text = message.getText();
            if (StringUtils.hasText(channelId)) {
                Channel channel = ctx.channel();
                message.setUserCode(userCode);
                channel.writeAndFlush(Message.transfer(message));
            } else if (StringUtils.hasText(text)) {
                log.info("收到" + message.getUserCode() + "消息: {}", text);
            }
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        CHANNEL = null;
    }
}

2.3 修改 ClientController类

package com.hahashou.netty.client.controller;

import com.hahashou.netty.client.config.Message;
import com.hahashou.netty.client.config.NettyClientHandler;
import io.netty.channel.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @description:
 * @author: 哼唧兽
 * @date: 9999/9/21
 **/
@RestController
@RequestMapping("/client")
@Slf4j
public class ClientController {

    @PostMapping("/send")
    public String send(@RequestBody Message dto) {
        Channel channel = NettyClientHandler.CHANNEL;
        if (channel == null) {
            return "服务端已下线";
        }
        channel.writeAndFlush(Message.transfer(dto));
        return "success";
    }
}

3. 通过修改配置信息, 生成2个客户端

3.1 A客户端 application.yml, 打包jar

server:
  port: 32001

logging:
  level:
    com.hahashou.netty: info

userCode: Aa

3.2 B客户端 application.yml, 打包jar

server:
  port: 32002

logging:
  level:
    com.hahashou.netty: info

userCode: Bb

3.3 启动A、B客户端

A与B服务启动

4. 测试

4.1 A与B互发消息

A向B发送消息json示例
根据上述示例, 以及下述图片, 自行补充相关信息(注意服务的切换)
A收到的消息
B收到的消息

4.2 A客户端向服务端发送消息

A向服务端发送消息
A客户端显示的时间

4.3 服务端向A单独通知以及全体广播

向A单独通知
全体广播
A客户端
A客户端
B客户端
B客户端

哈哈兽0026
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Netty实战二-实现UDP的单播和广播
m0_69526086的博客
04-28 1558
================ Netty里已经帮我们封装好了UDP相关的实现类。使用起来也非常方便 1、AddressedEnvelope 接口 interface AddressedEnvelope<M, A extends SocketAddress> extends ReferenceCounted 定义一个消息，其包装了另一个消息并带有发送者和接收者地址。其中M 是消息类型；A 是地址类型 2、DefaultAddressedEnvelope类 class DefaultA
Netty实战（十五）UDP广播事件（一）UDP简介和示例程序
一起学习一起进步~
06-13 856
TCP：是面向连接的传输，它管理了两个网络端点之间的连接的建立，在连接的生命周期内的有序和可靠的消息传输，以及最后，连接的有序终止。TCP 的消息是有序的，并且会在两个方向上流动。是无连接协议中，并没有持久化连接这样的概念，并且每个消息（一个 UDP 数据报）都是一个单独的传输单元。同时UDP 也没有 TCP 的纠错机制，其中每个节点都将确认它们所接收到的包，而没有被确认的包将会被发送方重新传输。UDP 消息是无序的，并且无法确定是否能到达目的地。UDP的优势和不足：优势：UDP的传输速度远远高于TCP。
netty学习（4）:通过SpringBoot Web发送消息实现netty实现多个客户端与服务器通信
weixin_42774617的博客
07-06 2064
在父工程创建message包。给client1发送消息。
Netty向设备发送消息并等待设备响应
最新发布
StruggleRookie的博客
06-08 291
在使用netty开发和硬件对接时，经常会遇到服务端给硬件设备发送命令后需要等待设备反馈响应命令后执行逻辑。
Netty简单实现客户端与服务端收发消息
weixin_47301645的博客
05-02 8118
Netty简单实现客户端与服务端收发消息 这个小案例主要是实现netty收发消息,分为客户端,及服务端,以及包含了相关状态处理,主要的代码会放在最后 gitHub 地址上,有需要可以看一下 首先来简单说明一下消息收发流程 1.客户端构建登录请求对象,服务端判断登录是否成功,并绑定成功状态 2.客户端判断登录成功,构建消息请求对象接收消息 3.服务端接收消息后进行处理,并构建消息返回对象,进行返回 4.客户端接收消息返回对象处理,流程结束 一 创建消息对象及状态新增 收发消息对象 消息请求对象 : @Dat
Netty-搭建一个简单的消息接收发送服务
yimint的博客
08-02 1345
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用。
使用netty编写客户端，实现同步发送消息并接收返回结果
chenmin_test的博客
09-06 9551
使用netty实现发送消息并返回结果功能
Netty作为服务端向客户端推送消息
weixin_43914278的博客
11-03 1082
1、可能有大量的线程处于休眠，只是等待输入或者输出数据2、每个线程的调用栈都分配内存很庞大3、线程间上下文切换开销可以理解为你要雇那么多工人还有给工人每个人分一块地盘，而且你还得不停地切换用哪个工人。设计统一的API，支持多种传输类型，阻塞的和非阻塞的简单而强大的线程模型真正的无连接数据报套接字支持链接逻辑组件以支持复用易于使用详实的Javadoc和大量的示例集不需要超过JDK 1.6+[7]的依赖。（一些可选的特性可能需要Java 1.7+和/或额外的依赖）性能。
Netty 如何做到像Feign一样简单的发送消息？
zsg1994的博客
08-11 273
Netty提供了高效的异步通信能力，使得重试数据的上报可以在绝大部分场景下以异步方式进行，从而更好地满足平台的高性能要求。在本实现中，我们仿照FeignClient的思路，也实现了一个NettyClient。如果你希望与Spring结合使用，可以参考Feign的实现，这也是非常简便的。在开发EasyRetry的过程中随着需要通信的节点越来越多，发现通过相似代码逐渐增多从而导致了代码的可读性差、维护困难等问题，比如下面的代码。总结: 将公共的代码在代理类中进行实现，外部只需要传入动态的参数即可。
netty3 客户端 服务端聊天
04-12
在这个“netty3 客户端 服务端聊天”的示例中，我们将探讨如何使用 Netty 3 实现客户端和服务端之间的长连接通信，以便进行实时的信息收发。 首先，Netty 的核心组件包括 Bootstrap（引导类）、Channel（通道）、...
Netty实现简单的聊天消息群发功能
12-12
客户端处理器则继承自`SimpleChannelInboundHandler`，用于接收服务端广播的消息并展示给用户。 以下是实现过程的关键步骤： 1. **服务器端设置**： - 创建`ServerBootstrap`实例，配置NioEventLoopGroup，一个...
SpringBoot+WebSocket+Netty实现消息推送的示例代码
08-19
在本文中，我们将深入探讨如何使用SpringBoot、WebSocket和Netty来实现消息推送功能。首先，让我们了解一下这三个组件的关键概念。 SpringBoot是一个流行的Java框架，它简化了Spring应用程序的开发，提供了快速启动...
netty-socketio：在Java上实现的Socket.IO服务器。 实时Java框架
02-03
Netty-socketio概述 该项目是服务器的开源Java实现。 基于服务器框架。... 支持netty-socketio节点之间的分布式广播（ ， ） 支持OSGi 支持春天 无锁和线程安全的实现 通过注解进行声明式处理程序配置 性能
通过Netty实现MQTT服务端Demo
04-12
这意味着该Demo已经能够处理MQTT协议中的SUBSCRIBE和PUBLISH报文类型，允许客户端连接并发送数据到服务端，但服务端无法将接收到的消息广播给其他订阅了相同主题的客户端。这表明在实际的应用场景中，可能还需要...
服务端给客户端推送消息用Netty+WS实现
KHOST的博客
04-09 2810
# 前言 曾几何时，不知道大家有没有在项目里遇到过需要服务端给客户端推送消息的需求，是否曾经苦恼过、纠结过，我们知道要想实现这样的需求肯定离不开websocket长连接方式，那么到底是该选原生的websocket还是更加高级的netty框架呢？在此我极力推荐netty，因为一款好的框架一般都是在原生的基础上进行包装成更好、更方便、更实用的东西，很多我们需要自己考虑的问题都基本可以不用去考虑...
netty实现简单的客户端、服务端互相发消息
种麦南山下的博客
02-03 822
引入maven依赖。
Netty框架实战篇 - 实现UDP单播和广播
wzljiayou的博客
12-02 3700
文章目录前言一、pandas是什么？总结 前言 一、pandas是什么？ 总结
05.netty实现简单的消息的广播
mazhongjia的博客
02-05 2170
思路： 1、使用netty提供的ChannelGroup来保存连接到服务端的客户端连接 ChannelGroup的作用（好处）是：通过操作ChannelGroup，实现对加入到ChannelGroup中的所有的Channel进行统一操作 2、在Server端的客户端与服务端建立好连接时的回调函数handlerAdded方法中，将新的连接加入到ChannelGroup channelGrou...
Netty实现长连接，客户端随时发送消息给服务端，可在任意代码位置发送消息给服务端
祁_z
12-23 6273
目 pom依赖 netty服务端代码 netty客户端 PosttingObject封装netty客户端连接信息 测试客户端发送消息到服务器端 1. 可以实现长连接，心跳机制每隔N秒客户端给服务器发送一条消息，代表客户端还存活。 2. 可以实现在随意代码位置按照用户id标识，发送消息给服务端。 pom依赖 <dependency> <groupId>io.netty</groupId> <artifactId>ne
Netty 服务端和客户端
04-05
Netty是一个高性能的网络编程框架，支持服务端和客户端的开发。 Netty服务端： 1. 创建一个ServerBootstrap对象，用于启动Netty服务端。 2. 配置ServerBootstrap对象，设置一些属性，例如端口号、线程池等。 3. 创建一个ChannelInitializer对象，用于初始化Channel管道。 4. 在ChannelInitializer对象中，添加一些ChannelHandler对象，用于处理客户端请求。 5. 调用ServerBootstrap的bind()方法，启动Netty服务端，等待客户端连接。 Netty客户端： 1. 创建一个Bootstrap对象，用于启动Netty客户端。 2. 配置Bootstrap对象，设置一些属性，例如远程地址、线程池等。 3. 创建一个ChannelInitializer对象，用于初始化Channel管道。 4. 在ChannelInitializer对象中，添加一些ChannelHandler对象，用于处理服务端响应。 5. 调用Bootstrap的connect()方法，连接远程Netty服务端。 6. 等待连接成功后，向服务端发送请求，等待服务端响应。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哈哈兽0026

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值