java 远程ftp

最新推荐文章于 2022-04-21 09:29:39 发布
最新推荐文章于 2022-04-21 09:29:39 发布
阅读量137 收藏
点赞数
文章标签： Java Apache JSP .net 交通
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DPC27149/article/details/83909015
版权 
 
import java.io.BufferedInputStream;   
import java.io.File;   
import java.io.FileInputStream;   
import java.io.FileNotFoundException;   
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.net.ftp.FTP;   
import org.apache.commons.net.ftp.FTPClient;   
import org.apache.commons.net.ftp.FTPClientConfig;   
import org.apache.commons.net.ftp.FTPReply;   
  
  
/**  
 * 实现FTP 客户端的各种操作  
 *  
 * 其实JDK里面也有支持FTP操作的包【jre/lib下的rt.jar】，但是SUN的DOC里面并没有提供相应文档，  
 * 因为这里面的包，不被官方支持，建议不要使用。我们可以使用第三方提供的包apache.commons。 apache.commons的包，都有文档，方便使用  
 * 另外IBM也有提供一个ftp包，我没有用过，有兴趣的可以去研究一下  
 *  
 * @commons-net：http://apache.mirror.phpchina.com/commons/net/binaries/commons-net-1.4.1.zip  
 * @jakarta-oro：http://mirror.vmmatrix.net/apache/jakarta/oro/source/jakarta-oro-2.0.8.zip  
 * @commons-io：http://apache.mirror.phpchina.com/commons/io/binaries/commons-io-1.3.2-bin.zip  
 *  
 * @author   
 * @version 2008-06-10 Ftp.java  
 *  
 */  
public class Ftp {   
  
    private static Log logger;   
    /**  
     * FTP 登录用户名  
     */  
    private static String UserName;   
    /**  
     * FTP 登录密码  
     */  
    private static String Password;   
    /**  
     * FTP 服务器地址IP地址  
     */  
    private static String Ip;   
    /**  
     * FTP 端口  
     */  
    private static int Port;   
    /**  
     * 属性集  
     */  
    private static Properties Property = null;   
    /**  
     * 配置文件的路径名  
     */  
    private static String ConfigFile = "src/com/wwkj/cms/test/ftp/ftpconfig.properties";   
    /**  
     * FTP 客户端代理  
     */  
    private static FTPClient FtpClient = null;   
    /**  
     * 时间格式化  
     */  
    private static SimpleDateFormat dateFormat = new SimpleDateFormat(   
            "yyyy-MM-dd hh:mm");   
    /**  
     * FTP  
     */  
    private static final String[] FILE_TYPES = { "文件", "目录", "符号链接", "未知类型" };   
    /**  
     * 传输模式为二进制文件.  
     */  
    public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;   
    /**  
     * 传输模式为ASCII，默认为ASCII  
     */  
    public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;   
     public  static int  i=1;   
    public static void main(String[] args) {   
        // setConfigFile("ftpconfig.properties");// 设置配置文件路径   
        connectServer();   
        // makeDirectory("eeee");   
  
        // changeWorkingDirectory("webroot");//进入文件夹webroot   
        // listRemoteFiles("*.jsp");//列出webroot目录下所有jsp文件   
        setFileType(FTP.BINARY_FILE_TYPE);// 设置传输二进制文件   
  
        //uploadFile("G:/临时文件/万维公司员工交通通讯报销标准（2008修订版）.doc",   
        //        "中国人也/万维公司员工交通通讯报销标准（2008修订版）.doc");//   
        // 上传文件woxingwosu.xml，重新命名为myfile.xml   
        // renameFile("viewDetail.jsp",   
        // "newName.jsp");//将文件viewDetail.jsp改名为newName.jsp   
//        uploadManyFile("G:/临时文件/staxmem", "dirdirdir/");   
        // deleteFile("/testtest/");//删除一个文件UpdateData.class   
        // deleteEmptyDirectory("dfd");//   
        // loadFile("jakarta-oro-2.0.8.jar", "E:/tmp/00000000000000001.jpg");//   
  
        // 01.jpg，并且重新命名为G:/临时文件/00000000000000001.jpg   
        // uploadFile("G:/临时文件");   
  
        // listRemoteFiles("eeee");// 列出所有文件和目录   
        // listRemoteFiles("58-20166.jpg");// 列出指定的文件和目录   
        closeConnect();// 关闭连接   
    }   
  
    /**  
     * 上传单个文件，并重命名  
     *  
     * @param localFilePath--本地文件路径  
     * @param newFileName--新的文件名,可以命名为空""  
     * @return true 上传成功，false 上传失败  
     */  
    public static boolean uploadFile(String localFile, String newFileName) {   
        boolean flag = true;   
        try {   
  
            connectServer();   
            FtpClient.setFileType(BINARY_FILE_TYPE);   
            // ftp.setFileType(FTP.ASCII_FILE_TYPE);   
            FtpClient.enterLocalPassiveMode();   
            // ftp.changeWorkingDirectory(remoteDir);   
            FtpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);   
            File file = new File(localFile);   
  
            File newFile = new File(newFileName);   
            String dir = newFile.getParentFile().getPath();   
            if (!FtpClient.changeWorkingDirectory(dir)) {// 如果不能进入dir下，说明此目录不存在！   
  
                if (!makeDirectory(newFile.getParentFile().getPath())) {   
  
                    System.out.println("创建文件目录【"+dir+"】 失败！");   
                }   
            }   
            changeWorkingDirectory("/");// 回到FTP根目录   
            InputStream input = new FileInputStream(file);   
  
            if (input == null) {   
                System.out.println("本地文件不存在");   
                logger.debug("本地文件不存在,请重新选择！");   
  
            }   
            if (newFileName.trim().equals("")) {   
  
                newFileName = file.getName();   
  
            }   
            flag = FtpClient.storeFile(newFileName, input);   
            if (flag) {   
                System.out.println("upload File succeed");   
  
            } else {   
                System.out.println("upload File false");   
  
            }   
            input.close();   
  
        } catch (IOException e) {   
            e.printStackTrace();   
            logger.debug("本地文件上传失败！", e);   
            // TODO: handle exception   
        } catch (Exception e) {   
            e.printStackTrace();   
            // logger.debug("本地文件上传失败！", e);   
            // TODO: handle exception   
        }   
        return flag;   
    }   
  
//    /**   
//     * 上传多个文件   
//     *   
//     * @param localFilePath--本地文件夹路径   
//     * @return true 上传成功，false 上传失败   
//     */   
//    public static String uploadManyFile(String localFile) {   
//        boolean flag = true;   
//        StringBuffer strBuf = new StringBuffer();   
//        int n = 0;   
//        try {   
//            connectServer();   
//            File file = new File(localFile);// 在此目录中找文件   
//   
//            File file2[] = file.listFiles();   
//   
//            for (int i = 0; i < file2.length; i ) {   
//   
//                File file1 = new File(file2[i].getAbsolutePath());   
//                if (file1.isDirectory()) {// 文件夹中还有文件夹   
//                    uploadManyFile(file2[i].getAbsolutePath());   
//                } else {   
//                    flag = uploadFile(file2[i].getAbsolutePath(), "");   
//                }   
//                if (!flag) {   
//                    n ;   
//                    strBuf.append(file2[i].getName() "\r\n");   
//   
//                }   
//            }   
//            if (n > 0) {   
//   
//                strBuf.insert(0, "共有" n "上传失败，分别为\r\n");   
//            }   
//            System.out.println(strBuf.toString());   
//        } catch (NullPointerException e) {   
//            e.printStackTrace();   
//            // logger.debug("本地文件上传失败！找不到上传文件！", e);   
//            // TODO: handle exception   
//        } catch (Exception e) {   
//            e.printStackTrace();   
//            logger.debug("本地文件上传失败！", e);   
//            // TODO: handle exception   
//        }   
//        return strBuf.toString();   
//    }   
//   
//    /**   
//     * 上传多个文件   
//     *   
//     * @param localFilePath--本地文件夹路径   
//     * @param newFileName--目标路径   
//     * @return true 上传成功，false 上传失败   
//     */   
//    public static String uploadManyFile(String localFile, String newFileName) {   
//        boolean flag = true;   
//        StringBuffer strBuf = new StringBuffer();   
//        int n = 0;   
//        try {   
//            connectServer();   
//            File file = new File(localFile);// 在此目录中找文件   
//   
//            File file2[] = file.listFiles();   
//   
//            for (int i = 0; i < file2.length; i ) {   
//   
//                File file1 = new File(file2[i].getAbsolutePath());   
//                System.out.println(file1.isFile());   
//                if (file1.isDirectory()) {// 文件夹中还有文件夹   
//   
//                    uploadManyFile(file2[i].getAbsolutePath(), newFileName);   
//                } else {   
//                    String tmpNewFileName = "";   
//                    if (newFileName.substring(newFileName.length() - 1).equals(   
//                            "/")) {   
//   
//                        tmpNewFileName = newFileName file2[i].getName();   
//                    } else {   
//   
//                        tmpNewFileName = newFileName "/" file2[i].getName();   
//                    }   
//                    System.out.println(tmpNewFileName);   
//                    flag = uploadFile(file2[i].getAbsolutePath(),   
//                            tmpNewFileName);   
//                }   
//                if (!flag) {   
//                    n ;   
//                    strBuf.append(file2[i].getName() "\r\n");   
//   
//                }   
//            }   
//            if (n > 0) {   
//   
//                strBuf.insert(0, "共有" n "上传失败，分别为\r\n");   
//            }   
//            System.out.println(strBuf.toString());   
//        } catch (NullPointerException e) {   
//            e.printStackTrace();   
//            logger.debug("本地文件上传失败！找不到上传文件！", e);   
//            // TODO: handle exception   
//        } catch (Exception e) {   
//            e.printStackTrace();   
//            logger.debug("本地文件上传失败！", e);   
//            // TODO: handle exception   
//        }   
//        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;   
//    }   
//   
//    /**   
//     * 删除一个文件   
//     */   
//    public static boolean deleteFile(String filename) {   
//        boolean flag = true;   
//        try {   
//            connectServer();   
//   
//            flag = FtpClient.deleteFile(filename);   
//            if (flag) {   
//                System.out.println("delete  File succeed");   
//   
//            } else {   
//                System.out.println("delete File false");   
//   
//            }   
//        } 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   
//     *            --匹配的正则表达式   
//     */   
//    @SuppressWarnings("unchecked")   
//    public static void listRemoteFiles(String regStr) {   
//        connectServer();   
//        try {   
//            // FtpClient.changeWorkingDirectory(regStr);   
//            String files[] = FtpClient.listNames(regStr);   
//            if (files == null || files.length == 0)   
//                System.out.println("There has not any file!");   
//            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) {   
        Ftp.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  
     */  
    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 +"】不存在！");   
            e1.printStackTrace();   
        } catch (IOException e) {   
            System.out.println("配置文件 【" +configFile+ "】无法读取！");   
            e.printStackTrace();   
        }   
  
        /*  
         * } catch (Exception e) { e.printStackTrace(); } finally { try { if  
         * (inBuff != null) inBuff.close(); } catch (Exception e) {  
         * e.printStackTrace(); } }  
         */  
    }   
  
    /**  
     * 连接到服务器  
     *  
     * @return true 连接服务器成功，false 连接服务器失败  
     */  
    public static boolean connectServer() {   
        boolean flag = true;   
        if (FtpClient == null) {   
            int reply;   
            try {   
                setArg(ConfigFile);   
                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+ "】失败,连接超时！");   
                // logger.debug("登录ftp服务器【" Ip "】失败");   
            } catch (IOException e) {   
                flag = false;   
  
                e.printStackTrace();   
                System.err.println("登录ftp服务器【"+ Ip +"】失败，FTP服务器无法打开！");   
                // logger.debug("登录ftp服务器【" Ip "】失败");   
            }   
  
        }   
        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  
     */  
    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;   
    }   
  
    public static Log getLogger() {   
        return logger;   
    }   
  
    public static void setLogger(Log logger) {   
        Ftp.logger = logger;   
    }   
  
}

 

dpc27149
关注
java通过http代理获取FTP的文件
a392852316的博客
07-29 1921
公司与外部合作项目，需要获取外部合作方ftp上的文件，公司服务器是布置在内网，需要通过代理才能访问到外网。 通常在内网我们访问FTP会使用org.apache.commons.net.ftp.FTPClient,只需要设置一下 FTPClient ftpClient = new FTPClient(); ftpClient.connect(ftpHostname); ftpClient.login(ftpUsername, ftpPassword); 就可以连接上要访问的ftp去获取...
java编程，通过代理服务器访问外网的FTP
weixin_30247781的博客
10-21 574
有些时候我们的网络不能直接连接到外网, 需要使用http或是https或是socket代理来连接到外网, 这里是java使用代理连接到外网的一些方法, 希望对你的程序有用.方法一：使用系统属性来完成代理设置, 这种方法比较简单, 但是不能对单独的连接来设置代理: /** *@paramargs */ /** *@paramargs */ publi...
java通过代理服务器实现对FTP和HTTP的访问
热门推荐
youchenlong的专栏
12-28 1万+
在网上搜索了一天,看了很多代码,终于给我弄出来了,现在把全部的代码贴出来,可以通过代理服务器实现对FTP和HTTP的访问(和网上的有些不一样, 网上对请求头的Proxy-Authorization属性进行代理设置只能实现对HTTP的访问)import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import
java远程操作ftp服务器上传下载
麻辣香蕉
07-18 2343
 注意里面的文件编码，连接过程编码与服务器编码不一致的话会导致上传中文乱码情况。 import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import org.apache.commons.net.ftp.*; import org...
FTP服务器搭建和JAVA调用
Stiles的博客
05-07 430
FTP服务器搭建和JAVA调用 ​ 本教程分为两个部分： 在Linux系统环境中基于vsftpd搭建 FTP 服务器 使用Apache Common-Net jar包使用Java语言操作远程FTP服务器 基于vsFtpd在Linux环境下搭建FTP服务器 ​ 环境准备： ubuntu 20 LTS 安装vsFtpd 检查原系统中是否有vsftpd dpkg -s vsftpd 如果没有安装则使用apt-get安装 sudo apt-get install vsftpd 卸载 sudo
java实现的远程ftp文件浏览
01-14
FtpList部分是用来显示FTP服务器上的文件;...以下是这三部分的JAVA源程序： (1)显示FTP服务器上的文件 void ftpList_actionPerformed(ActionEvent e) { String server=serverEdit.getText(); //输入的FTP服务器的IP地址
java实现ftp上传 如何创建文件夹
08-30
Java 实现 FTP 上传和创建文件夹 Java 实现 FTP 上传是指使用 Java 语言通过 FTP 协议将文件上传到 FTP 服务器的过程。在这个过程中，需要使用commons-net-3.3.jar包来实现 FTP 客户端的连接和文件上传。本文将详细...
Java实现FTP文件上传和下载
最新发布
10-21
在Java编程语言中，FTP（File Transfer Protocol）文件上传和下载是常见的网络操作，用于在本地计算机和远程服务器之间交换文件。以下将详细介绍如何使用Java实现FTP文件上传和下载的步骤，以及涉及到的关键知识点。...
Java语言实现简单FTP软件 FTP远程文件管理模块实现(10)
08-30
Java语言实现简单FTP软件，涉及的关键知识点主要包括FTP协议的理解、Java网络编程以及Swing图形用户界面（GUI）的使用。FTP（File Transfer Protocol）是一种用于在网络上进行文件传输的标准协议，它允许用户从远程...
pdf.js在java web项目中远程预览ftp上的pdf文件.docx
03-05
在Java web项目中，需要预览远程FTP服务器上的PDF文件。这可以通过使用pdf.js插件和自定义servlet来实现。 ### 2. pdf.js插件的使用 pdf.js插件是一个功能强大且轻量级的PDF查看器，可以在Web浏览器中预览PDF文件...
JAVA FTPClient——远程文件操作
无限大地NLP_空木的专栏
10-17 4775
FTPClient使用初探
FTP 协议（指令集）
flags_s的博客
09-15 2416
FTP协议采用一系列简单的协议来完成文件传输的各种任务，在发送命令的时候，总是在命令的最后加上一个回车换行符，在VB中可以用“vbcrlf”来实现，vc中以“/r/n”表示。以下的命令是从Postel和Reynolds所著的RFC 929修改而来，如果读者想查看详细内容，可以参见英文版RFC 929。注意以下出现地标志符CRLF表示的是回车符号，即相当于VC中的“/r/n”。 1.  ABOT（
java 使用ftp下载远程服务器文件
qq_41972358的博客
04-21 2238
第一种方法连接中带有账号密码直接远程下载: public Result<?> download(){ //进行下载文件---------------------------------开始 //远程服务器下载地址 String fileurl = "ftp://superAdmin:superAdmin123@192.168.1.8:8888/usr/mp4pt/rec/CHN0/10110120011100/00001.mp4"; /
java远程上传文件或者文件夹到ftp服务器
lzlnd的博客
01-11 2298
1.上传或者下载单个文件 import org.apache.commons.net.ftp.FTP; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPFile; import org.apache.commons.net.ftp.FTPReply; import java.i...
java实战3：用java实现数据文件上传到ftp服务器
weixin_43930865的博客
12-25 6693
1：ftp简介 文件传输协议（File Transfer Protocol，FTP）是用于在网络上进行文件传输的一套标准协议，它工作在 OSI 模型的第七层， TCP 模型的第四层， 即应用层， 使用 TCP 传输而不是 UDP， 客户在和服务器建立连接前要经过一个“三次握手”的过程， 保证客户与服务器之间的连接是可靠的， 而且是面向连接， 为数据传输提供可靠保证。 FTP允许用户以文件操作的方式（如文件的增、删、改、查、传送等）与另一主机相互通信。然而， 用户并不真正登录到自己想要存取的计算机上面而成为完
QT FTP上传文件
Beyond欣
08-06 2930
QT FTP上传文件两台电脑通过网线建立本地连接，保证网关在同一段；服务器端打开ftp；客户端网页测试远程访问；客户端cmd测试远程访问；客户端程序测试远程访问。 两台电脑通过网线建立本地连接，保证网关在同一段； 服务器端打开ftp； 控制面板→程序→启用或关闭windows功能→windows功能→Internet信息服务 启用“FTP服务”FTP扩展性” IIS管理控制台” 开始屏幕的...
FTPClient相关
pengxingjun的专栏
04-09 2622
FTPClient上传，下载，新建文件夹等
Ftp常用操作
weixin_30628077的博客
04-26 105
摘自：https://www.cnblogs.com/lzw0414/p/5411509.html import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; ...
java 远程ftp下载文件
07-25
你可以使用Java中的Apache Commons Net库来实现远程FTP下载文件的功能。以下是一个简单的示例代码： ```java import org.apache.commons.net.ftp.FTP; import org.apache.commons.net.ftp.FTPClient; import java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值