一个实用的FTP客户端，包含下载目录

最新推荐文章于 2024-07-13 13:03:16 发布
最新推荐文章于 2024-07-13 13:03:16 发布
阅读量633 收藏 1
点赞数
分类专栏： java 文章标签： string exception ftp服务器 file 服务器 null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cppvsjava/article/details/6661047
版权
这是根据网上的一个程序改的，在哪里找的忘了，但是没有我需要的下载目录的功能，自己添加了个下载目录的功能。 

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;
import java.text.SimpleDateFormat;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPConnectionClosedException;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

public class MyFTPTest {
 public static Log logger = LogFactory.getLog(FtpTest.class);

 private static String userName; // FTP 登录用户名
 private static String password; // FTP 登录密码
 private static String ip; // FTP 服务器地址IP地址
 private static int port; // FTP 端口
 private static Properties property = null; // 属性集
 private static String configFile = "E:\\test\\comftp\\ftpconfig.properties"; // 配置文件的路径名
 private static FTPClient ftpClient = null; // FTP 客户端代理
 // 时间格式化
 private static SimpleDateFormat dateFormat = new SimpleDateFormat(
   "yyyy-MM-dd hh:mm");
 // FTP状态码
 public static int i = 1;

 public static void main(String[] args) {
  connectServer();
  setFileType(FTP.BINARY_FILE_TYPE);// 设置传输二进制文件
  // uploadManyFile(new File("C:\\ooo\\upx"), new File("C:\\ooo\\upx"),
  // "/admin/ttt");
  downloadDir("/tt/1025", rootdir,"tt\\1025");
  closeConnect();// 关闭连接
  
 }

 /**
  * 上传单个文件，并重命名
  *
  * @param localFile
  *            --本地文件路径
  * @param distFolder
  *            --新的文件名,可以命名为空""
  * @return true 上传成功，false 上传失败
  */
 public static boolean uploadFile(File localFile, final File localRootFile,
   final String distFolder) {
  System.out.println("                    -------------------------");
  boolean flag = true;
  try {
   connectServer();
   ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
   ftpClient.enterLocalPassiveMode();
   ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
   InputStream input = new FileInputStream(localFile);
   // if (input == null) {
   // System.out.println("本地文件"+localFile.getPath()+"不存在!");
   // }
   // if (newFileName.trim().equals("")) {
   // newFileName = localFile.getName();
   // }

   String furi1 = localFile.getParentFile().getAbsoluteFile().toURI()
     .toString();
   String furi2 = localRootFile.getParentFile().getAbsoluteFile()
     .toURI().toString();

   String objFolder = distFolder + File.separator
     + furi1.substring(furi2.length());

   ftpClient.changeWorkingDirectory("/");
   ftpClient.makeDirectory(objFolder);
   System.out.println("a>>>>>>> : " + distFolder + File.separator
     + localFile.getParent());
   System.out.println("x>>>>>>> : " + objFolder);
   ftpClient.changeWorkingDirectory(objFolder);

   System.out.println("b>>>>>>> : " + localFile.getPath() + " "
     + ftpClient.printWorkingDirectory());
   flag = ftpClient.storeFile(localFile.getName(), input);
   if (flag) {
    System.out.println("上传文件成功！");
   } else {
    System.out.println("上传文件失败！");
   }
   input.close();
  } catch (IOException e) {
   e.printStackTrace();
   logger.debug("本地文件上传失败！", e);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }

 /**
  * 上传多个文件
  *
  * @param localFile
  *            --本地文件夹路径
  * @return true 上传成功，false 上传失败
  */
 public static String uploadManyFile(String localFile) {
  boolean flag = true;
  StringBuffer strBuf = new StringBuffer();
  try {
   connectServer();
   File file = new File(localFile); // 在此目录中找文件
   File fileList[] = file.listFiles();
   for (File f : fileList) {
    if (f.isDirectory()) { // 文件夹中还有文件夹
     uploadManyFile(f.getAbsolutePath());
    } else {
    }
    if (!flag) {
     strBuf.append(f.getName() + "\r\n");
    }
   }
   System.out.println(strBuf.toString());
  } catch (NullPointerException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
   logger.debug("本地文件上传失败！", e);
  }
  return strBuf.toString();
 }

 /**
  * 上传多个文件
  *
  * @param localFile
  *            ,--本地文件夹路径
  * @param distFolder
  *            --目标路径
  * @return true 上传成功，false 上传失败
  */
 public static String uploadManyFile(File localFile,
   final File localRootFile, final String distFolder) {
  System.out.println("-------------------------");
  boolean flag = true;
  StringBuffer strBuf = new StringBuffer();
  int n = 0;
  try {
   connectServer();
   ftpClient.makeDirectory(distFolder + File.separator
     + localFile.getParent());
   File fileList[] = localFile.listFiles();
   for (File upfile : fileList) {
    if (upfile.isDirectory()) {// 文件夹中还有文件夹
     uploadManyFile(upfile, localRootFile, distFolder);
    } else {
     flag = uploadFile(upfile, localRootFile, distFolder);
    }
    if (!flag) {
     strBuf.append(upfile.getName() + "\r\n");
    }
   }
   System.out.println(strBuf.toString());
  } catch (NullPointerException e) {
   e.printStackTrace();
   logger.debug("本地文件上传失败！找不到上传文件！", e);
  } catch (Exception e) {
   e.printStackTrace();
   logger.debug("本地文件上传失败！", e);
  }
  return strBuf.toString();
 }

 /**
  * 下载文件
  *
  * @param remoteFileName
  *            --服务器上的文件名
  * @param localFileName
  *            --本地文件名
  * @return true 下载成功，false 下载失败
  */
 public static boolean loadFile(String remoteFileName, String localFileName) {
  boolean flag = true;
  connectServer();
  // 下载文件
  BufferedOutputStream buffOut = null;
  try {
   buffOut = new BufferedOutputStream(new FileOutputStream(
     localFileName));
   flag = ftpClient.retrieveFile(remoteFileName, buffOut);
  } catch (Exception e) {
   e.printStackTrace();
   logger.debug("本地文件下载失败！", e);
  } finally {
   try {
    if (buffOut != null)
     buffOut.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  return flag;
 }

 /**
  *下载一个目录
  */
 private static String rootdir = "f:\\soft";
//private static String remoteRootDir="/";
 public static boolean downloadDir(String remoteFileName, String localDirName,String currdir) {
  boolean flag = true;
  //connectServer();
  // 下载文件
  BufferedOutputStream buffOut = null;
  String nextdir="";
  
  //String currdir="";
  try {
   // buffOut = new BufferedOutputStream(new FileOutputStream(
   // localDirName));
   //if (!currdir.equals("") ||  currdir.lastIndexOf("\\")!=currdir.length()-1  )   currdir+="\\";
   if (!remoteFileName.equals("/")) {
    nextdir = localDirName+"\\"+currdir;
    File fileDis = new File(nextdir);
    
    if (!fileDis.exists())
     fileDis.mkdirs();
   }
   else
   {
    nextdir = localDirName;
   }
   //System.out.println(nextdir);
   ftpClient.changeWorkingDirectory( remoteFileName);
   
     String[] names = ftpClient.listNames();
   FTPFile[] files = ftpClient.listFiles();
   for (int i = 0; i < files.length; i++) {
     // System.out.println(files[i].getName());
    if (files[i].getType() == 1)// 1表示是一个目录。0表示文件
    {
     if (!files[i].getName().equals(".") && !files[i].getName().equals(".."))
      downloadDir(files[i].getName(), nextdir,files[i].getName()  );
     //ftpClient.changeWorkingDirectory("..");
     //
    } else {
      System.out.println("ftp目录>>>>"+remoteFileName);
       System.out.println("下载>>>>>>>"+nextdir+"\\"+files[i].getName());
     
      ftpClient.changeWorkingDirectory(remoteFileName);
     loadFile(files[i].getName(), nextdir + "\\" + files[i].getName());
    }
   }
   ftpClient.changeToParentDirectory();
   // flag = ftpClient.retrieveFile(remoteFileName, buffOut);
  }
  catch (FTPConnectionClosedException e)
        {
            System.err.println("Server closed connection.");
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
  catch (Exception e) {
   e.printStackTrace();
   logger.debug("本地文件下载失败！", e);
  } finally {
   try {
    if (buffOut != null)
     buffOut.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  return flag;
 }

 /**
  * 删除一个文件
  */
 public static boolean deleteFile(String filename) {
  boolean flag = true;
  try {
   connectServer();
   flag = ftpClient.deleteFile(filename);
   if (flag) {
    System.out.println("删除文件成功！");
   } else {
    System.out.println("删除文件失败！");
   }
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
  return flag;
 }

 /**
  * 删除目录
  */
 public static void deleteDirectory(String pathname) {
  try {
   connectServer();
   File file = new File(pathname);
   if (file.isDirectory()) {
    File file2[] = file.listFiles();
   } else {
    deleteFile(pathname);
   }
   ftpClient.removeDirectory(pathname);
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 /**
  * 删除空目录
  */
 public static void deleteEmptyDirectory(String pathname) {
  try {
   connectServer();
   ftpClient.removeDirectory(pathname);
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 /**
  * 列出服务器上文件和目录
  *
  * @param regStr
  *            --匹配的正则表达式
  */
 public static void listRemoteFiles(String regStr) {
  connectServer();
  try {
   String files[] = ftpClient.listNames(regStr);
   if (files == null || files.length == 0)
    System.out.println("没有任何文件!");
   else {
    for (int i = 0; i < files.length; i++) {
     System.out.println(files[i]);
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 /**
  * 列出Ftp服务器上的所有文件和目录
  */
 public static void listRemoteAllFiles() {
  connectServer();
  try {
   String[] names = ftpClient.listNames();
   for (int i = 0; i < names.length; i++) {
    System.out.println(names[i]);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 /**
  * 关闭连接
  */
 public static void closeConnect() {
  try {
   if (ftpClient != null) {
    ftpClient.logout();
    ftpClient.disconnect();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 /**
  * 设置配置文件
  *
  * @param configFile
  */
 public static void setConfigFile(String configFile) {
  MyFTPTest.configFile = configFile;
 }

 /**
  * 设置传输文件的类型[文本文件或者二进制文件]
  *
  * @param fileType
  *            --BINARY_FILE_TYPE、ASCII_FILE_TYPE
  *
  */
 public static void setFileType(int fileType) {
  try {
   connectServer();
   ftpClient.setFileType(fileType);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 /**
  * 扩展使用
  *
  * @return ftpClient
  */
 protected static FTPClient getFtpClient() {
  connectServer();
  return ftpClient;
 }

 /**
  * 设置参数
  *
  * @param configFile
  *            --参数的配置文件
  */
 private static void setArg(String configFile) {
  property = new Properties();
  BufferedInputStream inBuff = null;
  try {
   File file = new File(configFile);
   inBuff = new BufferedInputStream(new FileInputStream(file));
   property.load(inBuff);
   userName = property.getProperty("username");
   password = property.getProperty("password");
   ip = property.getProperty("ip");
   port = Integer.parseInt(property.getProperty("port"));
  } catch (FileNotFoundException e1) {
   System.out.println("配置文件 " + configFile + " 不存在！");
  } catch (IOException e) {
   System.out.println("配置文件 " + configFile + " 无法读取！");
  }
 }

 /**
  * 连接到服务器
  *
  * @return true 连接服务器成功，false 连接服务器失败
  */
 public static boolean connectServer() {
  boolean flag = true;
  if (ftpClient == null) {
   int reply;
   try {
    // setArg(configFile);
    userName = "abc";
    password = "123";
    ip = "27.0.0.1";
    port = 21;
    ftpClient = new FTPClient();
    ftpClient.setControlEncoding("GBK");
    ftpClient.setDefaultPort(port);
    //ftpClient.configure(getFtpConfig());
    ftpClient.connect(ip);
    ftpClient.login(userName, password);
    ftpClient.setDefaultPort(port);
    // System.out.print(ftpClient.getReplyString());
    reply = ftpClient.getReplyCode();
    ftpClient.setDataTimeout(120000);

    if (!FTPReply.isPositiveCompletion(reply)) {
     ftpClient.disconnect();
     System.err.println("FTP server refused connection.");
     // logger.debug("FTP 服务拒绝连接！");
     flag = false;
    }
    // System.out.println(i);
    i++;
   } catch (SocketException e) {
    flag = false;
    e.printStackTrace();
    System.err.println("登录ftp服务器 " + ip + " 失败,连接超时！");
   } catch (IOException e) {
    flag = false;
    e.printStackTrace();
    System.err.println("登录ftp服务器 " + ip + " 失败，FTP服务器无法打开！");
   }
  }
  return flag;
 }

 /**
  * 进入到服务器的某个目录下
  *
  * @param directory
  */
 public static void changeWorkingDirectory(String directory) {
  try {
   connectServer();
   ftpClient.changeWorkingDirectory(directory);
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 /**
  * 返回到上一层目录
  */
 public static void changeToParentDirectory() {
  try {
   connectServer();
   ftpClient.changeToParentDirectory();
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 /**
  * 重命名文件
  *
  * @param oldFileName
  *            --原文件名
  * @param newFileName
  *            --新文件名
  */
 public static void renameFile(String oldFileName, String newFileName) {
  try {
   connectServer();
   ftpClient.rename(oldFileName, newFileName);
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
 }

 /**
  * 设置FTP客服端的配置--一般可以不设置
  *
  * @return ftpConfig
  */
 private static FTPClientConfig getFtpConfig() {
  FTPClientConfig ftpConfig = new FTPClientConfig(
    FTPClientConfig.SYST_UNIX);
  ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);
  return ftpConfig;
 }

 /**
  * 转码[ISO-8859-1 -> GBK] 不同的平台需要不同的转码
  *
  * @param obj
  * @return ""
  */
 private static String iso8859togbk(Object obj) {
  try {
   if (obj == null)
    return "";
   else
    return new String(obj.toString().getBytes("iso-8859-1"), "GBK");
  } catch (Exception e) {
   return "";
  }
 }

 /**
  * 在服务器上创建一个文件夹
  *
  * @param dir
  *            文件夹名称，不能含有特殊字符，如 \ 、/ 、: 、* 、?、 "、 <、>...
  */
 public static boolean makeDirectory(String dir) {
  connectServer();
  boolean flag = true;
  try {
   // System.out.println("dir=======" dir);
   flag = ftpClient.makeDirectory(dir);
   if (flag) {
    System.out.println("make Directory " + dir + " succeed");

   } else {

    System.out.println("make Directory " + dir + " false");
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }
}

cppvsjava
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT5.0实现FTP客户端
06-22
FTP客户端用于连接到FTP服务器，执行上传、下载、列举目录、改变工作目录等操作。在QT5.0中实现FTP客户端，主要涉及以下知识点： 1. **QNetworkAccessManager**：这是QT5的核心类，用于处理所有类型的网络请求。...
基于Qt的FTP客户端下载工具
12-18
【基于Qt的FTP客户端下载工具】是一个利用C++编程语言和Qt框架开发的应用程序，它提供了用户友好的界面，能够方便地进行FTP（文件传输协议）文件的下载操作。Qt是一个跨平台的C++图形用户界面库，允许开发者在多种...
自己写的FTPClient的使用
akingde
07-31 1113
首先来个FtpInfo类 package org.javawo.components.ftp; /*** FTP连接参数VO类* * @author 杨涛**/public class FtpInfo {/** 登录用户名*/private String name;/** 登录密码*/private String password;/** 登录IP地址*/private String ip...
C++ WinAPI FTP客户端
若歌的博客
05-01 840
Win32 API函数： 参考链接：https://blog.csdn.net/cddchina/article/details/38727545 InternetOpen 初始化 Win32 internet InternetConnect 打开一个FTP, HTTP, or Gopher 应用会话 FtpCreateDirectory 在服务器上建立一个新的目录 FtpRemo...
使用c++实现一个FTP客户端(一)
weixin_30394633的博客
02-24 2708
　　之前使用c++实现了一个FTP客户端，在这里做一些记录。 　　一、需要注意的几点 　　　　①FTP是一种文件传输协议，基于TCP，所以客户端与服务器建立的连接是可靠、安全的，并且要经过三次握手的过程。 　　　　②FTP传输数据默认采用二进制模式，即将文件内容转换为二进制表示后再传送，而若HTML等文本文件传输时需要转换成ASCII模式。 　　　　③FTP客户端在连接服务器时需要用到两个...
myftp开发文档
qq_43560037的博客
09-07 908
myftp开发文档准备工具 本文针对myftp项目的各个功能做出详细概述。 准备工具 Xshell6，云服务器（虚拟机），leapftp（客户端交互开发），editplus（方便代码编辑与查看）
Socket编程 ftp 客户端Client.cpp
海月的博客
07-14 528
Client.cpp #include <Winsock2.h> #include <stdio.h> #include <string.h> /* 客户端程序： 1、加载套接字库 2、创建套接字（socket）。 3、向服务器发出连接请求（connect）。 4、和服务器端进行通信（send/recv）。 5、关闭套接字。 */ #pragma comment(lib, "WS2_32.lib ") //WS2_32.lib这个库里面包含了send(),r
ftp.rar_FTP 服务端_ftp客户端_ftp目录
09-21
它可能是一个示例文件，用于演示如何使用FTP客户端从服务器下载或上传文件。 通过分析和学习这个“ftp.rar”中的源代码，我们可以深入理解FTP协议的工作机制，了解如何在C语言环境中实现FTP客户端和服务端，这将对...
一个FTP客户端程序.zip_FTP客户端程序_ftp_ftp客户端 vb
09-19
这个FTP客户端程序展示了VB如何用于构建实用的应用程序，以及如何通过面向对象的编程方法来组织和管理复杂的FTP交互。对于学习VB和FTP技术的人来说，这是一个很好的实例，可以从中学习到如何实现文件传输、网络通信...
FTP客户端代码_ftp客户端_
09-30
这个FTP客户端代码很可能包含了实现上述功能的类、方法和逻辑。开发者可以通过这个代码库了解FTP客户端的实现细节，学习如何与FTP服务器进行交互，以及如何优化文件传输性能。如果代码质量高且文档完善，它将是一个...
如何搭建FTP服务器实现文件的上传及下载？（亲测有效）
热门推荐
lajos的博客
06-21 16万+
        FTP服务器（File Transfer Protocol Server）是在互联网上提供文件存储和访问服务的计算机，它们依照FTP协议提供服务。 FTP是File Transfer Protocol(文件传输协议)。顾名思义，就是专门用来传输文件的协议。简单地说，支持FTP协议的服务器就是FTP服务器。        一、在windows下创建一个用户账户（用于FTP登录操作） ...
POCO C++库学习和分析 -- URI
weixin_30820077的博客
05-07 253
POCO C++库学习和分析 -- URI (Uniform Resource Identifiers) 1. 概述 URI(RFC 3986)意为统一资源标记，通常被用来标志web上的资源。 在Poco库中提供了POCO::URI、POCO::URIStreamFactory、POCO::URIStreamOpener类来对U...
【Linux】进程间通信——匿名管道
2201_76024104的博客
07-08 1146
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
服务器的分类有哪些
2301_78491269的博客
07-08 438
IA架构的服务器采用了开放体系结构，因而有了大量的硬件和软件的支持者，在近年有了长足的发展。所有上述描述是很不精确的，存在很多特殊情况的，比如一个网络的客户机可能很多，但对服务器的访问可能很少，就没有必要要一台功能超强的企业级服务器，由于这些因素的存在，使得这种服务器的分类方法更倾向于定性，而不是定量，也就是说从小组级到部门级到企业级，服务器的性能是在逐渐加强的，其他各种特性也是在逐渐加强的。如文件/打印服务器，这是最早的服务器种类，它可以执行文件存储和打印机资源共享的服务，至今，这种服务器还在办。
Nginx 是一个非常流行的 Web 服务器和反向代理服务器
MAMA6681的博客
07-08 549
Nginx 是一个非常流行的 Web 服务器和反向代理服务器，以其高性能、稳定性、丰富的功能集和低资源消耗而闻名。下面是一个简化的 Nginx 使用教程，包括基本的安装、配置和一些常见用途。
暴雨让服务器不怕热҈热҈热҈热҈
最新发布
BAOYUCompany的博客
07-13 234
据统计目前市场上冷板式液冷占总体液冷份额的90%以上，原因在于它的成本低，并且技术以及配套的产业链更为成熟，同时，冷板式与风冷在运维上差异较小，使用习惯一致，市场接受程度更高。从更长远的角度考虑，浸没式液冷的散热效率远优于冷板式液冷，随着服务器功率的攀升，未来液冷的终极一定是浸没式液冷。从目前市场价格来看，液冷的应用成本明显高于传统风冷，但从技术迭代材料设备改进等长远角度来看，随着单千瓦散热成本快速下降，成本拐点或将不久将来出现，液冷TCO优势逐渐显著，随之迎来的将会是液冷市场大规模应用大爆发。
(自用)共享单车服务器(二) 项目日志
weixin_44155149的博客
07-09 961
在通常情况下，Linux/UNIX每个程序在开始运行的时刻，都会打开3个已经打开的stream. 分别用来输入，输出，打印诊断和错误信息。例如，%d{%H:%M:%S,%l} 或 %d{%d %m %Y %H:%M:%S,%l}。上文，我们说过日志输出到终端或者文件中实际上是很慢的，会引起IO中断，所以我们可以输出到内存里StringQueueAppender，然后从StringQueueAppender输出到其它地方，这样我们的线程执行是比较高效的。日志级别的意思是低于该级别的日志不会被记录。
Android实现一个ftp客户端
09-08
好的，这是你可以使用的步骤来实现一个Android FTP客户端： 1. 使用Android Studio创建一个新的Android项目。 2. 在build.gradle文件中添加对Apache Commons Net库的依赖，它是实现FTP客户端所必需的库。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值