从ftp根据子目录名（按日期+时间）更新文件（原创）

情景是这样的：每天会发布到ftp服务器上以当天日期加时间的目录，下面存有要插入数据库的文件， 定时任务里 要去判断 ftp上是否有需要更新的数据文件 有则从ftp下载到本地 并把本地旧文件删除

这也许很简单，但是是我自己一个单词一个的打过来的，只想记录一下。
package com.ce.ftp;

import it.sauronsoftware.ftp4j.FTPAbortedException;
import it.sauronsoftware.ftp4j.FTPClient;
import it.sauronsoftware.ftp4j.FTPDataTransferException;
import it.sauronsoftware.ftp4j.FTPException;
import it.sauronsoftware.ftp4j.FTPFile;
import it.sauronsoftware.ftp4j.FTPIllegalReplyException;
import it.sauronsoftware.ftp4j.FTPListParseException;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import com.ce.util.CommonStringDateUtil;
import com.ce.util.PropertiesUtil;

/**
*
* @author faithlee
*
*/
public class FtpTool {

private static FTPClient client = new FTPClient();

/**
* 连接且登录到特定的FTP服务器文件夹
*
* @return
* @throws FTPException
* @throws FTPIllegalReplyException
* @throws IOException
* @throws IllegalStateException
*/
public boolean connectToServer(PropertiesUtil pro, String filename)
throws IllegalStateException, IOException,
FTPIllegalReplyException, FTPException {


String server = pro.getValue(filename, "ftp.ip");
String user = pro.getValue(filename, "ftp.user");
String password = pro.getValue(filename, "ftp.password");
String path = pro.getValue(filename, "ftp.path");

client.connect(server);
client.login(user, password);
System.out.println("连接ftp服务器成功");

client.changeDirectory(path);

if (client.isCompressionSupported()) {
client.setCompressionEnabled(true);
}
return true;
}

/**
* 判断是否有新的数据文件下载
* @param path
* @param localpath
* @param date
* @param remoteDirMap
* @param localDirMap
* @return
* @throws IllegalStateException
* @throws IOException
* @throws FTPIllegalReplyException
* @throws FTPException
* @throws FTPDataTransferException
* @throws FTPAbortedException
* @throws FTPListParseException
*/
public boolean doUpdate(String ftppath, String localpath, String date)
throws IllegalStateException, IOException,
FTPIllegalReplyException, FTPException, FTPDataTransferException,
FTPAbortedException, FTPListParseException {
Boolean bl = false;
Map<String, FileObject> remoteFileMap = new HashMap<String, FileObject>();
Map<String,String> localDirMap = new HashMap<String,String>();
Map<String,String> remoteDirMap = new HashMap<String,String>();

remoteDirMap = getRemoteDir();
localDirMap = getLocalDir(localpath);

if (!remoteDirMap.isEmpty() && localDirMap.isEmpty()) {
System.out.println("本地为空，需要导入数据");
System.out.println("下载需要更新的数据文件...");
Set<Entry<String, String>> fileEntrySet = remoteDirMap.entrySet();
String dirname = "";
int n = 1;
for (Entry<String, String> entry : fileEntrySet) {

dirname = entry.getValue();
System.out.println("下载"+dirname+"的数据");
if (n == 1) {
client.changeDirectory(dirname);
} else {
client.changeDirectoryUp();
client.changeDirectory(dirname);
}
remoteFileMap = getRemotefiles();
String localdir = localpath + dirname;
File f = new File(localdir);
if (!f.exists()) {
f.mkdirs();
}

for (String filename : remoteFileMap.keySet()) {

client.download(filename, new File(localdir + "/"
+ filename));
}
n++;
}
System.out.println("下载完成");
bl = true;
} else {

if (remoteDirMap.containsKey(date)
&& !localDirMap.containsKey(remoteDirMap.get(date))) {
System.out.println("有新数据需要导入");

for(String localdirpath : localDirMap.values()){
System.gc();
deleteDirectory(localdirpath);
}

System.out.println("删除成功");
String dir = remoteDirMap.get(date);
String remoteDir = ftppath + dir;
client.changeDirectory(remoteDir);
remoteFileMap = getRemotefiles();
String localdir = localpath + dir;
File f = new File(localdir);
if (!f.exists()) {
f.mkdirs();
}
System.out.println("下载需要更新的数据文件...");
System.out.println("下载"+dir+"的数据");

for (String filename : remoteFileMap.keySet()) {
// System.out.println(filename);

client.download(filename, new File(localdir + "/"
+ filename));
}
System.out.println("下载文件完成");
bl = true;

} else {
System.out.println("没有新的数据文件需要更新");
bl = false;
}

}
return bl;
}

/**
* 获取远程文件信息
* @return
* @throws IllegalStateException
* @throws IOException
* @throws FTPIllegalReplyException
* @throws FTPException
* @throws FTPDataTransferException
* @throws FTPAbortedException
* @throws FTPListParseException
*/
public Map<String, FileObject> getRemotefiles()
throws IllegalStateException, IOException,
FTPIllegalReplyException, FTPException, FTPDataTransferException,
FTPAbortedException, FTPListParseException {
FTPFile[] remotefiles = client.list();
Map<String, FileObject> rtn = new HashMap<String, FileObject>();
for (FTPFile file : remotefiles) {
if (".".equals(file.getName()) || "..".equals(file.getName())) {
continue;
}
FileObject fo = new FileObject();
fo.filename = file.getName();
fo.lasttime = CommonStringDateUtil.format(file.getModifiedDate());
rtn.put(fo.filename, fo);
}
return rtn;
}

/**
* 获取远程目录信息
* @return
* @throws IllegalStateException
* @throws IOException
* @throws FTPIllegalReplyException
* @throws FTPException
* @throws FTPDataTransferException
* @throws FTPAbortedException
* @throws FTPListParseException
*/
public Map<String, String> getRemoteDir() throws IllegalStateException,
IOException, FTPIllegalReplyException, FTPException,
FTPDataTransferException, FTPAbortedException,
FTPListParseException {
Map<String, String> remoteDirName = new HashMap<String, String>();

FTPFile[] list = client.list();

for (int i = 0; i < list.length; i++) {
FTPFile file = list[i];
if (file.getType() == FTPFile.TYPE_DIRECTORY) {
String name = list[i].getName();

String dirDate = name.substring(0, name.length() - 2);
remoteDirName.put(dirDate, name);
}
}
return remoteDirName;
}
/**
* 获取本地目录信息
* @param localpath
* @return
*/
public Map<String, String> getLocalDir(String localpath) {

Map<String, String> localDirName = new HashMap<String, String>();
File f = new File(localpath);
if (!f.exists()) {
System.out.println("目录不存在，创建目录");
f.mkdirs();
}
File[] ff = f.listFiles();

for (int i = 0; i < ff.length; i++) {
if (ff[i].isDirectory()) {
String name = ff[i].getName();
String path = ff[i].getPath();
localDirName.put(name, path);
}
}
return localDirName;
}

/**
* 删除目录
* @param localpath
*/
private void deleteDirectory(String path){
File f = new File(path);
if(!f.exists()){
System.out.println("not exists");
return;
}
if(f.delete()){
System.out.println("delete directory : "+f.getAbsolutePath());
}else{
File[] fs = f.listFiles();
for(int i=0;i<fs.length;i++){
if(fs[i].isDirectory()){
if(!fs[i].delete())deleteDirectory(fs[i].getAbsolutePath());
else System.out.println("刪除目录 directory : "+fs[i].getAbsolutePath());
}else{
fs[i].delete();

}
}
f.delete();

}
System.out.println("删除完成");
}

public void close() throws IllegalStateException, IOException,
FTPIllegalReplyException, FTPException {

client.disconnect(true);

}

}

class FileObject {
String filename;
String lasttime;

@Override
public String toString() {
return filename + "|" + lasttime;
}
}