FTPClient相关的链接、上传、下载、删除、转移文件、退出ftp操作

package com.sh.cms.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
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.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

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;

public class FtpUtil {
    private String path;

    private static FTPClient ftpClient;
    public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;
    public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;

    /**
     * 方法：connectServer 
     * 方法说明：    连接ftp服务器
     * @param      void
     * @return     FTPClient
    */
    public FTPClient connectServer() throws SocketException, IOException {
        ftpClient = new FTPClient();
        String ipAndPort = "";
        String ftpAddress = ftp地址;
        String startSub = ftpAddress.substring(0, ftpAddress.indexOf("@"));
        String endSub = ftpAddress.substring(ftpAddress.indexOf("@") + 1);
        String userPass = startSub.substring(startSub.lastIndexOf("/") + 1);
        String[] up = userPass.split(":");

        if (endSub.indexOf("/") != -1) {
            ipAndPort = endSub.substring(0, endSub.indexOf("/"));
            this.path = endSub.substring(endSub.indexOf("/") + 1);
        } else {
            ipAndPort = endSub;
        }
        String port;
        String ip;

        if (ipAndPort.contains(":")) {
            ip = ipAndPort.substring(0, ipAndPort.indexOf(":"));
            port = ipAndPort.substring(ipAndPort.indexOf(":") + 1);
        } else {
            ip = ipAndPort;
            port = "21";
        }
        connectServer(ip, Integer.parseInt(port), up[0], up[1]);
        return ftpClient;
    }

    /**
     * 方法：connectServer 
     * 方法说明：    连接ftp服务器
     * @param      void
     * @return     FTPClient
    */
    public FTPClient connectServer(String server, int port, String user,
            String password) throws SocketException, IOException {
        ftpClient = new FTPClient();
        ftpClient.setConnectTimeout(3000);
        ftpClient.setControlEncoding("UTF-8");
        ftpClient.connect(server, port);
        if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            ftpClient.login(user, password);
        } else {
            ftpClient.disconnect();
        }
        ftpClient.enterLocalPassiveMode();
        ftpClient.setBufferSize(1024);
        ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
        return ftpClient;
    }


    /**
     * 方法：uploadxml
     * 方法说明：    向ftp服务器上传xml文件
     * @param      input：文件流，fileName：文件名称
     * @return     boolean
    */
    public boolean uploadxml(InputStream input, String fileName,
            String directory) throws Exception {
        if (StringUtil.isNotEmpty(this.path)) {
            directory = this.path + directory;
        }
        String[] s = directory.split("/");
        for (String p : s) {
            if (StringUtil.isNotEmpty(p)) {
                boolean staus = ftpClient.changeWorkingDirectory(p);
                if (!staus) {
                    ftpClient.makeDirectory(p);
                    ftpClient.changeWorkingDirectory(p);
                }
            }
        }

        boolean storeFile = ftpClient.storeFile(fileName, input);
        input.close();
        return storeFile;
    }


    /**
     * 方法：download
     * 方法说明：    从ftp服务器下载文件
     * @param      loadFileName：ftp上文件信息，saveFileName：保存的文件信息
     * @return     boolean
    */
    public boolean download(String loadFileName, String saveFileName)
            throws Exception {
        FileOutputStream fos = null;
        fos = new FileOutputStream(saveFileName);
        boolean ss = ftpClient.retrieveFile(loadFileName, fos);
        fos.close();
        return ss;

    }

    /**
     * 方法：moveFtpDir
     * 方法说明：    ftp服务器上文件迁移
     * @param      fromdir：当前文件目录，todir：要保存的目录
     * @return     boolean
    */
    public String moveFtpDir(String fromdir, String todir) {
        String ftpUrl = null;
        try {
            DateFormat df = new SimpleDateFormat("yyyyMMdd");
            String format = df.format(new Date());
            // 判断当前日期的文件夹是否存在
            if (todir != null && !"".equals(todir)) {
                FTPFile[] alldirs = ftpClient.listFiles("/");
                boolean flgdir = false;
                for (int i = 0; i < alldirs.length; i++) {
                    String dirname = alldirs[i].getName();
                    if (!dirname.equals(todir.substring(1))) {
                        continue;
                    } else {
                        flgdir = true;
                        break;
                    }
                }
                if (!flgdir) {
                    ftpClient.makeDirectory(todir + "/");
                }
                FTPFile[] allFile = ftpClient.listFiles(todir);
                boolean flg = false;
                for (int i = 0; i < allFile.length; i++) {
                    String dirname = allFile[i].getName();
                    if (!dirname.equals(format)) {
                        continue;
                    } else {
                        flg = true;
                        break;
                    }
                }
                if (!flg) {
                    ftpClient.makeDirectory(todir + "/" + format + "/");
                }
            }
            todir = todir + "/" + format + "/";
            // 移动文件
            if (fromdir != null && !"".equals(fromdir)) {
                FTPFile[] allFile = ftpClient.listFiles(fromdir);
                ftpClient
                        .makeDirectory(todir
                                + fromdir.substring(fromdir.lastIndexOf("/") + 1)
                                + "/");
                todir = todir + fromdir.substring(fromdir.lastIndexOf("/") + 1)
                        + "/";
                for (int i = 0; i < allFile.length; i++) {
                    String name = allFile[i].getName();
                    ftpClient.rename(fromdir + "/" + name, todir + "/" + name);
                }
                ftpClient.removeDirectory(fromdir);
                ftpUrl = todir.substring(0, todir.length() - 1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ftpUrl;
    }
    /**
      * 方法：moveFtpFileToDir 
      * 方法说明：    ftp移动文件到指定目录
      * @param fromdir 从这个文件路径
      * @param fileName 文件名称
      * @param todir  目标路径
      * @return
     */
    public String moveFtpFileToDir(String fromdir,String fileName, String todir) {
        String ftpUrl = null;
        try {
            // 移动文件
            if (StringUtil.isNotEmpty(fromdir)) {
                ftpClient.rename(fromdir + "/" + fileName, todir + "/" + fileName);
                ftpUrl = todir.substring(0, todir.length() - Constants.NUMBER_1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ftpUrl;
    }

    /**
     * 方法：downloadFile
     * 方法说明：    ftp服务器上下载文件
     * @param      remoteFileName：当前文件名称，localDires：要保存的目录，remoteDownLoadPath：ftp上文件目录
     * @return     boolean
    */
    public boolean downloadFile(String remoteFileName, String localDires,
            String remoteDownLoadPath) {
        String strFilePath = localDires + remoteFileName;
        BufferedOutputStream outStream = null;
        boolean success = false;
        try {
            ftpClient.changeWorkingDirectory(remoteDownLoadPath);
            outStream = new BufferedOutputStream(new FileOutputStream(
                    strFilePath));
            success = ftpClient.retrieveFile(remoteFileName, outStream);
            if (success == true) {
                return success;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != outStream) {
                try {
                    outStream.flush();
                    outStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (success == false) {
        }
        return success;
    }


    /*** 
     * 将下载文件的输出流转为输入流 
     * @param remoteFileName   待下载文件名称 
     * @param remoteDownLoadPath remoteFileName所在的路径 
     * */

    public InputStream downloadMetadata(String remoteFileName,
            String remoteDownLoadPath) {
        InputStream in = null;
        try {
            ftpClient.changeWorkingDirectory(remoteDownLoadPath);
            in = ftpClient.retrieveFileStream(remoteFileName);
            return in;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return in;
    }

    /*** 
     * @上传文件夹 
     * @param localDirectory 
     *            当地文件夹 
     * @param remoteDirectoryPath 
     *            Ftp 服务器路径 以目录"/"结束 
     * */
    public boolean uploadDirectory(String localDirectory,
            String remoteDirectoryPath) {
        File src = new File(localDirectory);
        try {
            ftpClient.makeDirectory(remoteDirectoryPath);

            File[] allFile = src.listFiles();
            for (int currentFile = 0; currentFile < allFile.length; currentFile++) {
                if (!allFile[currentFile].isDirectory()) {
                    String srcName = allFile[currentFile].getPath().toString();
                    uploadFile(new File(srcName), remoteDirectoryPath);
                }
            }
            for (int currentFile = 0; currentFile < allFile.length; currentFile++) {
                if (allFile[currentFile].isDirectory()) {
                    // 递归
                    ftpClient.makeDirectory(remoteDirectoryPath + "/"
                            + allFile[currentFile].getName() + "/");
                    File src2 = new File(allFile[currentFile].getPath());
                    File[] allFile2 = src2.listFiles();
                    for (int currentFile2 = 0; currentFile2 < allFile2.length; currentFile2++) {
                        if (!allFile2[currentFile2].isDirectory()) {
                            uploadFile(new File(allFile2[currentFile2]
                                    .getPath().toString()), remoteDirectoryPath
                                    + "/" + allFile[currentFile].getName()
                                    + "/");
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    /*** 
     * 上传Ftp文件 
     * @param localFile 当地文件 
     * @param romotUpLoadePath上传服务器路径 - 应该以/结束 
     * */
    public boolean uploadFile(File localFile, String romotUpLoadePath) {
        BufferedInputStream inStream = null;
        boolean success = false;
        try {
            this.ftpClient.changeWorkingDirectory(romotUpLoadePath);// 改变工作路径
            inStream = new BufferedInputStream(new FileInputStream(localFile));
            success = this.ftpClient.storeFile(localFile.getName(), inStream);
            if (success == true) {
                return success;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inStream != null) {
                try {
                    inStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return success;
    }

    /*** 
     * 上传CDN需要的XML文件 
     * @param tempftpDirectory 
     * @param filename文件名字 
     * @param r文件内容
     * */
    public boolean uploadCDNxmlFile(String filename, String r,
            String tempftpDirectory) {
        boolean success = false;
        InputStream is = null;
        try {
            // 1.输入流
            is = new ByteArrayInputStream(r.getBytes("utf-8"));
            this.ftpClient.changeWorkingDirectory(tempftpDirectory);// 改变工作路径
            success = this.ftpClient.storeFile(filename, is);
            if (success == true) {
                return success;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return success;
    }


    /**
     * 
     * 类描述:    删除FTP上的文件夹
     * 参数:	  
     * 返回值：        void
     * @throws Exception
     */
    public void removeDirectoryFtp(String ftpHost, int ftpPort,
            String ftpUserName, String ftpPassword, String path) {

        FTPClient ftpClient = null;

        try {
            ftpClient = connectServer(ftpHost, ftpPort, ftpUserName,
                    ftpPassword);

            if (ftpClient.changeWorkingDirectory(path)) {

                FTPFile[] files = ftpClient.listFiles();

                if (files.length == 0) {
                    ftpClient.removeDirectory(path);
                } else {
                    for (int i = 0; i < files.length; i++) {

                        if (files[i].getType() == 0) {

                            ftpClient.deleteFile(files[i].getName());
                        } else {

                            if (files[i].getName().equals("..")
                                    || files[i].getName().equals(".")) {
                                continue;
                            }
                            removeDirectoryFtp(ftpHost, ftpPort, ftpUserName,
                                    ftpPassword,
                                    path + "/" + files[i].getName());
                        }
                    }
                    ftpClient.removeDirectory(path);
                }
            }

        } catch (final IOException ex) {
            ex.printStackTrace();
        } finally {
            if (ftpClient != null) {
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public void makeDirectory(String dir) throws IOException {
        ftpClient.makeDirectory(dir);
    }


    /**
     * 退出FTP服务器
     * 
     * @throws Exception
     */
    public static void EpgFtpLogout() {
        try {
            if (ftpClient.isConnected()) {
                ftpClient.disconnect();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    ftpClient.disconnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @return the ftpClient
     */
    public FTPClient getFtpClient() {
        return ftpClient;
    }

    /**
     * @param ftpClient the ftpClient to set
     */
    public void setFtpClient(FTPClient ftpClient) {
        this.ftpClient = ftpClient;
    }
    
}