FTP工具类开发

  1 import org.apache.commons.net.ftp.*;
  2 import org.slf4j.Logger;
  3 import org.slf4j.LoggerFactory;
  4 
  5 import java.io.*;
  6 import java.util.Arrays;
  7 import java.util.List;
  8 
  9 /**
 10  * FTP上传工具类
 11  */
 12 public class FtpUtil {
 13     private static Logger log = LoggerFactory.getLogger(FtpUtil.class);
 14     private final static String FILE_SEPARATOR = System.getProperties().getProperty("file.separator");
 15     private String ip;
 16     private String username;
 17     private String password;
 18     private int port = 21;
 19     private FTPClient ftpClient = null;
 20 
 21     public FtpUtil(String serverIP, String username, String password) {
 22         this.ip = serverIP;
 23         this.username = username;
 24         this.password = password;
 25     }
 26 
 27     public FtpUtil(String serverIP, int port, String username, String password) {
 28         this.ip = serverIP;
 29         this.username = username;
 30         this.password = password;
 31         this.port = port;
 32     }
 33 
 34     /**
 35      * 连接ftp服务器
 36      */
 37     public boolean connectServer() {
 38         boolean result = true;
 39         try {
 40             ftpClient = new FTPClient();
 41             ftpClient.setControlEncoding("GBK");
 42             FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
 43             conf.setServerLanguageCode("zh");
 44             ftpClient.configure(conf);
 45             ftpClient.connect(this.ip, this.port);
 46             ftpClient.login(this.username, this.password);
 47             ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
 48             int reply = ftpClient.getReplyCode();
 49             if (!FTPReply.isPositiveCompletion(reply)) {
 50                 ftpClient.disconnect();
 51                 result = false;
 52             }
 53         } catch (IOException e) {
 54             e.printStackTrace();
 55             log.error("连接ftp服务器失败", e);
 56             result = false;
 57         }
 58         return result;
 59     }
 60 
 61     /**
 62      * 断开与ftp服务器连接
 63      */
 64     public boolean closeServer() {
 65         try {
 66             if (ftpClient != null && ftpClient.isConnected()) {
 67                 ftpClient.logout();
 68                 ftpClient.disconnect();
 69             }
 70             return true;
 71         } catch (IOException e) {
 72             log.error("断开与ftp服务器连接失败", e);
 73             return false;
 74         }
 75     }
 76 
 77     /**
 78      * 向FTP根目录上传文件
 79      *
 80      * @param localFile
 81      * @param newName   文件名称
 82      * @throws Exception
 83      */
 84     public boolean uploadFile(String localFile, String newName) {
 85         boolean success = false;
 86         InputStream input = null;
 87         try {
 88             File file = null;
 89             if (checkFileExist(localFile)) {
 90                 file = new File(localFile);
 91             }
 92             input = new FileInputStream(file);
 93             success = ftpClient.storeFile(newName, input);
 94         } catch (Exception e) {
 95             log.error("FTP根目录上传文件上传失败（ps：传入文件名）", e);
 96         } finally {
 97             if (input != null) {
 98                 try {
 99                     input.close();
100                 } catch (IOException e) {
101                     e.printStackTrace();
102                     log.error("FTP根目录上传文件上传（ps：传入文件名）,输入流关闭失败", e);
103                 }
104             }
105         }
106         return success;
107     }
108 
109     /**
110      * 向FTP根目录上传文件
111      *
112      * @param input
113      * @param newName 新文件名
114      * @throws Exception
115      */
116     public boolean uploadFile(InputStream input, String newName) {
117         boolean success = false;
118         try {
119             success = ftpClient.storeFile(newName, input);
120         } catch (Exception e) {
121             log.error("FTP根目录上传文件上传失败（ps：传入文件流）", e);
122         } finally {
123             if (input != null) {
124                 try {
125                     input.close();
126                 } catch (IOException e) {
127                     e.printStackTrace();
128                     log.error("FTP根目录上传文件上传（ps：传入文件流）,输入流关闭失败", e);
129                 }
130             }
131         }
132         return success;
133     }
134 
135     /**
136      * 向FTP指定路径上传文件
137      *
138      * @param localFile
139      * @param newName        新文件名
140      * @param remoteFoldPath
141      * @throws Exception
142      */
143     public boolean uploadFile(String localFile, String newName, String remoteFoldPath) {
144         InputStream input = null;
145         boolean success = false;
146         try {
147             // 改变当前路径到指定路径
148             if (!this.changeDirectory(remoteFoldPath)) {
149                 return false;
150             }
151             File file = null;
152             if (checkFileExist(localFile)) {
153                 file = new File(localFile);
154             }
155             input = new FileInputStream(file);
156             success = ftpClient.storeFile(newName, input);
157         } catch (Exception e) {
158             log.error("FTP指定路径上传文件失败（ps：本地文件路径以及ftp服务器中文件名）", e);
159         } finally {
160             if (input != null) {
161                 try {
162                     input.close();
163                 } catch (IOException e) {
164                     e.printStackTrace();
165                     log.error("FTP指定路径上传文件失败（ps：本地文件路径以及ftp服务器中文件名）,输入流关闭失败", e);
166                 }
167             }
168         }
169         return success;
170     }
171 
172     /**
173      * 向FTP指定路径上传文件
174      *
175      * @param input
176      * @param newName        新文件名
177      * @param remoteFoldPath
178      * @throws Exception
179      */
180     public boolean uploadFile(InputStream input, String newName, String remoteFoldPath) throws Exception {
181         boolean success = false;
182         try {
183             // 改变当前路径到指定路径
184             if (!this.changeDirectory(remoteFoldPath)) {
185                 return false;
186             }
187             success = ftpClient.storeFile(newName, input);
188         } catch (Exception e) {
189             log.error("FTP指定路径上传文件失败（ps：本地文件流及ftp服务器中文件名）", e);
190         } finally {
191             if (input != null) {
192                 try {
193                     input.close();
194                 } catch (IOException e) {
195                     log.error("FTP指定路径上传文件失败（ps：本地文件流及ftp服务器中文件名）,输入流关闭失败", e);
196                 }
197             }
198         }
199         return success;
200     }
201 
202     /**
203      * 从FTP服务器下载文件
204      *
205      * @param remotePath FTP路径(不包含文件名)
206      * @param fileName   下载文件名
207      * @param localPath  本地路径
208      */
209     public boolean downloadFile(String remotePath, String fileName, String localPath) {
210         BufferedOutputStream output = null;
211         boolean success = false;
212         try {
213             // 检查本地路径
214             if (!this.checkFileExist(localPath)) {
215                 return false;
216             }
217             // 改变工作路径
218             if (!this.changeDirectory(remotePath)) {
219                 return false;
220             }
221             // 列出当前工作路径下的文件列表
222             List<FTPFile> fileList = this.getFileList();
223             if (fileList == null || fileList.size() == 0) {
224                 return false;
225             }
226             for (FTPFile ftpfile : fileList) {
227                 if (ftpfile.getName().equals(fileName)) {
228                     File localFilePath = new File(localPath + File.separator + ftpfile.getName());
229                     output = new BufferedOutputStream(new FileOutputStream(localFilePath));
230                     success = ftpClient.retrieveFile(ftpfile.getName(), output);
231                 }
232             }
233         } catch (Exception e) {
234             log.error("FTP服务器下载文件失败", e);
235         } finally {
236             if (output != null) {
237                 try {
238                     output.close();
239                 } catch (IOException e) {
240                     log.error("FTP服务器下载文件,输出流关闭失败", e);
241                 }
242             }
243         }
244         return success;
245     }
246 
247     /**
248      * 从FTP服务器获取文件流
249      *
250      * @param remoteFilePath
251      * @return
252      * @throws Exception
253      */
254     public InputStream downloadFile(String remoteFilePath) {
255         try {
256             return ftpClient.retrieveFileStream(remoteFilePath);
257         } catch (IOException e) {
258             log.error("FTP服务器获取文件流失败", e);
259         }
260         return null;
261     }
262 
263     /**
264      * 获取FTP服务器上[指定路径]下的文件列表
265      *
266      * @param remotePath
267      * @return
268      */
269     public List<FTPFile> getFtpServerFileList(String remotePath) {
270         try {
271             FTPListParseEngine engine = ftpClient.initiateListParsing(remotePath);
272             return Arrays.asList(engine.getNext(25));
273         } catch (IOException e) {
274             log.error("获取FTP服务器上[指定路径]下的文件列表(getFtpServerFileList)失败", e);
275         }
276         return null;
277     }
278 
279     /**
280      * 获取FTP服务器上[指定路径]下的文件列表
281      *
282      * @param remotePath
283      * @return
284      */
285     public List<FTPFile> getFileList(String remotePath) {
286         List<FTPFile> ftpfiles = null;
287         try {
288             ftpfiles = Arrays.asList(ftpClient.listFiles(remotePath));
289         } catch (IOException e) {
290             log.error("获取FTP服务器上[指定路径]下的文件列表(getFileList)失败", e);
291         }
292         return ftpfiles;
293     }
294 
295     /**
296      * 获取FTP服务器[当前工作路径]下的文件列表
297      *
298      * @return
299      */
300     public List<FTPFile> getFileList() {
301         List<FTPFile> ftpfiles = null;
302         try {
303             ftpfiles = Arrays.asList(ftpClient.listFiles());
304         } catch (IOException e) {
305             log.error("获取FTP服务器[当前工作路径]下的文件列表失败", e);
306         }
307         return ftpfiles;
308     }
309 
310     /**
311      * 改变FTP服务器工作路径
312      *
313      * @param remoteFoldPath
314      */
315     public boolean changeDirectory(String remoteFoldPath) {
316         boolean result = false;
317         try {
318             result = ftpClient.changeWorkingDirectory(new String(remoteFoldPath));
319         } catch (IOException e) {
320             log.error("改变FTP服务器工作路径失败", e);
321         }
322         return result;
323     }
324 
325     /**
326      * 删除文件
327      *
328      * @param remoteFilePath
329      * @return
330      * @throws Exception
331      */
332     public boolean deleteFtpServerFile(String remoteFilePath) {
333         boolean result = false;
334         try {
335             result = ftpClient.deleteFile(remoteFilePath);
336         } catch (IOException e) {
337             log.error("FTP服务器删除文件失败", e);
338         }
339         return result;
340     }
341 
342     /**
343      * 删除目录
344      *
345      * @param remoteFoldPath
346      * @return
347      * @throws Exception
348      */
349     public boolean deleteFold(String remoteFoldPath) {
350         boolean result = false;
351         try {
352             result = ftpClient.removeDirectory(remoteFoldPath);
353         } catch (IOException e) {
354             log.error("FTP服务器删除目录失败", e);
355         }
356         return result;
357     }
358 
359     /**
360      * 删除目录以及文件
361      *
362      * @param remoteFoldPath
363      * @return
364      */
365     public boolean deleteFoldAndsubFiles(String remoteFoldPath) {
366         boolean success = false;
367         List<FTPFile> list = this.getFileList(remoteFoldPath);
368         if (list == null || list.size() == 0) {
369             return deleteFold(remoteFoldPath);
370         }
371         for (FTPFile ftpFile : list) {
372             String name = ftpFile.getName();
373             if (ftpFile.isDirectory()) {
374                 success = deleteFoldAndsubFiles(remoteFoldPath + FILE_SEPARATOR + name);
375             } else {
376                 success = deleteFtpServerFile(remoteFoldPath + FILE_SEPARATOR + name);
377             }
378             if (!success) {
379                 break;
380             }
381         }
382         if (!success) {
383             return false;
384         }
385         success = deleteFold(remoteFoldPath);
386         return success;
387     }
388 
389     /**
390      * 创建目录
391      *
392      * @param remoteFoldPath
393      * @return
394      */
395     public boolean createFold(String remoteFoldPath) {
396         boolean result = false;
397         try {
398             result = ftpClient.makeDirectory(remoteFoldPath);
399         } catch (IOException e) {
400             log.error("FTP服务器创建目录失败", e);
401         }
402         return result;
403     }
404 
405 
406     /**
407      * 检查本地路径是否存在
408      *
409      * @param filePath
410      * @return
411      * @throws Exception
412      */
413     public boolean checkFileExist(String filePath) {
414         return new File(filePath).exists();
415     }
416 
417     /**
418      * 把文件移动到特定目录下
419      *
420      * @param remoteFile
421      * @param remoteNewPath
422      * @return
423      */
424     public boolean moveFtpServerFile(String remoteFile, String remoteNewPath) {
425         boolean result = false;
426         try {
427             result = ftpClient.rename(remoteFile, remoteNewPath);
428         } catch (IOException e) {
429             log.error("FTP服务器文件移动失败", e);
430         }
431         return result;
432     }
433 
434     /**
435      * 判断是文件还是目录
436      *
437      * @param remoteOldPath
438      * @return
439      */
440     public boolean isContents(String remoteOldPath) {
441         return changeDirectory(remoteOldPath);
442     }
443 
444     /**
445      * 递归创建远程服务器目录
446      *
447      * @param dirpath 远程服务器文件绝对路径
448      * @return 目录创建是否成功
449      */
450     public void createDirecroty(String dirpath) {
451         String directory = dirpath.substring(0, dirpath.lastIndexOf("/") + 1);
452         try {
453             if (!directory.equalsIgnoreCase("/") && !ftpClient.changeWorkingDirectory(new String(directory))) {
454                 // 如果远程目录不存在，则递归创建远程服务器目录
455                 int start = 0;
456                 int end = 0;
457                 if (directory.startsWith("/")) {
458                     start = 1;
459                 } else {
460                     start = 0;
461                 }
462                 end = directory.indexOf("/", start);
463                 while (true) {
464                     String subDirectory = new String(dirpath.substring(start, end));
465                     if (!ftpClient.changeWorkingDirectory(subDirectory)) {
466                         if (ftpClient.makeDirectory(subDirectory)) {
467                             ftpClient.changeWorkingDirectory(subDirectory);
468                         }
469                     }
470                     start = end + 1;
471                     end = directory.indexOf("/", start);
472                     // 检查所有目录是否创建完毕
473                     if (end <= start) {
474                         break;
475                     }
476                 }
477             }
478         } catch (IOException e) {
479             log.error("递归生成目录失败", e);
480         }
481     }
482 
483 
484     /**
485      * 复制
486      *
487      * @param remoteOldPath
488      * @param remoteNewPath
489      * @return
490      */
491     public boolean copyFtpServerFile(String remoteOldPath, String remoteNewPath) {
492         boolean copyFalg = false;
493         List<FTPFile> filelist;
494         try {
495             ftpClient.enterLocalPassiveMode();
496             filelist = this.getFileList(remoteOldPath);
497             int length = filelist == null || filelist.isEmpty() ? 0 : filelist.size();
498             String category = null;
499             ByteArrayOutputStream fos = null;
500             ByteArrayInputStream in = null;
501             if (length > 0) {
502                 boolean flage = false;
503                 if (this.isContents(remoteOldPath)) {
504                     flage = true;
505                 }
506                 changeDirectory("/");
507                 for (FTPFile ftpFile : filelist) {
508                     category = ftpFile.getName();
509                     if (ftpFile.isFile()) {
510                         // 如果是文件则复制文件
511                         ftpClient.setBufferSize(1024);
512                         fos = new ByteArrayOutputStream();
513                         copyFalg = ftpClient.retrieveFile(flage ? remoteOldPath + FILE_SEPARATOR + category : remoteOldPath, fos);
514                         if (!copyFalg) {
515                             return copyFalg;
516                         }
517                         // 如果读取的文件流不为空则复制文件
518                         if (fos != null) {
519                             in = new ByteArrayInputStream(fos.toByteArray());
520                             copyFalg = ftpClient.storeFile(remoteNewPath + FILE_SEPARATOR + category, in);
521                             // 关闭文件流
522                             fos.close();
523                             in.close();
524                             if (!copyFalg) {
525                                 return copyFalg;
526                             }
527                         }
528                     } else if (ftpFile.isDirectory()) {
529                         // 如果是目录则先创建该目录
530                         copyFalg = this.createFold(remoteNewPath + FILE_SEPARATOR + category);
531                         // 再进入子目录进行递归复制
532                         copyFtpServerFile(remoteOldPath + FILE_SEPARATOR + category, remoteNewPath + FILE_SEPARATOR + category);
533                     }
534                 }
535             }
536         } catch (IOException e) {
537             log.error("文件复制失败", e);
538             copyFalg = false;
539         }
540         return copyFalg;
541     }
542 
543     public static void main(String[] args) {
544         FtpUtil ftpUtil = new FtpUtil("", "", "");
545         //执行文件移动
546         /*if (ftpUtil.connectServer()) {
547             if (ftpUtil.changeDirectory("load")) {
548                 ftpUtil.moveFtpServerFile("xlsj_h1_v0.7.apk", ".." + FILE_SEPARATOR + "down" + FILE_SEPARATOR + "1.apk");
549                 ftpUtil.closeServer();
550             }
551         }*/
552         //复制  xlsj_h1_v0.8.apk是目录   xlsj_h1_v0.7.apk是文件
553        /* if (ftpUtil.connectServer()) {
554             ftpUtil.copyFtpServerFile("load/xlsj_h1_v0.8.apk", "down");
555             ftpUtil.copyFtpServerFile("load/xlsj_h1_v0.8.apk/xlsj_h1_v0.7.apk", "down");
556             ftpUtil.closeServer();
557         }*/
558 
559         if (ftpUtil.connectServer()) {
560             ftpUtil.copyFtpServerFile("load/安卓上传包/安卓开发包.apk", "down");
561             ftpUtil.closeServer();
562         }
563     }
564 }