利用enterprisedt包实现FTP的操作



package com.enterprisedt.net.ftp.ext;

import com.enterprisedt.net.ftp.FTPClient;
import com.enterprisedt.net.ftp.FTPException;
import com.enterprisedt.net.ftp.FTPFile;
import com.enterprisedt.net.ftp.FTPMessageCollector;
import com.enterprisedt.net.ftp.FTPTransferType;
import com.enterprisedt.net.ftp.FTPConnectMode;
import com.enterprisedt.util.debug.Level;
import com.enterprisedt.util.debug.Logger;
import com.enterprisedt.net.ftp.*;
import java.util.List;
import java.io.*;
import java.text.*;

/*
说明：
 一、使用edtftpj 2.0.1开源包
 二、实现了以下功能
    1、上传指定文件夹（包括子文件和文件夹） uploadFolder(String folderName, String ftpPath)
    2、下载FTP上指定的文件夹 downloadFolder(String ftppath, String outdir, String ftpdir)
    3、上传指定文件夹下的所有文件到FTP指定目录下 uploadAllFilesInFolder(String folderName, String ftpPath)
    4、删除指定文件夹下的所有文件（包括子文件夹里面的文件，但由于不知怎么删除目录，所以暂没有做删除目录的功能） deleteAllFilesInFolder(String ftppath, String ftpdir)
    5、删除指定文件 String deleteFile(String ftpPath)
    6、判断FTP上目录是否存在 isDirExist(String dirname, String[] files)
    7、上传单个文件 uploadFile(String clientFileName, String ftpPath)
    8、下载单个文件 downloadFile(String remoteFileName,String localFileName)
    9、删除指定文件夹下的所有文件（不包括子文件夹，只是删除指定文件夹下的文件）
*/
public class FtpEptUtil {
    private String ProxyServer;
    private String ProxyPort;
    private String ProxyUsername;
    private String ProxyPassword;
    private String ftpServer;
    private String ftpPort;
    private String ftpUserName;
    private String ftpPassword;
    private FTPClient ftpClient;
    private boolean isLogin = false;
   
    public FtpEptUtil(){    
    }
   
    /**
     * 初始化连接
     * @param pFtpServer FTP服务器地址
     * @param pFtpPort FTP服务器端口
     * @param pFtpUserName FTP登录用户名
     * @param pFtpPassword FTP登录密码
     * @throws IOException
    */   
 public FtpEptUtil(String pFtpServer, String pFtpPort, String pFtpUserName,
   String pFtpPassword) throws Exception {
  this.ftpServer = pFtpServer;
  if (pFtpPort.trim().equals(""))
   this.ftpPort = "21";
  else
   this.ftpPort = pFtpPort;
  if (pFtpUserName.trim().equals(""))
   this.ftpUserName = "Anonymous";
  else
   this.ftpUserName = pFtpUserName;
  this.ftpPassword = pFtpPassword;
  try {  
            ftpClient = new FTPClient(); //ftpServer, Integer.parseInt(ftpPort)
            ftpClient.setRemoteHost(ftpServer);
            ftpClient.setRemotePort(Integer.parseInt(ftpPort));
            ftpClient.setControlEncoding("gb2312"); //加上这一句后在 edtftpj 2.0.1 下就可以传中文文件名了
            System.out.println("开始登录");
            ftpClient.connect();
            ftpClient.login(ftpUserName, ftpPassword);
            System.out.println("登录成功");
            ftpClient.chdir("\\"); //在有的ftp服务器运行会出错，用ftpClient.chdir("/")又可以了
            System.out.println("已转入根目录");
            isLogin = true;
  } catch (Exception e) {
   throw new Exception(e.getMessage());
  }
 }
 
    /**
     * 初始化连接
     * @param ProxyServer 代理服务器地址
     * @param ProxyPort 代理服务器端口
     * @param ProxyUsername 代理服务器登录用户名
     * @param ProxyPassword 代理服务器登录密码
     * @param pFtpServer FTP服务器地址
     * @param pFtpPort FTP服务器端口
     * @param pFtpUserName FTP登录用户名
     * @param pFtpPassword FTP登录密码
     * @throws IOException
    */   
 public FtpEptUtil(String ProxyServer,String ProxyPort,String ProxyUsername,String ProxyPassword,String pFtpServer, String pFtpPort, String pFtpUserName,
   String pFtpPassword) throws Exception {
  if ((ProxyServer.trim().equals(""))||(ProxyServer==null))
   this.ProxyPort = "1080";
  else
   this.ProxyPort = ProxyPort;
 
  if ((ProxyUsername.trim().equals(""))||(ProxyUsername==null))
   this.ProxyUsername = "Anonymous";
  else
   this.ProxyUsername = ProxyUsername;
 
  if ((ProxyPassword.trim().equals(""))||(ProxyPassword==null))
   this.ProxyPassword = "";
  else
   this.ProxyPassword = ProxyPassword;

  if ((!ProxyServer.trim().equals(""))&&(ProxyServer!=null)){
   FTPClient.clearSOCKS();
   FTPClient.initSOCKS(ProxyPort,ProxyServer); //设置代理服务器
   FTPClient.initSOCKSAuthentication(ProxyUsername, ProxyPassword);//如果代理服务器，需要密码则使用这一句
  }
 
  this.ftpServer = pFtpServer;
  if (pFtpPort.trim().equals(""))
   this.ftpPort = "21";
  else
   this.ftpPort = pFtpPort;
  if (pFtpUserName.trim().equals(""))
   this.ftpUserName = "Anonymous";
  else
   this.ftpUserName = pFtpUserName;
 
  this.ftpPassword = pFtpPassword;
  try {  
            ftpClient = new FTPClient(); //ftpServer, Integer.parseInt(ftpPort)
            ftpClient.setRemoteHost(ftpServer);
            ftpClient.setRemotePort(Integer.parseInt(ftpPort));
            ftpClient.setControlEncoding("gbk"); //加上这一句后在 edtftpj 2.0.1 下就可以传中文文件名了
            System.out.println("开始登录");
            ftpClient.connect();
            ftpClient.login(ftpUserName, ftpPassword);
            System.out.println("登录成功");
            ftpClient.chdir("\\"); //在有的ftp服务器运行会出错，用ftpClient.chdir("/")又可以了
            System.out.println("已转入根目录");
            isLogin = true;
  } catch (Exception e) {
   throw new Exception(e.getMessage());
  }
 }
 
    /**
     * 连接服务器
     * @param pFtpServer FTP服务器地址
     * @param pFtpPort FTP服务器端口
     * @param pFtpUserName FTP登录用户名
     * @param pFtpPassword FTP登录密码
     * @throws IOException
    */   
 
    public void connServer(String pFtpServer, String pFtpPort,
                           String pFtpUserName, String pFtpPassword) throws
            Exception {
        this.ftpServer = pFtpServer;
        if (pFtpPort.trim().equals("")) {
            this.ftpPort = "21";
        } else {
            this.ftpPort = pFtpPort;
        }
        if (pFtpUserName.trim().equals("")) {
            this.ftpUserName = "Anonymous";
        } else {
            this.ftpUserName = pFtpUserName;
        }
        this.ftpPassword = pFtpPassword;
        try {
            ftpClient = new FTPClient(); //ftpServer, Integer.parseInt(ftpPort)
            ftpClient.setRemoteHost(ftpServer);
            ftpClient.setRemotePort(Integer.parseInt(ftpPort));
            ftpClient.setControlEncoding("gb2312"); //加上这一句后在 edtftpj 2.0.1 下就可以传中文文件名了
            System.out.println("开始登录");
            ftpClient.connect();
            ftpClient.login(ftpUserName, ftpPassword);
            System.out.println("登录成功");
            ftpClient.chdir("\\"); //在有的ftp服务器运行会出错，用ftpClient.chdir("/")又可以了
            System.out.println("已转入根目录");
            isLogin = true;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }
   
    /**
     * 连接ftp服务器
     * @param server 服务器地址
     * @param path 文件夹，空代表根目录
     * @param password 密码
     * @param user   登陆用户
     * @param ftppath 登录到的FTP目录，空代表根目录
     */
    public void connServer(String server,int port,String user, String password,String ftppath) {
     if(ftppath.trim().equals("")||(ftppath==null)){
      ftppath = "\\";
     }    
        try {
            ftpClient = new FTPClient();
            ftpClient.setRemoteHost(server);
            ftpClient.setRemotePort(port);
            ftpClient.setControlEncoding("gb2312"); //加上这一句后在 edtftpj 2.0.1 下就要可以传中文文件名了
            System.out.println("开始登录");
            ftpClient.connect();
            ftpClient.login(user, password);
            System.out.println("登录成功");
            ftpClient.chdir(ftppath); //在有的ftp服务器运行会出错，用ftpClient.chdir("/")又可以了
            System.out.println("已转入根目录");
            isLogin = true;
        } catch (FTPException ex) {
         ex.printStackTrace();
        } catch (IOException ex) {
         ex.printStackTrace();
        }
    }

    /**
     * 1、上传指定文件夹（以指定的文件夹开始，包括所有子文件和子文件夹）
     * @param folderName 文件夹在本地址全路径(包括文件夹本身,如：C:\\temp\\)
     * @param ftpPath 文件夹上传后在FTP服务器上的路径(应是形如：/wsq/yhp/的全路径)
     * @throws IOException
    */
    public String uploadFolder(String folderName, String ftpPath) throws
            Exception {
        if (isLogin) {
            String strMsg = "";
            try {
                File file = new File(folderName);

                if (file.isDirectory()) {
                    ftpClient.chdir("\\");
                    ftpClient.setType(FTPTransferType.BINARY);

                    if (checkFolderIsExist(ftpPath)) {
                        ftpClient.chdir(ftpPath);
                    } else {
                        createFolder(ftpPath);
                    }

                    if (!checkFolderIsExist(file.getName())) {
                        ftpClient.mkdir(file.getName());
                    }

                    ftpClient.chdir(file.getName());

                    ftpPath = ftpPath + "\\" + file.getName();
                    File[] files = file.listFiles();

                    for (int i = 0; i < files.length; i++) {
//                        System.out.println("==============================");
//                        System.out.println("ftpPath:"+ftpPath);
//                        System.out.println("files["+i+"]:"+files[i].getPath());
//                        System.out.println("==============================");

                        if (files[i].isDirectory()) {
                            uploadFolder(files[i].getPath(), ftpPath);
                        } else {
                            if (files[i].isFile()) {
                                try {
                                    //===========================方法一开始================================
                                    //ftpClient.chdir("\\");
                                    //ftpClient.chdir(ftpPath);
                                    //ftpClient.put(files[i].getPath(),files[i].getName());
                                    //===========================方法一结束=================================
                                    //
                                    //===========================方法二开始================================
                                    uploadFile(files[i].getPath(), ftpPath);
                                    //===========================方法二结束================================
                                } catch (Exception ee) {
                                    strMsg += "upload file<<：" +
                                            files[i].getPath() +
                                            ">> error！Message:" + ee.getMessage() +
                                            "\r\n";
                                }
                            }
                        }
                    }
                    if (!strMsg.equals("")) {
                        throw new Exception(strMsg);
                    }
                } else {
                    System.out.println("file:" + file.getName());
                    throw new Exception(folderName + " is not a folder'name!");
                }
            } catch (Exception e) {
                strMsg += e.getMessage() + "\r\n";
            }
            return strMsg;
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }
   
    /**
     * 5、删除指定文件 String deleteFile(String ftpPath)
     * @param ftpPath FTP上对于根目录的路径
     * @throws IOException
    */   
    public String deleteFile(String ftpPath) throws
            Exception {
        if (isLogin) {
            String strMsg = "";
            try {
                ftpClient.delete(ftpPath);
            } catch (FTPException ex) {
                strMsg += "删除文件错误：" + ex.getMessage();
            } catch (IOException ex) {
                strMsg += "操作文件错误：" + ex.getMessage();
            }
            return strMsg;
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 4、删除指定目录（包括文件夹本身）deleteFolder(String ftpPath)
     * @param ftpPath FTP上对于根目录的路径
     * @throws IOException
    */   
    public String deleteFolder(String ftpPath) throws
            Exception {
        if (isLogin) {
            String strMsg = "";
            ftpClient.chdir("\\"); //进入目录
            //列出目录下所有文件和文件夹
            FTPFile[] ftpfiles = ftpClient.dirDetails(ftpPath);
            for (int i = 0; i < ftpfiles.length; i++) {
                FTPFile tempftpfile = ftpfiles[i];
//                System.out.println("===================================");
//                System.out.println("文件名:"+tempftpfile.getName());
//                System.out.println("路径:"+tempftpfile.getPath());
//                System.out.println("是否是止录:"+tempftpfile.isDir());
//                System.out.println("最后修改日录:"+tempftpfile.lastModified());
//                System.out.println("===================================");

                if (tempftpfile.isDir()) {
                    ftpPath = ftpPath + "\\" + tempftpfile.getName();
                    System.out.println("1:" + ftpPath);
                    deleteFolder(ftpPath);
                } else {
                    ftpClient.delete(ftpPath + "\\" + tempftpfile.getName());
                }
            }
         ftpClient.cdup();
            ftpClient.rmdir(ftpPath);           
            return strMsg;
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 3、上传指定文件夹下的所有文件到FTP指定目录下
     * @param folderName 本地要上传的文件夹全路径
     * @param ftpPath FTP上对于根目录的路径
     * @throws IOException
    */   
    public void uploadAllFilesInFolder(String folderName, String ftpPath) throws
            Exception {
        if (isLogin) {
            String strMsg = "";
            try {
                File file = new File(folderName);
                if (file.isDirectory()) {
                    ftpClient.chdir("\\");
                    ftpClient.setType(FTPTransferType.BINARY);
                    if (checkFolderIsExist(ftpPath)) {
                        ftpClient.chdir(ftpPath);
                    } else {
                        createFolder(ftpPath);
                    }
                    File[] files = file.listFiles();
                    for (int i = 0; i < files.length; i++) {
                        if (files[i].isFile()) {
                            try {
                                ftpClient.put(files[i].getPath(),
                                              files[i].getName());
                            } catch (Exception ee) {
                                strMsg += "upload file<<：" + files[i].getPath() +
                                        ">> error！Message:" + ee.getMessage() +
                                        "\r\n";
                            }
                        }
                    }
                } else {
                    throw new Exception(folderName + " is not a folder'name!");
                }
            } catch (Exception e) {
                throw new Exception(e.getMessage());
            }
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 7、上传单个文件 uploadFile(String clientFileName, String ftpPath)
     * @param clientFileName 本地要上传的文件的全路径
     * @param ftpPath FTP上对于根目录的路径
     * @throws IOException
    */
    public void uploadFile(String clientFileName, String ftpPath) throws
            Exception {
        if (isLogin) {
            try {
                //获取文件名
                String filename = "";
                int index = clientFileName.lastIndexOf("\\");
                filename = clientFileName.substring(index + 1);
                ftpClient.chdir("\\");
                ftpClient.setType(FTPTransferType.BINARY);
                if (checkFolderIsExist(ftpPath)) {
                    ftpClient.chdir(ftpPath);
                } else {
                    createFolder(ftpPath);
                }
                ftpClient.put(clientFileName, filename);
            } catch (Exception ex) {
                throw new Exception(ex.getMessage());
            }
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 8、下载单个文件 downloadFile(String remoteFileName,String localFileName)
     * @param remoteFileName --服务器上的文件名(含全路径)
     * @param localFileName--本地文件名(全路径名)
     */
    public void downloadFile(String remoteFileName,String localFileName){
        try{
            ftpClient.get(localFileName, remoteFileName);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
        }
    }

    /**
     * 检查FTP服务器上文件夹是否存在
     * @param pFolder FTP上对于根目录的路径
     * @throws Exception
    */
    public boolean checkFolderIsExist(String pFolder) throws Exception {
        if (isLogin) {
            String folder = pFolder.trim();
            if (folder.startsWith("\\")) {
                folder = folder.substring(1);
            }
            if (folder.endsWith("\\")) {
                folder = folder.substring(0, folder.length() - 1);
            }
            String strLayer = "..";
            if (folder.indexOf("\\") > 0) {
                String[] folders = folder.split("\\\\");
                for (int i = 1; i < folders.length; i++) {
                    strLayer += ",";
                    //System.out.println("strLayer:"+strLayer);
                }
            }
            boolean result = false;
            try {
                ftpClient.chdir(folder);
                ftpClient.chdir(strLayer);
                result = true;
            } catch (Exception ex) {
                result = false;
            }
            return result;
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 创建远程FTP服务器文件夹
     * @param pFolder FTP上对于根目录的路径
     * @throws Exception
    */
    public void createFolder(String pFolder) throws Exception {
        if (isLogin) {
            if (checkFolderIsExist(pFolder) == false) {
                try {
                    String path = "";
                    ftpClient.chdir("\\");
                    String[] folders = pFolder.split("\\\\");
                    for (int i = 0; i < folders.length; i++) {
                        try {
                            ftpClient.chdir(folders[i]);
                        } catch (Exception ex) {
                            ftpClient.mkdir(folders[i]);
                            ftpClient.chdir(folders[i]);
                        }
                    }
                } catch (Exception ex) {
                    throw new Exception(ex.getMessage());
                }
            }
        } else {
            throw new Exception("you didnot login remote ftp server!");
        }
    }

    /**
     * 判断文件夹是否存在，这种方式不是很准
     * @param dirname 要判断的目录名
     * @param files FTP上的文件列表
    */
    public static boolean isDirExist(String dirname, String[] files) {
        for (int i = 0; i < files.length; i++) {
            if (files[i].indexOf("<DIR>") > -1 &&
                files[i].indexOf(dirname) > -1) {
                return true;
            }
        }
        return false;
    }
   
    /**
     * 在FTP服务上建立目录
     * @param directory FTP上对于根目录的路径
     * @param subDirectory 要在FTP上建立的目录
    */
    private static void createDirectory(String directory, String subDirectory) {
        String dir[];
        File fl = new File(directory);
        try {
            if (subDirectory == "" && fl.exists() != true) {
                fl.mkdir();
            } else if (subDirectory != "") {
                dir = subDirectory.replace('\\', '/').split("/");
                for (int i = 0; i < dir.length; i++) {
                    File subFile = new File(directory + File.separator + dir[i]);
                    if (subFile.exists() == false) {
                        subFile.mkdir();
                    }
                    directory += File.separator + dir[i];
                }
            }
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
    }

    /**
     * 下载FTP服务器上指定的文件下的文件和子文件夹
     * @param ftpdir 服务器上要下载的文件夹,以根目录开始的相对路径(不含要下载的文件夹名)
     * @param outdir 要存放文件的本地目录
     * @param ftpdir 要下载的文件夹
     * @throws IOException
    */
    public void downloadFolder(String ftppath, String outdir, String ftpdir) throws
            IOException {
        try {
            ftppath = ftppath.replace('\\', '/');
            if (!ftppath.endsWith("/")) {
                ftppath = ftppath + "/";
            }
            outdir = outdir.replace('\\', '/');
            if (!outdir.endsWith("/")) {
                outdir = outdir + "/";
            }
            System.out.println("当前FTP路径:" + File.separator + ftppath + ftpdir);
            System.out.println("当前本地路径：" + outdir);
            ftpClient.chdir(File.separator + ftppath + ftpdir); //进入目录
            //ftpClient.chdir(ftppath); //进入指定目录
            //列出目录下所有文件和文件夹
            FTPFile[] ftpfiles = ftpClient.dirDetails("");

            for (int i = 0; i < ftpfiles.length; i++) {
                FTPFile ftpobj = ftpfiles[i];
                // System.out.println("===================================");
                //System.out.println("文件名:"+ftpobj.getName());
                //System.out.println("路径:"+ftpobj.getPath());
                //System.out.println("是否是止录:"+ftpobj.isDir());
                //System.out.println("最后修改日录:"+ftpobj.lastModified());
                //System.out.println("===================================");
                if (!ftpobj.isDir()) { //是文件则直接下载文件
                    System.out.println("xiazaiwenjian:" + outdir +
                                       File.separator + ftpobj.getName());
                    // System.out.println("");
                    ftpClient.get(outdir + File.separator + ftpobj.getName(),
                                  ftpobj.getPath() + File.separator +
                                  ftpobj.getName());
                } else {
                    createDirectory(outdir, ftpobj.getName());
                    System.out.println(ftpobj.getPath());
                    downloadFolder(ftppath,
                                   outdir + File.separator + ftpobj.getName(),
                                   ftpdir + File.separator + ftpobj.getName());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除指定目录（包括文件夹本身）
     * @param ftppath 要删除的文件夹在ftp上的父路径
     * @param ftpdir 要删除的文件夹名
     * @throws IOException
    */
    public void deleteFolder(String ftppath, String ftpdir) throws
            IOException {
        try {
            ftppath = ftppath.replace('\\', '/');
            if (!ftppath.endsWith("/")) {
                ftppath = ftppath + "/";
            }

            System.out.println("当前FTP路径:" + File.separator + ftppath + ftpdir);

            ftpClient.chdir(File.separator + ftppath + ftpdir); //进入目录
            FTPFile[] ftpfiles = ftpClient.dirDetails("");

            for (int i = 0; i < ftpfiles.length; i++) {
                FTPFile ftpobj = ftpfiles[i];
                if (!ftpobj.isDir()) { //是文件则直接删除文件
                    ftpClient.delete(ftpobj.getPath() + File.separator +
                                     ftpobj.getName());
                } else {                
                 deleteFolder(ftppath,
                                           ftpdir + File.separator +
                                           ftpobj.getName());
                }
            }
         System.out.println("目录路径:"+ftppath + File.separator +ftpdir);
         ftpClient.cdup();
            ftpClient.rmdir(ftppath + File.separator +ftpdir);           
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 9、删除指定文件夹下的所有文件（不包括子文件夹，只是删除指定文件夹下的文件）
     * @param ftpdir FTP服务器上要删除文件的文件夹
     * @throws IOException
    */
    public void deleteFilesInFolder(String ftppath) throws IOException {
        try {
            ftpClient.chdir("\\"); //进入目录
            ftpClient.chdir(ftppath); //进入指定目录
            //列出目录下所有文件和文件夹
            FTPFile[] ftpfiles = ftpClient.dirDetails(".");

            for (int i = 0; i < ftpfiles.length; i++) {
                FTPFile tempftpfile = ftpfiles[i];
                if (!tempftpfile.isDir()) {
                    ftpClient.delete(tempftpfile.getName());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
  FtpEptUtil ftpeptutil = new FtpEptUtil();
  ftpeptutil.connServer("90.0.12.22",21,"ftptest", "1","\\");
 
  //1、上传指定文件夹（以指定的文件夹开始，包括所有子文件和子文件夹）
//  try {
//   ftpeptutil.uploadFolder(
//       "C:\\Documents and Settings\\Administrator\\桌面\\6\\200809.1",
//       "\\");
//   System.out.println("上传完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }
 
  //2、下载FTP上指定的文件夹
//  try {
//   ftpeptutil.downloadFolder(
//       "\\", //FTP服务器上的文件夹的父路径
//       "D:\\temp\\", //下载到的本地目录
//       "200809.1"); //要下载的FTP上的目录名(本地不创建此目录)
//   System.out.println("下载完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }
 
  //3、上传指定文件夹下的所有文件到FTP指定目录下
//  try {
//   ftpeptutil.uploadAllFilesInFolder(
//       "C:\\Documents and Settings\\Administrator\\桌面\\6\\200809.1", //要上传的文件所在的目录
//       "yhp"); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("上传完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }

  //4、删除指定目录（包括文件夹本身）
//  try {
//   ftpeptutil.deleteFolder("\\", "200809.1"); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("上传完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }
 
  //5、删除指定文件 String deleteFile(String ftpPath)
//  try {
//   ftpeptutil.deleteFile("\\20071009\\1.tif"); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("删除完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  } 

  //6、判断FTP上目录是否存在 isDirExist(String dirname, String[] files)
//  try {
//   String[] files = null;
//   ftpeptutil.isDirExist("\\20071009",files); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  } 
 
  //7、上传单个文件 uploadFile(String clientFileName, String ftpPath)
//  try {
//   ftpeptutil.uploadFile("C:\\Documents and Settings\\Administrator\\桌面\\6\\200809.1\\log4j使用手册和配置文件示例.rar","\\yhp\\log4j使用手册和配置文件示例.rar"); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("上传完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  } 

  //8、下载单个文件 downloadFile(String remoteFileName,String localFileName)
//  try {
//   ftpeptutil.downloadFile("\\yhp\\image001.jpg","D:\\temp\\image001.jpg");
//   System.out.println("下载完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }
 
  //9、删除指定文件夹下的所有文件（不包括子文件夹，只是删除指定文件夹下的文件）
//  try {
//   ftpeptutil.deleteFilesInFolder("200809.1"); //FTP上存放的目录（不存在则创建）
//   //此示例是将200809.1下的所有文件上传到FTP服务器上的yhp目录下(不含子目录)
//   System.out.println("上传完毕！");
//  } catch (Exception e) {
//   e.printStackTrace();
//  }
    }
}

 

 

/**

* 删除FTP服务器上文件夹及其文件的方法（使用edtftpj 2.0.3开源包）
* 删除指定目录(文件夹)下的文件夹（包括子文件夹中的文件与子文件夹本身）
* 实现：先删除目录下的文件，再删除目录下的文件夹
* @param folderftppath 需删除的文件夹的FTP工作路径（包含该文件夹本身） *
*/
public void deleteAll(String folderftppath) {
//判断用户需要删除的文件夹是否存在，放在需要调用删除文件夹方法的类中比较好
FTPDirectoryManager ftpdirmanager = new FTPDirectoryManager(ftpclient,folderftppath);
boolean dirisexist = ftpdirmanager.ftpDirectoryQuery();
if(dirisexist==false){
System.out.println("您要删除的文件夹不存在！");
return;//返回
}
//================================================
try{
ftpclient.changeDirectory(folderftppath);
FTPFile[] ftpFiles = ftpclient.directoryList(folderftppath);
for (FTPFile ftpFile : ftpFiles) {
if (!ftpFile.isDir()) {
ftpclient.deleteFile(ftpFile.getName());
}
else
{
String curpath=folderftppath+"/"+ftpFile.getName();
deleteAll(curpath);
}
}
//当前文件夹为空时，删除该空文件夹
ftpclient.deleteDirectory(folderftppath);
}catch (Exception e) {
e.printStackTrace();
}
}

 

**
* 删除指定目录下的某文件夹下的所有文件
* @param folderdelete 需要删除的文件夹名
* @param folderFTPdirectory 需要删除的文件夹所在的工作目录
*/
public void deleteFilesInFolder(String folderdelete, String folderFTPdirectory) {

boolean dirisexist = true;// 用户指定的文件目录是否存在
FTPDirectoryManager ftpdirmanager = null;
try {
// 判断用户指定的目录是否存在
ftpdirmanager = new FTPDirectoryManager(ftpclient, folderFTPdirectory);
dirisexist = ftpdirmanager.ftpDirectoryQuery();
if (dirisexist == true) {
// 文件目录存在时，将文件所在的FTP工作路径设置为当前工作目录
//String currenTPdir = ftpclient.getRemoteDirectory();
ftpclient.changeDirectory(folderFTPdirectory);
// 判断文件夹是否存在
FTPFile[] ftpFiles = ftpclient.directoryList(folderdelete);
for (FTPFile ftpFile : ftpFiles) {
// 判断当前是否为文件
if (!ftpFile.isDir()) {
//直接删除文件(方法1)
// ftpclient.changeDirectory(currenTPdir);
// ftpclient.deleteFile(ftpFile.getName());
ftpclient.deleteFile(ftpFile.getPath()+"/"+ftpFile.getName());//直接删除文件(方法2)
}
else{
//递归算法：删除当前文件夹目录下的所有文件
String folderdel=ftpFile.getName();
//String currePdir = ftpclient.getRemoteDirectory();
String currentFTPdir = ftpFile.getPath();
String subfolderFTPdir=null;
// 若是FTP根目录时