首页 > 代码库 > FTP

FTP

2024-09-20 10:51:48   220人阅读

  1. username=admin   
  2. password=123   
  3. ip=192.168.14.117   
  4. port=21  

参考：http://blog.csdn.net/yelove1990/article/details/41245039
实现类

 

 

[java] view plain copy
 
    1. package com.util;  
    2.   
    3. import java.io.*;  
    4. import java.net.SocketException;  
    5. import java.text.SimpleDateFormat;  
    6. import java.util.ArrayList;  
    7. import java.util.List;  
    8. import java.util.Properties;  
    9.   
    10. import org.apache.commons.logging.Log;  
    11. import org.apache.commons.logging.LogFactory;  
    12. import org.apache.commons.net.ftp.FTP;  
    13. import org.apache.commons.net.ftp.FTPClient;  
    14. import org.apache.commons.net.ftp.FTPClientConfig;  
    15. import org.apache.commons.net.ftp.FTPFile;  
    16. import org.apache.commons.net.ftp.FTPReply;  
    17.   
    18. public class FTPClientTest {  
    19.       
    20.     private static final Log logger = LogFactory.getLog(FTPClientTest.class);   
    21.   
    22.     private String userName;         //FTP 登录用户名   
    23.     private String password;         //FTP 登录密码   
    24.     private String ip;                     //FTP 服务器地址IP地址   
    25.     private int port;                        //FTP 端口   
    26.     private Properties property = null;    //属性集   
    27.     private String configFile = "conf/application.properties";    //配置文件的路径名   
    28.     private FTPClient ftpClient = null; //FTP 客户端代理   
    29.     //时间格式化   
    30.     private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");   
    31.     //FTP状态码   
    32.     public int i = 1;   
    33.   
    34.     /**  
    35.      * 连接到服务器  
    36.      *  
    37.      * @return true 连接服务器成功，false 连接服务器失败  
    38.      */   
    39.     public boolean connectServer() {   
    40.         boolean flag = true;   
    41.         if (ftpClient == null) {   
    42.             int reply;   
    43.             try {   
    44.                 if(setArg(configFile)){  
    45.                     ftpClient = new FTPClient();   
    46.                     ftpClient.setControlEncoding("GBK");   
    47.                     //ftpClient.configure(getFtpConfig());   
    48.                     ftpClient.connect(ip,port);   
    49.                     ftpClient.login(userName, password);  
    50.                     reply = ftpClient.getReplyCode();   
    51.                     ftpClient.setDataTimeout(120000);   
    52.   
    53.                     if (!FTPReply.isPositiveCompletion(reply)) {   
    54.                         ftpClient.disconnect();   
    55.                         logger.debug("FTP 服务拒绝连接！");   
    56.                         flag = false;   
    57.                     }   
    58.                     i++;   
    59.                 }else{  
    60.                     flag = false;   
    61.                 }  
    62.             } catch (SocketException e) {   
    63.                 flag = false;   
    64.                 e.printStackTrace();   
    65.                 logger.debug("登录ftp服务器 " + ip + " 失败,连接超时！");   
    66.             } catch (IOException e) {   
    67.                 flag = false;   
    68.                 e.printStackTrace();   
    69.                 logger.debug("登录ftp服务器 " + ip + " 失败，FTP服务器无法打开！");   
    70.             }   
    71.         }   
    72.         return flag;   
    73.     }  
    74.       
    75.     /** 
    76.      * 上传文件 
    77.      *  
    78.      * @param remoteFile 
    79.      *            远程文件路径,支持多级目录嵌套 
    80.      * @param localFile 
    81.      *            本地文件名称，绝对路径 
    82.      *  
    83.      */  
    84.     public boolean uploadFile(String remoteFile, File localFile)  
    85.             throws IOException {  
    86.         boolean flag = false;  
    87.         InputStream in = new FileInputStream(localFile);  
    88.         String remote = new String(remoteFile.getBytes("GBK"),"iso-8859-1");  
    89.         if(ftpClient.storeFile(remote, in)){  
    90.             flag = true;  
    91.             logger.debug(localFile.getAbsolutePath()+"上传文件成功！");  
    92.         }else{  
    93.             logger.debug(localFile.getAbsolutePath()+"上传文件失败！");  
    94.         }  
    95.         in.close();  
    96.         return flag;  
    97.     }  
    98.       
    99.     /**  
    100.      * 上传单个文件，并重命名  
    101.      *  
    102.      * @param localFile--本地文件路径  
    103.      * @param localRootFile--本地文件父文件夹路径  
    104.      * @param distFolder--新的文件名,可以命名为空""  
    105.      * @return true 上传成功，false 上传失败  
    106.      * @throws IOException  
    107.      */   
    108.     public boolean uploadFile(String local, String remote) throws IOException {   
    109.         boolean flag = true;   
    110.         String remoteFileName = remote;  
    111.         if (remote.contains("/")) {  
    112.             remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);  
    113.             // 创建服务器远程目录结构，创建失败直接返回  
    114.             if (!CreateDirecroty(remote)) {  
    115.                 return false;  
    116.             }  
    117.         }  
    118.         FTPFile[] files = ftpClient.listFiles(new String(remoteFileName));  
    119.         File f = new File(local);  
    120.         if(!uploadFile(remoteFileName, f)){  
    121.             flag = false;  
    122.         }  
    123.         return flag;   
    124.     }   
    125.   
    126.     /**  
    127.      * 上传文件夹内的所有文件  
    128.      *  
    129.      *  
    130.      * @param filename 
    131.      *       本地文件夹绝对路径 
    132.      * @param uploadpath 
    133.      *       上传到FTP的路径,形式为/或/dir1/dir2/../ 
    134.      * @return true 上传成功，false 上传失败  
    135.      * @throws IOException 
    136.      */   
    137.     public List uploadManyFile(String filename, String uploadpath) {   
    138.             boolean flag = true;   
    139.             List l = new ArrayList();  
    140.             StringBuffer strBuf = new StringBuffer();   
    141.             int n = 0; //上传失败的文件个数  
    142.             int m = 0; //上传成功的文件个数  
    143.             try {     
    144.                 ftpClient.setFileType(FTP.BINARY_FILE_TYPE);   
    145.                 ftpClient.enterLocalPassiveMode();   
    146.                 ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);  
    147.                 ftpClient.changeWorkingDirectory("/");   
    148.                 File file = new File(filename);  
    149.                 File fileList[] = file.listFiles();   
    150.                 for (File upfile : fileList) {   
    151.                         if (upfile.isDirectory()) {  
    152.                           uploadManyFile(upfile.getAbsoluteFile().toString(),uploadpath);   
    153.                         } else {   
    154.                             String local = upfile.getCanonicalPath().replaceAll("\\\\","/");  
    155.                             String remote = uploadpath.replaceAll("\\\\","/") + local.substring(local.indexOf("/") + 1);  
    156.                             flag = uploadFile(local, remote);  
    157.                             ftpClient.changeWorkingDirectory("/");  
    158.                         }   
    159.                         if (!flag) {   
    160.                                 n++;  
    161.                                 strBuf.append(upfile.getName() + ",");   
    162.                                 logger.debug("文件［" + upfile.getName() + "］上传失败");  
    163.                         } else{  
    164.                             m++;  
    165.                         }  
    166.                 }   
    167.                 l.add(0, n);  
    168.                 l.add(1, m);  
    169.                 l.add(2, strBuf.toString());  
    170.             } catch (NullPointerException e) {   
    171.                 e.printStackTrace();   
    172.                 logger.debug("本地文件上传失败！找不到上传文件！", e);   
    173.             } catch (Exception e) {   
    174.                 e.printStackTrace();   
    175.                 logger.debug("本地文件上传失败！", e);   
    176.             }   
    177.             return l;  
    178.     }   
    179.   
    180.     /**  
    181.      * 下载文件  
    182.      *  
    183.      * @param remoteFileName             --服务器上的文件名  
    184.      * @param localFileName--本地文件名  
    185.      * @return true 下载成功，false 下载失败  
    186.      */   
    187.     public boolean loadFile(String remoteFileName, String localFileName) {   
    188.         boolean flag = true;   
    189.         // 下载文件   
    190.         BufferedOutputStream buffOut = null;   
    191.         try {   
    192.             buffOut = new BufferedOutputStream(new FileOutputStream(localFileName));   
    193.             flag = ftpClient.retrieveFile(remoteFileName, buffOut);   
    194.         } catch (Exception e) {   
    195.             e.printStackTrace();   
    196.             logger.debug("本地文件下载失败！", e);   
    197.         } finally {   
    198.             try {   
    199.                 if (buffOut != null)   
    200.                     buffOut.close();   
    201.             } catch (Exception e) {   
    202.                 e.printStackTrace();   
    203.             }   
    204.         }   
    205.         return flag;   
    206.     }   
    207.   
    208.     /**  
    209.      * 删除一个文件  
    210.      */   
    211.     public boolean deleteFile(String filename) {   
    212.         boolean flag = true;   
    213.         try {   
    214.             flag = ftpClient.deleteFile(filename);   
    215.             if (flag) {   
    216.                 logger.debug("删除文件"+filename+"成功！");  
    217.             } else {   
    218.                 logger.debug("删除文件"+filename+"成功！");  
    219.             }   
    220.         } catch (IOException ioe) {   
    221.             ioe.printStackTrace();   
    222.         }   
    223.         return flag;   
    224.     }   
    225.   
    226.     /**  
    227.      * 删除目录  
    228.      */   
    229.     public void deleteDirectory(String pathname) {   
    230.         try {   
    231.             File file = new File(pathname);   
    232.             if (file.isDirectory()) {   
    233.                 File file2[] = file.listFiles();   
    234.             } else {   
    235.                 deleteFile(pathname);   
    236.             }   
    237.             ftpClient.removeDirectory(pathname);   
    238.         } catch (IOException ioe) {   
    239.             ioe.printStackTrace();   
    240.         }   
    241.     }   
    242.   
    243.     /**  
    244.      * 删除空目录  
    245.      */   
    246.     public void deleteEmptyDirectory(String pathname) {   
    247.         try {   
    248.             ftpClient.removeDirectory(pathname);   
    249.         } catch (IOException ioe) {   
    250.             ioe.printStackTrace();   
    251.         }   
    252.     }   
    253.   
    254.     /**  
    255.      * 列出服务器上文件和目录  
    256.      *  
    257.      * @param regStr --匹配的正则表达式  
    258.      */   
    259.     public void listRemoteFiles(String regStr) {   
    260.         try {   
    261.             String files[] = ftpClient.listNames(regStr);   
    262.             if (files == null || files.length == 0)   
    263.                 logger.debug("没有任何文件!");  
    264.             else {   
    265.                 for (int i = 0; i < files.length; i++) {   
    266.                     System.out.println(files[i]);   
    267.                 }   
    268.             }   
    269.         } catch (Exception e) {   
    270.             e.printStackTrace();   
    271.         }   
    272.     }   
    273.   
    274.     /**  
    275.      * 列出Ftp服务器上的所有文件和目录  
    276.      */   
    277.     public void listRemoteAllFiles() {   
    278.         try {   
    279.             String[] names = ftpClient.listNames();   
    280.             for (int i = 0; i < names.length; i++) {   
    281.                 System.out.println(names[i]);   
    282.             }   
    283.         } catch (Exception e) {   
    284.             e.printStackTrace();   
    285.         }   
    286.     }   
    287.   
    288.     /**  
    289.      * 关闭连接  
    290.      */   
    291.     public void closeConnect() {   
    292.         try {   
    293.             if (ftpClient != null) {   
    294.                 ftpClient.logout();   
    295.                 ftpClient.disconnect();   
    296.             }   
    297.         } catch (Exception e) {   
    298.             e.printStackTrace();   
    299.         }   
    300.     }   
    301.   
    302.   
    303.     /**  
    304.      * 设置传输文件的类型[文本文件或者二进制文件]  
    305.      *  
    306.      * @param fileType--BINARY_FILE_TYPE、ASCII_FILE_TYPE  
    307.      *  
    308.      */   
    309.     public void setFileType(int fileType) {   
    310.         try {   
    311.             ftpClient.setFileType(fileType);   
    312.         } catch (Exception e) {   
    313.             e.printStackTrace();   
    314.         }   
    315.     }   
    316.   
    317.   
    318.     /**  
    319.      * 设置参数  
    320.      *  
    321.      * @param configFile --参数的配置文件  
    322.      */   
    323.     private boolean setArg(String configFile) {   
    324.         boolean flag = true;  
    325.         property = new Properties();   
    326.         BufferedInputStream inBuff = null;   
    327.         try {   
    328.             inBuff = new BufferedInputStream(new FileInputStream(getClass().getResource("/").getPath() + configFile));   
    329.             property.load(inBuff);   
    330.             userName = property.getProperty("username");   
    331.             password = property.getProperty("password");   
    332.             ip = property.getProperty("ip");   
    333.             port = Integer.parseInt(property.getProperty("port"));   
    334.         } catch (FileNotFoundException e1) {   
    335.             flag = false;  
    336.             logger.debug("配置文件 " + configFile + " 不存在！");  
    337.         } catch (IOException e) {   
    338.             flag = false;  
    339.             logger.debug("配置文件 " + configFile + " 无法读取！");  
    340.         }   
    341.         return flag;  
    342.     }   
    343.   
    344.        
    345.   
    346.     /**  
    347.      * 进入到服务器的某个目录下  
    348.      *  
    349.      * @param directory  
    350.      */   
    351.     public boolean changeWorkingDirectory(String directory) {   
    352.         boolean flag = true;  
    353.         try {   
    354.             flag = ftpClient.changeWorkingDirectory(directory);   
    355.             if (flag) {   
    356.                 logger.debug("进入文件夹"+ directory + " 成功！");  
    357.   
    358.         } else {    
    359.             logger.debug("进入文件夹"+ directory + " 失败！");  
    360.         }   
    361.         } catch (IOException ioe) {   
    362.             ioe.printStackTrace();   
    363.         }   
    364.         return flag;  
    365.     }   
    366.   
    367.     /**  
    368.      * 返回到上一层目录  
    369.      */   
    370.     public void changeToParentDirectory() {   
    371.         try {   
    372.             ftpClient.changeToParentDirectory();   
    373.         } catch (IOException ioe) {   
    374.             ioe.printStackTrace();   
    375.         }   
    376.     }   
    377.   
    378.     /**  
    379.      * 重命名文件  
    380.      *  
    381.      * @param oldFileName --原文件名  
    382.      * @param newFileName --新文件名  
    383.      */   
    384.     public void renameFile(String oldFileName, String newFileName) {   
    385.         try {   
    386.             ftpClient.rename(oldFileName, newFileName);   
    387.         } catch (IOException ioe) {   
    388.             ioe.printStackTrace();   
    389.         }   
    390.     }   
    391.   
    392.     /**  
    393.      * 设置FTP客服端的配置--一般可以不设置  
    394.      *  
    395.      * @return ftpConfig  
    396.      */   
    397.     private FTPClientConfig getFtpConfig() {   
    398.         FTPClientConfig ftpConfig = new FTPClientConfig(FTPClientConfig.SYST_UNIX);   
    399.         ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);   
    400.         return ftpConfig;   
    401.     }   
    402.   
    403.     /**  
    404.      * 转码[ISO-8859-1 -> GBK] 不同的平台需要不同的转码  
    405.      *  
    406.      * @param obj  
    407.      * @return ""  
    408.      */   
    409.     private String iso8859togbk(Object obj) {   
    410.         try {   
    411.             if (obj == null)   
    412.                 return "";   
    413.             else   
    414.                 return new String(obj.toString().getBytes("iso-8859-1"), "GBK");   
    415.         } catch (Exception e) {   
    416.                 return "";   
    417.         }   
    418.     }   
    419.   
    420.     /**  
    421.      * 在服务器上创建一个文件夹  
    422.      *  
    423.      * @param dir 文件夹名称，不能含有特殊字符，如 \ 、/ 、: 、* 、?、 "、 <、>...  
    424.      */   
    425.     public boolean makeDirectory(String dir) {   
    426.         boolean flag = true;   
    427.         try {   
    428.             flag = ftpClient.makeDirectory(dir);   
    429.             if (flag) {   
    430.                 logger.debug("创建文件夹"+ dir + " 成功！");  
    431.   
    432.             } else {    
    433.                 logger.debug("创建文件夹"+ dir + " 失败！");  
    434.             }   
    435.         } catch (Exception e) {   
    436.             e.printStackTrace();   
    437.         }   
    438.         return flag;   
    439.     }  
    440.       
    441.     // 检查路径是否存在，存在返回true，否则false    
    442.     public boolean existFile(String path) throws IOException {      
    443.         boolean flag = false;      
    444.         FTPFile[] ftpFileArr = ftpClient.listFiles(path);      
    445.        /* for (FTPFile ftpFile : ftpFileArr) {     
    446.             if (ftpFile.isDirectory()     
    447.                     && ftpFile.getName().equalsIgnoreCase(path)) {     
    448.                 flag = true;     
    449.                 break;     
    450.             }     
    451.         } */  
    452.         if(ftpFileArr.length > 0){  
    453.             flag = true;      
    454.         }  
    455.         return flag;      
    456.     }    
    457.       
    458.     /** 
    459.      * 递归创建远程服务器目录 
    460.      *  
    461.      * @param remote 
    462.      *            远程服务器文件绝对路径 
    463.      *  
    464.      * @return 目录创建是否成功 
    465.      * @throws IOException 
    466.      */  
    467.      public boolean CreateDirecroty(String remote) throws IOException {  
    468.          boolean success = true;  
    469.          String directory = remote.substring(0, remote.lastIndexOf("/") + 1);  
    470.          // 如果远程目录不存在，则递归创建远程服务器目录  
    471.          if (!directory.equalsIgnoreCase("/")&& !changeWorkingDirectory(new String(directory))) {  
    472.             int start = 0;  
    473.              int end = 0;  
    474.              if (directory.startsWith("/")) {  
    475.                  start = 1;  
    476.              } else {  
    477.                  start = 0;  
    478.              }  
    479.              end = directory.indexOf("/", start);  
    480.              while (true) {  
    481.                  String subDirectory = new String(remote.substring(start, end).getBytes("GBK"),"iso-8859-1");  
    482.                  if (changeWorkingDirectory(subDirectory)) {  
    483.                      if (makeDirectory(subDirectory)) {  
    484.                          changeWorkingDirectory(subDirectory);  
    485.                      } else {  
    486.                         logger.debug("创建目录["+subDirectory+"]失败");  
    487.                         System.out.println("创建目录["+subDirectory+"]失败");  
    488.                          success = false;  
    489.                          return success;  
    490.                      }  
    491.                  }  
    492.                  start = end + 1;  
    493.                  end = directory.indexOf("/", start);  
    494.                  // 检查所有目录是否创建完毕  
    495.                  if (end <= start) {  
    496.                      break;  
    497.                  }  
    498.              }  
    499.          }  
    500.          return success;  
    501.     }  
    502.        
    503.     public static void main(String[] args) {  
    504.         FTPClientTest ftpClient = new FTPClientTest();  
    505.         if(ftpClient.connectServer()){  
    506.             ftpClient.setFileType(FTP.BINARY_FILE_TYPE);// 设置传输二进制文件   
    507.             ftpClient.uploadManyFile("H:\\d", "/d/");   
    508.             ftpClient.closeConnect();// 关闭连接   
    509.         }  
    510.     }  
    511. }  

FTP


联系
我们