java连接Ftp文件服务器

Ftp是一种常见的文件存储服务器，在很多的项目中都有使用，方便存储各种格式的文件，使用java连接ftp文件服务器也是常用的工具类。

下面是使用连接ftp文件服务器的步骤：

下载jar包

使用的是maven来管理jar包，下面试用的Apache的common-net包
<dependency>
    <groupId>commons-net</groupId>
    <artifactId>commons-net</artifactId>
    <version>3.4</version>
</dependency>

实现代码

import org.apache.commons.net.PrintCommandListener;
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.io.*;

public class FtpUtil {
    public FTPClient ftpClient = new FTPClient();

    public FtpUtil() {
        // 设置将过程中使用到的命令输出到控制台
        this.ftpClient.addProtocolCommandListener(new PrintCommandListener(
                new PrintWriter(System.out)));
    }

    public enum UploadStatus {
        Create_Directory_Fail,      //远程服务器相应目录创建失败
        Create_Directory_Success,   //远程服务器创建目录成功
        Upload_New_File_Success,    //上传新文件成功
        Upload_New_File_Failed,     //上传新文件失败
        File_Exits,                 //文件已经存在
        Remote_Bigger_Local,        //远程文件大于本地文件
        Upload_From_Break_Success,  //断点续传成功
        Upload_From_Break_Failed,   //断点续传失败
        Delete_Remote_Faild;        //删除远程文件失败
    }

    /**
     * 连接到FTP服务器
     *
     * @param hostname 主机名
     * @param port     端口
     * @param username 用户名
     * @param password 密码
     * @return 是否连接成功
     * @throws IOException
     */
    public boolean connect(String hostname, int port, String username,
                           String password) throws IOException {
        ftpClient.connect(hostname, port);
        ftpClient.enterLocalPassiveMode();
        if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            if (ftpClient.login(username, password)) {
                return true;
            }
        }
        disconnect();
        return false;
    }

    /**
     * 断开与远程服务器的连接
     *
     * @throws IOException
     */
    public void disconnect() throws IOException {
        if (ftpClient.isConnected()) {
            ftpClient.disconnect();
        }
    }

    /**
     * 上传文件到FTP服务器，支持断点续传
     *
     * @param local  本地文件名称，绝对路径
     * @param remote 远程文件路径，使用/home/directory1/subdirectory/file.ext
     *               按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
     * @return 上传结果
     * @throws IOException
     */
    public UploadStatus upload(String local, String remote) throws IOException {
        remote = new String(remote.getBytes("GBK"), "iso-8859-1");
        // 设置PassiveMode传输
        ftpClient.enterLocalPassiveMode();
        // 设置以二进制流的方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.setRemoteVerificationEnabled(false);
        ftpClient.setControlEncoding("utf-8");
        UploadStatus result = null;
        // 对远程目录的处理
        String remoteFileName = remote;
        if (remote.contains("/")) {
            remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
            String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
            if (!directory.equalsIgnoreCase("/")
                    && !ftpClient.changeWorkingDirectory(directory)) {
                // 如果远程目录不存在，则递归创建远程服务器目录
                int start = 0;
                int end = 0;
                if (directory.startsWith("/")) {
                    start = 1;
                } else {
                    start = 0;
                }
                end = directory.indexOf("/", start);
                while (true) {
                    String subDirectory = remote.substring(start, end);
                    if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                        if (ftpClient.makeDirectory(subDirectory)) {
                            ftpClient.changeWorkingDirectory(subDirectory);
                        } else {
                            System.out.println("创建目录失败");
                            return UploadStatus.Create_Directory_Fail;
                        }
                    }
                    start = end + 1;
                    end = directory.indexOf("/", start);

                    // 检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            }
        }

        // 检查远程是否存在文件
        FTPFile[] files = ftpClient.listFiles(remoteFileName);
        if (files.length == 1) {
            if (!ftpClient.deleteFile(remoteFileName)) {
                return UploadStatus.Delete_Remote_Faild;
            }
        }

        File f = new File(local);
        long remoteSize = 0;
        long localSize = f.length();
        if (remoteSize == localSize) {
            return UploadStatus.File_Exits;
        } else if (remoteSize > localSize) {
            return UploadStatus.Remote_Bigger_Local;
        }

        // 尝试移动文件内读取指针,实现断点续传
        InputStream is = new FileInputStream(f);
        ftpClient.storeFile(remoteFileName, is);

        if (is.skip(remoteSize) == remoteSize) {
            ftpClient.setRestartOffset(remoteSize);
            if (ftpClient.storeFile(remote, is)) {
                return UploadStatus.Upload_From_Break_Success;
            }
        }
        // 如果断点续传没有成功，则删除服务器上文件，重新上传
        if (!ftpClient.deleteFile(remoteFileName)) {
            return UploadStatus.Delete_Remote_Faild;
        }
        if (ftpClient.storeFile(remoteFileName, is)) {
            result = UploadStatus.Upload_New_File_Success;
        } else {
            result = UploadStatus.Upload_New_File_Failed;
        }
        is.close();
        return result;
    }
}