FTPUtil 多文件上传参考代码

  import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;
import java.text.SimpleDateFormat;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPReply;
import sun.net.TelnetInputStream;
import sun.net.ftp.FtpClient;
 
 
 
public class Ftp {
 FtpClient ftpClient = null;
    private static Log logger;  
     
    private static String UserName = null;  
     
    private static String Password = null;  
     
    private static String Ip = null;  
     
    private static Integer Port = null;  
     
    private static Properties Property = null;  
  
     
    private  FTPClient FtpClientTEMP = null;  
     
    private static SimpleDateFormat dateFormat = new SimpleDateFormat(  
            "yyyy-MM-dd hh:mm");  
     
    public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;  
     
    public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;  
    public  static int  i=1;  
    public static Boolean connect_flag = false;
   
       
        public boolean loadFile(Ftp ftp , String[] remoteFileName, String[] localFileName,InputStream is) { 
            boolean flag = true;  
//            InputStream is = null;
            FileOutputStream os = null;
            long result = 0;   
            try {  
             FtpClient client = connectServerClient(ftp,is);
             for(int i = 0; i < remoteFileName.length; i++){
              os = new FileOutputStream(localFileName[i]);
              is = client.get(remoteFileName[i]);
              byte[] bytes = new byte[1024];     
              int c;     
              while ((c = is.read(bytes)) != -1) {     
               os.write(bytes, 0, c);     
               result = result + c;     
              }
             }
            } catch (Exception e) {  
                e.printStackTrace();  
                logger.debug("本地文件下载失败！", e);  
            } finally {
             try {
     is.close();
     os.close();
     closeConnect(ftp);
    } catch (IOException e) {
     e.printStackTrace();
    }
            }  
            return flag;  
        }
   
     
    public boolean uploadFile(Ftp ftp,InputStream is,File[] docNew, String[] newFileName) {  
        boolean flag = true;  
        try {  
      connect_flag = connectServer(ftp,is);
　　　　　　　//设置的三步骤
            ftp.getFtpClientTEMP().setFileType(BINARY_FILE_TYPE);  
            ftp.getFtpClientTEMP().enterLocalPassiveMode();  
            ftp.getFtpClientTEMP().setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
            InputStream input = null;
            for(int i = 0; i < docNew.length; i++){
             File file = docNew[i];
             File newFile = new File(newFileName[i]);  
                String dir = newFile.getParentFile().getPath();  
                if (!ftp.getFtpClientTEMP().changeWorkingDirectory(dir)) {// 如果不能进入dir下，说明此目录不存在！  
     
                    if (!makeDirectory(ftp,is,newFile.getParentFile().getPath())) {  
     
                        System.out.println("创建文件目录【"+dir+"】失败！");  
                    }  
                }  
                changeWorkingDirectory(ftp,"/");// 回到FTP根目录  
                input = new FileInputStream(file);  
     
                if (input == null) {  
                    System.out.println("本地文件不存在");  
                    logger.debug("本地文件不存在,请重新选择！");  
     
                }  
                if (newFileName[i].trim().equals("")) {  
     
                    newFileName[i] = file.getName();  
     
                }  
                flag = ftp.getFtpClientTEMP().storeFile(newFileName[i], input);  
                if (flag) {  
                    System.out.println("upload File succeed");  
     
                } else {  
                    System.out.println("upload File false");  
     
                }
            }
            input.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
            logger.debug("本地文件上传失败！", e);  
            // TODO: handle exception  
        } catch (Exception e) {  
            e.printStackTrace();  
            // logger.debug("本地文件上传失败！", e);  
            // TODO: handle exception  
        }finally{
         closeConnect(ftp);
         
        }
       
        return flag;  
    }  
 
     
    public  void closeConnect(Ftp ftp) {
     FtpClientTEMP = ftp.getFtpClientTEMP();
     ftpClient = ftp.getFtpClient();
        try {  
         if(FtpClientTEMP != null){
          FtpClientTEMP.logout();
          FtpClientTEMP.disconnect();
          FtpClientTEMP = null;
         }
         
            if(ftpClient != null){
             ftpClient.closeServer();
             ftpClient = null;
            }
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
 
 
     
    public void setFileType(int fileType) {  
        try {  
//            connectServer();  
         FtpClientTEMP.setFileType(fileType);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
 
     
    protected FTPClient getFtpClient(Ftp ftp,InputStream is) {  
        connectServer(ftp,is);  
        return FtpClientTEMP;  
    }  
 
     
    private static void setArg(InputStream is) {  
        Property = new Properties();  
        BufferedInputStream inBuff = null;  
        try {  
//            File file = new File(configFile);  
 
            inBuff = new BufferedInputStream(is);  
 
            Property.load(inBuff);  
 
            UserName = Property.getProperty("username");  
            Password = Property.getProperty("password");  
            Ip = Property.getProperty("ip");  
            Port = Integer.parseInt(Property.getProperty("port"));  
        } catch (FileNotFoundException e1) {  
            System.out.println("FTP配置文件不存在！");  
            e1.printStackTrace();  
        } catch (IOException e) {  
            System.out.println("FTP配置文件无法读取！");  
            e.printStackTrace();  
        }  
 
    }  
 
     
    public boolean connectServer(Ftp ftp,InputStream is) {
     FtpClientTEMP  = ftp.getFtpClientTEMP();
        boolean flag = true;
        if (FtpClientTEMP == null) {  
            int reply;  
            try {  
                setArg(is);  
             FtpClientTEMP = new FTPClient();  
             FtpClientTEMP.setControlEncoding("GBK");  
                FtpClientTEMP.setDefaultPort(Port);  
                FtpClientTEMP.configure(getFtpConfig());  
                FtpClientTEMP.connect(Ip);  
                FtpClientTEMP.login(UserName, Password);  
                FtpClientTEMP.setDefaultPort(Port);  
                //System.out.print(FtpClient.getReplyString());  
                reply = FtpClientTEMP.getReplyCode();  
                FtpClientTEMP.setDataTimeout(120000);  
 
                if (!FTPReply.isPositiveCompletion(reply)) {  
                 FtpClientTEMP.disconnect();  
                    System.err.println("FTP server refused connection.");  
                    // logger.debug("FTP 服务拒绝连接！");  
                    flag = false;  
                }  
//                System.out.println(i);  
//                i ;  
                 
            } catch (SocketException e) {  
                flag = false;  
                e.printStackTrace();  
                System.err.println("登录ftp服务器【" +Ip+ "】失败,连接超时！");  
                // logger.debug("登录ftp服务器【" Ip "】失败");  
            } catch (IOException e) {  
                flag = false;  
 
                e.printStackTrace();  
                System.err.println("登录ftp服务器【"+ Ip +"】失败，FTP服务器无法打开！");  
                // logger.debug("登录ftp服务器【" Ip "】失败");  
            }  
 
        }  
        return flag;  
    }  
 
     
    public static void changeWorkingDirectory(Ftp ftp , String directory) {  
        try {  
         ftp.getFtpClientTEMP().changeWorkingDirectory(directory);  
        } catch (IOException ioe) {  
            ioe.printStackTrace();  
        }  
    }  
 
 
 
     
    public void renameFile(Ftp ftp,InputStream is,String oldFileName, String newFileName) {  
        try {  
         connectServer(ftp,is);
            FtpClientTEMP.rename(oldFileName, newFileName);  
        } catch (IOException ioe) {  
            ioe.printStackTrace();  
        }  
    }  
 
     
    private static FTPClientConfig getFtpConfig() {  
        FTPClientConfig ftpConfig = new FTPClientConfig(  
                FTPClientConfig.SYST_UNIX);  
        ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);  
        return ftpConfig;  
    }  
 
     
    private static String iso8859togbk(Object obj) {  
        try {  
            if (obj == null)  
                return "";  
            else 
                return new String(obj.toString().getBytes("iso-8859-1"), "GBK");  
        } catch (Exception e) {  
            return "";  
        }  
    }  
 
     
    public boolean makeDirectory(Ftp ftp,InputStream is,String dir) throws IOException {  
        boolean flag = true;  
        FtpClientTEMP = ftp.getFtpClientTEMP();
         if(FtpClientTEMP == null){
          connectServer(ftp,is);
         }
      flag = FtpClientTEMP.makeDirectory(dir);
            if (!flag) {  
             System.out.println("make Directory " +dir+ " false");  
            } 
        return flag;  
    }  
 
    public static Log getLogger() {  
        return logger;  
    }  
 
    public static void setLogger(Log logger) {  
        Ftp.logger = logger;  
    }  
        
    public FtpClient connectServerClient(Ftp ftp,InputStream is){     
        ftpClient = new FtpClient();
        setArg(is);
        try {     
            if(Port != -1){     
                    ftpClient.openServer(Ip,Port);     
            }else{     
                ftpClient.openServer(Ip);     
            }     
            ftpClient.login(UserName, Password);     
            ftpClient.binary();// 用2进制上传、下载
            System.out.println("已登录到"" + ftpClient.pwd() + ""目录");     
            return ftpClient;     
        }catch (IOException e){     
            e.printStackTrace();     
            return null;     
        }     
    }
 
 public FTPClient getFtpClientTEMP() {
  return FtpClientTEMP;
 }
 public void setFtpClientTEMP(FTPClient ftpClientTEMP) {
  FtpClientTEMP = ftpClientTEMP;
 }
 
 public void setFtpClient(FtpClient ftpClient) {
  this.ftpClient = ftpClient;
 }
 
 public FtpClient getFtpClient() {
  return ftpClient;
 }
 
   
}