SpringBoot项目使用Sigar获取系统参数:CPU，内存，硬盘，网络流量波动

最新推荐文章于 2023-05-25 14:47:43 发布
最新推荐文章于 2023-05-25 14:47:43 发布
阅读量7.4k 收藏 26
点赞数 4
分类专栏： Java服务端 文章标签： sigar 系统参数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lllllishi/article/details/105250372
版权

先下载sigar：http://sigar.hyperic.com/

将sigar-bin\lib目录下文件放到classpath中

 

 

1 pom

<dependency>
            <groupId>org.fusesource</groupId>
            <artifactId>sigar</artifactId>
            <version>${sigar.version}</version>
        </dependency>

2 配置到spring

@Slf4j
@Configuration
public class SigarConfig {

    static {
        try {
            initSigar();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *     初始化sigar的配置文件
     */
    public static void initSigar() throws IOException {
        SigarLoader loader = new SigarLoader(Sigar.class);
        String lib = null;

        try {
            lib = loader.getLibraryName();
            log.info("init sigar so文件====================="+lib);
        } catch (ArchNotSupportedException var7) {
            log.error("initSigar() error:{}",var7.getMessage());
        }
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        Resource resource = resourceLoader.getResource("classpath:/sigar.so/" + lib);
        if (resource.exists()) {
            InputStream is = resource.getInputStream();
            File tempDir = new File("./log");
            if (!tempDir.exists()){
                tempDir.mkdirs();
            }
            BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(new File(tempDir, lib), false));
            int lentgh = 0;
            while ((lentgh = is.read()) != -1){
                os.write(lentgh);
            }

            is.close();
            os.close();
            System.setProperty("org.hyperic.sigar.path", tempDir.getCanonicalPath());
        }

    }
}

 

3  api


import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.hyperic.sigar.*;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 服务器监控
 *
 * @author 111
 * @since 20200401
 */
@Slf4j
@RestController
@RequestMapping("/test")
public class Test{

    @Resource
    private RedisTemplate redisTemplate;

    @ApiOperation(value = "监控信息", notes = "监控信息")
    @GetMapping("/test")
    public MonitorVO info() throws Exception {
        MonitorVO monitorVO = new MonitorVO();
        Sigar sigar = new Sigar();
        monitorVO.setCpu(cpuPerc(sigar));
        monitorVO.setMemory(memory(sigar));
        monitorVO.setDisk(file(sigar));
        // 网络流量：查询最近
        List<NetVO> list = redisTemplate.opsForList().range(Constant.MONITOR_NET, Constant.ZERO_LONG, (Constant.MONITOR_NET_GET - 1));
        monitorVO.setNetList(list);
        try{
            sigar.close();
        }catch (Exception e){
            log.error("sigar close失败"+e.getMessage(), e);
        }
        return monitorVO;
    }

    /**
     *  内存
     */
    private MemoryVO memory(Sigar sigar) throws SigarException {
        MemoryVO memoryVO = new MemoryVO();
        // 使用sigar获取内存
        Mem mem = sigar.getMem();
        double memTotal = mem.getTotal();
        double memRam = mem.getRam();
        double memUsed = mem.getActualUsed();
        double memFree = mem.getActualFree();
        double memUsedPerc = mem.getUsedPercent();
        memoryVO.setMemory(String.format("%.2f", memTotal / 1024 / 1024 / 1024) + "GB");
        memoryVO.setMemRam(String.format("%.2f", memRam / 1024) + "GB");
        memoryVO.setMemUsed(String.format("%.2f", memUsed / 1024 / 1024 / 1024) + "GB");
        memoryVO.setMemFrees(String.format("%.2f", memFree / 1024 / 1024 / 1024) + "GB");
        memoryVO.setMemoryUsage(String.format("%.2f", memUsedPerc) + "%");
        return memoryVO;
    }

    /**
     *  cpu使用率
     */
    private static CpuVO cpuPerc(Sigar sigar) throws SigarException {
        CpuPerc cpu = sigar.getCpuPerc();
        CpuVO cpuVO = new CpuVO();
        cpuVO.setUser(CpuPerc.format(cpu.getUser()));
        cpuVO.setSys(CpuPerc.format(cpu.getSys()));
        cpuVO.setWait(CpuPerc.format(cpu.getWait()));
        cpuVO.setNice(CpuPerc.format(cpu.getNice()));
        cpuVO.setIdle(CpuPerc.format(cpu.getIdle()));
        cpuVO.setCombined(CpuPerc.format(cpu.getCombined()));
        return cpuVO;
    }

    private DiskVO file(Sigar sigar) throws Exception {
        DiskVO diskVO = new DiskVO();
        long total = 0L;
        long free = 0L;
        long avail = 0L;
        long used = 0L;
        FileSystem fslist[] = sigar.getFileSystemList();
        for (int i = 0; i < fslist.length; i++) {
            FileSystem fs = fslist[i];
            FileSystemUsage usage = null;
            try {
                usage = sigar.getFileSystemUsage(fs.getDirName());
            } catch (SigarException e) {
                log.info("{}-- 不可用",fs.getDirName());
                continue;
            }
            switch (fs.getType()) {
                case 0:
                    break;
                case 1:
                    break;
                case 2:
                    // 文件系统总大小
                    total += usage.getTotal();
                    // 文件系统剩余大小
                    free += usage.getFree();
                    // 文件系统可用大小
                    avail += usage.getAvail();
                    // 文件系统已经使用量
                    used += usage.getUsed();
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5:
                    break;
                case 6:
                    break;
                default:
                    break;
            }
        }
        diskVO.setTotal(String.format("%.2f", total / 1024 / 1024D) + "GB");
        diskVO.setFree(String.format("%.2f", free / 1024 / 1024D) + "GB");
        diskVO.setAvail(String.format("%.2f", avail / 1024 / 1024D) + "GB");
        diskVO.setUsed(String.format("%.2f", used / 1024 / 1024D) + "GB");
        diskVO.setUsePercent(String.format("%.2f", 100D * used / total) + "%");
        return diskVO;
    }


}

4 定时任务：定时将网络流量写入到redis

 
import cn.hutool.core.date.SystemClock;
import lombok.extern.slf4j.Slf4j;
import org.hyperic.sigar.NetInterfaceConfig;
import org.hyperic.sigar.NetInterfaceStat;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
 
import javax.annotation.Resource;
import java.util.Date;
import java.util.Objects;
 
/**
 *  网络net流量定时任务
 *
 */
@Slf4j
@Configuration
@EnableScheduling
public class NetScheduleTask {
 
    @Resource
    private RedisTemplate redisTemplate;
    @Value("${monitor.switch}")
    private Boolean monitorSwitch;
 
    @Scheduled(cron = "${monitor.cron}")
    private void task() {
        if(isLocal()){
            // 此处简短实现不执行。 实际上定时任务还在执行
            log.info("window环境，停止定时任务……");
            return;
        }
        if(monitorSwitch){
            long start = SystemClock.now();
            log.info("网络net流量定时任务start……");
            run();
            log.info("网络net流量定时任务end，耗时：{}ms……", (SystemClock.now()-start));
        }
    }
 
    /**
     *  执行
     */
    private void run(){
        Date now = new Date();
        // 获取当前时间下的网络状态
        NetVO net = null;
        try{
            net = net();
        }catch (Exception e){
            log.error("定时任务异常：{}", e.getMessage());
            return;
        }
        net.setCurrentTime(now);
        // 取出redis数据
        Long size = redisTemplate.opsForList().size("redis的key");
        if(Objects.isNull(size) || 0 == size){
            // 说明list为空
            net.setCurrentRxPackets(0L);
            net.setCurrentTxPackets(0L);
            net.setCurrentRxBytes(0L);
            net.setCurrentTxBytes(0L);
            redisTemplate.opsForList().leftPush("redis的key", net);
            return;
        }
        // 小于限制的长度时，取出最后一个：计算本次取数
        Object index = redisTemplate.opsForList().index("redis的key", 0L);
        NetVO netVO = (NetVO)index;
        net.setCurrentRxPackets(net.getRxPackets() - netVO.getRxPackets());
        net.setCurrentTxPackets(net.getTxPackets() - netVO.getTxPackets());
        net.setCurrentRxBytes(net.getRxBytes() - netVO.getRxBytes());
        net.setCurrentTxBytes(net.getTxBytes() - netVO.getTxBytes());
        redisTemplate.opsForList().leftPush("redis的key", net);
        // 长度限制
        if(3000 <= size){
            redisTemplate.opsForList().trim("redis的key", 0L, (3000 -1));
        }
    }
 
    /**
     * 主机网络信息
     */
    private NetVO net() throws SigarException {
        NetVO netVO = new NetVO();
        long rxPackets = 0L, txPackets = 0L, rxBytes = 0L, txBytes = 0L;
        Sigar sigar = new Sigar();
        String ifNames[] = sigar.getNetInterfaceList();
        for (int i = 0; i < ifNames.length; i++) {
            String name = ifNames[i];
            NetInterfaceConfig ifconfig = sigar.getNetInterfaceConfig(name);
            if ((ifconfig.getFlags() & 1L) <= 0L) {
                continue;
            }
            NetInterfaceStat ifstat = sigar.getNetInterfaceStat(name);
            // 接收的总包裹数
            rxPackets += ifstat.getRxPackets();
            // 发送的总包裹数
            txPackets += ifstat.getTxPackets();
            //接收到的总字节数
            rxBytes += ifstat.getRxBytes();
            //发送的总字节数
            txBytes += ifstat.getTxBytes();
        }
        netVO.setRxPackets(rxPackets);
        netVO.setTxPackets(txPackets);
        netVO.setRxBytes(rxBytes);
        netVO.setTxBytes(txBytes);
        return netVO;
    }
 
    /**
     *  是否window运行，true代表window
     */
    public static boolean isLocal(){
        return System.getProperties().getProperty("os.name").toUpperCase().contains("WINDOWS");
    }
}

 

5 VO


import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

/**
 * 监控vo
 *
 */
@Data
public class MonitorVO {

    @ApiModelProperty("cpu")
    private CpuVO cpu;
    @ApiModelProperty("内存")
    private MemoryVO memory;
    @ApiModelProperty("硬盘")
    private DiskVO disk;
    @ApiModelProperty("网络流量")
    private List<NetVO> netList;
}


import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * cpu vo
 *
 */
@Data
public class CpuVO {

    @ApiModelProperty("CPU用户使用率")
    private String user;
    @ApiModelProperty("CPU系统使用率")
    private String sys;
    @ApiModelProperty("CPU当前等待率")
    private String wait;
    @ApiModelProperty("CPU当前错误率")
    private String nice;
    @ApiModelProperty("CPU当前空闲率")
    private String idle;
    @ApiModelProperty("CPU总的使用率")
    private String combined;
}


import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 内存 vo
 *
 */
@Data
public class MemoryVO {

    @ApiModelProperty("内存总量")
    private String memory;
    @ApiModelProperty("内存使用量")
    private String memRam;
    @ApiModelProperty("使用中")
    private String memUsed;
    @ApiModelProperty("可用")
    private String memFrees;
    @ApiModelProperty("内存使用率")
    private String memoryUsage;

}


import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 内存 vo
 *
 */
@Data
public class DiskVO {

    @ApiModelProperty("总容量")
    private String total;
    @ApiModelProperty("剩余大小")
    private String free;
    @ApiModelProperty("可用大小")
    private String avail;
    @ApiModelProperty("已使用大小")
    private String used;
    @ApiModelProperty("资源利用率")
    private String usePercent;

}


import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;

/**
 * 流量 vo
 *
 */
@Data
public class NetVO {

    @ApiModelProperty("当前时间")
    private Date currentTime;
    @ApiModelProperty("当前接收包裹数")
    private Long currentRxPackets;
    @ApiModelProperty("当前发送包裹数")
    private Long currentTxPackets;
    @ApiModelProperty("当前接收字节数")
    private Long currentRxBytes;
    @ApiModelProperty("当前发送字节数")
    private Long currentTxBytes;

    @ApiModelProperty("接收总包裹数")
    private Long rxPackets;
    @ApiModelProperty("发送总包裹数")
    private Long txPackets;
    @ApiModelProperty("接收总字节数")
    private Long rxBytes;
    @ApiModelProperty("发送总字节数")
    private Long txBytes;

}

 

6 返回结果示例

{
  "code": 200,
  "data": {
    "cpu": {
      "user": "5.0%",
      "sys": "0.7%",
      "wait": "0.0%",
      "nice": "0.0%",
      "idle": "94.1%",
      "combined": "5.8%"
    },
    "memory": {
      "memory": "7.89GB",
      "memRam": "7.89GB",
      "memUsed": "4.80GB",
      "memFrees": "3.08GB",
      "memoryUsage": "60.89%"
    },
    "disk": {
      "total": "1050.75GB",
      "free": "936.43GB",
      "avail": "936.43GB",
      "used": "114.32GB",
      "usePercent": "10.88%"
    },
    "netList": [
      {
        "currentTime": "2020-04-01 13:27:00",
        "currentRxPackets": 359,
        "currentTxPackets": 503,
        "currentRxBytes": 85184,
        "currentTxBytes": 102932,
        "rxPackets": 51143,
        "txPackets": 73517,
        "rxBytes": 7123010,
        "txBytes": 12409005
      },
      {
        "currentTime": "2020-04-01 13:26:30",
        "currentRxPackets": 407,
        "currentTxPackets": 561,
        "currentRxBytes": 166228,
        "currentTxBytes": 147497,
        "rxPackets": 50784,
        "txPackets": 73014,
        "rxBytes": 7037826,
        "txBytes": 12306073
      }
    ]
  },
  "msg": "OK"
}

 

 

 

补充：
    VO中的NetVO，包裹和字节类型可优化改造为BigInteger

 

 

 

 

 

 

 

 

参考：https://www.jianshu.com/p/b05fd98c2a94

LLLLLiSHI
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
springboot监控服务器基本信息代码工具包
04-15
内容：Java代码，获取服务器的基本信息（内存，cpu，存储状态等） 适用场景：服务器均可适用，主要是监测服务器的使用状态。 使用方法： 1.添加工程依赖 <!-- 获取系统信息 --> <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>5.8.2</version> </dependency> 2. 把工具放进去 3. 写一个接口返回获取的信息 @GetMapping("cc") public Server cc() throws Exception { ServerInfo info = new ServerInfo(); info.copyInfo(); return new Result(info); }
如何监控Linux服务器的cpu使用率和内存使用率
tianshiyeben的专栏
03-08 819
WGCLOUD可以做到，安装比较简单了 WGCLOUD是一个高性能的分布式监控系统，server基于springboot架构开发，agent采用go开发，核心模块包括：主机监控，ES集群监控，CPU监控，CPU温度监控，大屏看板，docker监控，网络流量监控，内存监控，业务数据监控(mysql，oracle，pg等)，服务心跳检测，应用进程管理，磁盘IO监控，端口监控，日志文件监控，系统负载监控，监控告警信息推送。 下载：www.wgstart.com ...
【java】ssh封装类，linux指令下获取cpu频率+cpu核数+cpu用户应用使用率+cpu系统应用使用率+内存大小+内存使用率+硬盘总容量+硬盘总使用率+连接状态
weixin_48618536的博客
06-01 486
【java】ssh封装类，linux指令下获取cpu频率+cpu核数+cpu用户应用使用率+cpu系统应用使用率+内存大小+内存使用率+硬盘总容量+硬盘总使用率+连接状态
spring boot服务状态监控+shell远程连接服务
weixin_30877755的博客
03-06 344
1.在对应服务中引入对应spring boot起步依赖 2.在application.yml中加入对应配置 3.登录相关路径调用相关接口查看服务运行状态 http://localhost:30001/xxx 下表是相关监控接口 4.使用远程ssh工具监控服务状态 控制台中会打印出连接shell的密码，默认用户名：user 在远程连接工具...
SpringBoot结合Sigar获取服务器监控信息源代码
09-21
SpringBoot结合Sigar获取服务器监控信息提供restful接口的源代码, 并使用swagger生成接口文档, 包括 CPU信息,服务器基本信息,内存信息, JVM信息,磁盘信息等. 有详细的代码注释.
Java如何获取系统cpu、内存、硬盘信息
12-22
　前段时间摸索在Java中怎么获取系统信息包括cpu、内存、硬盘信息等，刚开始使用Java自带的包进行获取，但这样获取的内存信息不够准确并且容易出现找不到相应包等错误，所以后面使用sigar插件进行获取。下面列举出...
Sigar使用之：取得系统内存的数据
03-05
程序用到的jar 博文链接：https://wangrui.iteye.com/blog/153002
基于java通过第三方jar包sigar的支持，完成对服务器系统的参数监控，包括CPU、内存、硬盘以及网络流量的实时监控.zip
最新发布
03-24
基于java通过第三方jar包sigar的支持，完成对服务器系统的参数监控，包括CPU、内存、硬盘以及网络流量的实时监控
Java使用SSH连接Linux并获取cpu，内存，磁盘使用率
Joker_DJ
06-23 2943
获取依赖包hyperic 链接：https://pan.baidu.com/s/1EFTvC-lnjgRtdtLumiAHOQ 提取码：qnms 将hyperic-sigar-1.6.4.zip解压 将hyperic-sigar-1.6.4\sigar-bin\lib下的sigar.jar打包到maven仓库 将sigar-amd64-winnt.dll放到jdk的bin目录 打包命令 mvn install:install-file -Dfile=sigar.jar -DgroupId=org.hyp
Hyperic-Sigar
08-26
VMWare开发的一个收集系统各项底层信息的工具集
使用jsch-spring-boot在本地访问远程云服务
零下九度
06-24 3821
现在很多创业公司都不再自建机房，更多地选择云主机，如阿里云和腾讯云等。为了安全考虑，他们提供的关系数据库、nosql数据库等服务器都是不能直接访问的，只能通过云主机访问。因为在本地不能访问，这样在开发和测试过程中就比较麻烦。 在Java环境中，可以使用JSch解决这个问题。
SpringBoot项目实现网络测速功能
爱码猿的博客
05-17 2276
SpringBoot项目实现网络测速功能 网络测速功能实现思路： 上行速度：原理就是得到客户端的时间戳，然后向服务端发起POST请求（请求体尽量大）请求成功的时候执行回调函数，从服务端返回服务端接收到请求时候的时间戳和contentLength（单位字节Byte），再利用contentLength除以服务端时间和客户端时间差（注意需要将时间戳的单位ms转为s）就得到标准的每秒请求多少字节 根据国家宽带速率，需要乘以8，所以得到Bps。然后再根据单位换算得到响应的Kbps、Mbps。 1Byte=8Bits
SpringBoot自主监控，获取服务信息、JVM、CPU、内存、磁盘、堆、线程、GC等
C3Stones
03-09 6291
1. 简介 在日常开发中一些关键的业务服务，期望在高并发状态下可以正常工作，或在异常情况时可以记录当时的性能信息，所以就需要进行监控。常见的监控例如：Prometheus可以实现这个需求，如果需要更加简单方便的自主监控能力，可以引入本博客中的方案。 2. 相关博客 Promtail+Loki+Grafana搭建轻量级日志管理平台SpringBoot 2.x + Prometheus + ...
springboot使用oshi获取系统cpu、内存、jvm信息
qq_41358574的博客
01-16 4049
oshi的使用
springboot 通过SSH连接远程服务器
噗嗤
09-07 1870
处于对安全角度的考虑并且服务器不在同一个局域网下，服务器的访问地址不适合直接放到公网上，需要本地服务器通过ssh信道转发到远程服务器中。springboot单体项目连接服务器。
Springboot使用OSHI获取和操作操作系统和硬件信息
weixin_44727769的博客
05-25 3106
OSHI（Operating System and Hardware Information）是一个开源的Java库，用于获取和操作操作系统和硬件信息。它提供了一组简单易用的API，可以用于检索和监控诸如操作系统类型、处理器信息、内存使用情况、硬盘信息、网络接口等系统和硬件相关的数据。OSHI的主要功能包括：获取操作系统信息：可以获取操作系统的名称、版本、构建信息、位数等。还可以获取操作系统的启动时间、系统负载、当前进程数等信息。获取硬件信息：可以获取处理器（CPU）的信息，包括型号、频率、核心数、温度等。
SpringBoot指标监控
weixin_46278059的博客
11-21 1344
SpringBoot指标监控
java利用sigar获取电脑cpu 内存 硬盘使用率等信息java.lang.unsatisfiedlinkerror
成亚磊的博客
11-05 1194
1 下载安装sigar-1.6.4.zip 使用java自带的包获取系统数据，容易找不到包，尤其是内存信息不够准确，所以选择使用sigar获取系统信息。 下载地址：http://sourceforge.net/projects/sigar/files/latest/download?source=files 在自己的Java项目中引入sigar.ja...
sigar获取系统信息
03-24
Sigar 是一个跨平台的系统信息收集库，可以获取系统的 CPU、内存、磁盘、网络等信息。以下是获取系统信息的示例代码： ```java import org.hyperic.sigar.*; public class SigarDemo { public static void main(String[] args) throws SigarException { Sigar sigar = new Sigar(); System.out.println("CPU信息："); CpuInfo[] cpuInfos = sigar.getCpuInfoList(); for (CpuInfo cpuInfo : cpuInfos) { System.out.println("CPU型号：" + cpuInfo.getModel()); System.out.println("CPU频率：" + cpuInfo.getMhz() + "MHz"); System.out.println("CPU核数：" + cpuInfo.getTotalCores()); } System.out.println("内存信息："); Mem mem = sigar.getMem(); System.out.println("总内存：" + mem.getTotal() / 1024 / 1024 + "MB"); System.out.println("已用内存：" + mem.getUsed() / 1024 / 1024 + "MB"); System.out.println("剩余内存：" + mem.getFree() / 1024 / 1024 + "MB"); System.out.println("磁盘信息："); FileSystem[] fileSystems = sigar.getFileSystemList(); for (FileSystem fileSystem : fileSystems) { System.out.println("盘符：" + fileSystem.getDirName()); System.out.println("盘符类型：" + fileSystem.getTypeName()); FileSystemUsage usage = sigar.getFileSystemUsage(fileSystem.getDirName()); System.out.println("总大小：" + usage.getTotal() / 1024 / 1024 + "MB"); System.out.println("已用大小：" + usage.getUsed() / 1024 / 1024 + "MB"); System.out.println("剩余大小：" + usage.getFree() / 1024 / 1024 + "MB"); } System.out.println("网络信息："); NetInterfaceConfig[] netConfigs = sigar.getNetInterfaceConfigList(); for (NetInterfaceConfig netConfig : netConfigs) { System.out.println("网络设备名：" + netConfig.getName()); System.out.println("IP地址：" + netConfig.getAddress()); System.out.println("子网掩码：" + netConfig.getNetmask()); } } } ``` 注意：需要引入 sigar.jar 和 sigar-amd64-winnt.dll（或其它平台对应的库文件）。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值