用Apache Jakarta的common-net包写的访问FTP的程式

use : commons-net-1.4.1

package  com.sinomos.rpt.bean;

import  java.io.BufferedInputStream;
import  java.io.BufferedOutputStream;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;

import  org.apache.commons.net.ftp.FTPClient;
import  org.apache.commons.net.ftp.FTPClientConfig;
import  org.apache.commons.net.ftp.FTPConnectionClosedException;

/** */ /**
 * @applicability 10.1.10.19 10.1.10.20
 */
public   class  uFtp  ... {
    
    private FTPClient ftpClient = null;
    
    //private OutputStream outSteam = null;
    
    //ftp服务器地址
    private String hostName;
    
    //ftp服务器默认端口
    public static int defaultport = 21;
        
    //登录名
    private String userName;
        
    //登录密码   
    private String password;
        
    //需要访问的远程目录
    private String remoteDir;
    
    /** *//**
     * @param hostName    主机地址
     * @param port        端口号
     * @param userName    用户名
     * @param password    密码
     * @param remoteDir    默认工作目录
     * @param is_zhTimeZone    是否是中文FTP Server端
     * @return
     */
    public uFtp(String hostName,int port,String userName,String password,String remoteDir,boolean is_zhTimeZone) ...{
        this.hostName=hostName;
        this.userName=userName;
        this.password=password;
        this.remoteDir=remoteDir==null?"":remoteDir;        
        this.ftpClient = new FTPClient();
        if(is_zhTimeZone) ...{
            this.ftpClient.configure(uFtp.Config());
            this.ftpClient.setControlEncoding("GBK");
        }
        this.login();
        this.changeDir(this.remoteDir);
        this.setFileType(FTPClient.ASCII_FILE_TYPE);
        //this.changeDir(this.remoteDir);
        ftpClient.setDefaultPort(port);
    }    
    
    /** *//**
     * 登录FTP服务器
     */
    public void login() ...{
        try ...{
            ftpClient.connect(this.hostName);            
            ftpClient.login(this.userName, this.password);
        } catch (FTPConnectionClosedException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("连接到ftp服务器：" + this.hostName + " 成功..开始登录");
    }
    //FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
    
    private static FTPClientConfig Config() ...{
        FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
        conf.setRecentDateFormatStr("MM月dd日 HH:mm");
        //conf.setRecentDateFormatStr("(YYYY年)?MM月dd日( HH:mm)?");
        return conf;
    }
    /** *//**
     * 变更工作目录
     * @param remoteDir--目录路径 
     */
    public void changeDir(String remoteDir) ...{
        try ...{
            this.remoteDir = remoteDir;
            ftpClient.changeWorkingDirectory(remoteDir);
        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("变更工作目录为:"+remoteDir);
    }
    
    /** *//**
     * 返回上一级目录(父目录)
     */
    public void ToParentDir() ...{
        try ...{
            ftpClient.changeToParentDirectory();
        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    /** *//**
     * 列出当前工作目录下所有文件
     */
    public String[] ListAllFiles() ...{
        String[] names=this.ListFiles("*");
        return this.sort(names);
    }
    
    /** *//**
     * 列出指定工作目录下的匹配文件
     * @param dir exp: /cim/
     * @param file_regEx 通配符为*
     */
    public String[] ListAllFiles(String dir,String file_regEx) ...{
        String[] names=this.ListFiles(dir+file_regEx);
        return this.sort(names);
    }
    
    /** *//**
     * 列出匹配文件
     * @param file_regEx 匹配字符,通配符为*
     */
    public String[] ListFiles(String file_regEx) ...{
        try ...{
            /**//*
            FTPFile[] remoteFiles = ftpClient.listFiles(file_regEx);
            //System.out.println(remoteFiles.length);
            String[] name = new String[remoteFiles.length];
            if(remoteFiles != null) {
                for(int i=0;i<remoteFiles.length;i++) {
                    if(remoteFiles[i] == null)
                        name[i] = "";
                    else if(remoteFiles[i].getName()==null||remoteFiles[i].getName().equals(".")||remoteFiles[i].getName().equals("..")) {
                        name[i] = "";
                    }
                    else name[i] = remoteFiles[i].getName();
                    System.out.println(name[i]);
                }
            }
            */
            String[] name = ftpClient.listNames(file_regEx);
            if(name==null) 
                return new String[0];
            return this.sort(name);
        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return new String[0];
    }
    
    public void Lists(String reg) ...{
        try ...{
            String[] a=ftpClient.listNames(reg);
            for(String b:a) ...{
                System.out.println(b);
            }
        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    /** *//**
     * 设置传输文件的类型[文本文件或者二进制文件]
     * @param fileType--BINARY_FILE_TYPE,ASCII_FILE_TYPE 
     */
    public void setFileType(int fileType)...{
        try...{
            ftpClient.setFileType(fileType);
        }catch(IOException e)...{
            e.printStackTrace();
        }
    }
    
    /** *//**
     * 上传文件
     * @param localFilePath--本地文件路径+文件名
     * @param newFileName--新的文件名
     */
    public void uploadFile(String localFilePath,String newFileName)...{
        //上传文件
        BufferedInputStream buffIn=null;
        try...{
            buffIn=new BufferedInputStream(new FileInputStream(localFilePath));
            ftpClient.storeFile(newFileName, buffIn);
        }catch(Exception e)...{
            e.printStackTrace();
        }finally...{
            try...{
                if(buffIn!=null)
                    buffIn.close();
            }catch(Exception e)...{
                e.printStackTrace();
            }
        }
    }
    
    /** *//**
     * 下载文件(单个)
     * @param remoteFileName --服务器上的文件名
     * @param localFileName--本地文件名
     */
    public String downloadFile(String remoteFileName,String localFileName)...{
        BufferedOutputStream buffOut=null;
        try...{
            buffOut=new BufferedOutputStream(new FileOutputStream(localFileName));
            ftpClient.retrieveFile(remoteFileName, buffOut);
        }catch(Exception e)...{
            e.printStackTrace();
            return "";
        }finally...{
            try...{
                if(buffOut!=null)
                    buffOut.close();
            }catch(Exception e)...{
                e.printStackTrace();
            }
        }
        return localFileName;
    }
    
    /** *//**
     * 关闭FTP连接
     */
    public void close() ...{
        try...{
            if(ftpClient!=null)...{
                ftpClient.logout();
                ftpClient.disconnect();
            }
        }catch (Exception e)...{
            e.printStackTrace();
        }
    }
    
    /** *//**
     * 冒泡排序字符串(从大到小)
     */
    public String[] sort(String[] str_Array) ...{
        if(str_Array==null) ...{
            throw new NullPointerException("The str_Array can not be null!");
        }
        String tmp = "";
        for(int i=0;i<str_Array.length;i++) ...{
            for(int j=0;j<str_Array.length-i-1;j++) ...{
                if(str_Array[j].compareTo(str_Array[j+1])<0) ...{
                    tmp = str_Array[j];
                    str_Array[j] = str_Array[j + 1];
                    str_Array[j + 1] = tmp;
                }
            }
        }
        return str_Array;
    }

    /** *//**
     * @param args
     */
    public static void main(String[] args) ...{
        // TODO Auto-generated method stub
        
        //String[] files = null;
        uFtp ftp = new uFtp("10.1.10.19",uFtp.defaultport,"eda","sinomos","/tyne_home/wat/db/",true);
        //uftp.ListFiles();
        //ftp.changeDir("/tyne_home/wat/db/");
        //String[] s = ftp.ListFiles("*SN_141*.wdf");
        //System.out.println(s.length);
        ftp.Lists("SN_141.wdf");
        //ftp.downloadFile("SN_141.wdf", "Data/SN_141.wdf");
        /**//*
        System.out.println("==========================");
        for(int i=0;i<files.length;i++) {
            System.out.println("files["+i+"]:"+files[i]);
        }*/
        //uftp.uploadFile("D:/TestFile/temp.xml", "temp.xml");        
    }
}

 

如果用的是中文的FTP服务器端,则要在Project中重载
org.apache.commons.net.ftp.parser.UnixFTPEntryParser类

/**/ /*
 * Copyright 2001-2005 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package  org.apache.commons.net.ftp.parser;

import  java.text.ParseException;

import  org.apache.commons.net.ftp.FTPClientConfig;
import  org.apache.commons.net.ftp.FTPFile;

/** */ /**
 * Implementation FTPFileEntryParser and FTPFileListParser for standard Unix
 * Systems.
 * 
 * This class is based on the logic of Daniel Savarese's DefaultFTPListParser,
 * but adapted to use regular expressions and to fit the new FTPFileEntryParser
 * interface.
 * 
 * @version $Id: UnixFTPEntryParser.java,v 1.1 2007/01/18 04:20:59 others Exp $
 * @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for
 *      usage instructions)
 */
public   class  UnixFTPEntryParser  extends  ConfigurableFTPFileEntryParserImpl  ... {
    /** *//**
     * months abbreviations looked for by this parser. Also used to determine
     * which month is matched by the parser
     */
    @SuppressWarnings("unused")
    private static final String DEFAULT_MONTHS = "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)";

    static final String DEFAULT_DATE_FORMAT = "MMM d yyyy"; // Nov 9 2001

    static final String DEFAULT_RECENT_DATE_FORMAT = "MMM d HH:mm"; // Nov 9

    // 20:06

    static final String NUMERIC_DATE_FORMAT = "yyyy-MM-dd HH:mm"; // 2001-11-09

    // 20:06

    /** *//**
     * Some Linux distributions are now shipping an FTP server which formats
     * file listing dates in an all-numeric format:
     * <code>"yyyy-MM-dd HH:mm</code>. This is a very welcome development,
     * and hopefully it will soon become the standard. However, since it is so
     * new, for now, and possibly forever, we merely accomodate it, but do not
     * make it the default.
     * <p>
     * For now end users may specify this format only via
     * <code>UnixFTPEntryParser(FTPClientConfig)</code>. Steve Cohen -
     * 2005-04-17
     */
    public static final FTPClientConfig NUMERIC_DATE_CONFIG = new FTPClientConfig(
            FTPClientConfig.SYST_UNIX, NUMERIC_DATE_FORMAT, null, null, null,
            null);

    /** *//**
     * this is the regular expression used by this parser.
     * 
     * Permissions: r the file is readable w the file is writable x the file is
     * executable - the indicated permission is not granted L mandatory locking
     * occurs during access (the set-group-ID bit is on and the group execution
     * bit is off) s the set-user-ID or set-group-ID bit is on, and the
     * corresponding user or group execution bit is also on S undefined
     * bit-state (the set-user-ID bit is on and the user execution bit is off) t
     * the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and execution
     * is on T the 1000 bit is turned on, and execution is off (undefined bit-
     * state)
     */
    private static final String REGEX = "([bcdlfmpSs-])"
            + "(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))/+?/s+"
            + "(/d+)/s+" + "(/S+)/s+" + "(?:(/S+)/s+)?" + "(/d+)/s+"

            /**//*
             * numeric or standard format date
             */
            // + "((?:/d+[-/]/d+[-/]/d+)|(?:/S+/s+/S+))/s+"
            // 2007/01/16 Yyong modify to match chinese date format
            + "((?:/d+[-/]/d+[-/]/d+)|(?:/S+/s+/S+)|(?:/d+月/d+日))/s+"

            /**//*
             * year (for non-recent standard format) or time (for numeric or
             * recent standard format
             */
            + "(/d+(?::/d+)?)/s+"

            + "(/S*)(/s*.*)";

    /** *//**
     * The default constructor for a UnixFTPEntryParser object.
     * 
     * @exception IllegalArgumentException
     *                Thrown if the regular expression is unparseable. Should
     *                not be seen under normal conditions. It it is seen, this
     *                is a sign that <code>REGEX</code> is not a valid regular
     *                expression.
     */
    public UnixFTPEntryParser() ...{
        this(null);
    }

    /** *//**
     * This constructor allows the creation of a UnixFTPEntryParser object with
     * something other than the default configuration.
     * 
     * @param config
     *            The {@link FTPClientConfig configuration} object used to
     *            configure this parser.
     * @exception IllegalArgumentException
     *                Thrown if the regular expression is unparseable. Should
     *                not be seen under normal conditions. It it is seen, this
     *                is a sign that <code>REGEX</code> is not a valid regular
     *                expression.
     * @since 1.4
     */
    public UnixFTPEntryParser(FTPClientConfig config) ...{
        super(REGEX);
        configure(config);
    }

    /** *//**
     * Parses a line of a unix (standard) FTP server file listing and converts
     * it into a usable format in the form of an <code> FTPFile </code>
     * instance. If the file listing line doesn't describe a file,
     * <code> null </code> is returned, otherwise a <code> FTPFile </code>
     * instance representing the files in the directory is returned.
     * <p>
     * 
     * @param entry
     *            A line of text from the file listing
     * @return An FTPFile instance corresponding to the supplied entry
     */
    public FTPFile parseFTPEntry(String entry) ...{
        FTPFile file = new FTPFile();
        file.setRawListing(entry);
        int type;
        boolean isDevice = false;

        if (matches(entry)) ...{
            String typeStr = group(1);
            String hardLinkCount = group(15);
            String usr = group(16);
            String grp = group(17);
            String filesize = group(18);
            String datestr = group(19) + " " + group(20);
            String name = group(21);
            String endtoken = group(22);

            try ...{
                file.setTimestamp(super.parseTimestamp(datestr));
            } catch (ParseException e) ...{
                return null; // this is a parsing failure too.
            }

            // bcdlfmpSs-
            switch (typeStr.charAt(0)) ...{
            case 'd':
                type = FTPFile.DIRECTORY_TYPE;
                break;
            case 'l':
                type = FTPFile.SYMBOLIC_LINK_TYPE;
                break;
            case 'b':
            case 'c':
                isDevice = true;
                // break; - fall through
            case 'f':
            case '-':
                type = FTPFile.FILE_TYPE;
                break;
            default:
                type = FTPFile.UNKNOWN_TYPE;
            }

            file.setType(type);

            int g = 4;
            for (int access = 0; access < 3; access++, g += 4) ...{
                // Use != '-' to avoid having to check for suid and sticky bits
                file.setPermission(access, FTPFile.READ_PERMISSION, (!group(g)
                        .equals("-")));
                file.setPermission(access, FTPFile.WRITE_PERMISSION, (!group(
                        g + 1).equals("-")));

                String execPerm = group(g + 2);
                if (!execPerm.equals("-")
                        && !Character.isUpperCase(execPerm.charAt(0))) ...{
                    file
                            .setPermission(access, FTPFile.EXECUTE_PERMISSION,
                                    true);
                } else ...{
                    file.setPermission(access, FTPFile.EXECUTE_PERMISSION,
                            false);
                }
            }

            if (!isDevice) ...{
                try ...{
                    file.setHardLinkCount(Integer.parseInt(hardLinkCount));
                } catch (NumberFormatException e) ...{
                    // intentionally do nothing
                }
            }

            file.setUser(usr);
            file.setGroup(grp);

            try ...{
                file.setSize(Long.parseLong(filesize));
            } catch (NumberFormatException e) ...{
                // intentionally do nothing
            }

            if (null == endtoken) ...{
                file.setName(name);
            } else ...{
                // oddball cases like symbolic links, file names
                // with spaces in them.
                name += endtoken;
                if (type == FTPFile.SYMBOLIC_LINK_TYPE) ...{

                    int end = name.indexOf(" -> ");
                    // Give up if no link indicator is present
                    if (end == -1) ...{
                        file.setName(name);
                    } else ...{
                        file.setName(name.substring(0, end));
                        file.setLink(name.substring(end + 4));
                    }

                } else ...{
                    file.setName(name);
                }
            }
            return file;
        }
        return null;
    }

    /** *//**
     * Defines a default configuration to be used when this class is
     * instantiated without a {@link  FTPClientConfig  FTPClientConfig}
     * parameter being specified.
     * 
     * @return the default configuration for this parser.
     */
    protected FTPClientConfig getDefaultConfiguration() ...{
        return new FTPClientConfig(FTPClientConfig.SYST_UNIX,
                DEFAULT_DATE_FORMAT, DEFAULT_RECENT_DATE_FORMAT, null, null,
                null);
    }

}