增强的Java FTP工具----扩展免费版的edtftpj

edtftpjs是国外的一个公司所做。有免费版、企业版之分，还有不用语言的版本。商业版的功能强大，是非常优秀的FTP组建。免费的凑合能用，但是功能相对简单，实现粗糙。使用起来问题多多。

为了让免费版的edtftpj工具也具有商业版的一些强劲功能，本人利用业余时间做了扩展，经过测试可以正常使用。其中的算法也许不是最好，也欢迎高人提供更好的算法。

扩展的主要围绕最常用的功能来进行：

1、增强上传下载功能，使其支持文件和文件夹，如果是文件夹，上传下载保持源的目录结构。

2、增强判断文件、文件夹是否存在的方法，使得ftp的文件操作如本地文件File操作一样容易。

3、添加判断是否为文件、是否为目录的方法。

4、增加FTP配置管理的工具实现，这个不是主要的，就不贴了。

环境：

Java SE 1.5

edtftpjs-2.03 free版

实现思路：

继承FTP客户端核心的类com.enterprisedt.net.ftp.FileTransferClient，添加一些更为通用的有效的方法。本身考虑到覆盖，感觉不妥。就扩展吧！

实现代码：

import com.enterprisedt.net.ftp.FTPException;
import com.enterprisedt.net.ftp.FileTransferClient;
import com.enterprisedt.net.ftp.WriteMode;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import zzvcom.cms.ccm.commons.StringTookit;

import java.io.File;
import java.io.IOException;
import java.text.ParseException;

/**
* FTP增强工具
*
* @author leizhimin 2008-12-13 16:13:01
*/
public class UltraFTPClient extends FileTransferClient {
private static Log log = LogFactory.getLog(UltraFTPClient.class);

public UltraFTPClient() {
}

/**
* 下载文件（夹）,在本地保持FTP上的目录结构
*
* @param localFolderPath 本地存放文件夹
* @param remotePath远程文件（夹）路径
* @param remoteSubPath 远程文件存放相对根目录
* @throws FTPException
* @throws IOException
*/
public void ftpDownload(final String localFolderPath, final String remotePath, String remoteSubPath) throws FTPException, IOException, ParseException {
if (isDir(remoteSubPath)) {
String localPath = localFolderPath + StringTookit.getRelativeRootPath(remoteSubPath, StringTookit.getParentPath(remotePath));
if (!new File(localPath).exists())
new File(localPath).mkdirs();
String[] x = directoryNameList(remoteSubPath, false);
for (String fname : x) {
String rmFilePath = StringTookit.formatPath(remoteSubPath + "/" + fname);
if (isDir(rmFilePath)) {
ftpDownload(localFolderPath, remotePath, rmFilePath);
} else {
String _localPath = localFolderPath + "/" +
StringTookit.getRelativeRootPath(rmFilePath, StringTookit.getParentPath(remotePath));
downloadFile(_localPath, rmFilePath, WriteMode.OVERWRITE);
}
}
} else if (isFile(remotePath)) {
String localPath = localFolderPath + StringTookit.getRelativeRootPath(remoteSubPath, remotePath);
downloadFile(localPath, remoteSubPath, WriteMode.OVERWRITE);
} else {
log.error("所下载的文件或文件夹不存在，请检查！");
}
log.info("FTP下载从服务器上的" + remoteSubPath + "下载到本地" + localFolderPath + "结束！");
}

/**
* 上传文件（夹）,在FTP上保持本地的目录结构
*
* @param localFile 本地文件
* @param localFilePath 本地文件的路径
* @param remoteSubPath 远程文件存放相对根目录
* @throws IOException
* @throws FTPException
*/
public void ftpUpload(File localFile, final String localFilePath, final String remoteSubPath) throws IOException, FTPException {
if (localFile.isDirectory()) {
for (File file : localFile.listFiles()) {
if (file.isDirectory()) {
String remotePath = StringTookit.formatPath(remoteSubPath) + StringTookit.getRelativeRootPath(file.getPath(), StringTookit.getParentPath(localFilePath));
log.info(remotePath);
if (!isExist(remotePath)) createDirectory(remotePath);
ftpUpload(file, localFilePath, remoteSubPath);
} else {
String remotePath = StringTookit.formatPath(remoteSubPath) +
StringTookit.getRelativeRootPath(file.getPath(), StringTookit.getParentPath(localFilePath));
uploadFile(file.getPath(), remotePath, WriteMode.APPEND);
}
}
} else if (localFile.isFile()) {
String remotePath = StringTookit.formatPath(remoteSubPath) +
StringTookit.getRelativeRootPath(localFile.getPath(), StringTookit.getParentPath(localFilePath));
if (!isExist(StringTookit.getParentPath(remotePath)))
createDirectory(StringTookit.getParentPath(remotePath));
System.out.println(remotePath);
uploadFile(localFile.getPath(), remotePath, WriteMode.APPEND);
}
log.info("FTP上传" + localFile.getPath() + "到" + remoteSubPath + "目录下结束！");
}

/**
* @param remotePath 远程文件（夹）路径
* @return 远程的文件（夹）资源是否存在
*/
public boolean isExist(String remotePath) {
boolean flag = true;
try {
directoryList(remotePath);
} catch (Exception e) {
flag = false;
}
return flag;
}

/**
* @param remotePath 远程文件（夹）路径
* @return 当远程资源存在且为文件时返回ture，否则返回false
*/

public boolean isFile(String remotePath) {
try {
int size = directoryList(remotePath).length;
if (size >= 0) {
if (exists(remotePath)) {
return true;
}
}
} catch (Exception e) {
}
return false;
}

/**
* @param remotePath 远程文件（夹）路径
* @return 当远程资源存在且为文件夹时返回ture，否则返回false
*/
public boolean isDir(String remotePath) {
try {
int size = directoryList(remotePath).length;
if (size >= 0) {
if (exists(remotePath)) {
return false;
} else {
return true;
}
}
} catch (Exception e) {
}
return false;
}
}

为了支持目录运算与不同操作系统的兼容性，写了一个文件路径处理工具。有了这一整套的工具后，上面的工作才能更清晰的去做。

/**
* 字符串工具箱
*
* @author leizhimin 2008-12-15 22:40:12
*/
public final class StringTookit {
/**
* 将一个字符串的首字母改为大写或者小写
*
* @param srcString 源字符串
* @param flag大小写标识，ture小写，false大些
* @return 改写后的新字符串
*/
public static String toLowerCaseInitial(String srcString, boolean flag) {
StringBuilder sb = new StringBuilder();
if (flag) {
sb.append(Character.toLowerCase(srcString.charAt(0)));
} else {
sb.append(Character.toUpperCase(srcString.charAt(0)));
}
sb.append(srcString.substring(1));
return sb.toString();
}

/**
* 将一个字符串按照句点（.）分隔，返回最后一段
*
* @param clazzName 源字符串
* @return 句点（.）分隔后的最后一段字符串
*/
public static String getLastName(String clazzName) {
String[] ls = clazzName.split("//.");
return ls[ls.length - 1];
}

/**
* 格式化文件路径，将其中不规范的分隔转换为标准的分隔符,并且去掉末尾的"/"符号。
*
* @param path 文件路径
* @return 格式化后的文件路径
*/
public static String formatPath(String path) {
String reg = "////+|/+";
String temp = path.trim().replaceAll(reg, "/");
if (temp.endsWith("/")) {
return temp.substring(0, temp.length() - 1);
}
return temp;
}

/**
* 获取文件父路径
*
* @param path 文件路径
* @return 文件父路径
*/
public static String getParentPath(String path) {
return new File(path).getParent();
}

/**
* 获取相对路径
*
* @param fullPath 全路径
* @param rootPath 根路径
* @return 相对根路径的相对路径
*/
public static String getRelativeRootPath(String fullPath, String rootPath) {
String relativeRootPath = null;
String _fullPath = formatPath(fullPath);
String _rootPath = formatPath(rootPath);

if (_fullPath.startsWith(_rootPath)) {
relativeRootPath = fullPath.substring(_rootPath.length());
} else {
throw new RuntimeException("要处理的两个字符串没有包含关系，处理失败！");
}
if (relativeRootPath == null) return null;
else
return formatPath(relativeRootPath);
}
}

FTP客户端配置工具：

一个好的工具，配置也很讲究，这里也不例外，经过精心处理，FTP服务器配置变得轻松自如：

import com.enterprisedt.net.ftp.FTPConnectMode;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import zzvcom.cms.ccm.commons.JavaXmlTookit;
import zzvcom.cms.ccm.commons.SysParamsTookit;

/**
* FTP配置
*
* @author leizhimin 2008-12-5 22:49:39
*/
public class FtpServerConfigration {
private static final Log log = LogFactory.getLog(FtpServerConfigration.class);
private String username;//用户名
private String password;//密码
private String ip;//ip
private Integer port; //端口
private Integer timeout;//超时时间
private Integer buffersize; //缓存大小
private Integer notifytime; //通知时间
private String connectMode; //连接模式
private String encoding;//编码方式

public FtpServerConfigration(String username, String password, String ip, Integer port) {
this.username = username;
this.password = password;
this.ip = ip;
this.port = port;
this.timeout = Integer.valueOf(SysParamsTookit.getProperty("timeout", "36000000"));
this.buffersize = Integer.valueOf(SysParamsTookit.getProperty("buffersize", "2048000"));
this.notifytime = Integer.valueOf(SysParamsTookit.getProperty("notifytime", "5000"));
this.connectMode = SysParamsTookit.getProperty("connectMode", "PASV");
this.encoding = SysParamsTookit.getProperty("encoding", "GBK");
}

public FtpServerConfigration(String ftpConfigXml) {
FtpServerConfigration config = (FtpServerConfigration) JavaXmlTookit.xml2Java(ftpConfigXml, FtpServerConfigration.class);
if (StringUtils.isBlank(config.getUsername())
|| StringUtils.isBlank(config.getPassword())
|| StringUtils.isBlank(config.getIp())
|| config.getPort() == null) {
log.error("FTP最基本的配置属性（username、password、ip、port）不能为空，请检查！");
} else {
this.username = config.getUsername();
this.password = config.getPassword();
this.ip = config.getIp();
this.port = config.getPort();
}
if (config.getTimeout() == null)
this.timeout = Integer.valueOf(SysParamsTookit.getProperty("timeout", "36000000"));
if (config.getBuffersize() == null)
this.buffersize = Integer.valueOf(SysParamsTookit.getProperty("buffersize", "2048000"));
if (config.getNotifytime() == null)
this.notifytime = Integer.valueOf(SysParamsTookit.getProperty("notifytime", "5000"));
if (StringUtils.isBlank(config.getConnectMode()))
this.connectMode = SysParamsTookit.getProperty("connectMode", "PASV");
if (StringUtils.isBlank(config.getEncoding()))
this.encoding = SysParamsTookit.getProperty("encoding", "GBK");
}

/**
* 获取当前FTP连接配置
*
* @return 当前FTP连接配置
*/
public FtpServerConfigration getConfigration() {
return this;
}

/**
* 构建FTP客户端连接，并进行连接
*
* @return FTP客户端连接
* @throws Exception 当构建客户端失败时抛出
*/
public UltraFTPClient buildFtpClient() throws Exception {
UltraFTPClient client = new UltraFTPClient();
try {
client.setUserName(username);
client.setPassword(password);
client.setRemoteHost(ip);
client.setRemotePort(port);
client.setTimeout(timeout);
client.getAdvancedSettings().setTransferBufferSize(buffersize);
client.getAdvancedSettings().setTransferNotifyInterval(notifytime);
client.getAdvancedSettings().setControlEncoding(encoding);
//client.setEventListener(new UploadListener(client));//设置事件监听器
if (connectMode.equalsIgnoreCase("ACTIVE")) {
client.getAdvancedFTPSettings().setConnectMode(FTPConnectMode.ACTIVE); //设置为被动模式
} else if (connectMode.equalsIgnoreCase("PASV")) {
client.getAdvancedFTPSettings().setConnectMode(FTPConnectMode.PASV); //设置为被动模式
} else {
log.error("标识为" + connectMode + "的FTP连接模式配置错误，连接模式仅有两种ACTIVE和PASV，请检查！");
}
client.connect();
log.info("FTP连接成功！详细信息(远程主机：" + ip + "，用户名：" + username + ")");
} catch (Exception e) {
log.info("FTP创建连接发生异常！", e);
throw e;
}
return client;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getIp() {
return ip;
}

public void setIp(String ip) {
this.ip = ip;
}

public Integer getPort() {
return port;
}

public void setPort(Integer port) {
this.port = port;
}

public Integer getTimeout() {
return timeout;
}

public void setTimeout(Integer timeout) {
this.timeout = timeout;
}

public Integer getBuffersize() {
return buffersize;
}

public void setBuffersize(Integer buffersize) {
this.buffersize = buffersize;
}

public Integer getNotifytime() {
return notifytime;
}

public void setNotifytime(Integer notifytime) {
this.notifytime = notifytime;
}

public String getConnectMode() {
return connectMode;
}

public void setConnectMode(String connectMode) {
this.connectMode = connectMode;
}

public String getEncoding() {
return encoding;
}

public void setEncoding(String encoding) {
this.encoding = encoding;
}
}

系统默认的FtP参数配置：

### FTP默认配置参数 ###
# FTP连接模式：ACTIVE,PASV为两种连接模式
#port=21
ftp.timeout=360000
ftp.buffersize=20480
ftp.notifytime=5000
ftp.connectMode=PASV
ftp.encoding=GBK

进行测试：

这里只给出测试大概过程：

1、创建一个FTP配置对象，并从FTP配置对象构建一个增强的FTP客户端对象。

UltraFTPClient client = new FtpServerConfigration("testuser", "123456", "192.168.0.2", 21).buildFtpClient();

2、根据有了客户端后，就可以调用增强的和原有的任何方法，来完成你想要的FTP操作。

3、操作完成后关闭FTP连接。

client.disconnect();

遗留问题：

FTP的写模式在下载的时候无法指定，指定为WriteMode.APPEND（追加）是最理想的，但是现在无法做到，只要设置就出错。也许是因为我服务器配置的问题，原因不明。