Java实现连接FTP服务并传递文件

public class FtpClientUtil {

    private String host;

    private int port;

    private String username;

    private String password;

    private int bufferSize = 10 * 1024 * 1024;

    private int soTimeout = 15000;

    private FTPClient ftp;

    public FTPClient getFtp() {
        return ftp;
    }

    public void setFtp(FTPClient ftp) {
        this.ftp = ftp;
    }

    private UploadStatus uploadStatus;

    public UploadStatus getUploadStatus() {
        return uploadStatus;
    }

    public void setUploadStatus(UploadStatus uploadStatus) {
        this.uploadStatus = uploadStatus;
    }

    public static class Builder {
        private String host;
        private int port = 21;
        private String username;
        private String password;
        private int bufferSize = 1024 * 1024;
        private FTPClientConfig config;
        private int defaultTimeout = 15000;
        private int connectTimeout = 15000;
        private int dataTimeout = 15000;
        private int controlKeepAliveTimeout = 300;
        private int soTimeout = 15000;

        public Builder() {
        }

        public Builder host(String host) {
            this.host = host;
            return this;
        }

        public Builder port(int port) {
            this.port = port;
            return this;
        }

        public Builder username(String username) {
            this.username = username;
            return this;
        }

        public Builder password(String password) {
            this.password = password;
            return this;
        }

        public Builder bufferSize(int bufferSize) {
            this.bufferSize = bufferSize;
            return this;
        }

        public Builder config(FTPClientConfig config) {
            this.config = config;
            return this;
        }

        public Builder defaultTimeout(int defaultTimeout) {
            this.defaultTimeout = defaultTimeout;
            return this;
        }

        public Builder connectTimeout(int connectTimeout) {
            this.connectTimeout = connectTimeout;
            return this;
        }

        public Builder dataTimeout(int dataTimeout) {
            this.dataTimeout = dataTimeout;
            return this;
        }

        public Builder soTimeout(int soTimeout) {
            this.soTimeout = soTimeout;
            return this;
        }

        public Builder controlKeepAliveTimeout(int controlKeepAliveTimeout) {
            this.controlKeepAliveTimeout = controlKeepAliveTimeout;
            return this;
        }

        public FtpClientUtil build() throws IOException {
            FtpClientUtil instance = new FtpClientUtil(this.host, this.port, this.username, this.password,
                    this.bufferSize, this.config, this.defaultTimeout, this.dataTimeout, this.connectTimeout,
                    this.controlKeepAliveTimeout, this.soTimeout);
            return instance;
        }
    }

    private FtpClientUtil(String host, int port, String username, String password, int bufferSize,
            FTPClientConfig config, int defaultTimeout, int dataTimeout, int connectTimeout,
            int controlKeepAliveTimeout, int soTimeout) throws IOException {
        this.host = host;
        this.port = port;
        this.username = username;
        this.password = password;
        this.bufferSize = bufferSize;
        this.soTimeout = soTimeout;
        this.ftp = new FTPClient();
        if (config != null) {
            this.ftp.configure(config);
        }
        ftp.setControlEncoding("UTF-8");
//        ftp.setControlEncoding("GBK");
//        ftp.setControlEncoding("gb2312");
        ftp.enterLocalPassiveMode();
        ftp.setDefaultTimeout(defaultTimeout);
        ftp.setConnectTimeout(connectTimeout);
        ftp.setDataTimeout(dataTimeout);
        // ftp.setSendDataSocketBufferSize(1024 * 256);
        if (this.bufferSize > 0) {
            ftp.setBufferSize(this.bufferSize);
        }

        // keeping the control connection alive
        ftp.setControlKeepAliveTimeout(controlKeepAliveTimeout);// 每大约5分钟发一次noop，防止大文件传输导致的控制连接中断
    }

    public FtpClientUtil connect() throws SocketException, IOException {
        if (!this.ftp.isConnected()) {
            this.ftp.connect(this.host, this.port);
            int reply = this.ftp.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                logger.warn("ftp服务器返回码[{}], 连接失败...", reply);
                throw new IllegalStateException("连接ftp服务器失败,返回的状态码是" + reply);
            }
        }
        this.ftp.setSoTimeout(this.soTimeout);
        return this;
    }

    public FtpClientUtil login() throws IOException {
        boolean suc = this.ftp.login(this.username, this.password);
        if (!suc) {
            throw new IllegalStateException("登录ftp服务器失败");
        }
        return this;
    }

    /**
     * ftp上传文件功能
     * 
     * @param file
     *            要上传的文件
     * @param relativePath
     *            要上传到ftp服务器的相对路径
     * @return
     * @throws IOException
     */
    public FtpClientUtil upload(File file, String relativePath) throws IOException {
        FileInputStream fInputStream = new FileInputStream(file);
        return this.upload(fInputStream, file.getName(), relativePath, file.length());
    }

    public FtpClientUtil upload(InputStream inputStream, String name, String relativePath, long localSize)
            throws IOException {
        ftp.setFileType(FTP.BINARY_FILE_TYPE);
        changeWorkingDirectory(relativePath);

        this.ftp.enterLocalPassiveMode();
        FTPFile[] listFiles = this.ftp.listFiles(name);
        // long localSize = inputStream.available();// ? 不知道好用否
        if (listFiles.length == 1) {
            long remoteSize = listFiles[0].getSize();

            if (remoteSize == localSize) {
                this.setUploadStatus(UploadStatus.File_Exits);
                return this;
            } else if (remoteSize > localSize) {
                this.setUploadStatus(UploadStatus.Remote_Bigger_Local);
                return this;
            }
            this.uploadFile(inputStream, name, remoteSize, localSize);
        } else {
            this.uploadFile(inputStream, name, 0, localSize);
        }
        logger.info("{}/{} upload success", relativePath, name);
        return this;
    }

    private void uploadFile(InputStream inputStream, String name, long remoteSize, long localSize) throws IOException {
        this.ftp.enterLocalPassiveMode();
        OutputStream output = null;
        long step = localSize / 100;
        long process = 0;
        long localreadbytes = 0L;
        try {
            if (remoteSize > 0) {
                output = this.ftp.appendFileStream(name);
                this.ftp.setRestartOffset(remoteSize);
                inputStream.skip(remoteSize);
                process = remoteSize / step;
                localreadbytes = remoteSize;
            } else {
                output = this.ftp.storeFileStream(name);
            }
            byte[] bytes = new byte[1024];
            int c;
            while ((c = inputStream.read(bytes)) != -1) {
                output.write(bytes, 0, c);
                localreadbytes += c;
                if (localreadbytes / step >= process + 10) {
                    process = localreadbytes / step;
                    logger.info("文件【" + name + "】上传ftp进度汇报, process = " + process);
                }
            }
            logger.info("文件" + name + "上传ftp进度汇报, process = " + 100);
            output.flush();
            inputStream.close();
            output.close();
            boolean result = this.ftp.completePendingCommand();
            if (remoteSize > 0) {
                this.setUploadStatus(
                        result ? UploadStatus.Upload_From_Break_Success : UploadStatus.Upload_From_Break_Failed);
            } else {
                this.setUploadStatus(
                        result ? UploadStatus.Upload_New_File_Success : UploadStatus.Upload_New_File_Failed);
            }
        } catch (Exception e) {
            this.setUploadStatus(
                    remoteSize > 0 ? UploadStatus.Upload_From_Break_Failed : UploadStatus.Upload_New_File_Failed);
        }

    }

    public OutputStream upload(String name, String relativePath) throws IOException {
        ftp.setFileType(FTP.BINARY_FILE_TYPE);
        changeWorkingDirectory(relativePath);
        ftp.enterLocalPassiveMode();
        return this.ftp.storeFileStream(name);
    }

    public void changeWorkingDirectory(String relativePath) throws IOException {
        if (relativePath == null) {
            throw new NullPointerException("relativePath can't be null");
        }
        String[] dirs = relativePath.split("/");
        for (String dir : dirs) {
            if (!this.ftp.changeWorkingDirectory(dir)) {
                if (this.ftp.makeDirectory(dir)) {
                    this.ftp.changeWorkingDirectory(dir);
                } else {
                    logger.warn("{}目录创建失败, 导致不能进入合适的目录进行上传", dir);
                }
            }
        }
    }

    /**
     * ftp上传目录下所有文件的功能
     * 
     * @param file
     *            要上传的目录
     * @param relativePath
     *            要上传到ftp服务器的相对路径
     * @return
     * @throws IOException
     */
    public FtpClientUtil uploadDir(File file, String relativePath) throws IOException {
        if (!file.isDirectory()) {
            throw new IllegalArgumentException("file argument is not a directory!");
        }
        relativePath = relativePath + "/" + file.getName();
        File[] listFiles = file.listFiles();
        for (File f : listFiles) {
            this.uploadFree(f, relativePath);
        }
        return this;
    }

    /**
     * ftp上传文件, 调用方不用区分文件是否为目录，由该方法自己区分处理
     * 
     * @param file
     *            要上传的文件
     * @param relativePath
     *            要上传到ftp服务器的相对路径
     * @return
     * @throws IOException
     */
    public FtpClientUtil uploadFree(File file, String relativePath) throws IOException {
        if (file.isDirectory()) {
            this.uploadDir(file, relativePath);
        } else {
            this.upload(file, relativePath);
        }
        return this;
    }

    /**
     * 本方法是上传的快捷方法，方法中自身包含了ftp 连接、登陆、上传、退出、断开各个步骤
     * 
     * @param file
     *            要上传的文件
     * @param relativePath
     *            要上传到ftp服务器的相对路径
     */
    public boolean uploadOneStep(File file, String relativePath) {
        try {
            this.connect().login().uploadFree(file, relativePath);
            return true;
        } catch (IOException e) {
            String msg = String.format("ftp上传时发生异常, filename = [%s], relativePath = [%s]", file.getName(),
                    relativePath);
            logger.error(msg, e);
            return false;
        } finally {
            this.disconnectFinally();
        }
    }

    public boolean uploadOneStepForStream(InputStream inputStram, String name, String relativePath, long localSize) {
        try {
            this.connect().login().upload(inputStram, name, relativePath, localSize);
            return true;
        } catch (IOException e) {
            String msg = String.format("ftp上传时发生异常, filename = [%s], relativePath = [%s]", name, relativePath);
            logger.error(msg, e);
            return false;
        } finally {
            this.disconnectFinally();
        }
    }

    public interface OutputStreamForUpload {
        public void write(OutputStream outputStream) throws IOException;
    }

    public boolean uploadOneStepForStream(OutputStreamForUpload outputUpload, String name, String relativePath) {
        try {
            this.connect().login();
            OutputStream upload = this.upload(name, relativePath);
            outputUpload.write(upload);
            return true;
        } catch (IOException e) {
            String msg = String.format("ftp上传时发生异常, filename = [%s], relativePath = [%s]", name, relativePath);
            logger.error(msg, e);
            return false;
        } finally {
            this.disconnectFinally();
        }
    }

    public FtpClientUtil logout() throws IOException {
        this.ftp.logout();
        return this;
    }

    public void disconnect() {
        this.disconnectFinally();
    }

    private void disconnectFinally() {
        if (this.ftp.isConnected()) {
            try {
                this.ftp.disconnect();
            } catch (IOException ioe) {
                logger.warn("ftp断开服务器链接异常", ioe);
            }
        }
    }

    @Override
    public String toString() {
        return "FtpClientHelper [host=" + host + ", port=" + port + ", username=" + username + ", password=" + password
                + "]";
    }

}

看代码吧：