|
增强的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（追加）是最理想的，但是现在无法做到，只要设置就出错。也许是因为我服务器配置的问题，原因不明。
如果您解决了遗留问题，或者发现了新的问题，也请留言告诉我。
题外话：
下一步本人将利用业余时间使用Apache的Commons Net提供的基础API来实现这个FTP客户端。
一个人的精力和能力都是有限的，希望这个FTP客户端将来能成为一个颇受欢迎的开源组件，任何人都可以轻松使用其构建自己的FTP应用。
|
