导入ftp依赖
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.6</version>
</dependency>
FtpUtils
package com.onlineboot.utils;
import cn.hutool.core.util.StrUtil;
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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.UUID;
public class FtpApche {
private static FTPClient ftpClient = new FTPClient();
private static String encoding = "GBK";
private static final Logger logger = LoggerFactory.getLogger(FtpApche.class);
private static String tempPath = "/temp";
public static boolean ftpLogin(String url, int port, String username, String password){
boolean result = false;
int reply;
try {
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
logger.info("FTP连接失败");
ftpClient.disconnect();
return result;
}
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
public static boolean testUploadFile(String url, int port, String username, String password, String path, String filename,InputStream input){
boolean result = false;
int reply;
try {
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
System.out.println("连接失败");
ftpClient.disconnect();
return result;
}
boolean change = ftpClient.changeWorkingDirectory(path);
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
if(change){
ftpClient.setBufferSize(1024*1024);
BufferedInputStream in = new BufferedInputStream(input);
result = ftpClient.storeFile(new String(filename.getBytes(encoding),"iso-8859-1"),in);
if(result){
System.out.println("上传成功");
}
in.close();
}
input.close();
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
;
}
}
return result;
}
public static boolean downFile(String url, int port, String username, String password, String remotePath, String fileName,String nowFileName, HttpServletResponse response){
boolean result = false;
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
System.err.println("FTP server refused connection");
return result;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
response.reset();
response.setContentType("application/vnd.ms-excel;charset=utf-8");
response.setHeader("Content-disposition", "attachment;filename="+new String(nowFileName.getBytes("GB2312"),"ISO8859_1"));
response.setCharacterEncoding(encoding);
ftpClient.setBufferSize(1024*1024);
BufferedInputStream bis = new BufferedInputStream(ftpClient.retrieveFileStream(ff.getName()));
BufferedOutputStream bos = new BufferedOutputStream(response.getOutputStream());
byte buffer[] = new byte[4096];
int len;
while((len = bis.read(buffer)) > 0){
bos.write(buffer, 0, len);
}
bis.close();
bos.close();
}
}
ftpClient.logout();
result = true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static boolean downFzFile(String url, int port, String username, String password, String remotePath, String fileName,String nowFileName, HttpServletResponse response){
boolean result = false;
BufferedInputStream bis = null ;
BufferedOutputStream bos = null ;
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
System.err.println("FTP server refused connection");
return result;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
bis = new BufferedInputStream(ftpClient.retrieveFileStream(ff.getName()));
response.setContentType("application/x-dowmload");
response.setContentType("application/octet-stream");
response.setHeader("Content-Disposition", "attachment;filename="+ URLEncoder.encode(nowFileName,"UTF-8"));
response.addHeader("Content-Length","" + ff.getSize());
ftpClient.setBufferSize(1024*1024);
System.out.println("----------------------------------634650-------"+ff.getSize());
bos = new BufferedOutputStream(response.getOutputStream());
byte buffer[] = new byte[102400];
int len = -1;
while((len = bis.read(buffer)) != -1){
bos.write(buffer, 0, len);
}
bis.close();
bos.flush();
bos.close();
}
}
ftpClient.logout();
result = true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static boolean deleteFtpFile(String url,int port,String username,String password,String remotePath,String fileName){
boolean flag = false;
int reply;
try {
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
logger.info("连接失败");
ftpClient.disconnect();
return flag;
}
boolean change = ftpClient.changeWorkingDirectory(remotePath);
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
if(change){
ftpClient.dele(fileName);
ftpClient.logout();
flag = true;
}
logger.info("文件删除成功");
} catch (IOException e) {
logger.info("文件删除失败");
e.printStackTrace();
}finally {
if (ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return flag;
}
public static InputStream lookFile(String url,int port,String username,String password,String remotePath,String fileName){
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
logger.info("FTP server refused connection");
return null;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
ftpClient.setControlEncoding("UTF-8");
return ftpClient.retrieveFileStream(ff.getName());
}
}
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
public static boolean lookPdf(String url, int port, String username, String password, String remotePath, String fileName,HttpServletResponse response){
boolean result = false;
response.setContentType("application/pdf");
response.setHeader("Content-Disposition", "inline;filename="+fileName);
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
logger.info("FTP server refused connection");
return result;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
ftpClient.setBufferSize(1024*1024);
BufferedInputStream bis = new BufferedInputStream(ftpClient.retrieveFileStream(ff.getName()));
BufferedOutputStream bos = new BufferedOutputStream(response.getOutputStream());
byte buffer[] = new byte[4096];
int len;
while((len = bis.read(buffer)) > 0){
bos.write(buffer, 0, len);
}
bis.close();
bos.close();
}
}
ftpClient.logout();
response.getOutputStream().flush();
result = true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static String lookPicture(String url,int port,String username,String password,String remotePath,String fileName){
InputStream inputStream = null;
String re = null;
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
logger.info("FTP server refused connection");
return null;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(fileName.equals(ff.getName())){
inputStream = ftpClient.retrieveFileStream(ff.getName());
}
}
if (inputStream != null){
try {
byte[] data;
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
int dataSize = 0;
while (dataSize == 0){
dataSize = inputStream.available();
}
data = new byte[inputStream.available()];
int len = 0;
while ((len = inputStream.read(data)) != -1){
outputStream.write(data,0,len);
}
data = outputStream.toByteArray();
Base64.Encoder encoder = Base64.getEncoder();
re = encoder.encodeToString(data);
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != inputStream){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return re;
}
public static boolean uploadFile(String url, int port, String username, String password, String path, String filename,InputStream input){
boolean result = false;
int reply;
try {
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
logger.info("连接失败");
ftpClient.disconnect();
return result;
}
boolean change = ftpClient.changeWorkingDirectory(path);
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
if(!change){
String[] split = path.split("/");
String tempPath = "";
for (String str: split) {
if(StrUtil.isEmpty(str)){
continue;
}
tempPath+="/"+str;
if(!ftpClient.changeWorkingDirectory(tempPath)){
if(!ftpClient.makeDirectory(tempPath)){
return result;
}else {
change = ftpClient.changeWorkingDirectory(tempPath);
}
}
}
}
if(change){
ftpClient.setBufferSize(1024*1024);
BufferedInputStream in = new BufferedInputStream(input);
result = ftpClient.storeFile(new String(filename.getBytes(encoding),"iso-8859-1"),in);
if(result){
logger.info("上传成功");
}
in.close();
}
input.close();
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static List<String> getFileDirectoryList(String url, Integer port, String username, String password, String path) {
List<String> resultList = new ArrayList<>();
int reply;
try{
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
logger.info("连接失败");
ftpClient.disconnect();
return resultList;
}
boolean change = ftpClient.changeWorkingDirectory(path);
if(change){
FTPFile[] ftpFiles = ftpClient.listFiles();
for (FTPFile ftpFile : ftpFiles) {
if(ftpFile.isDirectory()){
System.out.println(ftpFile.getName());
resultList.add(path+"/"+ftpFile.getName());
continue;
}
}
return resultList;
}
}catch (IOException e){
e.printStackTrace();
}
return null;
}
public static List<String> getFileNameList(String url, Integer port, String username, String password, String path) {
List<String> resultList = new ArrayList<>();
int reply;
try{
ftpClient.connect(url,port);
ftpClient.login(username,password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
logger.info("连接失败");
ftpClient.disconnect();
return resultList;
}
boolean change = ftpClient.changeWorkingDirectory(path);
if(change){
FTPFile[] ftpFiles = ftpClient.listFiles();
for (FTPFile ftpFile : ftpFiles) {
if(ftpFile.isFile()){
System.out.println(ftpFile.getName());
resultList.add(path+"/"+ftpFile.getName());
continue;
}
}
return resultList;
}
}catch (IOException e){
e.printStackTrace();
}
return null;
}
private static boolean deleteOldFile(String url, int port, String username, String password,String path, String destFileName) throws IOException {
ftpClient.connect(url, port);
ftpClient.login(username, password);
ftpClient.setControlEncoding(encoding);
int reply = ftpClient.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftpClient.disconnect();
logger.info("文件服务器连接失败");
return false;
}
boolean flag = false;
boolean b = ftpClient.changeWorkingDirectory(path);
FTPFile[] fs = ftpClient.listFiles();
if (null!=fs && fs.length > 0) {
if (ftpClient.dele(destFileName) > 0) {
flag = true;
logger.info("删除已存在文件成功");
} else {
flag = false;
}
} else {
flag = true;
}
return flag;
}
private static boolean reName(String url, int port, String username, String password, String uid, String destDir, String destFileName) {
int reply;
boolean rename = false;
try {
ftpClient.connect(url, port);
ftpClient.login(username, password);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftpClient.disconnect();
logger.info("文件服务器连接失败");
return false;
}
boolean b = ftpClient.changeWorkingDirectory(destDir);
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
if (!b) {
String[] split = destDir.split("/");
String tempPath = "";
for (String str : split) {
if (StrUtil.isEmpty(str)) {
continue;
}
tempPath += "/" + str;
if (!ftpClient.changeWorkingDirectory(tempPath)) {
if (!ftpClient.makeDirectory(tempPath)) {
logger.info("文件目录创建失败");
}
}
}
}
System.out.println(b);
String s = ftpClient.printWorkingDirectory();
System.out.println(s);
String fileName = uid + destFileName.substring(destFileName.lastIndexOf("."));
rename = ftpClient.rename(tempPath + "/" + fileName, destDir + "/" + destFileName);
ftpClient.logout();
return rename;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public static boolean reName(String ftpIp, Integer ftpPort, String ftpUserName, String ftpPassword, String path_old, String guid_old, String path_new, String guid_new) {
int reply;
boolean rename = false;
try {
ftpClient.connect(ftpIp, ftpPort);
ftpClient.login(ftpUserName, ftpPassword);
ftpClient.setControlEncoding(encoding);
reply = ftpClient.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftpClient.disconnect();
logger.info("文件服务器连接失败");
return false;
}
boolean b = ftpClient.changeWorkingDirectory(path_new);
ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
if (!b) {
String[] split = path_new.split("/");
String tempPath = "";
for (String str : split) {
if (StrUtil.isEmpty(str)) {
continue;
}
tempPath += "/" + str;
if (!ftpClient.changeWorkingDirectory(tempPath)) {
if (!ftpClient.makeDirectory(tempPath)) {
logger.info("文件目录创建失败");
}
}
}
}
rename = ftpClient.rename(path_old + "/" + guid_old, path_new + "/" + guid_new);
ftpClient.logout();
return rename;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public static Boolean getFile(String url, Integer port, String username, String password, String remotePath, String fileName) {
boolean result = false;
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
System.err.println("FTP server refused connection");
return result;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
result = true;
}
}
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static boolean downZykFileTwo(String url, int port, String username, String password, String remotePath, String fileName,String path_new,String guid_new){
InputStream tempIn = null;
InputStream inputStream = null;
byte[] bytes = null;
boolean result = false;
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
System.err.println("FTP server refused connection");
return result;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
tempIn = ftpClient.retrieveFileStream(ff.getName());
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
byte[] buf = new byte[204800];
int bufsize = 0;
while ((bufsize = tempIn.read(buf,0,buf.length))!=-1){
byteOut.write(buf,0,bufsize);
}
bytes = byteOut.toByteArray();
byteOut.close();
tempIn.close();
}
}
ftpClient.logout();
inputStream = new ByteArrayInputStream(bytes);
return uploadFile(url, port, username, password, path_new, guid_new, inputStream);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(inputStream!=null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
public static InputStream downZykFile(String url, int port, String username, String password, String remotePath, String fileName){
try {
int reply;
ftpClient.setControlEncoding(encoding);
ftpClient.connect(url,port);
ftpClient.login(username,password);
reply = ftpClient.getReplyCode();
if(!FTPReply.isPositiveCompletion(reply)){
ftpClient.disconnect();
System.err.println("FTP server refused connection");
return null;
}
ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
ftpClient.changeWorkingDirectory(remotePath);
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile ff : fs){
if(ff.getName().equals(fileName)){
return ftpClient.retrieveFileStream(ff.getName());
}
}
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(ftpClient.isConnected()){
try {
ftpClient.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
}