`
langzhiwang888
  • 浏览: 182119 次
  • 性别: Icon_minigender_1
  • 来自: 青岛
社区版块
存档分类
最新评论

ftp

 
阅读更多

最近因工作需要，数据库中的数据需要从FTP服务中抽取数据文件然后校检再抽取到数据中。因为第一步需要从FTP服务中抽取数据文件。第二步采用JDBC批量数据更新。

1。采用Apache.FTPClient:

Java代码  收藏代码
  1. /** 
  2.  * Apache.FTPClient FTP操作共公类 
  3.  *  
  4.  * @author 张明学 
  5.  *  
  6.  */  
  7. public class FTPCommon {  
  8.   
  9.     private FTPClient ftpClient;  
  10.   
  11.     private FTPModel ftpModel;  
  12.   
  13.     public FTPCommon(FTPModel ftp) {  
  14.         super();  
  15.         // 从配置文件中读取初始化信息  
  16.         this.ftpClient = new FTPClient();  
  17.         this.ftpModel = ftp;  
  18.     }  
  19.   
  20.     /** 
  21.      * 连接并登录FTP服务器 
  22.      *  
  23.      */  
  24.     public boolean ftpLogin() {  
  25.         boolean isLogin = false;  
  26.         FTPClientConfig ftpClientConfig = new FTPClientConfig(  
  27.                 FTPClientConfig.SYST_NT);  
  28.         ftpClientConfig.setServerTimeZoneId(TimeZone.getDefault().getID());  
  29.         this.ftpClient.setControlEncoding("GBK");  
  30.         this.ftpClient.configure(ftpClientConfig);  
  31.         try {  
  32.             if (this.ftpModel.getPort() > 0) {  
  33.                 this.ftpClient.connect(ftpModel.getUrl(), ftpModel.getPort());  
  34.             } else {  
  35.                 this.ftpClient.connect(ftpModel.getUrl());  
  36.             }  
  37.             // FTP服务器连接回答  
  38.             int reply = this.ftpClient.getReplyCode();  
  39.             if (!FTPReply.isPositiveCompletion(reply)) {  
  40.                 this.ftpClient.disconnect();  
  41.                 return isLogin;  
  42.             }  
  43.             this.ftpClient.login(this.ftpModel.getUsername(), this.ftpModel  
  44.                     .getPassword());  
  45.             this.ftpClient.changeWorkingDirectory(this.ftpModel.getRemoteDir());  
  46.             this.ftpClient.setFileType(FTPClient.FILE_STRUCTURE);  
  47.             LogUtil.infoOutPut("成功登陆FTP服务器：" + this.ftpModel.getUrl() + " 端口号："  
  48.                     + this.getFtpModel().getPort() + " 目录："  
  49.                     + this.ftpModel.getRemoteDir());  
  50.             isLogin = true;  
  51.         } catch (SocketException e) {  
  52.             e.printStackTrace();  
  53.             LogUtil.logPrint("连接FTP服务失败！", Constants.LOG_EXCEPTION);  
  54.             LogUtil.logPrint(e.getMessage(), Constants.LOG_EXCEPTION);  
  55.         } catch (IOException e) {  
  56.             e.printStackTrace();  
  57.             LogUtil.logPrint("登录FTP服务失败！", Constants.LOG_EXCEPTION);  
  58.             LogUtil.logPrint(e.getMessage(), Constants.LOG_EXCEPTION);  
  59.         }  
  60.         System.out.println(this.ftpClient.getBufferSize());  
  61.         this.ftpClient.setBufferSize(1024 * 2);  
  62.         this.ftpClient.setDataTimeout(2000);  
  63.         return isLogin;  
  64.     }  
  65.   
  66.     /** 
  67.      * 退出并关闭FTP连接 
  68.      *  
  69.      */  
  70.     public void close() {  
  71.         if (null != this.ftpClient && this.ftpClient.isConnected()) {  
  72.             try {  
  73.                 boolean reuslt = this.ftpClient.logout();// 退出FTP服务器  
  74.                 if (reuslt) {  
  75.                     LogUtil.info("退出并关闭FTP服务器的连接");  
  76.                 }  
  77.             } catch (IOException e) {  
  78.                 e.printStackTrace();  
  79.                 LogUtil.exception("退出FTP服务器异常！");  
  80.                 LogUtil.exception(e.getMessage());  
  81.             } finally {  
  82.                 try {  
  83.                     this.ftpClient.disconnect();// 关闭FTP服务器的连接  
  84.                 } catch (IOException e) {  
  85.                     e.printStackTrace();  
  86.                     LogUtil.exception("关闭FTP服务器的连接异常！");  
  87.                     LogUtil.exception(e.getMessage());  
  88.                 }  
  89.             }  
  90.         }  
  91.     }  
  92.   
  93.     /** 
  94.      * 检查FTP服务器是否关闭 ，如果关闭接则连接登录FTP 
  95.      *  
  96.      * @return 
  97.      */  
  98.     public boolean isOpenFTPConnection() {  
  99.         boolean isOpen = false;  
  100.         if (null == this.ftpClient) {  
  101.             return false;  
  102.         }  
  103.         try {  
  104.             // 没有连接  
  105.             if (!this.ftpClient.isConnected()) {  
  106.                 isOpen = this.ftpLogin();  
  107.             }  
  108.         } catch (Exception e) {  
  109.             e.printStackTrace();  
  110.             LogUtil.exception("FTP服务器连接登录异常！");  
  111.             LogUtil.exception(e.getMessage());  
  112.             isOpen = false;  
  113.         }  
  114.         return isOpen;  
  115.     }  
  116.   
  117.     /** 
  118.      * 设置传输文件的类型[文本文件或者二进制文件] 
  119.      *  
  120.      * @param fileType--FTPClient.BINARY_FILE_TYPE,FTPClient.ASCII_FILE_TYPE 
  121.      */  
  122.     public void setFileType(int fileType) {  
  123.         try {  
  124.             this.ftpClient.setFileType(fileType);  
  125.         } catch (IOException e) {  
  126.             e.printStackTrace();  
  127.             LogUtil.exception("设置传输文件的类型异常！");  
  128.             LogUtil.exception(e.getMessage());  
  129.         }  
  130.     }  
  131.   
  132.     /** 
  133.      * 下载文件 
  134.      *  
  135.      * @param localFilePath 
  136.      *            本地文件名及路径 
  137.      * @param remoteFileName 
  138.      *            远程文件名称 
  139.      * @return 
  140.      */  
  141.     public boolean downloadFile(String localFilePath, String remoteFileName) {  
  142.         BufferedOutputStream outStream = null;  
  143.         boolean success = false;  
  144.         try {  
  145.             outStream = new BufferedOutputStream(new FileOutputStream(  
  146.                     localFilePath));  
  147.             success = this.ftpClient.retrieveFile(remoteFileName, outStream);  
  148.         } catch (FileNotFoundException e) {  
  149.             e.printStackTrace();  
  150.         } catch (IOException e) {  
  151.             e.printStackTrace();  
  152.         } finally {  
  153.             if (outStream != null) {  
  154.                 try {  
  155.                     outStream.flush();  
  156.                     outStream.close();  
  157.                 } catch (IOException e) {  
  158.                     e.printStackTrace();  
  159.                 }  
  160.             }  
  161.         }  
  162.         return success;  
  163.     }  
  164.   
  165.     /** 
  166.      * 下载文件 
  167.      *  
  168.      * @param localFilePath 
  169.      *            本地文件 
  170.      * @param remoteFileName 
  171.      *            远程文件名称 
  172.      * @return 
  173.      */  
  174.     public boolean downloadFile(File localFile, String remoteFileName) {  
  175.         BufferedOutputStream outStream = null;  
  176.         FileOutputStream outStr = null;  
  177.         boolean success = false;  
  178.         try {  
  179.             outStr = new FileOutputStream(localFile);  
  180.             outStream = new BufferedOutputStream(outStr);  
  181.             success = this.ftpClient.retrieveFile(remoteFileName, outStream);  
  182.         } catch (FileNotFoundException e) {  
  183.             e.printStackTrace();  
  184.         } catch (IOException e) {  
  185.             e.printStackTrace();  
  186.         } finally {  
  187.             try {  
  188.                 if (null != outStream) {  
  189.                     try {  
  190.                         outStream.flush();  
  191.                         outStream.close();  
  192.                     } catch (IOException e) {  
  193.                         e.printStackTrace();  
  194.                     }  
  195.                 }  
  196.             } catch (Exception e) {  
  197.                 e.printStackTrace();  
  198.             } finally {  
  199.                 if (null != outStr) {  
  200.                     try {  
  201.                         outStr.flush();  
  202.                         outStr.close();  
  203.                     } catch (IOException e) {  
  204.                         e.printStackTrace();  
  205.                     }  
  206.   
  207.                 }  
  208.             }  
  209.         }  
  210.         return success;  
  211.     }  
  212.   
  213.     /** 
  214.      * 上传文件 
  215.      *  
  216.      * @param localFilePath 
  217.      *            本地文件路径及名称 
  218.      * @param remoteFileName 
  219.      *            FTP 服务器文件名称 
  220.      * @return 
  221.      */  
  222.     public boolean uploadFile(String localFilePath, String remoteFileName) {  
  223.         BufferedInputStream inStream = null;  
  224.         boolean success = false;  
  225.         try {  
  226.             inStream = new BufferedInputStream(new FileInputStream(  
  227.                     localFilePath));  
  228.             success = this.ftpClient.storeFile(remoteFileName, inStream);  
  229.         } catch (FileNotFoundException e) {  
  230.             e.printStackTrace();  
  231.         } catch (IOException e) {  
  232.             e.printStackTrace();  
  233.         } finally {  
  234.             if (inStream != null) {  
  235.                 try {  
  236.                     inStream.close();  
  237.                 } catch (IOException e) {  
  238.                     e.printStackTrace();  
  239.                 }  
  240.             }  
  241.         }  
  242.         return success;  
  243.     }  
  244.   
  245.     /** 
  246.      * 上传文件 
  247.      *  
  248.      * @param localFilePath 
  249.      *            本地文件 
  250.      * @param remoteFileName 
  251.      *            FTP 服务器文件名称 
  252.      * @return 
  253.      */  
  254.     public boolean uploadFile(File localFile, String remoteFileName) {  
  255.         BufferedInputStream inStream = null;  
  256.         boolean success = false;  
  257.         try {  
  258.             inStream = new BufferedInputStream(new FileInputStream(localFile));  
  259.             success = this.ftpClient.storeFile(remoteFileName, inStream);  
  260.         } catch (FileNotFoundException e) {  
  261.             e.printStackTrace();  
  262.         } catch (IOException e) {  
  263.             e.printStackTrace();  
  264.         } finally {  
  265.             if (inStream != null) {  
  266.                 try {  
  267.                     inStream.close();  
  268.                 } catch (IOException e) {  
  269.                     e.printStackTrace();  
  270.                 }  
  271.             }  
  272.         }  
  273.         return success;  
  274.     }  
  275.   
  276.     /** 
  277.      * 变更工作目录 
  278.      *  
  279.      * @param remoteDir--目录路径 
  280.      */  
  281.     public void changeDir(String remoteDir) {  
  282.         try {  
  283.             this.ftpClient.changeWorkingDirectory(remoteDir);  
  284.             LogUtil.info("变更工作目录为:" + remoteDir);  
  285.         } catch (IOException e) {  
  286.             e.printStackTrace();  
  287.             LogUtil.exception("变更工作目录为:" + remoteDir + "时出错！");  
  288.             LogUtil.exception(e.getMessage());  
  289.         }  
  290.   
  291.     }  
  292.   
  293.     /** 
  294.      * 变更工作目录 
  295.      *  
  296.      * @param remoteDir--目录路径 
  297.      */  
  298.     public void changeDir(String[] remoteDirs) {  
  299.         String dir = "";  
  300.         try {  
  301.             for (int i = 0; i < remoteDirs.length; i++) {  
  302.                 this.ftpClient.changeWorkingDirectory(remoteDirs[i]);  
  303.                 dir = dir + remoteDirs[i] + "/";  
  304.             }  
  305.             LogUtil.info("变更工作目录为:" + dir);  
  306.         } catch (IOException e) {  
  307.             e.printStackTrace();  
  308.             LogUtil.exception("变更工作目录为:" + dir + "时出错！");  
  309.             LogUtil.exception(e.getMessage());  
  310.         }  
  311.   
  312.     }  
  313.   
  314.     /** 
  315.      * 返回上级目录 
  316.      *  
  317.      */  
  318.     public void toParentDir(String[] remoteDirs) {  
  319.         try {  
  320.             for (int i = 0; i < remoteDirs.length; i++) {  
  321.                 this.ftpClient.changeToParentDirectory();  
  322.             }  
  323.             LogUtil.info("返回上级目录");  
  324.         } catch (IOException e) {  
  325.             e.printStackTrace();  
  326.             LogUtil.exception("返回上级目录时出错！");  
  327.             LogUtil.exception(e.getMessage());  
  328.         }  
  329.     }  
  330.   
  331.     /** 
  332.      * 返回上级目录 
  333.      *  
  334.      */  
  335.     public void toParentDir() {  
  336.         try {  
  337.             this.ftpClient.changeToParentDirectory();  
  338.             LogUtil.info("返回上级目录");  
  339.         } catch (IOException e) {  
  340.             e.printStackTrace();  
  341.             LogUtil.exception("返回上级目录时出错！");  
  342.             LogUtil.exception(e.getMessage());  
  343.         }  
  344.     }  
  345.   
  346.     /** 
  347.      * 获得FTP 服务器下所有的文件名列表 
  348.      *  
  349.      * @param regex 
  350.      * @return 
  351.      */  
  352.     public String[] getListFiels() {  
  353.         String files[] = null;  
  354.         try {  
  355.             files = this.ftpClient.listNames();  
  356.         } catch (IOException e) {  
  357.             e.printStackTrace();  
  358.         }  
  359.         return files;  
  360.     }  
  361.   
  362.     public FTPClient getFtpClient() {  
  363.         return ftpClient;  
  364.     }  
  365.   
  366.     public FTPModel getFtpModel() {  
  367.         return ftpModel;  
  368.     }  
  369.   
  370.     public void setFtpModel(FTPModel ftpModel) {  
  371.         this.ftpModel = ftpModel;  
  372.     }  
  373.   
  374. }  

 2。采用FTP4J:

Java代码  收藏代码
  1. /** 
  2.  * ftp4j FTP操作共公类 
  3.  *  
  4.  * @author 张明学 
  5.  *  
  6.  */  
  7. public class FTP4JCommon {  
  8.     FTPClient ftpClient = null;  
  9.   
  10.     FTPModel ftpModel = null;  
  11.   
  12.     public FTP4JCommon() {  
  13.   
  14.     }  
  15.   
  16.     public FTP4JCommon(FTPModel ftpModel) {  
  17.         this.ftpModel = ftpModel;  
  18.     }  
  19.   
  20.     /** 
  21.      * 连接并登录FTP服务器 
  22.      *  
  23.      */  
  24.     public boolean ftpLogin() {  
  25.         ftpClient = new FTPClient();  
  26.         try {  
  27.             // 建立连接  
  28.             ftpClient.connect(ftpModel.getUrl());  
  29.             ftpClient.setType(FTPClient.TYPE_AUTO);  
  30.             ftpClient.setCharset("GBK");  
  31.         } catch (Exception e) {  
  32.             e.printStackTrace();  
  33.             LogUtil.infoOutPut("与FTP服务器建立连接失败！");  
  34.             LogUtil.exception(e.getMessage());  
  35.         }  
  36.         try {  
  37.             ftpClient.login(ftpModel.getUsername(), ftpModel.getPassword());  
  38.         } catch (Exception e) {  
  39.             e.printStackTrace();  
  40.             LogUtil.infoOutPut("登录FTP服务器失败！");  
  41.             LogUtil.exception(e.getMessage());  
  42.         }  
  43.         return true;  
  44.     }  
  45.   
  46.     /** 
  47.      * 退出并关闭FTP连接 
  48.      *  
  49.      */  
  50.     public void close() {  
  51.         if (null != ftpClient) {  
  52.             try {  
  53.                 ftpClient.disconnect(true);  
  54.             } catch (Exception e) {  
  55.                 e.printStackTrace();  
  56.                 LogUtil.infoOutPut("安全退出FTP服务时异常！");  
  57.                 LogUtil.exception(e.getMessage());  
  58.             }  
  59.         }  
  60.     }  
  61.   
  62.     /** 
  63.      * 下载文件 
  64.      *  
  65.      * @param localFilePath 
  66.      *            本地文件名及路径 
  67.      * @param remoteFileName 
  68.      *            远程文件名称 
  69.      * @return 
  70.      * @throws Exception 
  71.      */  
  72.     public void downloadFile(String localFilePath, String remoteFileName)  
  73.             throws Exception {  
  74.         File localFile = new File(localFilePath);  
  75.         try {  
  76.             ftpClient.download(remoteFileName, localFile);  
  77.         } catch (Exception e) {  
  78.             e.printStackTrace();  
  79.             LogUtil.infoOutPut("下载" + remoteFileName + "时出现异常！");  
  80.             LogUtil.exception(e.getMessage());  
  81.             throw e;  
  82.         }  
  83.     }  
  84.   
  85.     /** 
  86.      * 下载文件 
  87.      *  
  88.      * @param localFilePath 
  89.      *            本地文件名及路径 
  90.      * @param remoteFileName 
  91.      *            远程文件名称 
  92.      * @return 
  93.      * @throws Exception 
  94.      */  
  95.     public void downloadFile(File localFile, String remoteFileName)  
  96.             throws Exception {  
  97.         try {  
  98.             ftpClient.download(remoteFileName, localFile);  
  99.         } catch (Exception e) {  
  100.             e.printStackTrace();  
  101.             LogUtil.infoOutPut("下载" + remoteFileName + "时出现异常！");  
  102.             LogUtil.exception(e.getMessage());  
  103.             throw e;  
  104.         }  
  105.     }  
  106.   
  107.     /** 
  108.      * 获得FTP 服务器下所有的文件名列表 
  109.      *  
  110.      * @param regex 
  111.      * @return 
  112.      */  
  113.     public String[] getListFiels() {  
  114.         String fileNames[] = null;  
  115.         try {  
  116.             fileNames = this.ftpClient.listNames();  
  117.         } catch (Exception e) {  
  118.             e.printStackTrace();  
  119.             LogUtil.infoOutPut("获取文件名列表时出现异常！");  
  120.             LogUtil.exception(e.getMessage());  
  121.         }  
  122.         return fileNames;  
  123.     }  
  124.   
  125.     public FTPModel getFtpModel() {  
  126.         return ftpModel;  
  127.     }  
  128.   
  129.     public void setFtpModel(FTPModel ftpModel) {  
  130.         this.ftpModel = ftpModel;  
  131.     }  
  132.   
  133.     public FTPClient getFtpClient() {  
  134.         return ftpClient;  
  135.     }  
  136.   
  137. }  

 3。采用：jftp下载

Java代码  收藏代码
  1. /** 
  2.  * jftp FTP下载操作 
  3.  *  
  4.  * @author 张明学 
  5.  *  
  6.  */  
  7. public class JFTPDownloadCommon implements ConnectionListener {  
  8.   
  9.     private boolean isThere = false;  
  10.   
  11.     public static long time = 0;  
  12.   
  13.     private FTPModel ftpModel = null;  
  14.   
  15.     private ConnectionHandler handler = new ConnectionHandler();  
  16.   
  17.     private FtpConnection ftpcon = null;  
  18.   
  19.     public JFTPDownloadCommon(FTPModel ftpModel) {  
  20.         this.ftpModel = ftpModel;  
  21.         // 登录FTP  
  22.         this.ftpLogin();  
  23.     }  
  24.   
  25.     /** 
  26.      * 连接并登录FTP服务器 
  27.      *  
  28.      */  
  29.     public boolean ftpLogin() {  
  30.         ftpcon = new FtpConnection(this.ftpModel.getUrl());  
  31.         ftpcon.addConnectionListener(this);  
  32.         ftpcon.setConnectionHandler(handler);  
  33.         // 登录  
  34.         ftpcon.login(ftpModel.getUsername(), ftpModel.getPassword());  
  35.         while (!isThere) {  
  36.             try {  
  37.                 Thread.sleep(10);  
  38.             } catch (Exception ex) {  
  39.                 ex.printStackTrace();  
  40.             }  
  41.         }  
  42.         LogUtil.infoOutPut("是否登录成功：" + isThere);  
  43.         return isThere;  
  44.     }  
  45.   
  46.     /** 
  47.      * 关闭与FTP服务器的连接 
  48.      *  
  49.      */  
  50.     public void close() {  
  51.         ftpcon.disconnect();  
  52.         LogUtil.infoOutPut("关闭与FTP的连接");  
  53.     }  
  54.   
  55.     /** 
  56.      * 获得FTP 服务器下所有的文件名列表 
  57.      *  
  58.      * @param regex 
  59.      * @return 
  60.      */  
  61.     public String[] getListFiels() {  
  62.         ftpcon.exists("");  
  63.         Vector fileNameVector = ftpcon.currentFiles;  
  64.         String[] fileNames = new String[fileNameVector.size()];  
  65.         int i = 0;  
  66.         for (Iterator iter = fileNameVector.iterator(); iter.hasNext();) {  
  67.             String name = (String) iter.next();  
  68.             fileNames[i] = name;  
  69.             i++;  
  70.         }  
  71.         return fileNames;  
  72.     }  
  73.   
  74.     /** 
  75.      * 将FTP服务器上的file下载为bype型数据 
  76.      *  
  77.      * @param remoteFileName 
  78.      *            文件名 
  79.      * @return 
  80.      */  
  81.     public byte[] downloadToBinary(String remoteFileName) {  
  82.         Settings.bufferSize = 16384;  
  83.         long current = System.currentTimeMillis();  
  84.         byte[] bytes = null;  
  85.         try {  
  86.             InputStream is = ftpcon.getDownloadInputStream(remoteFileName);  
  87.             ByteArrayOutputStream bais = new ByteArrayOutputStream();  
  88.             int bit = 0;  
  89.             while ((bit = is.read()) != -1) {  
  90.                 bais.write(bit);  
  91.             }  
  92.             bytes = bais.toByteArray();  
  93.         } catch (Exception e) {  
  94.         }  
  95.         time = (System.currentTimeMillis() - current);  
  96.         System.out.println("下载花费时间：" + time + "ms.");  
  97.         return bytes;  
  98.     }  
  99.   
  100.     /** 
  101.      * 下载FTP服务器文件 
  102.      *  
  103.      * @param remoteFileName 
  104.      *            FTP服务器文件名 
  105.      * @param localFile 
  106.      *            本地文件名 
  107.      * @return 
  108.      * @throws Exception 
  109.      */  
  110.     public void downloadToBinary(String remoteFileName, File localFile)  
  111.             throws Exception {  
  112.         Settings.bufferSize = 16384;  
  113.         byte[] bytes = null;  
  114.         InputStream is = ftpcon.getDownloadInputStream(remoteFileName);  
  115.         ByteArrayOutputStream bais = new ByteArrayOutputStream();  
  116.         int bit = 0;  
  117.         while ((bit = is.read()) != -1) {  
  118.             bais.write(bit);  
  119.         }  
  120.         bytes = bais.toByteArray();  
  121.         CopyByteDataToLoacal(localFile, bytes);  
  122.   
  123.     }  
  124.   
  125.     /** 
  126.      * 将二进制文件下载到本地 
  127.      *  
  128.      * @param localFile 
  129.      *            目标文件名 
  130.      * @param fileDatas 
  131.      *            文件数据 
  132.      * @throws IOException 
  133.      */  
  134.     public void CopyByteDataToLoacal(File localFile, byte[] fileDatas)  
  135.             throws IOException {  
  136.         FileOutputStream fileOutStream = null;  
  137.         BufferedOutputStream bufferOutStream = null;  
  138.         try {  
  139.             if (localFile.exists()) {  
  140.                 localFile.delete();  
  141.             }  
  142.             fileOutStream = new FileOutputStream(localFile);  
  143.             bufferOutStream = new BufferedOutputStream(fileOutStream);  
  144.             bufferOutStream.write(fileDatas);  
  145.         } catch (FileNotFoundException e) {  
  146.             LogUtil.exception(e.getMessage());  
  147.             throw e;  
  148.         } catch (IOException e) {  
  149.             LogUtil.exception(e.getMessage());  
  150.             throw e;  
  151.         } finally {  
  152.             try {  
  153.                 if (null != bufferOutStream) {  
  154.                     bufferOutStream.flush();  
  155.                     bufferOutStream.close();  
  156.                 }  
  157.             } catch (IOException e) {  
  158.                 e.printStackTrace();  
  159.             } finally {  
  160.                 if (null != fileOutStream) {  
  161.                     try {  
  162.                         fileOutStream.flush();  
  163.                         fileOutStream.close();  
  164.                     } catch (IOException e) {  
  165.                         e.printStackTrace();  
  166.                     }  
  167.                 }  
  168.             }  
  169.         }  
  170.     }  
  171.   
  172.     public void connectionFailed(BasicConnection arg0, String arg1) {  
  173.         LogUtil.infoOutPut("与FTP服务器连接失败!");  
  174.     }  
  175.   
  176.     public void connectionInitialized(BasicConnection arg0) {  
  177.         isThere = true;  
  178.     }  
  179.   
  180.     public void updateRemoteDirectory(BasicConnection arg0) {  
  181.     }  
  182.   
  183.     public void updateProgress(String arg0, String arg1, long arg2) {  
  184.     }  
  185.   
  186.     public void actionFinished(BasicConnection arg0) {  
  187.     }  
  188.   
  189. }  

上面都用到了一个ftpModel如下(get,set方法省了)：

Java代码  收藏代码
  1. /** 
  2.  * FTP实体对象 
  3.  *  
  4.  * @author 张明学 
  5.  *  
  6.  */  
  7. public class FTPModel {  
  8.   
  9.     private String ftpId;  
  10.   
  11.     private String username;  
  12.   
  13.     private String password;  
  14.   
  15.     private String url;  
  16.   
  17.     private int port;  
  18.   
  19.     private String remoteDir;  
  20.   
  21.     public FTPModel() {  
  22.   
  23.     }  
  24.   
  25.     public FTPModel(String username, String password, String url, int port,  
  26.             String remoteDir) {  
  27.         this.username = username;  
  28.         this.password = password;  
  29.         this.url = url;  
  30.         this.port = port;  
  31.         this.remoteDir = remoteDir;  
  32.     }  
  33. }  
 

上述仅仅列出了一点常用的操作，更多的操作需要参看它的们API文件。

 

还有，我采用的Serv-U作为FTP服务器，按装之后新建用户不法登录。后来找到了原因是：要把IIS服务中的FTP服务关掉。

分享到：
| ie6,ie7兼容性总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    webftp.zip ftp源码

    WebFTP是一种基于Web的FTP（File Transfer Protocol）客户端软件，允许用户通过网页浏览器进行FTP文件传输操作。在本文中，我们将深入探讨FTP的基本概念、WebFTP的工作原理以及它在实际应用中的重要性。 FTP，全称...

    FTP服务器单文件绿色版FTPServer

    FTP服务器是一种用于在互联网上进行文件传输的服务，它允许用户从一台计算机（客户端）向另一台计算机（服务器）上传或下载文件。FTP（File Transfer Protocol）是这项服务的基础协议，它是一个标准网络协议，用于在...

    使用 ftp-srv 在 nodejs 创建FTP服务器，简单版

    FTP（File Transfer Protocol）是一种广泛使用的网络协议，用于在计算机之间传输文件。在这个场景中，我们将探讨如何使用Node.js中的`ftp-srv`库来创建一个简单的FTP服务器。`ftp-srv`是一个易于使用的FTP服务器模块...

    传送图片至FTP及显示FTP上图片

    在IT行业中，FTP（File Transfer Protocol）是一种广泛用于在互联网上传输文件的协议。本教程将详细介绍如何将图片传输到FTP服务器以及如何在FTP服务器上显示这些图片。 首先，我们需要理解FTP的基本工作原理。FTP...

    ftp.rar_ftpput_ftpput ftpget_实现ftpget与ftpput功能

    FTP（File Transfer Protocol）是一种基于TCP/IP协议的网络协议，用于在网络上进行文件传输。本文将详细探讨如何实现FTP客户端的两个关键功能：FTPGET（下载文件）和FTPPUT（上传文件），以及这两个功能在实际应用中...

    webFTP一个PHP写的在线FTP文件管理系统

    **webFTP概述** webFTP是一个基于PHP开发的在线FTP文件管理系统，它允许用户通过Web界面进行FTP服务器的文件管理和操作，极大地提升了FTP管理的便捷性和灵活性。作为一个轻量级的解决方案，webFTP使得用户无需安装...

    QT5.0实现FTP服务器

    FTP（File Transfer Protocol）是一种标准网络协议，用于在计算机网络上在客户端和服务器之间传输文件。在QT5.0中实现FTP服务器，可以让我们自定义一个能够处理文件上传和下载的服务，这对于开发文件管理或共享应用...

    麒麟V10服务器搭建FTP服务

    麒麟V10服务器搭建FTP服务 FTP（File Transfer Protocol）是一种常用的文件传输协议，麒麟V10服务器搭建FTP服务可以帮助用户快速搭建FTP服务器，实现文件的上传、下载和共享。本文将指导用户如何在麒麟V10服务器上...

    详解ftp创建文件权限问题

    详解ftp创建文件权限问题 一、问题 有一个这样的需求，admin为一个Linux为其FTP应用创建的一个有权限限制的用户，通过admin用户可以进行登录FTP服务，登录FTP服务后，创建文件夹，该文件夹的用户和用户组都是admin，...

    一个FTP客户端

    如果用本FTP客户端登录某个FTP服务器，则先必须申请一个FTP空间，申请FTP空间时，它会给你一个FTP主机地址、用户名称、用户密码。 测试步骤： 1、项目编译并运行。 2、申请一个FTP空间（这里不讨论）。 3、输入FTP...

    ftp4j-一个开源的支持代理的FTP组件

    ftp4j是个很年轻的开源项目，但是试用后发现很好很强大，如果你找一个纯java的FTP库，要支持socks4，socks4a，socks5，http代理，就是他了！ 比apache的FTPClient（不支持代理）、半商业的edtFTPj（PRO支持代理，...

    ftp批量上传文件bat

    实现FTP批量上传文件到指定目录功能的bat脚本： @echo off @echo delete iplist.txt @del iplist.txt @setlocal EnableDelayedExpansion @echo create upload iplist.... @for /L %%i in (51,1,52) do ( @echo ...

    FTP开源代码 C++

    FTP（File Transfer Protocol）是一种广泛使用的网络协议，用于在互联网上进行文件传输。在这个开源代码库中，我们关注的是C++实现的FTP客户端或服务器端的代码，这为理解和学习FTP工作原理提供了宝贵资源。 首先，...

    QT5.0实现FTP客户端

    2. **QNAM与FTP**：虽然QNetworkAccessManager没有直接提供FTP操作的接口，但可以通过构造一个QNAM的子类并重写其内部的槽函数，来监听FTP相关的信号，从而实现FTP客户端功能。 3. **QNetworkRequest**：创建...

    FTP服务器绿色单文件中文免费版(FTPserver)

    FTP服务器绿色单文件中文免费版(FTPserver) FTPserver这是一款免费的、绿色的(无需安装，只有一个文件)、小巧的(84KB)的FTP服务器软件。可以轻松地将它放在U盘里，邮箱里，网盘里，或者网站上随时下载，这样，就有了...

    FTP Utility 2.0 日文

    FTP Utility 2.0 是一款由柯尼卡美能达公司开发的日文版FTP客户端工具，主要用于方便用户在计算机和远程服务器之间传输文件。这款软件适用于企业或个人，特别是那些需要频繁进行文件上传和下载的用户。通过FTP ...

    FTP被动模式分析，ftp抓包分析

    FTP 的两种不同工作模式：PORT（主动模式）与PASV（被动模式） 1、首先，我们要了解，FTP 工作的时候，需要用到两个连接：控制连接与数据连接，控制 连接专门用于FTP 控制命令及命令执行信息传送；数据连接专门用于...

    FTP客户端绿色版安装包

    FTP客户端绿色版安装包是一种无需正式安装即可使用的文件传输协议（FTP）客户端工具。FTP是Internet上用于在不同计算机之间交换文件的标准协议，而“绿色版”指的是这种软件不需通过传统的安装步骤，只需解压即可...

    Andftp pro 已付费

    《Andftp Pro：安卓FTP传输神器的深度解析》 在当今移动设备高度发达的时代，文件传输的需求日益增长，尤其是在IT行业内。Andftp pro是一款专为安卓用户设计的专业FTP（File Transfer Protocol）传输工具，它以其...

Magicbox
Global site tag (gtag.js) - Google Analytics