Springboot集成Netty

最新推荐文章于 2024-05-17 09:55:41 发布
最新推荐文章于 2024-05-17 09:55:41 发布
阅读量281 收藏 1
点赞数 1
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47600724/article/details/134387317
版权

一、Springboot＋Netty环境搭建

1、引入依赖：

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

2、application.yml配置 

server:
  port:8080
netty:
  host: 127.0.0.1
  port: 7397

3、配置服务端 

（1）定义nettyServer组件，用于绑定端口，关闭通道，获取通道操作

@Component("nettyServer")
public class NettyServer {
    private Logger logger = LoggerFactory.getLogger(NettyServer.class);

    private final EventLoopGroup parentGroup = new NioEventLoopGroup();
    private final EventLoopGroup childGroup = new NioEventLoopGroup();
    private Channel channel;


    /**
     * 绑定端口
     * @param address
     * @return
     */
    public ChannelFuture bind(InetSocketAddress address) {
        ChannelFuture channelFuture = null;
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(parentGroup, childGroup)
                    .channel(NioServerSocketChannel.class)    //非阻塞模式
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childHandler(new MyChannelInitializer());
            channelFuture = b.bind(address).syncUninterruptibly();
            channel = channelFuture.channel();
        } catch (Exception e) {
            logger.error(e.getMessage());
        } finally {
            if (null != channelFuture && channelFuture.isSuccess()) {
                logger.info("netty server start done.");
            } else {
                logger.error("netty server start error.");
            }
        }
        return channelFuture;
    }


    /**
     * 销毁
     */
    public void destroy() {
        if (null == channel) return;
        channel.close();
        parentGroup.shutdownGracefully();
        childGroup.shutdownGracefully();
    }


    /**
     * 获取通道
     * @return
     */
    public Channel getChannel() {
        return channel;
    }


}

（2）创建继承通道初始化类的类，用于初始化通道

public class MyChannelInitializer extends ChannelInitializer<SocketChannel> {
    /**
     * 初始化channel
     * @param channel
     * @throws Exception
     */
    @Override
    protected void initChannel(SocketChannel channel) throws Exception {
        // 日志打印
        channel.pipeline().addLast(new LoggingHandler(LogLevel.INFO));
        // 基于换行符号
        channel.pipeline().addLast(new LineBasedFrameDecoder(1024));
        // 解码转String，注意调整自己的编码格式GBK、UTF-8
        channel.pipeline().addLast(new StringDecoder(Charset.forName("GBK")));
        // 解码转String，注意调整自己的编码格式GBK、UTF-8
        channel.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
        // 在管道中添加我们自己的接收数据实现方法
        channel.pipeline().addLast(new MyServerHandler());

    }
}

（3）定义一个类继承通道的拦截类 ，处理通道连接请求

public class MyServerHandler extends ChannelInboundHandlerAdapter {

    private Logger logger = LoggerFactory.getLogger(MyServerHandler.class);

    /**
     * 当客户端主动链接服务端的链接后，这个通道就是活跃的了。也就是客户端与服务端建立了通信通道并且可以传输数据
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        SocketChannel channel = (SocketChannel) ctx.channel();
        //通知客户端链接建立成功
        String str = "通知客户端链接建立成功" + " " + new Date() + " " + channel.localAddress().getHostString() + "\r\n";
        ctx.writeAndFlush(str);
    }

    /**
     * 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        logger.info("客户端断开链接{}", ctx.channel().localAddress().toString());
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //接收msg消息{与上一章节相比，此处已经不需要自己进行解码}
        logger.info(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 服务端接收到消息：" + msg);
        //通知客户端链消息发送成功
        String str = "服务端收到：" + new Date() + " " + msg + "\r\n";
        ctx.writeAndFlush(str);
    }

    /**
     * 抓住异常，当发生异常的时候，可以做一些相应的处理，比如打印日志、关闭链接
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        logger.info("异常信息：\r\n" + cause.getMessage());
    }


}

（4）最后调用，启动服务端

@SpringBootApplication
@ComponentScan("com.shu")
public class NettyApplication implements CommandLineRunner {

    @Value("${netty.host}")
    private String host;
    @Value("${netty.port}")
    private int port;
    @Autowired
    private NettyServer nettyServer;

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

    @Override
    public void run(String... args) throws Exception {
        InetSocketAddress address = new InetSocketAddress(host, port);
        ChannelFuture channelFuture = nettyServer.bind(address);
        Runtime.getRuntime().addShutdownHook(new Thread(() -> nettyServer.destroy()));
        channelFuture.channel().closeFuture().syncUninterruptibly();
    }
}

4.配置客户端

public class ApiTest {
    public static void main(String[] args) {
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.AUTO_READ, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel channel) throws Exception {
                    // 日志打印
                    channel.pipeline().addLast(new LoggingHandler(LogLevel.INFO));
                    // 基于换行符号
                    channel.pipeline().addLast(new LineBasedFrameDecoder(1024));
                    // 解码转String，注意调整自己的编码格式GBK、UTF-8
                    channel.pipeline().addLast(new StringDecoder(Charset.forName("GBK")));
                    // 解码转String，注意调整自己的编码格式GBK、UTF-8
                    channel.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                    // 在管道中添加我们自己的接收数据实现方法
                    channel.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            //接收msg消息{与上一章节相比，此处已经不需要自己进行解码}
                            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 客户端接收到消息：" + msg);
                        }
                    });
                }
            });
            ChannelFuture f = b.connect("127.0.0.1", 7397).sync();
            System.out.println(" client start done");
            //向服务端发送信息
            f.channel().writeAndFlush("你好，SpringBoot启动的netty服务端，“我的结尾是一个换行符，用于传输半包粘包处理”\r\n");
            f.channel().writeAndFlush("你好，SpringBoot启动的netty服务端，“我的结尾是一个换行符，用于传输半包粘包处理”\r\n");
            f.channel().writeAndFlush("你好，SpringBoot启动的netty服务端，“我的结尾是一个换行符，用于传输半包粘包处理”\r\n");
            f.channel().writeAndFlush("你好，SpringBoot启动的netty服务端，“我的结尾是一个换行符，用于传输半包粘包处理”\r\n");
            f.channel().writeAndFlush("你好，SpringBoot启动的netty服务端，“我的结尾是一个换行符，用于传输半包粘包处理”\r\n");
            f.channel().closeFuture().syncUninterruptibly();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

二、 Netty实现简单的文件传输

1、定义两个实体，一个用于接收一个用于返回

@Data
public class FileResponse implements Serializable {
    private long length;
    private File file;

    public FileResponse() {
    }

    public FileResponse(long length, File file) {
        this.length = length;
        this.file = file;
    }

    public long getLength() {
        return length;
    }

    public File getFile() {
        return file;
    }
}


@Data
public class FileRequest implements Serializable {
    private String fileName;

    public FileRequest() {
    }

    public FileRequest(String fileName) {
        this.fileName = fileName;
    }

    public String getFileName() {
        return fileName;
    }
}

2、 配置服务端

 （1）定义配置连接的组件

@Component("fileServer")
public class FileServer {

    private Logger logger = LoggerFactory.getLogger(FileServer.class);


    /**
     * 绑定端口
     *
     * @param port
     * @return
     */
    public void bind(int port) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new ObjectEncoder())
                                    .addLast(new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.weakCachingConcurrentResolver(null)))
                                    .addLast(new FileServerHandler());
                        }
                    });

            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
            System.out.println("服务端启动成功，端口：" + port);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }

}

（2）继承通道处理器，自定义通道处理器

public class FileServerHandler extends ChannelInboundHandlerAdapter  {

    private static final String FILE_PATH = "D:\\coreconfig.txt";

    private Logger logger = LoggerFactory.getLogger(FileServerHandler.class);


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
        logger.info("channelActive");
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("channelRead");
        if (msg instanceof FileRequest) {
            FileRequest request = (FileRequest) msg;
            if (request.getFileName().equals(FILE_PATH)) {
                File file = new File(FILE_PATH);
                if (file.exists()) {
                    RandomAccessFile raf = new RandomAccessFile(file, "r");
                    long length = raf.length();
                    FileResponse response = new FileResponse(length, file);
                    ctx.writeAndFlush(response);

                    ChannelFuture sendFileFuture = ctx.writeAndFlush(new DefaultFileRegion(raf.getChannel(), 0, length), ctx.newProgressivePromise());
                    sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
                        @Override
                        public void operationComplete(ChannelProgressiveFuture future) throws Exception {
                            System.out.println("File transfer completed.");
                            raf.close();
                        }

                        @Override
                        public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) throws Exception {
                            if (total < 0) {
                                System.err.println("File transfer progress: " + progress);
                            } else {
                                System.err.println("File transfer progress: " + progress + " / " + total);
                            }
                        }
                    });
                } else {
                    System.err.println("File not found: " + FILE_PATH);
                }
            } else {
                System.err.println("Invalid file name: " + request.getFileName());
            }
        }
    }

}

3、配置客户端

 （1）配置客户端连接信息：

public class FileClient {
    private static final int PORT = 8080;
    private static final String HOST = "localhost";
    private Logger logger = LoggerFactory.getLogger(FileClient.class);
    private final EventLoopGroup parentGroup = new NioEventLoopGroup();


    /**
     * 连接服务端
     */
    public void connect() {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap()
                    .group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new ObjectEncoder())
                                    .addLast(new ObjectDecoder(ClassResolvers.weakCachingConcurrentResolver(null)))
                                    .addLast(new FileClientHandler());
                        }
                    });

            ChannelFuture future = bootstrap.connect(HOST, PORT).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            group.shutdownGracefully();
        }
    }
}

（2） 定义客户端连接拦截器

public class FileClientHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        FileRequest request = new FileRequest("D:\\coreconfig.txt");
        ctx.writeAndFlush(request);
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FileResponse) {
            FileResponse response = (FileResponse) msg;
            File file = response.getFile();
            long fileLength = response.getLength();
            FileOutputStream fos = new FileOutputStream(file);
            FileChannel channel = fos.getChannel();
//            channel.transferFrom(channel, 0, fileLength);
            System.out.println("File " + file.getName() + " received.");
        } else {
            System.err.println("Invalid response type: " + msg.getClass());
        }
    }

}

转载：Netty+SpringBoot整合（一）-CSDN博客 

 

 

 

咚咚锵敲代码
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot集成netty实现代理服务器
12-21
springboot集成netty实现代理服务器，实现http和https请求的代理功能
SpringBoot使用netty
阿靖的博客
06-29 3万+
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP...
springboot — springboot与netty整合
qq_38658567的博客
07-05 1万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
SpringBoot整合Netty(服务端)
最新发布
m0_70554089的博客
05-17 2963
Netty是由JBOSS提供的一个Java开源框架，现为Github上的独立项目。它是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序。Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用。Netty提供了一套完整的API，用于处理网络IO操作，如TCP和UDP套接字。它封装了底层的网络编程细节，使得开发者可以更加专注于业务逻辑的实现。
2019年java工作面试题汇总
目不识丁
11-05 1137
临近年关，有些java人事都在考虑向新的工作发起挑战， 还是需要对相关的知识点进行系统的复习一下。整理了一些面试准备的知识点，后续会陆续的发出来，让大家更好的学习。 1. JDK 和 JRE 有什么区别？ JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。 JRE：Java Runtime Environment 的简称，...
Java常用框架（三）SpringBoot及Netty
folyh
02-23 3002
Java常用框架（三）SpringBoot及Netty
SpringBoot 集成 netty 源码 dome
10-12
本项目"SpringBoot集成netty源码dome"旨在教你如何将Netty集成到Spring Boot应用中，实现两者之间的高效通信。 首先，让我们了解Spring Boot的核心特性。Spring Boot的核心在于自动配置，它基于Spring框架，提供了...
springboot+netty实现mqtt协议的broken
11-09
标题"springboot+netty实现mqtt协议的broken"可能意味着这个项目旨在解决Spring Boot与Netty集成时可能出现的问题，或者是一个关于如何处理MQTT连接中断的教程。在实际应用中，MQTT连接可能会因为各种原因断开，例如...
SpringBoot整合Netty心跳机制过程详解
08-24
SpringBoot 整合 Netty 心跳机制过程详解 SpringBoot 整合 Netty 心跳机制过程详解是指通过 SpringBoot 框架整合 Netty 网络框架来实现心跳机制的过程。心跳机制是指客户端和服务端之间的连接维持机制，当客户端和...
springboot整合netty的demo
01-22
在SpringBoot项目中，我们可以通过添加对应的依赖来引入Netty，例如在`pom.xml`中加入`spring-boot-starter-webflux`，这个依赖集成了Reactor Netty，它是Spring Framework 5.x对响应式编程的支持，底层就是基于...
SpringBoot整合Netty
热门推荐
Venus's Blog
09-14 13万+
Netty是一个基于Java的开源网络应用框架，它提供了高性能、异步事件驱动的网络编程能力。Netty旨在帮助开发者构建高性能、高可靠性的网络应用程序。Netty提供了简洁的API和丰富的功能，可以轻松处理各种网络通信协议，如TCP、UDP、WebSocket等。它的设计理念是基于事件驱动和回调机制，而不是传统的线程模型，这使得它可以实现高并发、低延迟的网络通信。通过使用Netty，开发者可以方便地处理复杂的网络通信逻辑，例如请求-响应模式、长连接、心跳检测等。
Netty+SpringBoot整合（一）
长安不及十里的博客
05-08 8907
前面我们介绍了Netty的基本用法以及基本知识，但是在我们的实际开发中要用到SpringBoot，下面我们来看看SpringBoot的整合与简单的文件传输吧。
Spring Boot与Netty的完美结合：打造高性能网络通信
里查叔叔
03-08 6030
本文介绍了如何在Spring Boot项目中添加Netty依赖、编写Netty服务端和客户端代码，并将Netty的启动和关闭整合到Spring Boot的生命周期中。一旦你整合了Netty到你的Spring Boot应用中，并实现了必要的业务逻辑处理器，你就可以构建并运行你的应用来测试Netty服务了。此外，Netty还提供了丰富的编解码器、处理器和工具类，大大简化了网络编程的复杂性。要在Spring Boot项目中集成Netty，我们需要添加Netty的依赖，并编写Netty的服务端和客户端代码。
SpringBoot 整合 Netty
摸鱼佬的博客
07-25 6713
一、common工程 1.maven依赖 2.自定义Netty数据包类型 3.自定义Netty数据包 4.自定义Netty数据包处理事件 二、netty-server工程 1.Netty服务端 2.Netty服务端初始化配置 3.Netty服务端处理器 4.Netty服务端自定义数据包处理监听器 5.Netty服务端启动类 三、netty-client工程 1.Netty客户端 2.Netty客户端通道初始化 3.Netty客户端处理器 4.Netty客户端自定义数据包处理监听器 5.Netty客户端启动类
Netty的使用-spring boot整合篇
hello world ！
04-11 3345
1、什么是Netty？ Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是基于nio的，它封装了jdk的nio，让我们使用起来更加方法灵活。 2、它有什么特点？ 高并发：Netty 是一款基于 NIO（Nonblocking IO，非阻塞IO）开发的网络通信框架，对比于 BIO（Blocking I/O，阻塞IO），它的并发性能得到了很大提高。 传输快：Netty 的传输依赖于零拷贝特性，尽量减少不必要的内存拷贝，实现了更高效率的传输。 封装好：N
Springboot+Netty搭建TCP服务端
蚂蚁舞
06-02 3万+
Netty是业界最流行的nio框架之一，它具有功能强大、性能优异、可定制性和可扩展性的优点 Netty的优点： 1.API使用简单，开发入门门槛低。 2.功能十分强大，预置多种编码解码功能，支持多种主流协议。 3.可定制、可扩展能力强，可以通过其提供的ChannelHandler进行灵活的扩展。 4.性能优异，特别在综合性能上的优异性。 5.成熟，稳定，适用范围广。 6.可用于智能G...
Spring Boot 整合 Netty服务
woaiwojialanxi的专栏
03-28 2397
Spring Boot 整合 Netty服务
netty框架学习及springboot整合集成
shy871的博客
04-23 5503
netty框架学习及springboot整合集成
springboot集成netty
07-28
在Spring Boot中集成Netty可以通过以下步骤完成： 1. 添加Netty依赖：在你的Spring Boot项目的pom.xml文件中添加Netty的依赖。 ```xml <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.53.Final</version> </dependency> ``` 2. 创建Netty服务器：创建一个Netty服务器类，该类需要继承自`io.netty.channel.ChannelInboundHandlerAdapter`。 ```java public class NettyServer extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { // 处理接收到的消息 // ... } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // 处理异常情况 // ... } @Override public void channelActive(ChannelHandlerContext ctx) { // 在连接建立时执行一些初始化操作 // ... } @Override public void channelInactive(ChannelHandlerContext ctx) { // 在连接关闭时执行一些清理操作 // ... } } ``` 3. 配置Netty服务器：在Spring Boot的配置文件中配置Netty服务器的相关参数，例如端口号、线程池等。 ```properties # application.properties netty.server.port=8080 netty.server.workerThreads=10 ``` 4. 启动Netty服务器：在Spring Boot的启动类中初始化并启动Netty服务器。 ```java @SpringBootApplication public class YourApplication { @Autowired private NettyServer nettyServer; public static void main(String[] args) { SpringApplication.run(YourApplication.class, args); } @PostConstruct public void startNettyServer() { // 获取Netty服务器配置参数 int port = Integer.parseInt(env.getProperty("netty.server.port")); int workerThreads = Integer.parseInt(env.getProperty("netty.server.workerThreads")); // 创建EventLoopGroup和ServerBootstrap EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(workerThreads); ServerBootstrap serverBootstrap = new ServerBootstrap(); try { // 设置服务器参数 serverBootstrap.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); // 添加自定义的Handler pipeline.addLast(nettyServer); } }); // 启动Netty服务器 ChannelFuture channelFuture = serverBootstrap.bind(port).sync(); channelFuture.channel().closeFuture().sync(); } catch (InterruptedException e) { // 处理启动异常 } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } } ``` 这样，你就成功地在Spring Boot项目中集成了Netty。你可以在`NettyServer`类中编写自定义的业务逻辑来处理接收到的消息，并在`channelRead`方法中进行处理。同时，你也可以根据需要在`exceptionCaught`、`channelActive`和`channelInactive`方法中处理异常、连接建立和连接关闭等事件。记得在服务器关闭时进行资源的释放和清理操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值