騰訊雲cos存儲服務、FTP服務器，文件操作工具類整理

詳細說明及api請參考官網，這里只整理常用的一些簡單方法

ftpUtil

package platform.modules.claim.util;

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.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.SocketException;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;

@Component
public final class FTPUtil {

  private final static Log logger = LogFactory.getLog(FTPUtil.class);

  // ftp主機地址
  @Value("${ftpHost}")
  private String ftpHost;
  // ftp用戶名
  @Value("${ftpUserName}")
  private String ftpUserName;
  // ftp密碼
  @Value("${ftpPassword}")
  private String ftpPassword;
  // ftp端口
  @Value("${ftpPort}")
  private int ftpPort;
  // ftp影像件地址
  @Value("${ftpImagePath}")
  private String ftpImagePath;
  // ftp數據下載地址
  @Value("${ftpDownPath}")
  private String ftpDownPath;
  // 本地臨時存儲文件夾
  @Value("${localTempPath}")
  private String localTempPath;
  // 代理服務器
  @Value("${proxyHost}")
  private String proxyHost;
  // 代理服務器端口
  @Value("${proxyPort}")
  private int proxyPort;
  @Value("${proxyFlag}")
  private boolean proxyFlag;

  // ftp客戶端
  public FTPClient ftpClient;

  public FTPUtil(String ftpHost, int ftpPort, String ftpUserName, String ftpPassword,
      String ftpImagePath, String ftpDownPath) {
    super();
    this.ftpHost = ftpHost;
    this.ftpUserName = ftpUserName;
    this.ftpPassword = ftpPassword;
    this.ftpPort = ftpPort;
    this.ftpImagePath = ftpImagePath;
    this.ftpDownPath = ftpDownPath;
  }

  /**
   * 獲取FTPClient對象
   * 
   * @param ftpHost FTP主機服務器
   * @param ftpPassword FTP 登錄密碼
   * @param ftpUserName FTP登錄用戶名
   * @param ftpPort FTP端口 默認為21
   * @return
   */
  public FTPClient initClient() {

    ftpClient = new FTPClient();
    try {

      if (proxyFlag) {// 使用代理模式
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
        ftpClient.setProxy(proxy);
      }
      ftpClient.connect(ftpHost, ftpPort);// 連接FTP服務器
      boolean flag = ftpClient.login(ftpUserName, ftpPassword);// 登陸FTP服務器
      // ftpClient.setKeepAlive(true);
      logger.info(flag + "登錄標記:");
      logger.info(JSON.toJSONString(ftpClient.getReplyCode()));
      if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
        logger.error("未連接到FTP，用戶名或密碼錯誤。");
        ftpClient.disconnect();
      } else {
        logger.info("FTP連接成功。");
        logger.info(JSON.toJSONString(ftpClient.listNames()));
      }
    } catch (SocketException e) {
      e.printStackTrace();
      logger.error(e.getMessage());
      logger.error("FTP的IP地址可能錯誤，請正確配置。");
    } catch (IOException e) {
      e.printStackTrace();
      logger.error(e.getMessage());
      logger.error("FTP的端口錯誤,請正確配置。");
    }
    return ftpClient;
  }

  /**
   * 列舉文件列表
   * 
   * @param ftpPath ftp文件存放物理路徑
   */
  public List<String> listFiles(String filePath) {
    
    initClient();
    String[] fileNames = null;
    try {
      fileNames = ftpClient.listNames(filePath);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if (fileNames == null || fileNames.length <= 0) {
      logger.error("此文件夾下無文件");
      return null;
    }
    return Arrays.asList(fileNames);
    
    
  }
  
  /**
   * 下載文件
   * 
   * @param ftpHost ftp服務器地址
   * @param ftpUserName anonymous匿名用戶登錄，不需要密碼。administrator指定用戶登錄
   * @param ftpPassword 指定用戶密碼
   * @param ftpPort ftp服務員器端口號
   * @param ftpPath ftp文件存放物理路徑
   * @param fileName 文件路徑 filepath ftp上文件路徑
   * @param input 文件輸入流，即從本地服務器讀取文件的IO輸入流
   */
  public File downloadFile(String fileName, String filePath) {
    File localFile = null;
    OutputStream os = null;
    try {
      initClient();
      ftpClient.setControlEncoding("UTF-8"); // 中文支持
      ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
      ftpClient.enterLocalPassiveMode();
      ftpClient.changeWorkingDirectory(filePath);

      String tempfilePath = localTempPath;
      localFile = new File(tempfilePath + fileName);
      os = new FileOutputStream(localFile);
      ftpClient.retrieveFile(fileName, os);

    } catch (FileNotFoundException e) {
      logger.error("沒有找到" + filePath + fileName + "文件");
      e.printStackTrace();
      return null;
    } catch (SocketException e) {
      logger.error("連接FTP失敗.");
      // e.printStackTrace();
      return null;
    } catch (IOException e) {
      logger.error("文件讀取錯誤。");
      // e.printStackTrace();
      return null;
    } finally {
      try {
        if (os != null) {
          os.close();
        }
        ftpClient.logout();
        //ftpClient.disconnect();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    logger.info("文件下載成功！" + filePath + fileName);
    return localFile;
  }


  /**
   * 下載文件
   * 
   * @param ftpHost ftp服務器地址
   * @param ftpUserName anonymous匿名用戶登錄，不需要密碼。administrator指定用戶登錄
   * @param ftpPassword 指定用戶密碼
   * @param ftpPort ftp服務員器端口號
   * @param ftpPath ftp文件存放物理路徑
   * @param fileName 文件路徑
   * @param input 文件輸入流，即從本地服務器讀取文件的IO輸入流
   */
  public File downloadFile(String fileName) {
    File localFile = null;
    try {
      initClient();
      ftpClient.setControlEncoding("UTF-8"); // 中文支持
      ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
      ftpClient.enterLocalPassiveMode();
      ftpClient.changeWorkingDirectory(ftpImagePath);

      localFile = new File(localTempPath + File.separatorChar + fileName);
      OutputStream os = new FileOutputStream(localFile);
      ftpClient.retrieveFile(fileName, os);
      os.close();
      ftpClient.logout();

    } catch (FileNotFoundException e) {
      logger.error("沒有找到" + ftpDownPath + "文件");
      e.printStackTrace();
    } catch (SocketException e) {
      logger.error("連接FTP失敗.");
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
      logger.error("文件讀取錯誤。");
      e.printStackTrace();
    }
    return localFile;
  }

  /**
   * 上傳文件
   * 
   * @param ftpHost ftp服務器地址
   * @param ftpUserName anonymous匿名用戶登錄，不需要密碼。administrator指定用戶登錄
   * @param ftpPassword 指定用戶密碼
   * @param ftpPort ftp服務員器端口號
   * @param ftpPath ftp文件存放物理路徑
   * @param fileName 文件名
   * @param input 文件輸入流，即從本地服務器讀取文件的IO輸入流
   */
  public boolean uploadFile(File zipFile) {

    if (!zipFile.exists()) {
      logger.error("文件不存在!");
      return false;
    }
    InputStream input = null;
    String uploadFileName = zipFile.getName();
    try {
      input = new FileInputStream(zipFile);
      ftpClient = initClient();
      ftpClient.changeWorkingDirectory(ftpImagePath);
      ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
      ftpClient.enterLocalPassiveMode();
      ftpClient.storeFile(uploadFileName, input);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        input.close();
        ftpClient.logout();
        ftpClient.disconnect();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return true;
  }

  /**
   * 上傳文件
   * 
   * @param ftpHost ftp服務器地址
   * @param ftpUserName anonymous匿名用戶登錄，不需要密碼。administrator指定用戶登錄
   * @param ftpPassword 指定用戶密碼
   * @param ftpPort ftp服務員器端口號
   * @param ftpPath ftp文件存放物理路徑
   * @param fileName 文件名
   * @param input 文件輸入流，即從本地服務器讀取文件的IO輸入流
   */
  public boolean uploadFile(File file, String uploadPath) {

    if (!file.exists()) {
      logger.error("文件不存在!");
      return false;
    }
    InputStream input = null;
    String uploadFileName = file.getName();
    try {
      input = new FileInputStream(file);
      ftpClient = initClient();
      ftpClient.changeWorkingDirectory(uploadPath);
      ftpClient.enterLocalPassiveMode();
      ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
      uploadFileName = new String(uploadFileName.getBytes(), "UTF-8");
      ftpClient.storeFile(uploadFileName, input);
      logger.info("upload成功!");

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        input.close();
        ftpClient.logout();
        ftpClient.disconnect();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return true;
  }

  /**
   * 上傳文件
   * 
   * @param ftpHost ftp服務器地址
   * @param ftpUserName anonymous匿名用戶登錄，不需要密碼。administrator指定用戶登錄
   * @param ftpPassword 指定用戶密碼
   * @param ftpPort ftp服務員器端口號
   * @param ftpPath ftp文件存放物理路徑
   * @param fileName 文件名
   * @param input 文件輸入流，即從本地服務器讀取文件的IO輸入流
   */
  public String[] ListFileNames(String uploadPath) {

    ftpClient = initClient();
    try {
      return ftpClient.listNames(uploadPath);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        ftpClient.logout();
        ftpClient.disconnect();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return null;
  }
}

qCloudUtil

package platform.modules.claim.util;

import java.io.*;
import com.qcloud.cos.COSClient;
import com.qcloud.cos.ClientConfig;
import com.qcloud.cos.auth.BasicCOSCredentials;
import com.qcloud.cos.auth.COSCredentials;
import com.qcloud.cos.http.HttpProtocol;
import com.qcloud.cos.model.COSObject;
import com.qcloud.cos.model.COSObjectInputStream;
import com.qcloud.cos.model.COSObjectSummary;
import com.qcloud.cos.model.GetObjectRequest;
import com.qcloud.cos.model.ListObjectsRequest;
import com.qcloud.cos.model.ObjectListing;
import com.qcloud.cos.model.ObjectMetadata;
import com.qcloud.cos.model.PutObjectRequest;
import com.qcloud.cos.model.PutObjectResult;
import com.qcloud.cos.region.Region;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public final class QCloudCOSUtil {

  private static final Logger logger = LoggerFactory.getLogger(QCloudCOSUtil.class);
  // 申明變量
  private String QCloudSecretId;
  private String QCloudSecretKey;
  private String bucketName;
  private String qcloudRegion;
  private COSCredentials cred;
  public COSClient cosClient;
  // 代理服務器
  @Value("${proxyHost}")
  private String proxyHost;  
  // 代理服務器端口
  @Value("${proxyPort}")
  private int proxyPort;
  @Value("${proxyFlag}")
  private boolean proxyFlag;

  /**
   * 帶參數構造
   * @param qCloudSecretId
   * @param qCloudSecretKey
   * @param bucketName
   * @param qcloudRegion
   */
  public QCloudCOSUtil(String qCloudSecretId, String qCloudSecretKey, String bucketName,
      String qcloudRegion) {
    super();
    QCloudSecretId = qCloudSecretId;
    QCloudSecretKey = qCloudSecretKey;
    this.bucketName = bucketName;
    this.qcloudRegion = qcloudRegion;
  }

  /**
   * 初始化
   */
  public void init() {

    //// 1 初始化用戶身份信息（secretId, secretKey）
    cred = new BasicCOSCredentials(QCloudSecretId, QCloudSecretKey);
    // 2 設置 bucket 的區域, COS 地域的簡稱請參照 https://cloud.tencent.com/document/product/436/6224
    // clientConfig 中包含了設置 region, https(默認 http), 超時, 代理等 set 方法, 使用可參見源碼或者常見問題 Java SDK 部分。
    Region region = new Region(qcloudRegion);
    ClientConfig clientConfig = new ClientConfig(region);
    clientConfig.setHttpProtocol(HttpProtocol.https);
    if (proxyFlag) {// 使用代理模式
      clientConfig.setHttpProxyIp(proxyHost);
      clientConfig.setHttpProxyPort(proxyPort);
    }
    // 3 生成 cos 客戶端。
    cosClient = new COSClient(cred, clientConfig);
  }

  /**
   * 關閉客戶端
   */
  public void close() {
    // 關閉客戶端(關閉后台線程)
    cosClient.shutdown();
  }

  /**
   * 查看bucket下所有的object
   * @param bucketName 存儲桶
   */
  public void getAllBucketObject(String prefixPath) {
    init();
    try {
      ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
      // 設置 bucket 名稱
      listObjectsRequest.setBucketName(bucketName);
      // prefix 表示列出的 object 的 key 以 prefix 開始
      listObjectsRequest.setPrefix(prefixPath);
      // 設置最大遍歷出多少個對象, 一次 listobject 最大支持1000
      listObjectsRequest.setMaxKeys(1000);
      // deliter表示分隔符, 設置為/表示列出當前目錄下的object, 設置為空表示列出所有的object
      listObjectsRequest.setDelimiter("");
      ObjectListing objectListing = cosClient.listObjects(listObjectsRequest);
      // common prefix表示表示被delimiter截斷的路徑, 如delimter設置為/, common prefix則表示所有子目錄的路徑
      for (COSObjectSummary cosObjectSummary : objectListing.getObjectSummaries()) {
        // 對象的路徑 key
        String key = cosObjectSummary.getKey();
        // 對象的 etag
        String etag = cosObjectSummary.getETag();
        
        // 對象的長度
        long fileSize = cosObjectSummary.getSize();
        // 對象的存儲類型
        String storageClass = cosObjectSummary.getStorageClass();
        System.out.println("filekey:" + key + "; etag:" + etag + "; fileSize:" + fileSize
            + "; storageClass:" + storageClass+";"+cosObjectSummary.getBucketName());
      }
    } catch (Exception exception) {
      exception.printStackTrace();
    } finally {
      close();
    }
  }

  /**
   * qcloud文件上傳
   * 
   * @param cosClient
   * @param bucketName 保存到某個存儲桶
   * @param key 保存文件的key （以key-value形式保存）其實就是一個url路徑
   * @param file 上傳文件
   */
  public PutObjectResult qcloudUpload(File localFile, String fileKey) {
    init();
    PutObjectResult putObjectResult = null;
    try {
      PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileKey, localFile);
      putObjectResult = cosClient.putObject(putObjectRequest);
    } catch (Exception serverException) {
      serverException.printStackTrace();
    } finally {
      close();
    }
    return putObjectResult;
  }
  /**
   * qcloud文件上傳
   * 以文件流上傳
   * @param cosClient
   * @param bucketName 保存到某個存儲桶
   * @param key 保存文件的key （以key-value形式保存）其實就是一個url路徑
   * @param file 上傳文件
   */
  public PutObjectResult qcloudUploadInput(File localFile, String fileKey) {
    init();
    PutObjectResult putObjectResult = null;
    FileInputStream fileInputStream = null;
    try {
      // 方法2 從輸入流上傳(需提前告知輸入流的長度, 否則可能導致 oom)
      fileInputStream = new FileInputStream(localFile);
      ObjectMetadata objectMetadata = new ObjectMetadata();
      // 設置輸入流長度為500
      objectMetadata.setContentLength(500);  
      // 設置 Content type, 默認是 application/octet-stream
      //content-type, 對於本地文件上傳, 默認根據本地文件的后綴進行映射，如 jpg 文件映射 為image/jpg,可以不設置
      objectMetadata.setContentType("image/jpg");
      putObjectResult = cosClient.putObject(bucketName, fileKey, fileInputStream, objectMetadata);
      // 關閉輸入流...
    } catch (Exception serverException) {
      serverException.printStackTrace();
    } finally {
      try {
        fileInputStream.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
      close();
    }
    return putObjectResult;
  }
  
  /**
   * qcloud文件上傳
   * 以文件流上傳
   * @param cosClient
   * @param bucketName 保存到某個存儲桶
   * @param key 保存文件的key （以key-value形式保存）其實就是一個url路徑
   * @param file 上傳文件
   */
  public PutObjectResult qcloudUploadInput(InputStream fileInputStream, String fileKey) {
    init();
    PutObjectResult putObjectResult = null;
    try {
      // 方法2 從輸入流上傳(需提前告知輸入流的長度, 否則可能導致 oom)
      ObjectMetadata objectMetadata = new ObjectMetadata();
      // 設置輸入流長度為20971520
      //objectMetadata.setContentLength(20971520);  
      // 設置 Content type, 默認是 application/octet-stream
      //content-type, 對於本地文件上傳, 默認根據本地文件的后綴進行映射，如 jpg 文件映射 為image/jpg,可以不設置
      objectMetadata.setContentType("image/jpg");
      putObjectResult = cosClient.putObject(bucketName, fileKey, fileInputStream, objectMetadata);
      // 關閉輸入流...
    } catch (Exception serverException) {
      serverException.printStackTrace();
    } finally {
      try {
        fileInputStream.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
      close();
    }
    return putObjectResult;
  }  

  /**
   * qcloud文件下載
   * 
   * @param bucketName 下載某個存儲桶的數據
   * @param key 下載文件的key
   * @param targetFilePath 下載文件保存地址
   */
  public ObjectMetadata qcloudDownload(String keyname, String targetFilePath) {
    init();
    ObjectMetadata downObjectMeta = null;
    try {
      // 指定要下載到的本地路徑
      File downFile = new File(targetFilePath);
      GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, keyname);
      downObjectMeta = cosClient.getObject(getObjectRequest, downFile);
    } catch (Exception exception) {
      exception.printStackTrace();
    } finally {
      close();
    }
    return downObjectMeta;
  }
  
  /**
   * qcloud文件下載,獲取對象流
   * 
   * @param bucketName 下載某個存儲桶的數據
   * @param key 下載文件的key
   */
  public COSObjectInputStream qcloudDownloadInput(String keyname) {
    
    init();
    COSObjectInputStream cosObjectInput = null;
    try {
      // 指定要下載到的本地路徑
      GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, keyname);
      COSObject cosObject = cosClient.getObject(getObjectRequest);
      cosObjectInput = cosObject.getObjectContent();
    } catch (Exception exception) {
      exception.printStackTrace();
      logger.error("文件不存在");
      return null;
    } finally {
      close();
    }
    return cosObjectInput;
  }

  /**
   * 文件刪除
   * 
   * @param cosClient
   * @param bucketName 刪除文件所在存儲桶
   * @param key 刪除文件key
   */
  public void qcloudDeleteObject(String bucketName, String key) {
    init();
    try {
      cosClient.deleteObject(bucketName, key);
    } catch (Exception exception) {
      exception.printStackTrace();
    } finally {
      close();
    }
  }
}