ftp文件传输

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.RandomAccessFile;

import java.net.SocketException;

import java.util.ArrayList;

import java.util.List;

 

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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;

 

/**

 * FTP工具类

 *

 * @author WangXianfeng 1:16:50 PM Jul 16, 2011

 */

public class FtpUtil {

       private FTPClient ftpClient;

       private static Log log = LogFactory.getLog(FtpUtil.class);

      

       /**

        * 根路径为"/",如果需要链接服务器之后跳转到路径，则在path中定义

        * @param ftpConfig

        * @throws SocketException

        * @throws IOException

        */

       public boolean connectServer(FtpConfig ftpConfig) throws SocketException,

                     IOException {

              String server = ftpConfig.getServer();

              int port = ftpConfig.getPort();

              String user = ftpConfig.getUsername();

              String password = ftpConfig.getPassword();

              String path = ftpConfig.getPath();

              return connectServer(server, port, user, password, path);

       }

       /**

        * 连接ftp服务器

        * @param server 服务器ip

        * @param port 端口，通常为21

        * @param user 用户名

        * @param password 密码

        * @param path 进入服务器之后的默认路径

        * @return 连接成功返回true，否则返回false

        * @throws SocketException

        * @throws IOException

        */

       public boolean connectServer(String server, int port, String user,

                     String password, String path) throws SocketException, IOException {

              ftpClient = new FTPClient();

              ftpClient.connect(server, port);

              ftpClient.setControlEncoding("GBK");

              log.info("Connected to " + server + ".");

              log.info("FTP server reply code:" + ftpClient.getReplyCode());

              if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {

                     if (ftpClient.login(user, password)) {

                            // Path is the sub-path of the FTP path

                            if (path.length() != 0) {

                                   ftpClient.changeWorkingDirectory(path);

                            }

                            return true;

                     }

              }

              disconnect();

              return false;

       }

       /**

        * 断开与远程服务器的连接

        * @throws IOException

        */

       public void disconnect() throws IOException {

              if (ftpClient.isConnected()) {

                     ftpClient.disconnect();

              }

       }

      

       /**

        * 从FTP服务器上下载文件,支持断点续传，下载百分比汇报

        * @param remote 远程文件路径及名称

        * @param local 本地文件完整绝对路径

        * @return 下载的状态

        * @throws IOException

        */

       public DownloadStatus download(String remote, String local)

                     throws IOException {

              // 设置被动模式

              ftpClient.enterLocalPassiveMode();

              // 设置以二进制方式传输

              ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

              DownloadStatus result;

 

              // 检查远程文件是否存在

              FTPFile[] files = ftpClient.listFiles(new String(

                            remote.getBytes("GBK"), "iso-8859-1"));

              if (files.length != 1) {

                     log.info("远程文件不存在");

                     return DownloadStatus.RemoteFileNotExist;

              }

 

              long lRemoteSize = files[0].getSize();

              File f = new File(local);

              // 本地存在文件，进行断点下载

              if (f.exists()) {

                     long localSize = f.length();

                     // 判断本地文件大小是否大于远程文件大小

                     if (localSize >= lRemoteSize) {

                            log.info("本地文件大于远程文件，下载中止");

                            return DownloadStatus.LocalFileBiggerThanRemoteFile;

                     }

 

                     // 进行断点续传，并记录状态

                     FileOutputStream out = new FileOutputStream(f, true);

                     ftpClient.setRestartOffset(localSize);

                     InputStream in = ftpClient.retrieveFileStream(new String(remote

                                   .getBytes("GBK"), "iso-8859-1"));

                     byte[] bytes = new byte[1024];

                     long step = lRemoteSize / 100;

                     step = step==0?1:step;//文件过小，step可能为0

                     long process = localSize / step;

                     int c;

                     while ((c = in.read(bytes)) != -1) {

                            out.write(bytes, 0, c);

                            localSize += c;

                            long nowProcess = localSize / step;

                            if (nowProcess > process) {

                                   process = nowProcess;

                                   if (process % 10 == 0){

                                          log.info("下载进度：" + process);

                                   }

                            }

                     }

                     in.close();

                     out.close();

                     boolean isDo = ftpClient.completePendingCommand();

                     if (isDo) {

                            result = DownloadStatus.DownloadFromBreakSuccess;

                     } else {

                            result = DownloadStatus.DownloadFromBreakFailed;

                     }

              } else {

                     OutputStream out = new FileOutputStream(f);

                     InputStream in = ftpClient.retrieveFileStream(new String(remote

                                   .getBytes("GBK"), "iso-8859-1"));

                     byte[] bytes = new byte[1024];

                     long step = lRemoteSize / 100;

                     step = step==0?1:step;//文件过小，step可能为0

                     long process = 0;

                     long localSize = 0L;

                     int c;

                     while ((c = in.read(bytes)) != -1) {

                            out.write(bytes, 0, c);

                            localSize += c;

                            long nowProcess = localSize / step;

                            if (nowProcess > process) {

                                   process = nowProcess;

                                   if (process % 10 == 0){

                                          log.info("下载进度：" + process);

                                   }

                            }

                     }

                     in.close();

                     out.close();

                     boolean upNewStatus = ftpClient.completePendingCommand();

                     if (upNewStatus) {

                            result = DownloadStatus.DownloadNewSuccess;

                     } else {

                            result = DownloadStatus.DownloadNewFailed;

                     }

              }

              return result;

       }

 

       public boolean changeDirectory(String path) throws IOException {

              return ftpClient.changeWorkingDirectory(path);

       }

 

       public boolean createDirectory(String pathName) throws IOException {

              return ftpClient.makeDirectory(pathName);

       }

 

       public boolean removeDirectory(String path) throws IOException {

              return ftpClient.removeDirectory(path);

       }

 

       public boolean removeDirectory(String path, boolean isAll)

                     throws IOException {

 

              if (!isAll) {

                     return removeDirectory(path);

              }

 

              FTPFile[] ftpFileArr = ftpClient.listFiles(path);

              if (ftpFileArr == null || ftpFileArr.length == 0) {

                     return removeDirectory(path);

              }

              //  

              for (FTPFile ftpFile : ftpFileArr) {

                     String name = ftpFile.getName();

                     if (ftpFile.isDirectory()) {

                            log.info("* [sD]Delete subPath [" + path + "/" + name + "]");

                            if (!ftpFile.getName().equals(".")

                                          && (!ftpFile.getName().equals(".."))) {

                                   removeDirectory(path + "/" + name, true);

                            }

                     } else if (ftpFile.isFile()) {

                            log.info("* [sF]Delete file [" + path + "/" + name + "]");

                            deleteFile(path + "/" + name);

                     } else if (ftpFile.isSymbolicLink()) {

 

                     } else if (ftpFile.isUnknown()) {

 

                     }

              }

              return ftpClient.removeDirectory(path);

       }

 

       /**

        * 查看目录是否存在

        * @param path

        * @return

        * @throws IOException

        */

       public boolean isDirectoryExists(String path) throws IOException {

              boolean flag = false;

              FTPFile[] ftpFileArr = ftpClient.listFiles(path);

              for (FTPFile ftpFile : ftpFileArr) {

                     if (ftpFile.isDirectory()

                                   && ftpFile.getName().equalsIgnoreCase(path)) {

                            flag = true;

                            break;

                     }

              }

              return flag;

       }

 

       /**

        * 得到某个目录下的文件名列表

        * @param path

        * @return

        * @throws IOException

        */

       public List<String> getFileList(String path) throws IOException {

              // listFiles return contains directory and file, it's FTPFile instance

              // listNames() contains directory, so using following to filer

              // directory.

              // String[] fileNameArr = ftpClient.listNames(path);

              FTPFile[] ftpFiles = ftpClient.listFiles(path);

 

              List<String> retList = new ArrayList<String>();

              if (ftpFiles == null || ftpFiles.length == 0) {

                     return retList;

              }

              for (FTPFile ftpFile : ftpFiles) {

                     if (ftpFile.isFile()) {

                            retList.add(ftpFile.getName());

                     }

              }

              return retList;

       }

      

       public boolean deleteFile(String pathName) throws IOException {

              return ftpClient.deleteFile(pathName);

       }

 

       /**

        * 上传文件到FTP服务器，支持断点续传

        * @param local 本地文件名称，绝对路径

        * @param remote 远程文件路径，按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构

        * @return 上传结果

        * @throws IOException

        */

       public UploadStatus upload(String local, String remote) throws IOException {

              // 设置PassiveMode传输

              ftpClient.enterLocalPassiveMode();

              // 设置以二进制流的方式传输

              ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

              ftpClient.setControlEncoding("GBK");

              UploadStatus result;

              // 对远程目录的处理

              String remoteFileName = remote;

              if (remote.contains("/")) {

                     remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);

                     // 创建服务器远程目录结构，创建失败直接返回

                     if (createDirecroty(remote, ftpClient) == UploadStatus.CreateDirectoryFail) {

                            return UploadStatus.CreateDirectoryFail;

                     }

              }

 

              // 检查远程是否存在文件

              FTPFile[] files = ftpClient.listFiles(new String(remoteFileName

                            .getBytes("GBK"), "iso-8859-1"));

              if (files.length == 1) {

                     long remoteSize = files[0].getSize();

                     File f = new File(local);

                     long localSize = f.length();

                     if (remoteSize == localSize) { // 文件存在

                            return UploadStatus.FileExits;

                     } else if (remoteSize > localSize) {

                            return UploadStatus.RemoteFileBiggerThanLocalFile;

                     }

 

                     // 尝试移动文件内读取指针,实现断点续传

                     result = uploadFile(remoteFileName, f, ftpClient, remoteSize);

 

                     // 如果断点续传没有成功，则删除服务器上文件，重新上传

                     if (result == UploadStatus.UploadFromBreakFailed) {

                            if (!ftpClient.deleteFile(remoteFileName)) {

                                   return UploadStatus.DeleteRemoteFaild;

                            }

                            result = uploadFile(remoteFileName, f, ftpClient, 0);

                     }

              } else {

                     result = uploadFile(remoteFileName, new File(local), ftpClient, 0);

              }

              return result;

       }

      

       /**

        * 递归创建远程服务器目录

        * @param remote 远程服务器文件绝对路径

        * @param ftpClient FTPClient对象

        * @return 目录创建是否成功

        * @throws IOException

        */

       public UploadStatus createDirecroty(String remote, FTPClient ftpClient)

                     throws IOException {

              UploadStatus status = UploadStatus.CreateDirectorySuccess;

              String directory = remote.substring(0, remote.lastIndexOf("/") + 1);

              if (!directory.equalsIgnoreCase("/")

                            && !ftpClient.changeWorkingDirectory(new String(directory

                                          .getBytes("GBK"), "iso-8859-1"))) {

                     // 如果远程目录不存在，则递归创建远程服务器目录

                     int start = 0;

                     int end = 0;

                     if (directory.startsWith("/")) {

                            start = 1;

                     } else {

                            start = 0;

                     }

                     end = directory.indexOf("/", start);

                     while (true) {

                            String subDirectory = new String(remote.substring(start, end)

                                          .getBytes("GBK"), "iso-8859-1");

                            if (!ftpClient.changeWorkingDirectory(subDirectory)) {

                                   if (ftpClient.makeDirectory(subDirectory)) {

                                          ftpClient.changeWorkingDirectory(subDirectory);

                                   } else {

                                          log.info("创建目录失败");

                                          return UploadStatus.CreateDirectoryFail;

                                   }

                            }

                            start = end + 1;

                            end = directory.indexOf("/", start);

                            // 检查所有目录是否创建完毕

                            if (end <= start) {

                                   break;

                            }

                     }

              }

              return status;

       }

      

       /**

        * 上传文件到服务器,新上传和断点续传

        * @param remoteFile 远程文件名，在上传之前已经将服务器工作目录做了改变

        * @param localFile 本地文件File句柄，绝对路径

        * @param processStep 需要显示的处理进度步进值

        * @param ftpClient FTPClient引用

        * @return

        * @throws IOException

        */

       public UploadStatus uploadFile(String remoteFile, File localFile,

                     FTPClient ftpClient, long remoteSize) throws IOException {

              UploadStatus status;

              // 显示进度的上传

              System.out.println("localFile.length():"+localFile.length());

              long step = localFile.length() / 100;

              step = step==0?1:step;//文件过小，step可能为0

              long process = 0;

              long localreadbytes = 0L;

              RandomAccessFile raf = new RandomAccessFile(localFile, "r");

              OutputStream out = ftpClient.appendFileStream(new String(remoteFile

                            .getBytes("GBK"), "iso-8859-1"));

              // 断点续传

              if (remoteSize > 0) {

                     ftpClient.setRestartOffset(remoteSize);

                     process = remoteSize / step;

                     raf.seek(remoteSize);

                     localreadbytes = remoteSize;

              }

              byte[] bytes = new byte[1024];

              int c;

              while ((c = raf.read(bytes)) != -1) {

                     out.write(bytes, 0, c);

                     localreadbytes += c;

                     if (localreadbytes / step != process) {

                            process = localreadbytes / step;

                            if (process % 10 == 0){

                                   log.info("上传进度：" + process);

                            }

                     }

              }

              out.flush();

              raf.close();

              out.close();

              boolean result = ftpClient.completePendingCommand();

              if (remoteSize > 0) {

                     status = result ? UploadStatus.UploadFromBreakSuccess

                                   : UploadStatus.UploadFromBreakFailed;

              } else {

                     status = result ? UploadStatus.UploadNewFileSuccess

                                   : UploadStatus.UploadNewFileFailed;

              }

              return status;

       }

 

       public InputStream downFile(String sourceFileName) throws IOException {

              return ftpClient.retrieveFileStream(sourceFileName);

       }

      

       public enum UploadStatus {

              CreateDirectoryFail, // 远程服务器相应目录创建失败

              CreateDirectorySuccess, // 远程服务器闯将目录成功

              UploadNewFileSuccess, // 上传新文件成功

              UploadNewFileFailed, // 上传新文件失败

              FileExits, // 文件已经存在

              RemoteFileBiggerThanLocalFile, // 远程文件大于本地文件

              UploadFromBreakSuccess, // 断点续传成功

              UploadFromBreakFailed, // 断点续传失败

              DeleteRemoteFaild; // 删除远程文件失败

       }

 

       public enum DownloadStatus {

              RemoteFileNotExist, // 远程文件不存在

              DownloadNewSuccess, // 下载文件成功

              DownloadNewFailed, // 下载文件失败

              LocalFileBiggerThanRemoteFile, // 本地文件大于远程文件

              DownloadFromBreakSuccess, // 断点续传成功

              DownloadFromBreakFailed; // 断点续传失败

       }

}

FtpConfig类：
/**
 *
 */
package com.pccw.portlet.publictools;

/**
 * FTP配置类
 * @author WangXianfeng 1:18:45 PM Jul 16, 2011
 */
public class FtpConfig {
    private String server;
    private int port;
    private String username;
    private String password;
    private String path;
    gets  。。sets。。
}

测试类：
import java.util.List;

import com.pccw.portlet.publictools.FtpConfig;
import com.pccw.portlet.publictools.FtpUtil;




/**
 *
 * @author WangXianfeng 1:20:45 PM Jul 16, 2011
 */
public class HelloWorld {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        FtpConfig config = new FtpConfig();
        config.setServer("192.168.0.199");
        config.setPort(21);
        config.setUsername("wxf");
        config.setPassword("wxf");
        config.setPath("bankafile");
        FtpUtil ftp = new FtpUtil();
        ftp.connectServer(config);
        String localFile = "c:\\Seagull.rar";
        ftp.upload(localFile, "sea.rar");
        List<String> files = ftp.getFileList("");
        //ftp.changeDirectory("bankafile");
       
        for(String file:files){
            System.out.println(file);
            String local = "D:\\ct\\199\\temp\\" + file;
            ftp.download(file, local);
        }

    }

}