FtpUtil 工具类使用代码,Java代码库,德仔网

代码语言
代码分类
【Java】 FtpUtil 工具类使用
作者:秀清 / 发布于2016/12/6/ 830
package com.test.util;  
  
  
import java.io.BufferedInputStream;  
import java.io.BufferedReader;  
import java.io.BufferedWriter;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.FileWriter;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.Properties;  
  
import org.apache.commons.httpclient.util.DateUtil;  
import org.apache.commons.net.ftp.FTPClient;  
import org.apache.commons.net.ftp.FTPFile;  
import org.apache.commons.net.ftp.FTPReply;  
import org.springframework.stereotype.Component;  
  
import com.ucf.channel.protocol.FinanceChannel;  
import com.ucf.platform.framework.core.log.UcfLogger;  
import com.ucf.platform.framework.core.log.UcfLoggerFactory;  
  
  
/**  
 * FTP服务器工具类  
 *   
 * @author 码农先生  
 * @version 1.0  
 * @date 2013-11-18  
 * @see 参数 地址1：http://blog.csdn.net/hbcui1984/article/details/2720204  
 * @see 参数 地址2:http://blog.csdn.net/yibing548/article/details/38586073  
 * @see 参考地址3：http://blog.csdn.net/for_china2012/article/details/16820607  
 * @see 参考地址3：http://blog.csdn.net/kardelpeng/article/details/6588284  
 * @see 参考地址3：http://commons.apache.org/proper/commons-net/apidocs/org/apache/commons/net/ftp/FTPClient.html  
 *   
 */  
@SuppressWarnings("all")  
public class FtpUtil {  
    protected static final UcfLogger logger = UcfLoggerFactory.getLogger(FtpUtil.class);  
    private static FtpUtil ftpUtils;  
    private FTPClient ftpClient;  
  
    private String serverUrl; //服务器地址  
    private String port; // 服务器端口  
    private String username; // 用户登录名  
    private String password; // 用户登录密码  
    private InputStream is; // 文件下载输入流  
  
    /**  
     * 私有构造方法  
     */  
    private FtpUtil() {  
        initConfig();  
        if (null == ftpClient) {  
            ftpClient = new FTPClient();  
        }  
    }  
  
    /**  
     * 获取FTPUtils对象实例  
     *   
     * @return FTPUtils对象实例  
     */  
    public synchronized static FtpUtil getInstance() {  
        if (null == ftpUtils) {  
            ftpUtils = new FtpUtil();  
        }  
        return ftpUtils;  
    }  
  
    /**  
     * 初始化FTP服务器连接属性  
     */  
    public void initConfig() {  
        // 构造Properties对象  
        Properties properties = new Properties();  
        // 定义配置文件输入流  
        InputStream is = null;  
        try {  
            // 获取配置文件输入流  
            is = new BufferedInputStream(new FileInputStream("src/test/resources/parameter.properties"));  
            // 加载配置文件  
            properties.load(is);  
            // 172.30.50.104ftp读取配置文件  
            serverUrl = (String) properties.get("ftpClientCmbcIp"); // 设置服务器地址  
            port = (String) properties.get("ftpPort"); // 设置端口  
            username = (String) properties.get("ftpusername"); // 设置用户名  
            password = (String) properties.get("ftppassword"); // 设置密码  
        } catch (IOException e) {  
            logger.error("加载配置文件FTP异常！",e);  
        }catch(Exception e){  
            logger.error("加载配置文件异常！",e);  
        } finally {  
            // 判断输入流是否为空  
            if (null != is) {  
                try {  
                    // 关闭输入流  
                    is.close();  
                } catch (IOException e) {  
                    logger.error("关闭文件流异常！",e);  
                }  
            }  
        }  
    }  
  
    /**  
     * 连接（配置通用连接属性）至服务器  
     *   
     * @param serverName  
     *            服务器名称  
     * @param remotePath  
     *            当前访问目录  
     * @return <b>true</b>：连接成功 <br/>  
     *         <b>false</b>：连接失败  
     */  
    public boolean connectToTheServer(String remotePath) {  
        // 定义返回值  
        boolean result = false;  
        try {  
            // 连接至服务器，端口默认为21时，可直接通过URL连接  
            ftpClient.connect(serverUrl, Integer.parseInt(port));  
            // 登录服务器  
            ftpClient.login(username, password);  
            // 判断返回码是否合法  
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {  
                // 不合法时断开连接  
                ftpClient.disconnect();  
                // 结束程序  
                return result;  
            }  
            //设置文件传输模式  
            //被动模式  
//          ftpClient.enterLocalPassiveMode();  
            //创建目录  
            ftpClient.makeDirectory(remotePath);  
            // 设置文件操作目录  
            result = ftpClient.changeWorkingDirectory(remotePath);  
            // 设置文件类型，二进制  
            result = ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);  
            // 设置缓冲区大小  
            ftpClient.setBufferSize(3072);  
            // 设置字符编码  
            ftpClient.setControlEncoding("UTF-8");  
              
        } catch (IOException e) {  
            logger.error("连接FTP服务器异常",e);  
            throw new RuntimeException("连接FTP服务器异常" , e);  
        }  
        return result;  
    }  
  
    /**  
     * 上传文件至FTP服务器  
     *   
     * @param serverName  
     *            服务器名称  
     * @param storePath  
     *            上传文件存储路径  
     * @param fileName  
     *            上传文件存储名称  
     * @param is  
     *            上传文件输入流  
     * @return <b>true</b>：上传成功 <br/>  
     *         <b>false</b>：上传失败  
     */  
    public boolean storeFile( String storePath, String fileName, InputStream is) {  
        boolean result = false;  
        try {  
            // 连接至服务器  
            result = connectToTheServer(storePath);  
            // 判断服务器是否连接成功  
            if (result) {  
                // 上传文件  
                result = ftpClient.storeFile(fileName, is);  
            }  
            // 关闭输入流  
            is.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 判断输入流是否存在  
            if (null != is) {  
                try {  
                    // 关闭输入流  
                    is.close();  
                } catch (IOException e) {  
                    logger.error("上传文件至FTP异常"+e.getMessage());  
                    throw new RuntimeException("上传文件至FTP异常" , e);  
                }  
            }  
            // 登出服务器并断开连接  
            ftpUtils.logout();  
        }  
        return result;  
    }  
  
    /**  
     * 下载FTP服务器文件至本地<br/>  
     * 操作完成后需调用logout方法与服务器断开连接  
     *   
     * @param serverName  
     *            服务器名称  
     * @param remotePath  
     *            下载文件存储路径  
     * @param fileName  
     *            下载文件存储名称  
     * @return <b>InputStream</b>：文件输入流  
     */  
    public InputStream retrieveFile(String remotePath,String fileName) {  
        try {  
            boolean result = false;  
            // 连接至服务器  
            result = connectToTheServer(remotePath);  
            // 判断服务器是否连接成功  
            if (result) {  
                // 获取文件输入流  
                is = ftpClient.retrieveFileStream(fileName);  
            }  
        } catch (IOException e) {  
            logger.error("从FTP下载文件到本地异常"+e.getMessage());  
            throw new RuntimeException("从FTP下载文件到本地异常" , e);  
        }  
        return is;  
    }  
  
    /**  
     * Description: 从FTP服务器下载文件  
     *   
     * @Version1.0 Jul 27, 2008 5:32:36 PM by 崔红保（cuihongbao@d-heaven.com）创建  
     * @param remotePath  
     *            FTP服务器上的相对路径  
     * @param fileName  
     *            要下载的文件名  
     * @param localPath  
     *            下载后保存到本地的路径  
     * @return  
     */  
    public boolean retrieveFile(String remotePath, String fileName,String localPath) {  
        // 初始表示下载失败  
        boolean success = false;  
        //表示是否连接成功  
        boolean result = false;  
        File file = new File(localPath);  
        if (!file.exists()) {  
            file.mkdirs();  
        }  
        try {  
            // 连接至服务器  
            result = connectToTheServer(remotePath);  
            if(result){  
                // 列出该目录下所有文件  
                FTPFile[] fs = ftpClient.listFiles();  
                // 遍历所有文件，找到指定的文件  
                for (FTPFile ff : fs) {  
                    if (ff.getName().equals(fileName)) {  
                        // 根据绝对路径初始化文件  
                        File localFile = new File(localPath + "/" + ff.getName());  
                        //输出流  
                        OutputStream is = new FileOutputStream(localFile);  
                        //下载文件  
                        success=ftpClient.retrieveFile(ff.getName(), is);  
                        is.close();  
                    }  
                }  
            }  
  
        } catch (IOException e) {  
            logger.error("从FTP服务器下载文件异常",e);  
        } finally {  
            // 登出服务器并断开连接  
            ftpUtils.logout();  
        }  
        return success;  
    }  
  
  
    /**  
     * 删除FTP服务器文件  
     *   
     * @param serverName  
     *            服务器名称  
     * @param remotePath  
     *            当前访问目录  
     * @param fileName  
     *            文件存储名称  
     * @return <b>true</b>：删除成功 <br/>  
     *         <b>false</b>：删除失败  
     */  
    public boolean deleteFile(String remotePath,String fileName) {  
        boolean result = false;  
        // 连接至服务器  
        result = connectToTheServer(remotePath);  
        // 判断服务器是否连接成功  
        if (result) {  
            try {  
                // 删除文件  
                result = ftpClient.deleteFile(fileName);  
            } catch (IOException e) {  
                logger.error("删除FTP服务器上的 文件异常"+e.getMessage());  
                throw new RuntimeException("删除FTP服务器上的 文件异常" , e);  
            } finally {  
                // 登出服务器并断开连接  
                ftpUtils.logout();  
            }  
        }  
        return result;  
    }  
  
    /**  
     * 检测FTP服务器文件是否存在  
     *   
     * @param serverName  
     *            服务器名称  
     * @param remotePath  
     *            检测文件存储路径  
     * @param fileName  
     *            检测文件存储名称  
     * @return <b>true</b>：文件存在 <br/>  
     *         <b>false</b>：文件不存在  
     */  
    public boolean checkFile( String remotePath,String fileName) {  
        boolean result = false;  
        try {  
            // 连接至服务器  
            result = connectToTheServer(remotePath);  
            // 判断服务器是否连接成功  
            if (result) {  
                // 默认文件不存在  
                result = false;  
                // 获取文件操作目录下所有文件名称  
                String[] remoteNames = ftpClient.listNames();  
                // 循环比对文件名称，判断是否含有当前要下载的文件名  
                for (String remoteName : remoteNames) {  
                    if (fileName.equals(remoteName)) {  
                        result = true;  
                    }  
                }  
            }  
        } catch (IOException e) {  
            logger.error("检查FTP文件是否存在异常"+e.getMessage());  
            throw new RuntimeException("检查FTP文件是否存在异常" , e);  
        } finally {  
            // 登出服务器并断开连接  
            ftpUtils.logout();  
        }  
        return result;  
    }  
  
    /**  
     * 登出服务器并断开连接  
     *   
     * @param ftp  
     *            FTPClient对象实例  
     * @return <b>true</b>：操作成功 <br/>  
     *         <b>false</b>：操作失败  
     */  
    public boolean logout() {  
        boolean result = false;  
        if (null != is) {  
            try {  
                // 关闭输入流  
                is.close();  
            } catch (IOException e) {  
                logger.error("登录FTP服务器异常"+e.getMessage());  
                throw new RuntimeException("登录FTP服务器异常" , e);  
            }  
        }  
        if (null != ftpClient) {  
            try {  
                // 登出服务器  
                result = ftpClient.logout();  
            } catch (IOException e) {  
                logger.error("登录FTP服务器异常"+e.getMessage());  
                throw new RuntimeException("登录FTP服务器异常" , e);  
            } finally {  
                // 判断连接是否存在  
                if (ftpClient.isConnected()) {  
                    try {  
                        // 断开连接  
                        ftpClient.disconnect();  
                    } catch (IOException e) {  
                        logger.error("关闭FTP服务器异常"+e.getMessage());  
                        throw new RuntimeException("关闭FTP服务器异常" , e);  
                    }  
                }  
            }  
        }  
        return result;  
    }  
  
  
  
  
  
    /**  
     * Description: 从FTP服务器下载文件  
     *   
     * @param url  
     *            FTP服务器hostname  
     * @param port  
     *            FTP服务器端口  
     * @param username  
     *            FTP登录账号  
     * @param password  
     *            FTP登录密码  
     * @param remotePath  
     *            FTP服务器上的相对路径  
     * @param fileName  
     *            要下载的文件名  
     * @param localPath  
     *            下载后保存到本地的路径  
     * @return  
     */  
    public static boolean downFile(String url, int port, String username,  
            String password, String remotePath, String fileName,  
            String localPath) {  
        // 初始表示下载失败  
        boolean success = false;  
        // 创建FTPClient对象  
        FTPClient ftp = new FTPClient();  
        try {  
            int reply;  
            // 连接FTP服务器  
            // 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器  
            ftp.connect(url, port);  
            reply = ftp.getReplyCode();  
            /*  
             * 判断是否连接成功  
             */  
            if (!FTPReply.isPositiveCompletion(reply)) {  
                ftp.disconnect();  
                return success;  
            } else {  
                // 登录ftp  
                if (ftp.login(username, password)) {  
                    // 转到指定下载目录  
                    ftp.changeWorkingDirectory(remotePath);  
                    // 列出该目录下所有文件  
                    FTPFile[] fs = ftp.listFiles();  
                    // 遍历所有文件，找到指定的文件  
                    for (FTPFile ff : fs) {  
                        if (ff.getName().equals(fileName)) {  
                            // 根据绝对路径初始化文件  
                            File localFile = new File(localPath + "/"  
                                    + ff.getName());  
                            // 输出流  
                            OutputStream is = new FileOutputStream(localFile);  
                            // 下载文件  
                            ftp.retrieveFile(ff.getName(), is);  
                            is.close();  
                        }  
                    }  
                    // 退出ftp  
                    ftp.logout();  
                    // 下载成功  
                    success = true;  
                }  
            }  
        } catch (IOException e) {  
            logger.error("从FTP服务器下载文件异常"+e.getMessage());  
            throw new RuntimeException("从FTP服务器下载文件异常" , e);  
        } finally {  
            if (ftp.isConnected()) {  
                try {  
                    ftp.disconnect();  
                } catch (IOException ioe) {  
                    logger.error("关闭FTP连接异常"+ioe.getMessage());  
                    throw new RuntimeException("关闭FTP连接异常" , ioe);  
                }  
            }  
        }  
        return success;  
    }  
  
    /**  
     * 读取本地TXT  
     *   
     * @param filepath  
     *            txt文件目录即文件名  
     */  
  
    public ArrayList<String> readtxt(String filepath) {  
        ArrayList<String> readList = new ArrayList<String>();  
        ArrayList retList = new ArrayList();  
        try {  
            String temp = null;  
            File f = new File(filepath);  
            String adn = "";  
            // 指定读取编码用于读取中文  
            InputStreamReader read = new InputStreamReader(new FileInputStream(  
                    f), "UTF-8");  
            BufferedReader reader = new BufferedReader(read);  
            // bufReader = new BufferedReader(new FileReader(filepath));  
            do {  
                temp = reader.readLine();  
                readList.add(temp);  
            } while (temp != null);  
            read.close();  
        } catch (Exception e) {  
            // TODO: handle exception  
            logger.error("读取本地txt异常"+e.getMessage());  
            throw new RuntimeException("读取本地txt异常" , e);  
        }  
        return readList;  
    }  
  
  
    /**  
     * @param properties  
     * @param batchNo  
     * @param status  
     * @param financeChannel  
     * @param fileDownUtil  
     * @return  
     * @throws Exception  
     */  
//  public  String downCmbcCallBackFile(Properties properties,FTPClient ftpClient, String batchNo, String status, FinanceChannel financeChannel, FileDownUtil fileDownUtil) throws Exception {  
//      FTPClient ftp = new FTPClient();  
//      FileOutputStream is = null;  
//      File localEncoFile = null;  
//      File dirLocalEncoPath = null;  
//      String fileName = "";  
//      String filePath = "";  
//      String romoteEncoPeerPath = properties.getProperty("romoteEncoPeerPath") + batchNo.split("_")[0];  
//      String romoteEncoCorssPath = properties.getProperty("romoteEncoCorssPath") + batchNo.split("_")[0];  
//      String localEncoPeerPath = this.getClass().getResource("/").getPath()+properties.getProperty("localEncoPeerPath") + batchNo.split("_")[0];  
//      String localEncoCorssPath = this.getClass().getResource("/").getPath()+properties.getProperty("localEncoCorssPath") + batchNo.split("_")[0];  
//      try {  
//          int reply;  
//          ftp.connect(properties.getProperty("url"));  
//          // 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器  
//          ftp.login(properties.getProperty("ftpusername"), properties.getProperty("ftppassword"));// 登录  
//          ftp.setFileType(FTPClient.BINARY_FILE_TYPE);  
//          reply = ftp.getReplyCode();  
//          if (!FTPReply.isPositiveCompletion(reply)) {  
//              ftp.disconnect();  
//              return null;  
//          }  
//          if ("Peer".equals(financeChannel.getSameOrCorssBank().name())) {  
//              dirLocalEncoPath = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoPeerPath") + batchNo.split("_")[0] + "/");// 加密目录  
//              ftp.changeWorkingDirectory(properties.getProperty("romotePeerPath") + batchNo.split("_")[0] + "/");// 转移到FTP服务器目录  
//              localEncoPeerPath =this.getClass().getResource("/").getPath()+properties.getProperty("localEncoPeerPath") + DateUtil.formatDate(new Date(), "yyyyMMdd");  
//              romoteEncoPeerPath = properties.getProperty("romoteEncoPeerPath") + DateUtil.formatDate(new Date(), "yyyyMMdd");  
//              dirLocalEncoPath = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoPeerPath") + DateUtil.formatDate(new Date(), "yyyyMMdd") + "/");// 加密目录  
//              if (!dirLocalEncoPath.exists()) {  
//                  dirLocalEncoPath.mkdirs();  
//                  logger.info("创建本地目录成功:" + dirLocalEncoPath);  
//              }  
//          } else {  
//              dirLocalEncoPath = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoCorssPath") + batchNo.split("_")[0] + "/");// 加密目录  
//              ftp.changeWorkingDirectory(properties.getProperty("romoteCorssPath") + batchNo.split("_")[0] + "/");// 转移到FTP服务器目录  
//              localEncoCorssPath = this.getClass().getResource("/").getPath()+properties.getProperty("localEncoCorssPath") + DateUtil.formatDate(new Date(), "yyyyMMdd");  
//              romoteEncoCorssPath = properties.getProperty("romoteEncoCorssPath") + DateUtil.formatDate(new Date(), "yyyyMMdd");  
//              dirLocalEncoPath = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoCorssPath") + DateUtil.formatDate(new Date(), "yyyyMMdd") + "/");// 加密目录  
//  
//              if (!dirLocalEncoPath.exists()) {  
//                  dirLocalEncoPath.mkdirs();  
//                  logger.info("创建本地目录成功:" + dirLocalEncoPath);  
//              }  
//          }  
//          FTPFile[] fs = ftp.listFiles();  
//          for (FTPFile ff : fs) {  
//              if ("Peer".equals(financeChannel.getSameOrCorssBank().name())) {  
//                  if (ff.getName().equals("res_" + batchNo + ".txt")) {  
//                      String newBatchNo = CmbcUtil.modifyBatchNo(batchNo, DateUtil.formatDate(new Date(), "yyyyMMdd"));  
//                      localEncoFile = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoPeerPath") + DateUtil.formatDate(new Date(), "yyyyMMdd") + "/" + "res_" + newBatchNo + ".txt");  
//                      is = new FileOutputStream(localEncoFile);  
//                      ftp.retrieveFile(ff.getName(), is);  
//                      fileName = "res_" + newBatchNo + ".txt";  
//                      // 先用生产key解密文件  
//                      CmbcUtil.decodeAESFile(properties.getProperty("deProPassword").getBytes(), localEncoPeerPath + "/" + "dePeer.txt", localEncoPeerPath + "/" + fileName);  
//                      // 再用测试key加密文件  
//                      CmbcUtil.encodeAESFile(properties.getProperty("dePassword").getBytes(), localEncoPeerPath + "/" + "dePeer.txt", localEncoPeerPath + "/" + fileName);  
//                      filePath = fileDownUtil.ftpUploadFile(ftpClient,properties,localEncoPeerPath, romoteEncoPeerPath, fileName);  
//                      break;  
//                  }  
//              } else {  
//                  if (ff.getName().equals("res_outer_" + batchNo + ".txt")) {  
//                      String newBatchNo = CmbcUtil.modifyBatchNo(batchNo, DateUtil.formatDate(new Date(), "yyyyMMdd"));  
//                      localEncoFile = new File(this.getClass().getResource("/").getPath()+properties.getProperty("localEncoCorssPath") + DateUtil.formatDate(new Date(), "yyyyMMdd") + "/" + "res_outer_" + newBatchNo + ".txt");  
//                      is = new FileOutputStream(localEncoFile);  
//                      ftp.retrieveFile(ff.getName(), is);  
//                      fileName = "res_outer_" + newBatchNo + ".txt";  
//                      // 先用生产key解密文件  
//                      CmbcUtil.decodeAESFile(properties.getProperty("deProPassword").getBytes(), localEncoCorssPath + "/" + "deCorss.txt", localEncoCorssPath + "/" + fileName);  
//                      // 再用测试key加密文件  
//                      CmbcUtil.encodeAESFile(properties.getProperty("dePassword").getBytes(), localEncoCorssPath + "/" + "deCorss.txt", localEncoCorssPath + "/" + fileName);  
//                      filePath = fileDownUtil.ftpUploadFile(ftpClient,properties,localEncoCorssPath, romoteEncoCorssPath, fileName);  
//                      break;  
//                  }  
//              }  
//          }  
//  
//      } catch (IOException e) {  
//          logger.error("关闭FTP服务器连接异常", e);  
//          throw new RuntimeException("从FTP服务器下载文件异常", e);  
//  
//      } finally {  
//          if (null != ftp) {  
//              try {  
//                  ftp.logout();  
//              } catch (IOException e) {  
//                  logger.error("关闭FTP服务器连接异常", e);  
//              }  
//          }  
//          if (ftp.isConnected()) {  
//              try {  
//                  ftp.disconnect();  
//              } catch (IOException e) {  
//                  logger.error("关闭FTP服务器连接异常", e);  
//              }  
//          }  
//          if (null != is) {  
//              try {  
//                  is.close();  
//              } catch (IOException e) {  
//                  logger.error("关闭FTP服务器连接异常", e);  
//              }  
//          }  
//      }  
//      return filePath;  
//  }  
  
      
      
      
    /**   
     * 把配置文件先写到本地的一个文件中取   
     *    
     * @param ftpPath   
     * @param str   
     * @return   
     */    
    public boolean write(String fileName, String fileContext,    
            String writeTempFielPath) {    
        try {    
            logger.info("开始写配置文件");    
            File f = new File(writeTempFielPath + "/" + fileName);    
            if(!f.exists()){    
                if(!f.createNewFile()){    
                    logger.info("文件不存在，创建失败!");    
                }    
            }    
            BufferedWriter bw = new BufferedWriter(new FileWriter(f, true));    
            bw.write(fileContext.replaceAll("\n", "\r\n"));    
            bw.flush();    
            bw.close();    
            return true;    
        } catch (Exception e) {    
            logger.error("写文件没有成功");    
            e.printStackTrace();    
            return false;    
        }    
    }    
  
    /**  
     *   
     * @Description： 测试连接ftP服务器  
     * @author: GuXiYang  
     * @date: 2015-6-18 下午4:28:15  
     * @param args  
     */  
    public static void main(String[] args) {  
        FtpUtil ftp = FtpUtil.getInstance();  
        String localPath="D:/home/xfzf/finExchange/CCB/offline/ccb_counteroffer.xls";  
        String remotePath = "/ccb_offline_withdrawal/CCB/offline";  
        String fileName = "ccb_counteroffer.xls";  
        //文件上传  
//              try {    
//                  FileInputStream in=new FileInputStream(new File(localPath));    
//                  boolean flag = ftp.storeFile(remotePath, fileName,in);  
//                  logger.info("文件上传结果："+flag);    
//              } catch (FileNotFoundException e) {    
//                  e.printStackTrace();    
//              }    
  
        //文件下载  
        //      InputStream in=ftp.retrieveFile(remotePath, fileName);  
        //      StringBuffer resultBuffer = new StringBuffer();    
        //      BufferedReader br = new BufferedReader(new InputStreamReader(in));    
        //      String data = null;    
        //      try {    
        //          while ((data = br.readLine()) != null) {    
        //              resultBuffer.append(data + "\n");    
        //          }    
        //      } catch (IOException e) {    
        //          logger.error("文件读取错误。");    
        //          e.printStackTrace();    
        //      }  
        //     System.out.println(resultBuffer.toString());  
  
  
        //在FTP服务器上生成一个文件，并将一个字符串写入到该文件中  
//      try {    
//          InputStream input = new ByteArrayInputStream("一切只能靠自己！".getBytes("utf-8"));    
//          boolean flag = ftp.storeFile(remotePath,"test.txt",input);    
//          System.out.println(flag);    
//      } catch (UnsupportedEncodingException e) {    
//          e.printStackTrace();    
//      }    
  
  
    }  
}
试试其它关键字
　FtpUtil　　工具类使用　
同语言下
可能有用的
秀清贡献的其它代码(25)