将前端上传的文件同步到sftp服务器

于 2024-08-22 09:00:29 发布
阅读量361 收藏 1
点赞数 2
文章标签： 前端 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/be_insighted/article/details/141412794
版权

将前端上传的文件同步到sftp服务器

配置

        <!--连接ssh-->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.55</version> <!-- 检查最新版本 -->
        </dependency>
    @PostMapping("/voice/file/upload")
    @ApiOperation("文件--上传录音文件")
    public Result uploadFile(UploadVoiceFileReq req, @RequestParam("uploadFile") MultipartFile uploadFile) {
        if (CommonUtil.isEmpty(req.getContent())) {
            return Result.fail("语音内容不能为空");
        }
        if (CommonUtil.isEmpty(req.getLanguage())) {
            return Result.fail("语音语言类别不能为空");
        }
        if (CommonUtil.isEmpty(req.getFileName())) {
            return Result.fail("文件名称不能为空");
        }
        String filename = uploadFile.getOriginalFilename();
        if (CommonUtil.isEmpty(uploadFile)) {
            return Result.fail("上传文件不能为空！");
        }
        long fileSize = uploadFile.getSize();
        if (0 == fileSize) {
            return Result.fail("上传文件内容不能为空！");
        }
        String originalFilename = uploadFile.getOriginalFilename();
        String suffix = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        if (ObjectUtil.isEmpty(suffix)) {
            return Result.fail("上传文件格式缺失！");
        }
        if (!suffix.equals("wav")) {
            return Result.fail("不支持的文件格式！");
        }

        VoiceFile voiceFile = new VoiceFile();
        // 存储绝对路径
        voiceFile.setFilePath(ctiConfig.getFlowFilePath() + filename);
        voiceFile.setFileName(filename);
        voiceFile.setContent(req.getContent());
        if (null == UserContext.getUser()) {
            voiceFile.setAuthor("local_test");
        } else {
            String username = UserContext.getUser().getUsername();
            voiceFile.setAuthor(username);
        }
        voiceFile.setLanguage(req.getLanguage());
        voiceFile.setStatus(0);
        voiceFile.setDuration(30);
        ChannelSftp channel = null;
        try {
            InputStream inputStream = uploadFile.getInputStream();
            channel = (ChannelSftp) SftpUtil.initialChannel(null, sftpCtiConfiguration.getAccountSftp(), sftpCtiConfiguration.getEntranceTicketSftp(), sftpCtiConfiguration.getServerIp(), sftpCtiConfiguration.getPortSftp(), "180000");
            if (channel == null) {
                log.error(this.getClass().getSimpleName() + "#callVoiceFileList, step0:初始化连接sftp服务器失败！");
                return Result.fail("连接服务器(CTI)失败，请排查配置信息！");
            }
            channel.put(inputStream, ctiConfig.getFlowFilePath() + filename);

        } catch (Exception e) {
            log.error(getClassName() + "#uploadFile,上传失败！");
            e.printStackTrace();
            return Result.fail("uploadFile，文件上传发生异常！");
        } finally {
            SftpUtil.closeChannel(channel);
        }
        // 上传到sftp服务器
        voiceFileService.save(voiceFile);
        return Result.ok();
    }

sftp工具类


import com.jcraft.jsch.*;
import com.zhuao.constant.BusinessCode;
import com.zhuao.dto.SftpFile;
import com.zhuao.exception.FileBizException;
import lombok.extern.slf4j.Slf4j;
import java.io.*;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

@Slf4j
public class SftpUtil {


    public static Channel initialChannel(String sshKnownHost, String sftpUsername, String sftpPassword, String sftpHost, String sftpPort, String sftpTimeOut) {
        Channel channel = null;
        try {
            JSch jsch = new JSch();
            if (sshKnownHost != null) {
                jsch.setKnownHosts(sshKnownHost);
            }
            Session session = jsch.getSession(sftpUsername, sftpHost, Integer.valueOf(sftpPort));

            if (sshKnownHost == null) {
                java.util.Properties config = new java.util.Properties();
                config.put("StrictHostKeyChecking", "no");
                session.setConfig(config);
            }

            if (sftpPassword != null) {
                session.setPassword(sftpPassword);
            }
            Integer timeout = 30000;
            if (sftpTimeOut != null) {
                timeout = Integer.valueOf(sftpTimeOut);
                session.setTimeout(timeout);
            }
            session.connect(timeout);
            channel = session.openChannel("sftp");
            channel.connect(timeout);
        } catch (Exception e) {
            log.error("", e);
        }
        return channel;
    }

    public static void closeChannel(Channel channel) {
        try {
            Session session = null;
            if (channel != null && channel.isConnected()) {
                session = channel.getSession();
                channel.disconnect();
            }
            if (session != null && session.isConnected()) {
                session.disconnect();
            }
        } catch (JSchException e) {
            log.error("", e);
        }
    }

    /**
     * Download single file from remote to local
     */
    public static File download(ChannelSftp channelSftp, String local, String remote) throws SftpException, IOException {
        File localFile = new File(local);
        FileOutputStream fio = null;
        try {
            if (!channelSftp.isConnected() || channelSftp.stat(remote) == null) {
                return localFile;
            }
        } catch (Exception e) {
            // TODO: handle exception
            log.error("", e);
            throw e;
        }

        if (localFile.exists() && localFile.isDirectory()) {
            Path filePath = Paths.get(remote);
            String fileName = filePath.getFileName().toString();
            localFile = new File(localFile, fileName);

        } else if (!localFile.exists()) {
            try {
                localFile.createNewFile();
            } catch (Exception e) {
                log.error("", e);
                throw e;
            }
        }
        try {
            fio = new FileOutputStream(localFile);
            channelSftp.get(remote, fio);

        } catch (Exception e) {
            log.error("", e);
            throw e;
        } finally {
            if (fio != null) {
                try {
                    fio.flush();
                    fio.close();
                } catch (Exception e) {
                    log.error("", e);
                }
            }
        }
        return localFile;
    }

    /**
     * Download single file from remote to local by OutputStream
     */
    public static void download(ChannelSftp channelSftp, OutputStream fio, String remote) throws SftpException {
        try {
            if (!channelSftp.isConnected() || channelSftp.stat(remote) == null) {
                return;
            }
        } catch (Exception e) {
            log.error("", e);
            throw new SftpException(BusinessCode.BusinessStatus.FILE_NOT_EXIST.getCode(), "文件不存在！");
        }

        try {
            channelSftp.get(remote, fio);
        } catch (Exception e) {
            log.error("", e);
            throw new SftpException(BusinessCode.BusinessStatus.FILE_NOT_EXIST.getCode(), "文件不存在");
        } finally {
            if (fio != null) {
                try {
                    fio.flush();
                    fio.close();
                } catch (Exception e) {
                    log.error("", e);
                    throw new SftpException(BusinessCode.BusinessStatus.FILE_DOWNLOAD_FAILED.getCode(), BusinessCode.BusinessStatus.FILE_DOWNLOAD_FAILED.getValue());
                }
            }
        }
    }


    /**
     * Download file folder from remote to local
     */
    public static File downloadAll(ChannelSftp channelSftp, String localDir, String remoteDir) {
        File localFile = new File(localDir);
        FileOutputStream fio = null;
        try {
            if (!channelSftp.isConnected() || channelSftp.stat(remoteDir) == null) {
                return localFile;
            }
        } catch (Exception e) {
            // TODO: handle exception
            log.error("", e);
        }

        try {
            Vector<ChannelSftp.LsEntry> entries = channelSftp.ls(remoteDir);
            log.info("entries->" + entries);

            //download all from root folder
            for (ChannelSftp.LsEntry en : entries) {
                if (en.getFilename().equals(".") || en.getFilename().equals("..") || en.getAttrs().isDir()) {
                    continue;
                }

                System.out.println(en.getFilename());
                File localDownloadedFile = new File(localDir + en.getFilename());
                if (!localDownloadedFile.exists()) {
                    localDownloadedFile.createNewFile();

                    try {
                        fio = new FileOutputStream(localDownloadedFile);
                        channelSftp.get(remoteDir + en.getFilename(), fio);
//		    		    logger.debug(String.format("Complete get remote file to '%s'", localFile.getName().toString()));

                    } catch (Exception e) {
                        log.error("", e);
                    } finally {
                        if (fio != null) {
                            try {
                                fio.flush();
                                fio.close();
                            } catch (Exception e) {
                                log.error("", e);
                            }
                        }
                    }

                }

            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fio != null) {
                try {
                    fio.flush();
                    fio.close();
                } catch (Exception e) {
                    log.error("", e);
                }
            }
        }
        return localFile;
    }

    /**
     * 指定路径下的所有文件上传到服务器
     *
     * @param channelSftp
     * @param local
     * @param remote
     * @throws FileNotFoundException
     * @throws SftpException
     */
    public static void uploads(ChannelSftp channelSftp, String local, String remote)
            throws FileNotFoundException, SftpException {
        File localFile = new File(local);
        SftpATTRS attrs = null;
        if (!localFile.exists()) {
            throw new FileNotFoundException();
        }
        if (!localFile.isDirectory()) {
            upload(channelSftp, local, remote);
            return;
        }
        queryAndCreateFolders(channelSftp, remote);
        try {
            attrs = channelSftp.stat(remote);
        } catch (SftpException e) {
            channelSftp.mkdir(remote);
            attrs = channelSftp.stat(remote);
//            e.printStackTrace();
        }
        if (attrs != null && !attrs.isDir()) {
            // Cannot copy directory contains multiple files to a single file, but move to same directory.
            remote = Paths.get(remote).getParent().toString();
        }
        for (File file : localFile.listFiles()) {
            if (file.isDirectory()) {
                uploads(channelSftp, file.getPath(),
                        String.format("%s/%s", remote, file.getName()));
                continue;
            }
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(localFile);
                channelSftp.put(fis, String.format("%s/%s", remote, file.getName()));
//				logger.debug(String.format("Complete put '%s' to remote", file.getName().toString()));
            } catch (FileNotFoundException | SftpException e) {
                log.error("", e);
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        log.error("fis close error...", e);
                    }
                }
            }
        }
        return;
    }


    /**
     * @param channelSftp
     * @param local
     * @param remote
     * @throws FileNotFoundException
     * @throws SftpException
     * @Description 指定文件(单个)上传到服务器
     */
    public static void upload(ChannelSftp channelSftp, String local, String remote) throws FileNotFoundException, SftpException {
        File localFile = new File(local);
        SftpATTRS attrs = null;
        if (!localFile.exists()) {
            throw new FileNotFoundException();
        }
        if (localFile.isDirectory()) {
            uploads(channelSftp, local, remote);
            return;
        }
        queryAndCreateFolders(channelSftp, remote);
        try {
            attrs = channelSftp.stat(remote);
        } catch (SftpException e) {
//            channelSftp.mkdir(remote);
//            e.printStackTrace();
            log.error("", e);
        }
        if (attrs != null && attrs.isDir()) {
            // Cannot replace existing directory by file, copy to that directory
            Path filePath = Paths.get(local);
            String fileName = filePath.getFileName().toString();
            remote = String.format("%s/%s", remote, fileName);
        }
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(localFile);
            channelSftp.put(fis, remote);
//		    logger.debug(String.format("Complete put '%s' to remote", localFile.getName().toString()));
        } catch (FileNotFoundException | SftpException e) {
            log.error("", e);
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    log.error("fis close error...", e);
                }
            }
        }
        return;
    }

    /**
     * Upload single file to remote path
     */
    public static void upload(ChannelSftp channelSftp, File localFile, String remote)
            throws FileNotFoundException, SftpException {
        log.info("execute upload start-->");
        SftpATTRS attrs = null;
        if (!localFile.exists()) {
            throw new FileNotFoundException();
        }
        queryAndCreateFolders(channelSftp, remote);
        try {
            attrs = channelSftp.stat(remote);
        } catch (SftpException e) {

            log.error("channelSftp.stat() error...", e);
        }
        if (attrs != null && attrs.isDir()) {
            // Cannot replace existing directory by file, copy to that directory
            String fileName = localFile.getName();
            remote = String.format("%s/%s", remote, fileName);
        }
        log.info("remote-->" + remote);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(localFile);
            channelSftp.put(fis, remote);
//		    logger.debug(String.format("Complete put '%s' to remote", localFile.getName().toString()));
        } catch (FileNotFoundException | SftpException e) {
            log.error("", e);
            throw new FileBizException(BusinessCode.BusinessStatus.FILE_NOT_EXIST.getCode(), "上傳文件失敗");
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    log.error("fis close error...", e);
                }
            }
        }
        log.info("execute upload end");
        return;
    }

    /**
     * linux環境，判斷是否存在路徑，不存在則創建
     *
     * @param channelSftp
     * @param filePath
     * @throws SftpException
     */
    private static void queryAndCreateFolders(ChannelSftp channelSftp, String filePath) throws SftpException {
        String[] paths = filePath.split("/");
        StringBuilder sb = new StringBuilder();
        for (String p : paths) {
            if (CommonUtil.isEmpty(p)) {
                continue;
            }
            sb.append("/" + p);
            String nextPath = sb.toString();
            try {
                channelSftp.ls(nextPath);
            } catch (Exception e) {
                channelSftp.mkdir(nextPath);
            }
        }
    }

    public static boolean isExistFile(ChannelSftp sftp, String path) throws SftpException {
        boolean isExist = false;
        try {
            SftpATTRS sftpATTRS = sftp.stat(path);
            isExist = true;
        } catch (Exception e) {
            String errMsg = e.getMessage();
            if (!CommonUtil.isEmpty(errMsg) && errMsg.toLowerCase().equals("no such file")) {
                isExist = false;
            } else {
                throw e;
            }
        }
        return isExist;

    }

    public static void main(String[] args) {
        ChannelSftp channelSftp = (ChannelSftp) initialChannel(null, "root", "ZHyjzx@2023!#", "10.152.245.14", "22", "180000");
        if (channelSftp == null) {
            return;
        }
        try {
            //upload(channelSftp, "C:\\Users\\nigel.szeto\\Desktop\\testFolder", "/mnt/c/Users/nigel.szeto/Desktop/testDes");
            //listAllFiles(channelSftp, "/usr/local/isoftcall/data/user/0/flow/");

            System.err.println("*******************************************************************");
            listAllFileNames(channelSftp, "/usr/local/isoftcall/data/user/0/flow/");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            log.error("", e);
        }
        closeChannel(channelSftp);
    }

    public static List<SftpFile> listAllFiles(ChannelSftp sftp, String remoteDir) {
        List<SftpFile> sftpFileList = new ArrayList<>();
        try {
            sftp.ls(remoteDir).forEach(vector -> {
                SftpFile sftpFile = new SftpFile();
                ChannelSftp.LsEntry lsEntry = (ChannelSftp.LsEntry) vector;
                sftpFile.setFilename(lsEntry.getFilename());
                sftpFile.setLongname(lsEntry.getLongname());
                sftpFile.setSize(lsEntry.getAttrs().getSize());
                sftpFile.setAtime(lsEntry.getAttrs().getATime());
                sftpFile.setMtime(lsEntry.getAttrs().getMTime());
                sftpFile.setFlags(lsEntry.getAttrs().getFlags());
                sftpFile.setGid(lsEntry.getAttrs().getGId());

                sftpFileList.add(sftpFile);
            });
        } catch (SftpException e) {
            log.error("", e);
        }
        try {
            sftp.getSession().disconnect();
        } catch (JSchException e) {
            log.error("", e);
        }
        sftpFileList.stream().forEach(System.out::println);
        return sftpFileList;
    }


    public static List<String> listAllFileNames(ChannelSftp sftp, String remoteDir) {
        List<String> fileNameList = new ArrayList<>();
        try {
            sftp.ls(remoteDir).forEach(vector -> {
                ChannelSftp.LsEntry lsEntry = (ChannelSftp.LsEntry) vector;
                if (!lsEntry.getAttrs().isDir() && lsEntry.getFilename().endsWith(".wav")) {
                    fileNameList.add(lsEntry.getFilename());
                }
            });
        } catch (SftpException e) {
            log.error("", e);
        }
        closeChannel(sftp);
        fileNameList.stream().forEach(System.out::println);
        return fileNameList;
    }
}

Be_insighted
关注
PHP实现上传文件到FTP服务器(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-18 120
PHP实现上传文件到FTP服务器(附完整源码)
ftp服务器文件不同步,FTP文件传输，传输的文件和原文件大小不一致的原因
weixin_39768917的博客
08-06 1834
问题： 项目中有个功能模块是需要用到FTP协议传输文件，但发现传输成功的文件比原文件大的情况。 首先我先修改了传输的代码，部分源代码如下：byte[] buffer = new byte[1024];while (inputStream.read(buffer) != -1) {out.write(buffer);......修改后的代码，部分源代码如下：byte[] buffer = new b...
使用前端插件上传文件到ftp服务器
08-24
使用前端插件上传文件到ftp服务器，上传配置灵活，通过配置文件即可配置文件类型大小，还有ftp服务器连接信息
js实现上传文件到ftp服务器上
最新发布
m0_47827825的博客
01-17 1581
上面就是用react做的页面，用js做的服务，然后来上传本地文件到ftp服务器，还有两个ftp服务器之间进行数据传送。上面就是把文件从本地上传到ftp服务器上。到这里两个ftp服务器文件传输结束了。希望能对你有所帮助。
前端node.js 自动打包上传到sftp 并通知钉钉机器人
木贝西的博客
03-23 1539
sftp上传 const path = require('path') const axios = require('axios'); const package=require('./package.json') const shell = require("shelljs"); if (shell.exec("yarn build").code !== 0) { // 执行npm run build 命令 shell.echo("Error: get coding failed"
HTML页面传图片到sftp
我思故我在
11-26 2953
为了实现上传图片这个功能还是费了老大的劲的，上代码之前首先了解下现在的服务器架构，一共有两个服务器，一个是nginx+sftp专门做图片服务的，另一个是程序服务器，放我们的程序的，我们要做的就是从个人电脑传图片到程序服务器，然后程序服务器再上传到图片服务器。 我们的实现顺序从后向前，现在开始实现程序服务器上传到sftp 我的程序架构简单的来说是这样的 首先按照这篇文章，实现从
Springboot通过SFTP上传文件到服务器
Bin Deng得博客
04-29 2629
流程是这样的: 前端选择文件上传-------->调用后台接口,后台连接服务器(Linux)--------->上传成功 前端无论是通过ajax，还是form表单直接提交都可以，这里暂时以form方式提交 这里需要依靠一个Sftps的工具类 先导入依赖 <dependency> <groupId>com.jcraft</groupId&...
js怎么实现ftp上传文件到服务器,js ftp上传文件到服务器
weixin_35112750的博客
08-06 1951
js ftp上传文件到服务器 内容精选换一换CDM支持周期性自动将新增文件上传到OBS，不需要写代码，也不需要用户频繁手动上传即可使用OBS的海量存储能力进行文件备份。这里以CDM周期性备份FTP的文件到OBS为例进行介绍。例如：FTP服务器的to_obs_test目录下有一个子目录another_dir和两个文件file1和file2，其中file2在another_dir目录下监控数据上报功能...
前端开源库-gulp-sftp
08-29
在前端开发中，SSH常用来上传和同步本地代码到远程服务器，确保开发环境和生产环境的一致性。`gulp-sftp`通过提供简单的配置选项，使得这个过程变得简单易行。 使用`gulp-sftp`，你需要先安装Gulp和`gulp-sftp`，...
前端开源库-ssh2-sftp-client
08-29
3. **服务器管理工具**：对于需要定期备份或同步服务器文件的前端应用，`ssh2-sftp-client`提供了一个实用的解决方案。 **扩展学习：** 要深入理解和使用`ssh2-sftp-client`，需要了解基础的SSH和SFTP协议，以及...
SFTPServer:得益于ssh2模块，用node.js编写的SFTP服务器
05-08
SFTP服务器 设计为使用模块的简单方法。 会承认，这样做只是作为概念证明，只是为了好玩……因为我可以。 此SFTP服务器将允许somoene使用保存在数据库中的ssh公钥通过文件系统或数据库下载文件。 对文件和密钥使用适配器可以将它们存储在任何需要适配器的地方。 如果要将文件存储在AWS S3存储桶中，请创建一个适配器以检索文件。 是否要使用MongoDB代替SQL Server？ 创建一个新的数据库适配器。 lib目录中的所有文件均使用ES2015进行编码。 由于我仅安装了Node.js 0.12.7，因此我使用babel转换为ES5。 如果您拥有Node.js 4+或io.js，则可能不需要babel。 安装 假设您已经安装了node.js（我已经安装了0.12.7），请运行npm install来安装依赖项。 为了实现数据库连接，请在根目录中创建一个db_config.jso
dploy, 在 node.js 中，构建了一个 ftp/sftp部署工具.zip
09-18
dploy, 在 node.js 中，构建了一个 ftp/sftp部署工具 DPLOYDPLOY是内置在 node.js 中的ftp/sftp部署工具通过将服务器上的版本与git存储库进行比较来上传最新的更改。安装安装DPLOY并通过运行它来全局运行：npm install dploy -g
sftp上传文件的js脚本
qq_35275973的博客
07-08 1398
1、首先执行 npm install 安装ssh2-sftp-client 、path、recursive-readdir 。ssh2-sftp-client是请求时使用的client,path用来读取路径，recursive-readdir读取本地执行的文件夹 let Client = require('ssh2-sftp-client'); let path = require(...
ssh2-sftp-client实现前端项目自动部署
每天都要努力学习哦~~
10-18 1357
exec():要在命令行执行的完整命令:可选参数，JSON对象async: 异步执行.如果你提供了回调方法，这个值就一定为true，无论你怎么设置silent:打印信息不输出到命令控制台Node.js 的方法的其他参数都可以用:当进程终止时调用，并带上输出。返回值： 同步模式下，将返回一个ShellString（shelljs v0.6.xf返回一个形如{ code:..., stdout:... , stderr:... }的对象）；
上传文件到服务器端后进一步推送到sftp服务器
weixin_34354173的博客
08-02 368
扩展安装 要想sftp服务端发送文件，就需要php脚本具有作为ssh客户端的能力，所以需先为php安装如下扩展 openssl openssl-dev libssh phpssh 扩展 按照下面的命令进行安装 1 rpm -qa | grep openssl 2 wget http://www.libssh2.org/download/lib...
JSch - Java实现的SFTP（文件上传详解篇）
awj321000的专栏
03-14 4844
JSch是Java Secure Channel的缩写。JSch是一个SSH2的纯Java实现。它允许你连接到一个SSH服务器，并且可以使用端口转发，X11转发，文件传输等，当然你也可以集成它的功能到你自己的应用程序。   本文只介绍如何使用JSch实现的SFTP功能。   SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供
NodeJS sftp 上传文件
遗忘了的自己
09-22 2380
1. 使用 ssh2-sftp-client 上传文件到 sftp npm i ssh2-sftp-client -s 2. 核心代码： // SftpTool const Client = require('ssh2-sftp-client'); /** * sftp tool */ class SftpTool { /** * {host: ip, port: 22, username: name, password: pwd} * @param {Object} conf
Javascript —— Webstorm的ftp/sftp远程部署
starter_____的博客
12-27 3623
使用WebStorm可以远程部署项目到服务器, 支持ftp/sftp等多种协议，还可以设置自动同步,非常方便。 第一步：设置Deployment Preferences/Settings -> Build,Execution,Deployment->Deployment 选择添加 第二步：填入Name和Type（协议种类） 第三步：填写连接服务器的信息Conne
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值