Netty转发数据

已于 2024-07-24 09:47:33 修改
阅读量458 收藏 6
点赞数 4
分类专栏： skill 文章标签： java 前端 服务器
于 2024-07-15 17:06:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lb_bei/article/details/140380099
版权

环境：win10、jdk17、springboot3

1.Netty概述

        Netty 是一个基于 Java 的异步事件驱动的网络应用框架，用于快速开发高性能、高可靠性的网络服务器和客户端。它提供了对各种协议（如 HTTP、TCP、UDP）的支持，并通过其强大的网络编程能力，简化了网络应用的开发过程。

2.Netty使用

https://netty.io/wiki/user-guide-for-4.x.htmlicon-default.png?t=N7T8https://netty.io/wiki/user-guide-for-4.x.html

2.1 导入依赖

<!-- netty -->
<dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>

        <version>4.1.84.Final</version>
</dependency>

        如果有用到redis，记得去掉redis自带的netty

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>netty-transport</artifactId>
                    <groupId>io.netty</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>netty-handler</artifactId>
                    <groupId>io.netty</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>netty-common</artifactId>
                    <groupId>io.netty</groupId>
                </exclusion>
            </exclusions>
        </dependency>

2.2 Netty 服务器启动类

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.net.InetSocketAddress;

@Slf4j
@Component
public class NettyServer {

    public void start(InetSocketAddress address) {
        //配置服务端的NIO线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)  // 绑定线程池
                    .channel(NioServerSocketChannel.class)
                    .localAddress(address)
                    .childHandler(new NettyServerChannelInitializer())//编码解码
                    .option(ChannelOption.SO_BACKLOG, 12800)  //服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝
                    .childOption(ChannelOption.SO_KEEPALIVE, true);  //保持长连接，2小时无数据激活心跳机制
            // 绑定端口，开始接收进来的连接
            ChannelFuture future = bootstrap.bind(address).sync();
            log.info("netty服务器开始监听端口：" + address.getPort());
            //关闭channel和块，直到它被关闭
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

2.4 服务端初始化类

import io.netty.channel.ChannelInitializer;
import io.netty.channel.FixedRecvByteBufAllocator;
import io.netty.channel.socket.SocketChannel;

/**
 * @Author luobei
 **/
public class NettyServerChannelInitializer extends ChannelInitializer<SocketChannel> {

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

        // 设置接收缓冲区大小
        channel.config().setRecvByteBufAllocator(new FixedRecvByteBufAllocator(2048));

        // 添加自定义的解码器
        channel.pipeline().addLast("decoder", new Decoder());
        // 添加自定义的编码器
        channel.pipeline().addLast("encoder", new Encoder());
        // 添加处理器
        channel.pipeline().addLast(new NettyServerHandler());
    }
}

2.5 解码器

import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;

 import java.util.List;

 /**
  * 解码器
  */

 public class Decoder extends ByteToMessageDecoder {

     @Override
     protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
         //创建字节数组,buffer.readableBytes可读字节长度
         byte[] b = new byte[buffer.readableBytes()];
         //复制内容到字节数组b
         buffer.readBytes(b);
         out.add(toHexString1(b));
     }

     private String toHexString1(byte[] b) {
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < b.length; ++i) {
             buffer.append(toHexString1(b[i]));
         }
         return buffer.toString();
     }

     private String toHexString1(byte b) {
         String s = Integer.toHexString(b & 0xFF);
         if (s.length() == 1) {
             return "0" + s;
         } else {
             return s;
         }
     }
 }

2.6 编码器

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * 编码器
 */
public class Encoder extends MessageToByteEncoder<String> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, String s, ByteBuf byteBuf) throws Exception {
        //将16进制字符串转为数组
        byteBuf.writeBytes(CodeUtil.hexString2Bytes(s));
    }
    /**
     * @Title:hexString2Bytes
     * @Description:16进制字符串转字节数组
     * @param src 16进制字符串
     * @return 字节数组
     */
    public static byte[] hexString2Bytes(String src) {
        int l = src.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            ret[i] = (byte) Integer.valueOf(src.substring(i * 2, i * 2 + 2), 16).byteValue();
        }
        return ret;
    }
}

2.7 netty消息处理类

import com.nettydemo.entity.NettyChannelDto;
import com.nettydemo.service.ProtocolFactoryService;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.net.InetSocketAddress;

@Slf4j
@Component
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    private static NettyServerHandler nettyServerHandler;

    @PostConstruct
    public void init() {
        nettyServerHandler = this;
    }

    /**
     * @param ctx
     * @DESCRIPTION: 有客户端连接服务器会触发此函数
     * @return: void
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        //保存通道信息
        log.info(ctx.toString());
    }

    /**
     * @param ctx
     * @DESCRIPTION: 有客户端终止连接服务器会触发此函数
     * @return: void
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        delChannel(ctx, 1);
    }

    /**
     * @param ctx
     * @DESCRIPTION: 有客户端发消息会触发此函数
     * @return: void
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String cmd = msg.toString();
        log.info("客户端发消息:{}", cmd);
        /**
         *  下面可以解析数据，保存数据。
         */
        ThreadExecutor.execute(() -> {
            log.info(ctx+msg.toString());
            //处理数据
        });

    }

    private NettyChannelDto getNettyChannelDto(ChannelHandlerContext ctx){

        NettyChannelDto dto = NettyContextUtil.CHANNEL_MAP.get(ctx.channel().id());
        if(dto==null){
            return updateChannel(ctx);
        }
        return dto;
    }

    private NettyChannelDto updateChannel(ChannelHandlerContext ctx){
        //获取连接通道唯一标识
        ChannelId channelId = ctx.channel().id();
        NettyChannelDto dto = NettyContextUtil.CHANNEL_MAP.get(channelId);
        if(dto==null){
            InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
            String clientIp = insocket.getAddress().getHostAddress();
            int clientPort = insocket.getPort();

            //有新的连接，将连接信息写入缓存
            NettyChannelDto nettyChannelDto = new NettyChannelDto();
            nettyChannelDto.setContext(ctx);
            nettyChannelDto.setClientIp(clientIp);
            nettyChannelDto.setClientPort(clientPort);
            NettyContextUtil.CHANNEL_MAP.put(channelId, nettyChannelDto);
            log.info("客户端【" + channelId + "】连接netty服务器[IP:" + clientIp + "--->PORT:" + clientPort + "]");
            return nettyChannelDto;
        }
        return dto;
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

        String socketString = ctx.channel().remoteAddress().toString();

        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                log.info("Client: " + socketString + " READER_IDLE 读超时");
                ctx.disconnect();
            } else if (event.state() == IdleState.WRITER_IDLE) {
                log.info("Client: " + socketString + " WRITER_IDLE 写超时");
                ctx.disconnect();
            } else if (event.state() == IdleState.ALL_IDLE) {
                log.info("Client: " + socketString + " ALL_IDLE 总超时");
                ctx.disconnect();
            }
        }
    }

    /**
     * @param ctx
     * @DESCRIPTION: 发生异常会触发此函数
     * @return: void
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("异常", cause.getMessage());
        delChannel(ctx, 2);
        ctx.close();
    }

    /**
     * 通道失去连接时调用
     * @param ctx
     * @param type 通道断开类型：1.正常断开（正常失去连接） 2.异常断开（服务端捕获到异常，断开连接）
     */
    public void delChannel(ChannelHandlerContext ctx, int type){
        switch (type){
            case 1://服务器正常断开连接

                InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();

                String clientIp = insocket.getAddress().getHostAddress();

                ChannelId channelId = ctx.channel().id();
                //有客户端断开连接，将连接信息移除
                log.info("客户端【" + channelId + "】退出netty服务器[IP:" + clientIp + "--->PORT:" + insocket.getPort() + "]");
                break;
            case 2:
                //连接错误清除通道
        }
    }
}
import com.nettydemo.entity.NettyChannelDto;
import io.netty.channel.ChannelId;
import org.apache.logging.log4j.util.Strings;
import java.util.concurrent.ConcurrentHashMap;

public class NettyContextUtil {

    /**
     * 保存连接服务端的通道数量
     */
    public static final ConcurrentHashMap<ChannelId, NettyChannelDto> CHANNEL_MAP = new ConcurrentHashMap<>();
}

2.8 通道信息实体类

@Data
public class NettyChannelDto {

    //通道连接
    private ChannelHandlerContext context;
    //客户端ip
    private String clientIp;
    //端口
    private int clientPort;
    //回复命令
    private String cmd;
    //密码
    private String password;
}

2.9 netty客户端（用来转发消息）

package com.nettydemo.util;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
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 io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class NettyClient {

    private ChannelFuture f;
    private final EventLoopGroup workerGroup = new NioEventLoopGroup();
    private final String host;
    private final int port;

    public NettyClient(String host, int port) {
        this.host = host;
        this.port = port;
        connect();
    }

    public void sendMessage(String message) throws Exception {
        if (f == null || !f.channel().isActive()) {
            log.warn("连接未建立或连接已失效，正在尝试重新连接");
            connect();
        }

        if (f != null && f.channel().isActive()) {
            f.channel().writeAndFlush(message).addListener((ChannelFuture future) -> {
                if (future.isSuccess()) {
                    log.info("消息已发送: {}", message);
                } else {
                    log.error("消息发送失败", future.cause());
                }
            }).sync();
        } else {
            log.error("无法发送消息，连接未建立");
        }
    }

    private void connect() {
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) {
                    ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));
                    ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));
                }
            });
            f = b.connect(host, port).sync();
            log.info("连接成功: {}:{}", host, port);
        } catch (Exception e) {
            log.error("连接失败", e);
            if (workerGroup != null && !workerGroup.isShutdown()) {
                workerGroup.shutdownGracefully();
            }
        }
    }

    public void shutdown() {
        if (workerGroup != null && !workerGroup.isShutdown()) {
            workerGroup.shutdownGracefully();
            log.info("工作组已关闭");
        }
    }
}

         用的地方直接调用方法（最好只创建一次nett客户端，保持一个连接）

private static NettyClient nettyClient;

@PostConstruct
public void init() {
    nettyClient = new NettyClient(HOST, PORT);
}

try {
    nettyClient.sendMessage(msg);
} catch (Exception e) {
    throw new RuntimeException(e);
}

 2.10 netty启动监听器

        在 Spring Boot 应用程序启动后自动启动 Netty 服务器

@Component
public class NettyStartListener implements ApplicationRunner {

    @Autowired
    private NettyServer nettyServer;

    @Value("${nettyserver.ip}")
    private String SERVER_IP;

    @Value("${nettyserver.port}")
    private Integer SERVER_PORT;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        InetSocketAddress address=new InetSocketAddress(SERVER_IP,SERVER_PORT);
        nettyServer.start(address);
    }
}
LB_bei
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
netty 请求 转发http_netty整合springMVC，实现高效HTTP服务请求
weixin_39618597的博客
01-14 920
单点：客户端通过TCP链接和服务器建立长连接，client和server都是通过管道(ChannelPipeline)的addLast方法的添加顺序来处理接收或者发送的数据。这个和struts的filter的doFilter原理类似，处理完一个filter，如果后面还有其他的filter，就将数据chain.doFilter来继续处理。大家可以点击加群【JAVA架构知识学习讨论群】47398464...
netty代理转发_使用Netty代理你的请求
weixin_42495504的博客
01-17 1762
你是否在寻找一个代理来调试你的客户端-服务端的通讯？不需要再寻觅！Netty已经通过示例来展现这个功能了！Netty是一个NIO C/S框架，能够快速、简单的开发协议服务器和客户端等网络应用。它能够很大程度上简单化、流水线化开发网络应用，例如TCP/UDP socket服务器。你可以在这里找到Netty的指导教程。在Netty中，实现的代码或者业务逻辑的切入点需要依赖于处理器。处理器基于拦截器模式...
记一次netty数据中转服务开发
最新发布
V_zxw的博客
05-30 836
近日需要开发一个服务去对接上游的TCP数据源，同时将数据转发给下游去处理，该服务只做前置的登录鉴权、心跳等操作。
Netty数据转发工具
04-13
Netty实现端口数据转发：3000进4000出
netty 转发服务
weixin_30338497的博客
01-29 902
NettyServer package com.youxiong.netty.server; import com.youxiong.netty.handler.MyChannelHandler; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channe...
Netty模型和消息转发
users24146的博客
05-02 620
梳理一下Netty的模型。处理事件的handler。Netty 消息转发。handler处理器。
netty-nat:基于netty实现的TCPHttp请求转发的代理程序，可用做内网穿透工具
03-15
净资产 基于netty的TCP / Http请求转发代理程序 简介 在特定的网络环境或安全审核要求下，我们可能会面临网络被限定为单向访问的情况，本工具可以实现在单向网络中设置代理从而实现双向访问的目的。透工具。 依赖/知识准备 netty-高性能NIO通信框架 tcp / ip通信基础知识 工具原理说明 程序运行时序图！[image] [tmp] 使用方式 将项目克隆到本地 修改配置文件项目包含两个独立配置文件，分别为netty-nat | --netty-client | ---- properties.properties |-网络服务器| ---- properties.properties 客户端对应的属性配置： internal.server.port代理程序服务端端口internal.server.host代理程序服务端地址proxy.client.port被代理程序的端口p
springboot 日志管理
qq_33106591的博客
09-27 253
问题说明 如果日志打印成文件,需要配置文件路径,如下所示: <property name="log.path" value="/home/projetc/logs" /> 问题:在uat和prod中我需要配置不同路径,难道每次打包都修改logback-spring.xml文件? 解决方法 https://docs.spring.io/spring-boot/docs/curren...
基于netty4 的udp字节数据接收服务
11-08
在本文中，我们将深入探讨如何利用 Netty 4 构建基于 UDP（用户数据报协议）的数据接收服务，以及如何实现相应的发送服务。 首先，UDP 是一种无连接的传输层协议，它不保证数据的顺序或可靠性，但具有较低的开销，...
Netty实现数据转发（服务端代码）
qq771650656的博客
04-13 3562
Netty实现数据转发Netty数据转发服务端Server实现： Netty数据转发 Netty实现数据转发功能，服务端定义两个端口，两个客户端相连，实现两个客户端的通讯。比如：3000端口进，转发到4000端口的服务器。 服务端Server实现： 服务器的功能实现： 定义两个端口 定义构造器 设置客户端请求 定义run（）方法，创建两个线程组bossGroup和workerGroup 创建一个serverBootstrap（服务端启动引导类） 设置server 绑定两个端口
Netty实现简单的聊天消息群发功能
12-12
使用Netty实现的简单的聊天消息群发的工具类，支持多客户端发送消息给服务端，并由服务端将详细群发给所有的客户端，也可以在此基础上修改，实现一对一的聊天消息发送，希望对初学Netty的同学有所帮助。
spring boot 整合的netty 实现的socket的服务端和客户端
05-08
spring boot 整合的netty 实现的socket的demo（包括服务端和客户端是分开的两个项目，导入idea，启动即可）。
Netty一个端口支持tcp和websocket
09-29
同一个端口支持tcp和websocket 这样就不需要开两个端口了
netty简单的转发例子
做你想做的人，没有时间的限制，只要愿意，什么时候都可以start。
01-27 882
maven <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.36.Final</version> </dependency> netty引导类 import java.net.InetSocketAddress; import io.netty.boo
【netty从入门到放弃】netty转发tcp数据到多客户端
程序猿学社的博客
10-19 1108
接到一个需求，需要实现转发通讯模块其他的服务器，也就是转发tcp数据到注意：本篇文章是只是实现转发操作，不支持转发的服务器，反向控制设备，需要做特殊处理，如果大家感兴趣，给我留言下面我们根据我们头脑风暴的结果，来想办法实现上面的过程。
netty代理转发_Netty实现代理模式的通信
weixin_39790102的博客
01-17 758
该demo是从netty提供的demo修改并添加注释按我的理解简单的说一下netty中代理通信的编程模型。代理就是通过一个中间服务器去目标服务器请求所要的信息，然后通过代理服务器返回信息给客户端。在netty中，netty客户端请求代理服务器，连接到代理服务器时->inbound，代理服务器马上去连接目标服务器->outbound，当连接目标服务器成功时，这是开始读取客户端给代理服务器...
Netty实现TCP转发
weixin_42287867的博客
09-28 725
公司网络部分故障，测试环境某些网段到Oracle连接失败，排查修复慢，故整了个TCP链接转发工具，放到好的网段去进行转发，使开发业务流程不中断。
一文搞懂Netty发送数据全流程 | 你想知道的细节全在这里
bin的技术小屋
04-08 4981
关于Netty如何高效地发送网络数据，你想知道的所有细节都在这里
springboot中netty怎么接收数据转发数据
08-09
在Spring Boot中，使用Netty接收数据并转发数据可以通过以下步骤完成： 1. 首先，我们需要在Spring Boot项目中引入Netty的依赖。可以通过在pom.xml文件中添加以下代码来实现： ```xml <groupId>io.netty ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值