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);
}
}
}
Apache common FTP
精选 转载
提问和评论都可以，用心的回复会被更多人看到
评论
发布评论
相关文章
-
Apache Common Id
Apache Common Id
ID ide sed apache -
lab-bill-common-ftp-davidey
lab-bill-common-ftp-davidey
ftp common lab bill -
Apache -Common-lang包使用
1、Common-lang的下载点击打开链接 2、方法： ArrayUtils – 用于对数
字符串 数组 java apache 不区分大小写 -
Apache Common-Lang ToStringBuilder分析
如何使用apache common lang的ToStringBuilder实现java对象的toString方法；apache common lang的ToStringBuilder的原理
java apache common lang ToStringBuilder
