/**
* FTPClientTemplate.java
*/
package com.yinzhijie.ebill.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketException;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.log4j.Logger;
public class FTPClientTemplate {
private Logger logger = Logger.getLogger(this.getClass().getName());
/** logger */
protected final Logger log = Logger.getLogger(getClass());
private String host;
private int port;
private String username;
private String password;
private boolean binaryTransfer = true;
private boolean passiveMode = true;
private String encoding = "UTF-8";
private int clientTimeout = 3000;
private boolean flag=true;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
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 boolean isBinaryTransfer() {
return binaryTransfer;
}
public void setBinaryTransfer(boolean binaryTransfer) {
this.binaryTransfer = binaryTransfer;
}
public boolean isPassiveMode() {
return passiveMode;
}
public void setPassiveMode(boolean passiveMode) {
this.passiveMode = passiveMode;
}
public String getEncoding() {
return encoding;
}
public void setEncoding(String encoding) {
this.encoding = encoding;
}
public int getClientTimeout() {
return clientTimeout;
}
public void setClientTimeout(int clientTimeout) {
this.clientTimeout = clientTimeout;
}
//---------------------------------------------------------------------
// private method
//---------------------------------------------------------------------
/**
* 返回一个FTPClient实例
*
* @throws FTPClientException
*/
private FTPClient getFTPClient() throws FTPClientException {
FTPClient ftpClient = new FTPClient(); //构造一个FtpClient实例
ftpClient.setControlEncoding(encoding); //设置字符集
connect(ftpClient); //连接到ftp服务器
logger.info("ftp连接成功");
//设置为passive模式
if (passiveMode) {
ftpClient.enterLocalPassiveMode();
}
setFileType(ftpClient); //设置文件传输类型
try {
ftpClient.setSoTimeout(clientTimeout);
} catch (SocketException e) {
throw new FTPClientException("Set timeout error.", e);
}
return ftpClient;
}
/**
* 设置文件传输类型
*
* @throws FTPClientException
* @throws IOException
*/
private void setFileType(FTPClient ftpClient) throws FTPClientException {
try {
if (binaryTransfer) {
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
} else {
ftpClient.setFileType(FTPClient.ASCII_FILE_TYPE);
}
} catch (IOException e) {
throw new FTPClientException("Could not to set file type.", e);
}
}
/**
* 连接到ftp服务器
*
* @param ftpClient
* @return 连接成功返回true，否则返回false
* @throws FTPClientException
*/
public boolean connect(FTPClient ftpClient) throws FTPClientException {
try {
ftpClient.connect(host, port);
// 连接后检测返回码来校验连接是否成功
int reply = ftpClient.getReplyCode();
if (FTPReply.isPositiveCompletion(reply)) {
//登陆到ftp服务器
if (ftpClient.login(username, password)) {
setFileType(ftpClient);
return true;
}
} else {
ftpClient.disconnect();
throw new FTPClientException("FTP server refused connection.");
}
} catch (IOException e) {
if (ftpClient.isConnected()) {
try {
ftpClient.disconnect(); //断开连接
} catch (IOException e1) {
throw new FTPClientException("Could not disconnect from server.", e);
}
}
throw new FTPClientException("Could not connect to server.", e);
}
return false;
}
/**
* 断开ftp连接
*
* @throws FTPClientException
*/
private void disconnect(FTPClient ftpClient) throws FTPClientException {
try {
ftpClient.logout();
if (ftpClient.isConnected()) {
ftpClient.disconnect();
}
} catch (IOException e) {
throw new FTPClientException("Could not disconnect from server.", e);
}
}
//---------------------------------------------------------------------
// public method
//---------------------------------------------------------------------
/**
* 上传一个本地文件到远程指定文件
*
* @param serverFile 服务器端文件名(包括完整路径)
* @param localFile 本地文件名(包括完整路径)
* @return 成功时，返回true，失败返回false
* @throws FTPClientException
*/
public boolean put(String serverFile, String localFile) throws FTPClientException {
return put(serverFile, localFile, false);
}
/**
* 上传一个本地文件到远程指定文件
*
* @param serverFile 服务器端文件名(包括完整路径)
* @param localFile 本地文件名(包括完整路径)
* @param delFile 成功后是否删除文件
* @return 成功时，返回true，失败返回false
* @throws FTPClientException
*/
public boolean put(String serverFile, String localFile, boolean delFile) throws FTPClientException {
FTPClient ftpClient = null;
InputStream input = null;
try {
ftpClient = getFTPClient();
// 处理传输
input = new FileInputStream(localFile);
ftpClient.storeFile(serverFile, input);
log.debug("put " + localFile);
input.close();
if (delFile) {
(new File(localFile)).delete();
}
log.debug("delete " + localFile);
return true;
} catch (FileNotFoundException e) {
throw new FTPClientException("local file not found.", e);
} catch (IOException e) {
throw new FTPClientException("Could not put file to server.", e);
} finally {
try {
if (input != null) {
input.close();
}
} catch (Exception e) {
throw new FTPClientException("Couldn't close FileInputStream.", e);
}
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
}
/**
* 下载一个远程文件到本地的指定文件
*
* @param serverFile 服务器端文件名(包括完整路径)
* @param localFile 本地文件名(包括完整路径)
* @return 成功时，返回true，失败返回false
* @throws FTPClientException
*/
public boolean get(String serverFile, String localFile) throws FTPClientException {
return get(serverFile, localFile, false);
}
/**
* 下载一个远程文件到本地的指定文件
*
* @param serverFile 服务器端文件名(包括完整路径)
* @param localFile 本地文件名(包括完整路径)
* @return 成功时，返回true，失败返回false
* @throws FTPClientException
*/
public boolean get(String serverFile, String localFile, boolean delFile) throws FTPClientException {
OutputStream output = null;
try {
output = new FileOutputStream(localFile);
return get(serverFile, output, delFile);
} catch (FileNotFoundException e) {
throw new FTPClientException("local file not found.", e);
} finally {
try {
if (output != null) {
output.close();
}
} catch (IOException e) {
throw new FTPClientException("Couldn't close FileOutputStream.", e);
}
}
}
/**
* 下载一个远程文件到指定的流
* 处理完后记得关闭流
*
* @param serverFile
* @param output
* @return
* @throws FTPClientException
*/
public boolean get(String serverFile, OutputStream output) throws FTPClientException {
return get(serverFile, output, false);
}
/**
* 下载一个远程文件到指定的流
* 处理完后记得关闭流
*
* @param serverFile
* @param output
* @param delFile
* @return
* @throws FTPClientException
*/
public boolean get(String serverFile, OutputStream output, boolean delFile) throws FTPClientException {
FTPClient ftpClient = null;
try {
ftpClient = getFTPClient();
// 处理传输
ftpClient.retrieveFile(serverFile, output);
if (delFile) { // 删除远程文件
ftpClient.deleteFile(serverFile);
}
return true;
} catch (IOException e) {
throw new FTPClientException("Couldn't get file from server.", e);
} finally {
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
}
/**
* 从ftp服务器上删除一个文件
*
* @param delFile
* @return
* @throws FTPClientException
*/
public boolean delete(String delFile) throws FTPClientException {
FTPClient ftpClient = null;
try {
ftpClient = getFTPClient();
ftpClient.deleteFile(delFile);
return true;
} catch (IOException e) {
throw new FTPClientException("Couldn't delete file from server.", e);
} finally {
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
}
/**
* 批量删除
*
* @param delFiles
* @return
* @throws FTPClientException
*/
public boolean delete(String[] delFiles) throws FTPClientException {
FTPClient ftpClient = null;
try {
ftpClient = getFTPClient();
for (String s : delFiles) {
ftpClient.deleteFile(s);
}
return true;
} catch (IOException e) {
throw new FTPClientException("Couldn't delete file from server.", e);
} finally {
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
}
/**
* 列出远程默认目录下所有的文件
*
* @return 远程默认目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组
* @throws FTPClientException
*/
public String[] listNames() throws FTPClientException {
return listNames(null);
}
/**
* 列出远程目录下所有的文件
*
* @param remotePath 远程目录名
* @return 远程目录下所有文件名的列表，目录不存在或者目录下没有文件时返回0长度的数组
* @throws FTPClientException
*/
public String[] listNames(String remotePath) throws FTPClientException {
FTPClient ftpClient = null;
try {
ftpClient = getFTPClient();
String[] listNames = ftpClient.listNames(remotePath);
return listNames;
} catch (IOException e) {
throw new FTPClientException("列出远程目录下所有的文件时出现异常", e);
} finally {
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
}
public boolean isExist(String remoteFilePath)throws FTPClientException{
FTPClient ftpClient = null;
try{
ftpClient = getFTPClient();
File file=new File(remoteFilePath);
String remotePath=remoteFilePath.substring(0,(remoteFilePath.indexOf(file.getName())-1));
String[] listNames = ftpClient.listNames(remotePath);
System.out.println(remoteFilePath);
for(int i=0;i<listNames.length;i++){
if(remoteFilePath.equals(listNames[i])){
flag=true;
System.out.println("文件:"+file.getName()+"已经存在了");
break;
}else {
flag=false;
}
}
} catch (IOException e) {
throw new FTPClientException("查询文件是否存在文件时出现异常", e);
} finally {
if (ftpClient != null) {
disconnect(ftpClient); //断开连接
}
}
return flag;
}
public static void main(String[] args) throws FTPClientException {
FTPClientTemplate ftp = new FTPClientTemplate();
ftp.setHost("192.1.1.1");
ftp.setPort(21);
ftp.setUsername("ftp");
ftp.setPassword("ftp");
ftp.setBinaryTransfer(true);
ftp.setPassiveMode(true);
ftp.setEncoding("utf-8");
String serverFile="/data/20110101/test.txt";
String localFile="E:/xxxxxx.txt";
//
System.out.println(ftp.isExist("/ftpdata/OUT_HX/20111231dc_sv_acct_link.txt"));
// System.out.println("远程目录:"+ftp.listNames("/ftpdata/OUT_HX"));
//
// System.out.println(ftp.get(serverFile, localFile));
// String serverFilePath="/ftpdata/OUT_HX/20111231dc_sv_acct_link.txt";
// File file=new File(serverFilePath);
// System.out.println(file.getName());
// System.out.println(serverFilePath.indexOf("20111231dc_sv_acct_link.txt"));
// System.out.println(serverFilePath.substring(0, 15));
// try {
// System.out.println(file.getCanonicalPath());
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println(file.getAbsolutePath());
// System.out.println(serverFilePath.indexOf("/", 3));
}
}
