基于apache的commons-net-3.3.jar的 ftp java代码上传下载文件

package com.mnt.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.io.FileUtils;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

/**
 * FTP服务器工具
 * 注意：执行顺序
 * 1、先连接FTP服务器
 * 2、设置上传/下载目录
 * 3、执行其它
 * 
 * @author zcq
 * @version 1.0
 * 
 *          变更履历：
 *          v1.0 2016-7-29 zcq 初版
 */
public class FtpUtil {

    public static final Logger LOGGER = LoggerFactory.getLogger(FtpUtil.class);

    public static final String ANONYMOUS_LOGIN = "anonymous";

    private FTPClient ftp;

    private boolean is_connected;

    public FtpUtil() {
        ftp = new FTPClient();
        is_connected = false;

        ftp.setDefaultTimeout(7200);
        ftp.setConnectTimeout(7200);
        ftp.setDataTimeout(7200);
    }

    public FtpUtil(int defaultTimeoutSecond, int connectTimeoutSecond, int dataTimeoutSecond) {
        ftp = new FTPClient();
        is_connected = false;

        ftp.setDefaultTimeout(defaultTimeoutSecond);
        ftp.setConnectTimeout(connectTimeoutSecond);
        ftp.setDataTimeout(dataTimeoutSecond);
    }

    /**
     * 连接FTP服务器
     * 
     * @author zcq
     * @param host
     * @param port
     * @param user
     * @param password
     * @param isTextMode
     * @throws IOException
     */
    public void connect(String host, int port, String user, String password, boolean isTextMode) throws IOException {
        // 连接FTP服务器
        try {
            ftp.connect(host, port);
        } catch (UnknownHostException ex) {
            LOGGER.error("找不到FTP服务器【" + host + "】");
        } catch (SocketTimeoutException e) {
            LOGGER.error("连接FTP服务器【" + host + "】超时！");
        }

        // 检测连接FTP服务器是否成功
        int reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            disconnect();
            LOGGER.error("连接FTP服务器【" + host + "】失败！");
        }

        // 登录
        if (!ftp.login(StringUtils.isEmpty(user) ? ANONYMOUS_LOGIN : user, password)) {
            is_connected = false;
            disconnect();
            LOGGER.error("登录FTP服务器【" + host + "】失败！请检查用户名和密码！");
        } else {
            is_connected = true;
        }

        // 设置数据转换类型
        if (isTextMode) {
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        } else {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        }
        LOGGER.info("连接FTP服务器【" + host + "】成功！");
    }

    /**
     * 上传文件
     * 
     * @author zcq
     * @param ftpFileName
     * @param localFile
     * @throws IOException
     */
    public void upload(String ftpFileName, File localFile) throws IOException {
        // 检查文件是否存在
        if (!localFile.exists()) {
            LOGGER.error("该文件【" + localFile.getAbsolutePath() + "】不存在！");
        }
        // 上传操作
        InputStream in = null;
        try {
            // 使用被动模式通过防火墙
            ftp.enterLocalPassiveMode();
            ftp.changeWorkingDirectory(this.getWorkingDirectory());
            in = new BufferedInputStream(new FileInputStream(localFile));
            if (!ftp.storeFile(ftpFileName, in)) {
                LOGGER.error("上传文件【" + ftpFileName + "】失败！请检查用户权限和文件路径！");
            }
        } finally {
            try {
                in.close();
            } catch (IOException ex) {
            }
        }
    }

    /**
     * 下载文件
     * 
     * @author zcq
     * @param ftpFileName
     * @param localFile
     * @throws IOException
     */
    public void download(String ftpFileName, File localFile) throws IOException {
        // 下载文件
        OutputStream out = null;
        try {
            // 使用被动模式通过防火墙
            ftp.enterLocalPassiveMode();
            // 获取文件信息
            FTPFile[] fileInfoArray = ftp.listFiles(ftpFileName);
            if (fileInfoArray == null) {
                LOGGER.error("该文件【" + ftpFileName + "】未能在FTP服务器上找到！");
            }
            // 检查文件大小
            FTPFile fileInfo = fileInfoArray[0];
            long size = fileInfo.getSize();
            if (size > Integer.MAX_VALUE) {
                LOGGER.error("文件【" + ftpFileName + "】太大！");
            }
            // 下载操作
            out = new BufferedOutputStream(new FileOutputStream(localFile));
            if (!ftp.retrieveFile(ftpFileName, out)) {
                LOGGER.error("下载文件【" + ftpFileName + "】失败！请检查用户权限和文件路径！");
            }
            out.flush();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException ex) {
                }
            }
        }
    }

    /**
     * 删除文件
     * 
     * @author zcq
     * @param ftpFileName
     * @throws IOException
     */
    public void remove(String ftpFileName) throws IOException {
        if (!ftp.deleteFile(ftpFileName)) {
            LOGGER.error("删除文件【" + ftpFileName + "】失败！");
        }
    }

    /**
     * 列出指定FTP目录下的文件
     * 
     * @author zcq
     * @param filePath
     * @return
     * @throws IOException
     */
    public List<String> list(String filePath) throws IOException {
        List<String> fileList = new ArrayList<String>();
        // 使用被动模式通过防火墙
        ftp.enterLocalPassiveMode();

        FTPFile[] ftpFiles = ftp.listFiles(filePath);
        int size = (ftpFiles == null) ? 0 : ftpFiles.length;
        for (int i = 0; i < size; i++) {
            FTPFile ftpFile = ftpFiles[i];
            if (ftpFile.isFile()) {
                fileList.add(ftpFile.getName());
            }
        }
        return fileList;
    }

    /**
     * 发送一个FTP服务器站点特定的命令
     * 
     * @author zcq
     * @param args
     * @throws IOException
     */
    public void sendSiteCommand(String args) throws IOException {
        if (ftp.isConnected()) {
            try {
                ftp.sendSiteCommand(args);
            } catch (IOException ex) {
            }
        }
    }

    /**
     * 断开FTP服务器连接
     * 
     * @author zcq
     * @throws IOException
     */
    public void disconnect() throws IOException {
        if (ftp.isConnected()) {
            try {
                ftp.logout();
                ftp.disconnect();
                is_connected = false;
            } catch (IOException ex) {
            }
        }
    }

    /**
     * 创建文件在FTP服务器上的完整名称
     * 
     * @author zcq
     * @param ftpPath
     * @param localFile
     * @return
     */
    public String makeFTPFileName(String ftpPath, File localFile) {
        if (ftpPath == "") {
            return localFile.getName();
        } else {
            String path = ftpPath.trim();
            if (path.charAt(path.length() - 1) != '/') {
                path = path + "/";
            }

            return path + localFile.getName();
        }
    }

    /**
     * 测试是否连接上FTP服务器
     * 
     * @author zcq
     * @return
     */
    public boolean isConnected() {
        return is_connected;
    }

    /**
     * 获取当前工作目录
     * 
     * @author zcq
     * @return
     */
    public String getWorkingDirectory() {
        if (!is_connected) {
            return "";
        }

        try {
            return ftp.printWorkingDirectory();
        } catch (IOException e) {
        }

        return "";
    }

    /**
     * 设置当前工作目录
     * 
     * @author zcq
     * @param dir
     * @return
     */
    public boolean setWorkingDirectory(String dir) {
        if (!is_connected) {
            return false;
        }

        try {
            return ftp.changeWorkingDirectory(dir);
        } catch (IOException e) {
        }

        return false;
    }

    /**
     * 更改工作目录的父目录上的FTP服务器路径
     * 
     * @author zcq
     * @return
     */
    public boolean setParentDirectory() {
        if (!is_connected) {
            return false;
        }

        try {
            return ftp.changeToParentDirectory();
        } catch (IOException e) {
        }

        return false;
    }

    /**
     * 获取父目录
     * 
     * @author zcq
     * @return
     */
    public String getParentDirectory() {
        if (!is_connected) {
            return "";
        }

        String w = getWorkingDirectory();
        setParentDirectory();
        String p = getWorkingDirectory();
        setWorkingDirectory(w);

        return p;
    }

    /**
     * 下载FTP服务器指定文件流
     * 
     * @author zcq
     * @param ftpFileName
     * @param out
     * @throws IOException
     */
    public void getFile(String ftpFileName, OutputStream out) throws IOException {
        try {
            // 使用被动模式通过防火墙
            ftp.enterLocalPassiveMode();

            // 获取文件信息
            FTPFile[] fileInfoArray = ftp.listFiles(ftpFileName);
            if (fileInfoArray == null) {
                LOGGER.error("该文件【" + ftpFileName + "】未能在FTP服务器上找到！");
            }

            // 检查文件大小
            FTPFile fileInfo = fileInfoArray[0];
            long size = fileInfo.getSize();
            if (size > Integer.MAX_VALUE) {
                LOGGER.error("文件【" + ftpFileName + "】太大！");
            }

            // 下载文件
            if (!ftp.retrieveFile(ftpFileName, out)) {
                LOGGER.error("下载文件【" + ftpFileName + "】失败！请检查用户权限和文件路径！");
            }
            out.flush();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException ex) {
                }
            }
        }
    }

    /**
     * 上传指定文件流放到FTP服务器上
     * 
     * @author zcq
     * @param ftpFileName
     * @param in
     * @throws IOException
     */
    public void putFile(String ftpFileName, InputStream in) throws IOException {
        try {
            // 使用被动模式通过防火墙
            ftp.enterLocalPassiveMode();

            if (!ftp.storeFile(ftpFileName, in)) {
                LOGGER.error("上传文件【" + ftpFileName + "】失败！请检查用户权限和文件路径！");
            }
        } finally {
            try {
                in.close();
            } catch (IOException ex) {
            }
        }
    }

    // =========================================自定义方法==============================================

    /**
     * 写入文件
     * 
     * @author zcq
     * @param result
     */
    public void writeFile(String filePath, String result) {
        try {
            FileUtils.writeStringToFile(new File(filePath), result, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读取文件
     * 
     * @author zcq
     * @param result
     * @return
     */
    public String readFile(String path) {
        String sql = "";
        try {
            sql = FileUtils.readFileToString(new File(path), "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sql;
    }

}