Springboot整合Netty，实现Socket通信

已于 2022-07-17 21:01:27 修改
阅读量6.8k 收藏 33
点赞数 4
分类专栏： Springboot 文章标签： spring boot netty
于 2021-06-30 13:01:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43630831/article/details/118353922
版权

文章目录

Springboot整合Netty，实现Socket通信

1.模拟单客户端

引入Netty依赖：

当前Springboot版本为：2.5.1

<!--Netty网络通信框架依赖（不用声明版本号，因为 spring-boot-dependencies 中已经声明了最新的Netty依赖）-->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
</dependency>

SocketChannelInitializer.java：

package com.kd.opt.socket;

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

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 *
 * 设置出站和入站的编码器和解码器（该方法在SocketClientConfig.java中被重写）
 *
 * 客户端
 *
 * @author 小辰哥哥
 */

public class SocketChannelInitializer extends ChannelInitializer<SocketChannel> {
    protected void initChannel(SocketChannel channel) throws Exception {
        ChannelPipeline p = channel.pipeline();
        p.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
        p.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        p.addLast(new SocketHandler());
    }
}

SocketHandler.java：

package com.kd.opt.socket;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 *
 * 初始化操作、接受服务端发送过来的消息（该方法在SocketClient.java中被重写）
 *
 * 客户端
 *
 * @author 小辰哥哥
 */

public class SocketHandler extends ChannelInboundHandlerAdapter {

    // 日志打印
    private static final Logger LOGGER = LoggerFactory.getLogger(SocketHandler.class);

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        LOGGER.debug("SocketHandler Active（客户端）");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        LOGGER.debug("####接收服务端发送过来的消息####");
        LOGGER.debug("SocketHandler read Message：" + msg);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        LOGGER.debug("####客户端断开连接####");
    }

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

SocketClient.java：

package com.kd.opt.socket;

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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 * 
 * 核心文件（与服务端进行数据交互）
 * 
 * 客户端
 *
 * @author 小辰哥哥
 */
public class SocketClient {
    // 服务端IP
    static final String HOST = System.getProperty("host", "127.0.0.1");

    // 服务端开放端口
    static final int PORT = Integer.parseInt(System.getProperty("port", "5555"));

    // 数据包大小
    static final int SIZE = Integer.parseInt(System.getProperty("size", "256"));

    // 日志打印
    private static final Logger LOGGER = LoggerFactory.getLogger(SocketClient.class);

    // 主函数启动
    public static void main(String[] args) throws InterruptedException {
        sendMessage("Hello World");
    }

    /**
     * 核心方法（处理：服务端向客户端发送的数据、客户端向服务端发送的数据）
     *
     * @param content
     * @throws InterruptedException
     * @author 小辰哥哥
     */
    public static void sendMessage(String content) throws InterruptedException {
        // Configure the client.
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
                            p.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
                            p.addLast(new SocketHandler() {
                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) {
                                    LOGGER.debug("####接收服务端发送过来的消息####");
                                    LOGGER.debug("服务端发送过来的数据：" + msg);

                                    // 主动与服务端断开连接（客户端触发）
                                    ctx.channel().close();
                                }
                            });
                        }
                    });

            ChannelFuture future = b.connect(HOST, PORT).sync();
            future.channel().writeAndFlush(content);

            // 程序阻塞
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

}

使用sokit软件（充当服务端）开始测试：
在这里插入图片描述
点击TCP侦听：
在这里插入图片描述
在这里插入图片描述
主函数启动程序：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
服务端发送消息，然后客户端主动断开连接：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
服务端主动断开连接：
在这里插入图片描述
在这里插入图片描述

2.模拟单服务端

yml相关配置：

# 配置Netty通信IP和端口
netty:
  port: 5555
  url: 127.0.0.1

NettyChannelInitializer.java：

package com.kd.opt.socket;

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

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 *
 * 设置出站和入站的编码器和解码器
 *
 * 服务端
 *
 * @author 小辰哥哥
 */
public class NettyChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel channel) throws Exception {
        channel.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
        channel.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        channel.pipeline().addLast(new NettyHandler());
    }
}

NettyHandler.java：

package com.kd.opt.socket;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.SocketAddress;

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 *
 * 初始化操作、处理客户端与服务端相关消息
 *
 * 服务端
 *
 * @author 小辰哥哥
 */
public class NettyHandler extends ChannelInboundHandlerAdapter {

    public static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    // 日志打印
    private static final Logger LOGGER = LoggerFactory.getLogger(NettyHandler.class);

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        LOGGER.debug("SocketHandler Active（服务端）");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        // 客户端向服务端发送数据（获取客户端IP和端口、相关数据）
        SocketAddress socketAddress = ctx.channel().remoteAddress();

        LOGGER.debug("####接收客户端发送过来的消息####");
        LOGGER.debug("获取IP和端口：" + socketAddress);
        LOGGER.debug("SocketHandler read Message：" + msg);

        // 服务端向客户端发送数据
        ctx.write("Send Client：Dear Grilfriend!");
        
        // 刷新缓存区
        ctx.flush();
        
		// 断开客户端连接
        ctx.channel().close();
        
    }

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

NettyServer.java：

package com.kd.opt.socket;

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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.net.InetSocketAddress;

/**
 * Springboot整合Netty，实现Socket信息交互（本项目用于与C语言程序进行交互）
 *
 * 核心文件（开启服务端）
 *
 * 服务端
 *
 * @author 小辰哥哥
 */

@Component
public class NettyServer {

    // 日志打印
    private static final Logger LOGGER = LoggerFactory.getLogger(NettyServer.class);

    // 开启服务端口
    public static void start(InetSocketAddress address) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .localAddress(address)
                    .childHandler(new NettyChannelInitializer())
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 绑定端口，开始接收进来的连接
            ChannelFuture future = bootstrap.bind(address).sync();
            LOGGER.debug("开启Netty服务端口：" + address.getPort());
            future.channel().closeFuture().sync();

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

}

Springboot启动类：

package com.kd.opt;

import com.kd.opt.socket.NettyServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.net.InetSocketAddress;

// 正常模式启动（Netty模拟单客户端操作时）
//@SpringBootApplication
//public class OperateTicketApplication {
//
//    public static void main(String[] args) {
//        SpringApplication.run(OperateTicketApplication.class, args);
//    }
//
//}

// Netty模拟单服务端操作时
@SpringBootApplication
public class OperateTicketApplication implements CommandLineRunner {

    @Value("${netty.port}")
    private int PORT;

    @Value("${netty.url}")
    private String URL;

    @Autowired
    private NettyServer server;

    public static void main(String[] args) {
        SpringApplication.run(OperateTicketApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        InetSocketAddress address = new InetSocketAddress(URL, PORT);
        server.start(address);
    }
}

启动项目：
在这里插入图片描述
使用sokit软件（充当客户端）开始测试：在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
开始进行数据通信，然后服务端断开客户端连接：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

总结

每天一个提升小技巧！！！

小辰哥哥
关注
专栏目录
SpringBoot+netty 实现socket通讯
TangHL_world的博客
08-17 770
服务端 1.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <ar
spring boot 整合的netty 实现的socket的服务端和客户端
05-08
spring boot 整合的netty 实现的socket的demo（包括服务端和客户端是分开的两个项目，导入idea，启动即可）。
Spring-boot 集成 SocketIO（保姆级教程，包括前后端代码示例）
最新发布
对博客内容有任何疑问，欢迎私信我
08-08 1611
Socket.IO 是一个可以在浏览器与服务器之间实现实时、双向、基于事件的通信的工具库。Socket.IO 能够在任何平台、浏览器或设备上运行,可靠性和速度同样出色。
SpringBoot 集成 Netty 使用Socket功能
七濑武的博客
07-07 1179
SpringBoot 集成 Netty 使用Socket功能
SpringBoot Netty socket使用
高性价比服务器就选：蓝易云
01-20 413
总之，通过以上步骤，可以在Spring Boot项目中使用Netty进行Socket编程。Netty提供了高性能和灵活的网络编程框架，适用于构建基于TCP/UDP的网络应用。
springboot+netty实现socket编程
zhaocuit的博客
11-06 5549
springboot+netty实现socket编程 Java socket网络编程一直没有怎么接触到，虽然以前也自学过netty，但未在实际项目中使用过，始终感觉肤浅。最近看到lcnV4.0.2版本时，才算明白如何在实际springboot项目中如何使用netty实现socket编程。（注意：lcn5.+，代码比较晦涩难懂，如果只是想学习如何在springboot环境下使用netty实现socket编程，建议阅读lcn4.+） 服务端和客户端交互的数据报文约定 但lcnV4.x是直接使用的Json，但还是
springboot netty实现socket_从零开始实现mvc框架
weixin_39642687的博客
12-05 152
造个轮子— 从socket到mvc框架 1. 缘起为什么要造这个轮子？现在Java领域的mvc框架层出不穷，springmvc，struts2，jfinal；容器方面有tomcat，jetty，undertow。为什么要造这个不成熟的东西出来？我想起我在大二刚接触java web是学的struts2，一大堆xml配置让我看到吐，感觉这掩盖了网络编程的本来面目，为什么不从底层的socket写起，解析...
springboot整合netty,实现socket通信
06-14
Spring Boot可以很方便地整合Netty，以实现Socket通信。Netty是一个高可扩展性的Java异步网络编程框架，可以用于开发高性能的网络应用程序和协议服务器。 要实现Spring Boot整合Netty，需要添加Netty依赖。可以在...
基于springBoot + netty-socket.io + mongodb 的即时聊天后台.zip
04-08
学生可以通过此项目学习到如何使用SpringBoot构建后端服务，如何用Netty处理实时通信，以及如何利用NoSQL数据库（如MongoDB）存储和检索数据。 **7. 部署与测试** 项目说明和部署教程应包含在压缩包内，帮助用户...
Spring-Boot快速集成netty-socketio(socket服务实现，支持认证)
qq_42271561的博客
08-09 5496
Spring-Boot快速集成netty-socketio(socket服务实现，支持认证) netty-socketio是一个开源的Socket.io服务器端的一个java的实现，它基于Netty框架，可用于服务端推送消息给客户端。 说到服务端推送技术，一般会涉及WebSocket，WebSocket是HTML5最新提出的规范，虽然主流浏览器都已经支持，但仍然可能有不兼容的情况，为了兼容所有浏览器，给程序员提供一致的编程体验，SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一
SpringBoot搭建Netty+Socket+Tcp服务端和客户端
Wcybaonier
05-19 5420
这里为了测试,写了Main方法,可以参考服务端,配置启动类 ,实现跟随项目启动。有测试的,,,但是忘记截图了......................想写就参考服务端......
netty介绍一
weixin_48755260的博客
12-03 242
Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。 “快速”和“简单”并不用产生维护性或性能上的问题。
Spring Boot集成Netty-SocketIO
网络技术联盟站
01-15 1480
Netty-SocketIO是基于Netty的一个开源框架，用于构建实时、双向通信的应用。它基于SocketIO协议，为开发者提供了轻松构建实时Web应用的能力。在Spring Boot中集成Netty-SocketIO可以使得我们更方便地处理实时通信需求。在传统的Web应用中，基于HTTP的通信模式存在一定的限制，特别是在处理实时数据时。Netty-SocketIO通过提供全双工通信、实时事件处理等特性，使得开发者能够更容易地构建具有实时性要求的应用，例如在线聊天、协同编辑等。
Springboot 整合 Socket 实战案例 ，实现 单点发送、广播群发，1对1，1对多
默默不代表沉默
07-29 7843
7步学会 springboot整合 socket
springBoot + netty搭建高性能 websocket 服务 & 性能测试（包含python 测试脚本）
卷心菜投手
09-13 6880
springBoot netty websocket 性能测试
SpringBoot整合Netty+SSL Socket
qq_43890604的博客
03-29 474
SpringBoot整合Netty+SSL Socket
springboot +netty-socket使用详细说明
陌上花开然不归矣
03-29 4285
springboot 实现socket通信
SpringBoot实现Socket客户端，Netty服务端实现Java通讯（附源码及注释详解）
热门推荐
beishanyingluo的博客
09-26 1万+
SpringBoot实现Socket通讯： 使用Netty实现一个Socket通讯，包括客户端和服务端，通过服务端进行监听，客户端发送信息，服务端可进行接收，并进行返回数据，完成一个完整的通讯 客户端用的Socket编程，而服务端用到Netty框架实现。源码地址： 源码地址！！！！！！！！ 而且启动初始化及调用的日志、注释写的很清楚，如下： package com.xu.server; impo...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小辰哥哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值