使用commons-net包写的一个FTP上传下载类，支持断点续传，可上传整个目录

饶桃雨

　　在http://zhouzaibao.iyunv.com/blog/346000基础上进行了修改
　　
　　利用org.apache.commons.net.ftp包实现一个简单的ftp客户端实用类。主要实现一下功能
　　1.支持上传下载。支持断点续传
　　2.支持对于中文目录及中文文件创建的支持。
　　具体请看代码，上面有详细的注释。简化版本请参见http://zhouzaibao.iyunv.com/blog/342766
　　
　　枚举类UploadStatus代码:
　　

public enum DownloadStatus {
REMOTE_FILE_NOEXIST, // 远程文件不存在
LOCAL_BIGGER_REMOTE, // 本地文件大于远程文件
DOWNLOAD_FROM_BREAK_SUCCESS, // 断点下载文件成功
DOWNLOAD_FROM_BREAK_FAILED, // 断点下载文件失败
DOWNLOAD_NEW_SUCCESS, // 全新下载文件成功
DOWNLOAD_NEW_FAILED; // 全新下载文件失败
}
　　
　　枚举类DownloadStatus代码:
　　

public enum UploadStatus {
CREATE_DIRECTORY_FAIL, // 远程服务器相应目录创建失败
CREATE_DIRECTORY_SUCCESS, // 远程服务器闯将目录成功
UPLOAD_NEW_FILE_SUCCESS, // 上传新文件成功
UPLOAD_NEW_FILE_FAILED, // 上传新文件失败
FILE_EXITS, // 文件已经存在
REMOTE_BIGGER_LOCAL, // 远程文件大于本地文件
UPLOAD_FROM_BREAK_SUCCESS, // 断点续传成功
UPLOAD_FROM_BREAK_FAILED, // 断点续传失败
DELETE_REMOTE_FAILD; // 删除远程文件失败
}
　　
　　流及文件操作工具类的代码:
　　


public class FileUtil {
/**
* 文件拷贝
*
* @param insm
* @param outsm
* @throws IOException
*/
public static void copyFile(File srcFile, File destFile) throws IOException {
if (!srcFile.exists()) {
throw new FileNotFoundException(srcFile.getName() + "不存在!");
}
if (!destFile.exists()) {
destFile.createNewFile();
}
InputStream in = new FileInputStream(srcFile);
OutputStream out = new FileOutputStream(destFile);
copyStream(in, out);
}
/**
* 流拷贝，通过对流的操作完成
*
* @param insm
* @param outsm
* @throws IOException
*/
public static void copyStream(InputStream insm, OutputStream outsm)
throws IOException {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(insm);
bos = new BufferedOutputStream(outsm);
byte[] b = new byte[8192];
int readBytes = -1;
while ((readBytes = bis.read(b)) != -1) {
bos.write(b, 0, readBytes);
}
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
if (bis != null)
bis.close();
if (bos != null)
bos.close();
}
}
}

　　
　　核心类FTPOperationProccessor代码:
　　

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 org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import cn.com.servyou.ftpuploadtool.status.DownloadStatus;
import cn.com.servyou.ftpuploadtool.status.UploadStatus;
import cn.com.servyou.ftpuploadtool.util.FileUtil;
/**
* <p>
* Title: FTPOperationProcessor
* </p>
*
* <p>
* Description: FTP操作处理类
* </p>
*
* <p>
* Copyright: Copyright (c) 2010
* </p>
*
* @author servyou
*
* @version 1.0
*/
public class FTPOperationProcessor {
private FTPClient client = new FTPClient();
/** 默认编码 */
public final static String ENCODING = "GBK";
/** FTP传输用的编码 */
public final static String FTP_ENCODING = "ISO-8859-1";
/** 目录前缀 */
public final static String PREFIX = "/";
public FTPOperationProcessor() {
super();
}
/**
* 连接FTP服务器
*
* @param hostname
*            服务器IP，或主机名
* @param port
*            端口号
* @param username
*            用户名
* @param password
*            密码
* @return 连接成功返回true,失败返回false
* @throws IOException
*/
public boolean connect(String hostname, int port, String username,
String password) throws IOException {
int reply;
client.connect(hostname);
System.out.println("Connected to " + hostname + ".");
System.out.println(client.getReplyString());
reply = client.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
client.disconnect();
System.out.println("FTP服务器拒绝连接！");
throw new IOException("FTP服务器拒绝连接！");
} else {
if (client.login(username, password)) {
client.setListHiddenFiles(true);
return true;
}
}
return false;
}
/**
* 用户登出，并关闭连接
*
* @throws IOException
*/
public void disConnect() throws IOException {
if (client.isConnected()) {
client.logout();
client.disconnect();
}
}
/**
* 遍历服务器的某一目录
*
* @param pathname
*            FTP服务器的路径，如/dir1/dir2/
* @throws IOException
*/
public void traverseDirectory(String pathname) throws IOException {
client.changeWorkingDirectory(pathname);
FTPFile[] fileList = client.listFiles(pathname);
traverse(fileList);
}
/**
* 遍历FTP服务器的目录
*
* @param ftpClient
*            FTPClient
* @param fileList
*            文件列表
* @throws IOException
*/
private void traverse(FTPFile[] fileList) throws IOException {
String tempDir = null;
for (FTPFile file : fileList) {
if (file.getName().equals(".") || file.getName().equals("..")) {
continue;
}
if (file.isDirectory()) {
System.out.println("***************** Directory: " + file.getName()
+ "  Start **************");
tempDir = client.printWorkingDirectory();
if (tempDir.matches("^((/\\w+))+$"))
tempDir += "/" + file.getName();
else
tempDir += file.getName();
client.changeWorkingDirectory(new String(tempDir.getBytes(ENCODING),
FTP_ENCODING));
traverse(client.listFiles(tempDir));
// 不是目录，是文件的情况
System.out.println("***************** Directory:" + file.getName()
+ "   End **************\n");
} else {
System.out.println("FileName:" + file.getName() + " FileSize:"
+ file.getSize() / (1024) + "KB" + " CreateTime:"
+ file.getTimestamp().getTime());
}
}
// 遍历完当前目录，就要将工作目录改为当前目录的父目录
client.changeToParentDirectory();
}
/**
* 下载单个文件
*
* @param remote
*            远端文件
* @param local
*            本地文件
* @throws IOException
*/
public DownloadStatus download(String remote, File localFile)
throws IOException {
client.enterLocalPassiveMode();
client.setFileType(FTPClient.BINARY_FILE_TYPE);
DownloadStatus result = null;
// 检查远程文件是否存在
FTPFile[] files = client.listFiles(new String(remote.getBytes(ENCODING),
FTP_ENCODING));
if (files.length != 1) {
System.out.println("远程文件不存在");
return DownloadStatus.REMOTE_FILE_NOEXIST;
}
long lRemoteSize = files[0].getSize();
// 本地存在文件，进行断点下载
if (localFile.exists()) {
long localSize = localFile.length();
// 判断本地文件大小是否大于远程文件大小
if (localSize >= lRemoteSize) {
System.out.println("本地文件大于远程文件，下载中止");
return DownloadStatus.LOCAL_BIGGER_REMOTE;
}
// 进行断点续传，并记录状态
FileOutputStream out = new FileOutputStream(localFile, true);
client.setRestartOffset(localSize);
InputStream in = client.retrieveFileStream(new String(remote
.getBytes(ENCODING), FTP_ENCODING));
FileUtil.copyStream(in, out);
boolean isDo = client.completePendingCommand();
if (isDo) {
result = DownloadStatus.DOWNLOAD_FROM_BREAK_SUCCESS;
} else {
result = DownloadStatus.DOWNLOAD_FROM_BREAK_FAILED;
}
} else {
localFile.createNewFile();
FileOutputStream out = new FileOutputStream(localFile);
InputStream in = client.retrieveFileStream(new String(remote
.getBytes(ENCODING), FTP_ENCODING));
FileUtil.copyStream(in, out);
}
return result;
}
/**
* 上传文件到FTP服务器，支持断点续传
*
* @param local
*            本地文件名称，绝对路径
* @param remote
*            远程文件路径，使用/home/directory1/subdirectory/file.ext
*            按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
* @return 上传结果
* @throws IOException
*/
public UploadStatus upload(String local, String remote) throws IOException {
// 设置PassiveMode传输
client.enterLocalPassiveMode();
// 设置以二进制流的方式传输
client.setFileType(FTPClient.BINARY_FILE_TYPE);
client.setControlEncoding(ENCODING);
UploadStatus result;
// 对远程目录的处理
String remoteFileName = remote;
if (remote.contains("/")) {
remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
// 创建服务器远程目录结构，创建失败直接返回
// 以下两句存在问题??
// if (createDirectory(remote) == UploadStatus.CREATE_DIRECTORY_FAIL) {
// return UploadStatus.CREATE_DIRECTORY_FAIL;
// }
}
// 检查远程是否存在文件
FTPFile[] files = client.listFiles(new String(remoteFileName
.getBytes(ENCODING), FTP_ENCODING));
if (files != null && files.length == 1) {
long remoteSize = files[0].getSize();
File f = new File(local);
long localSize = f.length();
if (remoteSize == localSize) {
return UploadStatus.FILE_EXITS;
} else if (remoteSize > localSize) {
return UploadStatus.REMOTE_BIGGER_LOCAL;
}
// 尝试移动文件内读取指针,实现断点续传
result = uploadFile(remoteFileName, f, remoteSize);
// 如果断点续传没有成功，则删除服务器上文件，重新上传
if (result == UploadStatus.UPLOAD_FROM_BREAK_FAILED) {
if (!client.deleteFile(remoteFileName)) {
return UploadStatus.DELETE_REMOTE_FAILD;
}
result = uploadFile(remoteFileName, f, 0);
}
} else {
result = uploadFile(remoteFileName, new File(local), 0);
}
return result;
}
/**
* 上传单个文件，断点续传功能
*
* @param remote
*            远程文件
* @param localFile
*            本地文件
* @throws IOException
*/
public UploadStatus uploadFile(String remote, File localFile, long remoteSize)
throws IOException {
UploadStatus status = null;
long localreadbytes = 0l;
RandomAccessFile raf = new RandomAccessFile(localFile, "r");
OutputStream out = client.appendFileStream(new String(remote
.getBytes(ENCODING), FTP_ENCODING));
// 断点续传,根据FTP服务器上文件与本地机器上文件的大小比较来判断
if (remoteSize > 0) {
client.setRestartOffset(remoteSize);
raf.seek(remoteSize);
localreadbytes = remoteSize;
}
byte[] bytes = new byte[8096];
int c;
while ((c = raf.read(bytes)) != -1) {
out.write(bytes, 0, c);
localreadbytes += c;
}
if (out != null)
out.flush();
if (raf != null)
raf.close();
if (out != null)
out.close();
boolean result = client.completePendingCommand();
if (remoteSize > 0) {
status = result ? UploadStatus.UPLOAD_FROM_BREAK_SUCCESS
: UploadStatus.UPLOAD_FROM_BREAK_FAILED;
} else {
status = result ? UploadStatus.UPLOAD_NEW_FILE_SUCCESS
: UploadStatus.UPLOAD_NEW_FILE_FAILED;
}
return status;
}
/**
* 创建目录,(远程目录格式必须是/aaa/bbb/ccc/ddd/的形式)
*
* @param remote
*            远程目录路径
* @throws IOException
*/
public UploadStatus createDirectory(String remote) throws IOException {
int start = 0, end = 0;
start = remote.startsWith("/") ? 1 : 0;
end = remote.indexOf("/", start);
for (; start < end;) {
String subDirectory = remote.substring(start, end);
if (!client.changeWorkingDirectory(new String(subDirectory
.getBytes(ENCODING), FTP_ENCODING))) {
// 目录不存在则在服务器端创建目录
if (!client.makeDirectory(new String(subDirectory.getBytes(ENCODING),
FTP_ENCODING))) {
return UploadStatus.CREATE_DIRECTORY_FAIL;
} else {
client.changeWorkingDirectory(new String(subDirectory
.getBytes(ENCODING), FTP_ENCODING));
}
}
start = end + 1;
end = remote.indexOf("/", start);
}
return UploadStatus.CREATE_DIRECTORY_SUCCESS;
}
/**
* 递归遍历本地机器的要上传的目录，遍历的同时，在FTP服务器上创建目录
* （如果在FTP服务器上目录不存在的话），上传文件
*
* @param directory
*            本地目录
* @throws IOException
*/
private void traverseLocalDirectory(File directory) throws IOException {
File[] files = directory.listFiles();
if (files == null || files.length == 0) {
client.changeToParentDirectory();
return;
}
for (File file : files) {
if (file.isDirectory()) {
String directoryName = file.getName();
client.makeDirectory(new String(directoryName.getBytes(ENCODING),
FTP_ENCODING));
client.changeWorkingDirectory(new String(directoryName
.getBytes(ENCODING), FTP_ENCODING));
traverseLocalDirectory(file);
} else {
System.out.println("FileName : " + file.getName());
upload(file.getAbsolutePath(), client.printWorkingDirectory() + "/"
+ file.getName());
}
}
client.changeToParentDirectory();
}
/**
* 上传本地机器的某一目录到FTP服务器的某一路径
*
* @param remoteBasePath
*            FTP服务器的一个路径
* @param localRootDirectoryPath
*            本地机器需要上传的目录路径
* @throws IOException
*/
public UploadStatus uploadDirectory(String remoteBasePath,
String localDirectoryPath) throws IOException {
if (createDirectory(remoteBasePath) == UploadStatus.CREATE_DIRECTORY_FAIL) {
return UploadStatus.CREATE_DIRECTORY_FAIL;
// remoteBasePath FTP服务器上基目录,创建成功的话
} else {
if (client.changeWorkingDirectory(new String(remoteBasePath
.getBytes(ENCODING), FTP_ENCODING))) {
File localDirectory = new File(localDirectoryPath);
traverseLocalDirectory(localDirectory);
return UploadStatus.CREATE_DIRECTORY_SUCCESS;
} else {
return UploadStatus.CREATE_DIRECTORY_FAIL;
}
}
}
}
　　
　　
　　使用方法简介：
　　
　　1.需要创建目录：
　　

FTPOperationProcessor processor = new FTPOperationProcessor();
try {
boolean flag = processor.connect("192.168.30.190", 21, "anonymous", "");
if (flag == false) {
System.out.println("连接服务器失败");
processor.disConnect();
} else {
processor.createDirectory("/中1/中文的/信息/还是中文的/目录是中文的/xx林寺xxa11/");
}
} catch (IOException e) {
e.printStackTrace();
}
　　
　　则可在FTP服务器的根目录生成目录

/中1/中文的/信息/还是中文的/目录是中文的/xx林寺xxa11
　　
　　2.上传整个目录到FTP服务器的某一目录:
　　

processor.uploadDirectory("/Jay Chang/Study/Example/", "D:\\My Documents\\Study\\Example\\");
　　
　　3.下载某一文件到本地:
　　
　　

processor.download("/backup/sys.gho", "f:\\sys.gho");