Java的FTP工具类 FTPUtils.java

package com.lbs.lrs.common.utils;


import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;


import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.net.PrintCommandListener;
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;


public class FTPUtils {
private FTPClient ftpClient = new FTPClient();


/**
* 对象构造 设置将过程中使用到的命令输出到控制台
*/
public FTPUtils() {
this.ftpClient.addProtocolCommandListener(new PrintCommandListener(
new PrintWriter(System.out)));
}


/**
* 
* 用于连接到FTP服务器
* 
* @param hostname
*            主机名
* 
* @param port
*            端口
* 
* @param username
*            用户名
* 
* @param password
*            密码
* 
* @return 是否连接成功
* 
* @throws IOException
*/


public boolean connect() throws IOException {
//String hostname="10.202.71.162"; 
String hostname="10.202.71.164"; 
int port=21;
String username="administrator";
String password="admin123";
/* 
String hostname="192.168.1.25"; 
int port=21;
String username="admin";
String password="yjb666";
*/ 
ftpClient.connect(hostname, port);
if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
if (ftpClient.login(username, password)) {
System.out.println("success");
return true;
}
}
disconnect();
return false;
}


/**
* 删除远程FTP文件
* 
* @param remote
*            远程文件路径
* @return
* @throws IOException
*/
public FTPStatus delete(String remote) throws IOException {
ftpClient.enterLocalPassiveMode();
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
FTPStatus result = null;
FTPFile[] files = ftpClient.listFiles(remote);
if (files.length == 1) {
boolean status = ftpClient.deleteFile(remote);
result = status ? FTPStatus.Delete_Remote_Success
: FTPStatus.Delete_Remote_Faild;
} else {
result = FTPStatus.Not_Exist_File;
}
System.out.println("FTP服务器文件删除标识：" + result);
return result;
}


/**
* 重命名远程FTP文件
* 
* @param name
*            新远程文件名称(路径-必须保证在同一路径下)
* 
* @param remote
*            远程文件路径
* 
* @return 是否成功
* 
* @throws IOException
*/
public FTPStatus rename(String name, String remote) throws IOException {
ftpClient.enterLocalPassiveMode();


ftpClient.setFileType(FTP.BINARY_FILE_TYPE);


FTPStatus result = null;


FTPFile[] files = ftpClient.listFiles(remote);
if (files.length == 1) {
boolean status = ftpClient.rename(remote, name);
result = status ? FTPStatus.Remote_Rename_Success
: FTPStatus.Remote_Rename_Faild;
} else {
result = FTPStatus.Not_Exist_File;
}
System.out.println("FTP服务器文件名更新标识：" + result);
return result;
}


/**
* 
* 从FTP服务器上下载文件
* 
* @param fileName
*            下载文件的名字(包括后缀名)
* 
* @param remote
*            远程文件路径
* 
* @param local
*            本地文件路径
* 
* @return 是否成功
* 
* @throws IOException
*/


public FTPStatus download(String fileName, String remote,
HttpServletResponse response) throws IOException {
// 开启输出流弹出文件保存路径选择窗口
response.setContentType("application/octet-stream");
response.setContentType("application/OCTET-STREAM;charset=UTF-8");
response.setHeader("Content-Disposition", "attachment;filename="
+ fileName);
ftpClient.enterLocalPassiveMode();
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
FTPStatus result;
OutputStream out = response.getOutputStream();
boolean status = ftpClient.retrieveFile(remote, out);
result = status ? FTPStatus.Download_From_Break_Success
: FTPStatus.Download_From_Break_Faild;
System.out.println("FTP服务器文件下载标识：" + result);
out.close();
return result;
}


/**
* 
* 从FTP服务器上下载文件
* 
* @param remote
*            远程文件路径
* 
* @param local
*            本地文件路径
* 
* @return 是否成功
* 
* @throws IOException
*/


@SuppressWarnings("resource")
public FTPStatus download(String remote, String local) throws IOException {
ftpClient.enterLocalPassiveMode();
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
FTPStatus result;
File f = new File(local);
FTPFile[] files = ftpClient.listFiles(remote);
if (files.length != 1) {
System.out.println("远程文件不唯一");
return FTPStatus.File_Not_Unique;
}
long lRemoteSize = files[0].getSize();
if (f.exists()) {
OutputStream out = new FileOutputStream(f, true);
System.out.println("本地文件大小为:" + f.length());
if (f.length() >= lRemoteSize) {
System.out.println("本地文件大小大于远程文件大小，下载中止");
return FTPStatus.Remote_smaller_local;
}
ftpClient.setRestartOffset(f.length());
boolean status = ftpClient.retrieveFile(remote, out);
result = status ? FTPStatus.Download_From_Break_Success
: FTPStatus.Download_From_Break_Faild;
out.close();
} else {
OutputStream out = new FileOutputStream(f);
boolean status = ftpClient.retrieveFile(remote, out);
result = status ? FTPStatus.Download_From_Break_Success
: FTPStatus.Download_From_Break_Faild;
out.close();
}
return result;
}


/**
* 
* 上传文件到FTP服务器，支持断点续传
* 
* @param local
*            本地文件名称，绝对路径
* 
* @param remote
*            远程文件路径，使用/upload/photo/20150710/text.jpg
*            按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
* 
* @return 上传结果
* 
* @throws IOException
*/


@SuppressWarnings("resource")
public FTPStatus upload(File f, String remote) throws IOException {
// 设置PassiveMode传输
ftpClient.enterLocalPassiveMode();
// 设置以二进制流的方式传输
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
FTPStatus result;
// 对远程目录的处理
String remoteFileName = remote;
if (remote.contains("/")) {
remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
if (!directory.equalsIgnoreCase("/")
&& !ftpClient.changeWorkingDirectory(directory)) {
// 如果远程目录不存在，则递归创建远程服务器目录
int start = 0;
int end = 0;
if (directory.startsWith("/")) {
start = 1;
} else {
start = 0;
}
end = directory.indexOf("/", start);
while (true) {
String subDirectory = remote.substring(start, end);
if (!ftpClient.changeWorkingDirectory(subDirectory)) {
if (ftpClient.makeDirectory(subDirectory)) {
ftpClient.changeWorkingDirectory(subDirectory);
} else {
System.out.println("创建目录失败");
return FTPStatus.Create_Directory_Fail;
}
}
start = end + 1;
end = directory.indexOf("/", start);
// 检查所有目录是否创建完毕
if (end <= start) {
break;
}
    }
}
}
// 检查远程是否存在文件
FTPFile[] files = ftpClient.listFiles(remoteFileName);
if (files.length == 1) {
long remoteSize = files[0].getSize();
long localSize = f.length();
if (remoteSize == localSize) {
return FTPStatus.File_Exits;
} else if (remoteSize > localSize) {
return FTPStatus.Remote_Bigger_Local;
}
// 尝试移动文件内读取指针,实现断点续传
InputStream is = new FileInputStream(f);
if (is.skip(remoteSize) == remoteSize) {
ftpClient.setRestartOffset(remoteSize);
if (ftpClient.storeFile(remote, is)) {
return FTPStatus.Upload_From_Break_Success;
}
}
// 如果断点续传没有成功，则删除服务器上文件，重新上传
if (!ftpClient.deleteFile(remoteFileName)) {
return FTPStatus.Delete_Remote_Faild;
}
is = new FileInputStream(f);
if (ftpClient.storeFile(remote, is)) {
result = FTPStatus.Upload_New_File_Success;
} else {
result = FTPStatus.Upload_New_File_Failed;
}
is.close();
} else {
InputStream is = new FileInputStream(f.getPath());
if (ftpClient.storeFile(remoteFileName, is)) {
result = FTPStatus.Upload_New_File_Success;
} else {
result = FTPStatus.Upload_New_File_Failed;
}
is.close();
}
return result;
}
//上传图片，以字节流方式获取
public FTPStatus upload(byte[] f, String remote) throws IOException {
// 设置PassiveMode传输
ftpClient.enterLocalPassiveMode();
// 设置以二进制流的方式传输
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
FTPStatus result;
// 对远程目录的处理
String remoteFileName = remote;
if (remote.contains("/")) {
remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
if (!directory.equalsIgnoreCase("/")
&& !ftpClient.changeWorkingDirectory(directory)) {
// 如果远程目录不存在，则递归创建远程服务器目录
int start = 0;
int end = 0;
if (directory.startsWith("/")) {
start = 1;
} else {
start = 0;
}
end = directory.indexOf("/", start);
while (true) {
String subDirectory = remote.substring(start, end);
if (!ftpClient.changeWorkingDirectory(subDirectory)) {
if (ftpClient.makeDirectory(subDirectory)) {
ftpClient.changeWorkingDirectory(subDirectory);
} else {
System.out.println("创建目录失败");
return FTPStatus.Create_Directory_Fail;
}
}
start = end + 1;
end = directory.indexOf("/", start);
// 检查所有目录是否创建完毕
if (end <= start) {
break;
}
    }
}
}
// 检查远程是否存在文件
FTPFile[] files = ftpClient.listFiles(remoteFileName);
if (files.length == 1) {
long remoteSize = files[0].getSize();
long localSize = f.length;
if (remoteSize == localSize) {
return FTPStatus.File_Exits;
} else if (remoteSize > localSize) {
return FTPStatus.Remote_Bigger_Local;
}
// 尝试移动文件内读取指针,实现断点续传
InputStream is = new ByteArrayInputStream(f);
if (is.skip(remoteSize) == remoteSize) {
ftpClient.setRestartOffset(remoteSize);
if (ftpClient.storeFile(remote, is)) {
return FTPStatus.Upload_From_Break_Success;
}
}
// 如果断点续传没有成功，则删除服务器上文件，重新上传
if (!ftpClient.deleteFile(remoteFileName)) {
return FTPStatus.Delete_Remote_Faild;
}
is = new ByteArrayInputStream(f);
if (ftpClient.storeFile(remote, is)) {
result = FTPStatus.Upload_New_File_Success;
} else {
result = FTPStatus.Upload_New_File_Failed;
}
is.close();
} else {
InputStream is = new ByteArrayInputStream(f);
if (ftpClient.storeFile(remoteFileName, is)) {
result = FTPStatus.Upload_New_File_Success;
} else {
result = FTPStatus.Upload_New_File_Failed;
}
is.close();
}
return result;
}
/**
     * 根据文件路径获取文件流
     * @param path
     * @return
    */
  public InputStream downloadFile(String remoteFilePath) throws Exception {
       return ftpClient.retrieveFileStream(remoteFilePath);
   }
  
/**
* 
* 断开与远程服务器的连接
* 
* @throws IOException
*/


public void disconnect() throws IOException {


if (ftpClient.isConnected()) {
ftpClient.disconnect();
}
}
 
/*public static void main(String[] args) {
FTPUtils myFtp = new FTPUtils();
try {
//myFtp.connect("172.16.4.140", 21, "Ace", "19920214");
myFtp.connect();
//myFtp.upload("F:\\test.txt", "/../20150709/20150709.txt");
myFtp.download("/../20160321.JPG", "F://2015071004245913.jpg");
//InputStream inputfile = myFtp.downloadFile("/../20160321.JPG");
// myFtp.delete("/../upload/photo/2015-07-13/2015071310244205.jpg");
// System.out.println("上传成功");
// System.out.println(inputfile);
// byte tmp[] = new byte[256];
//  ServletOutputStream output;
//  output = response.getOutputStream();
  //   int i=0;
   //  while ((i = inputfile.read(tmp)) != -1) {
     //    output.write(tmp, 0, i);
  //   }
  //   inputfile.close();
   //  output.flush(); //强制清出缓冲区               
   //  output.close();
myFtp.disconnect();
} catch (IOException e) {
System.out.println("FTP下载文件异常：" + e.getMessage());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} */


}