AWS3兼容青云对象存储操作类 JAVA单例模式

最近用到青云的对象存储，所以简单封装了一下。

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.Protocol;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.*;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.Upload;
import com.amazonaws.util.IOUtils;
import com.amazonaws.util.StringUtils;
import com.google.common.base.Strings;
import com.tscloud.common.framework.config.ConfigHelper;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by caicf on 2016/11/7.
 *
 * @author cai_cf@126.com
 */
public class QingObjStoreAWS3 {

//    private static String AccessKey="";
//    private static String SecrectKey="";
//    private static String endPoint="https://s3.pek3a.qingstor.com";

    private static final Logger log = LoggerFactory.getLogger(QingObjStoreAWS3.class);

    private static QingObjStoreAWS3 instance;

    private static AmazonS3Client amazonS3Client;

    private QingObjStoreAWS3(){}

    public static QingObjStoreAWS3 getInstance() {
        if (instance == null) {
            synchronized (AmazonS3Client.class) {
                if (instance == null) {
                    instance = new QingObjStoreAWS3();
                }
            }
        }
        return instance;
    }

    /**
     * 初始化并配置AmazonS3Client
     */
    private void initAmazonS3Client() {
        AWSCredentials credentials = new BasicAWSCredentials(ConfigHelper.getValue("aws_access_key_id"), ConfigHelper.getValue("aws_secret_access_key"));
        ClientConfiguration clientConfig = new ClientConfiguration();
        clientConfig.setProtocol(Protocol.HTTP);
        amazonS3Client = new AmazonS3Client(credentials, clientConfig);
        amazonS3Client.setEndpoint(ConfigHelper.getValue("endpoint"));
    }

    /**
     * 获取client
     *
     * @return
     */
    private AmazonS3Client getAmazonS3Client() {
        if (amazonS3Client == null) {
            initAmazonS3Client();
        }
        return amazonS3Client;
    }

    /**
     * create bucket
     *
     * @param bucketName
     * @return
     */
    public boolean createBucket(String bucketName) {
        boolean flag = false;
        AmazonS3Client client = getAmazonS3Client();
        if (!client.doesBucketExist(bucketName)) { //不存在则新建
            Bucket bucket = client.createBucket(bucketName);
            log.info("create Bucket success: " + bucket.getName());
            flag = true;
        }
        return flag;
    }

    /**
     * delete bucket
     *
     * @param bucketName
     * @return
     */
    public Boolean deleteBucket(String bucketName) {
        boolean flag = false;
        AmazonS3Client client = getAmazonS3Client();
        if (client.doesBucketExist(bucketName)) {
            client.deleteBucket(bucketName);
            log.info("deleteBucket success: " + bucketName);
            flag = true;
        }
        return flag;
    }

    /**
     * get objects
     *
     * @param bucketName
     * @param keyName
     * @return
     */
    public InputStream getObjects(String bucketName, String keyName) {
        try {
            AmazonS3Client client = getAmazonS3Client();
            if (client.doesObjectExist(bucketName, keyName)) {
                S3Object object = client.getObject(new GetObjectRequest(bucketName, keyName));
                S3ObjectInputStream objStream = object.getObjectContent();
                InputStream is = new BufferedInputStream(objStream);
                log.info("get object success { " + bucketName + ":" + keyName + " }");
                return is;
            } else {
                log.info("object does not exists!");
            }
        } catch (Exception e) {
            log.error("getObjects error", e.getMessage());
        }
        return null;
    }

    /**
     * Deleting an Object (Non-Versioned Bucket)
     *
     * @param bucketName
     * @param keyName    delete file：abc/c3p0-0.9.1.2.jar   delete folder：adc/
     */
    public Boolean deleteOneObject(String bucketName, String keyName) {
        boolean flag = false;
        try {
            AmazonS3Client client = getAmazonS3Client();
            if (keyName.endsWith("/")) {
                List<String> list = listObjects(client, bucketName, keyName);
                if (list.isEmpty() || list.get(0).equals(keyName)) {
                    log.info("delete folder : { " + bucketName + " : " + keyName + " } success!");
                    client.deleteObject(new DeleteObjectRequest(bucketName, keyName));
                    flag = true;
                } else {
                    log.info("only empty folder can be removed!");
                }
            } else {
                if (client.doesObjectExist(bucketName, keyName)) {
                    client.deleteObject(new DeleteObjectRequest(bucketName, keyName));
                    flag = true;
                    log.info("delete object : { " + bucketName + " : " + keyName + " } success!");
                }
            }
        } catch (AmazonServiceException ase) {
            log.error("delete object error : {" + ase.getErrorCode() + " : " + ase.getErrorMessage() + "}");
        } catch (AmazonClientException ace) {
            log.error("delete object error with AmazonClient :{" + ace.getMessage() + "}");
        }
        return flag;
    }

    /**
     * upload object file
     *
     * @param bucketName
     * @param keyName    eg:abc/111.txt   upload to / set keyName "" or null
     * @param file
     * @return
     */
    public Boolean uploadObject(String bucketName, String keyName, File file) {
        boolean flag = true;
        try {
            AmazonS3Client client = getAmazonS3Client();
            String newKeyName = "";
            if (file != null) {
                if (Strings.isNullOrEmpty(keyName)) {
                    newKeyName = file.getName();
                } else if (keyName.length() > 1 && keyName.endsWith("/")) {
                    newKeyName = keyName + file.getName();
                } else {
                    newKeyName = keyName + "/" + file.getName();
                }
                if (!client.doesBucketExist(bucketName) || client.doesObjectExist(bucketName, newKeyName)) {
                    return flag = false;
                }
                client.putObject(new PutObjectRequest(bucketName, newKeyName, file));
                log.info("Uploading a new object to {" + bucketName + "/" + keyName + "} from file {" + file.getName() + "}");
            }
        } catch (AmazonServiceException ase) {
            log.error("upload object error  {" + bucketName + "/" + keyName + "} from file {" + file.getName() + "}", ase.getErrorCode() + " " + ase.getMessage());
        } catch (AmazonClientException ace) {
            flag = false;
            log.error("upload object error with AmazonS3Client :" + ace.getMessage());
        }
        return flag;
    }

    /**
     * upload file form InputStream
     *
     * @param bucketName
     * @param keyName
     * @param fileInputStream
     * @param objectMetadata
     * @return
     */
    public Boolean uploadObject(String bucketName, String keyName, InputStream fileInputStream, ObjectMetadata objectMetadata) {
        boolean flag = true;
        try {
            AmazonS3Client client = getAmazonS3Client();
            if (fileInputStream != null) {
                //bucket doesn't exists or object already exists
                if (!client.doesBucketExist(bucketName) || client.doesObjectExist(bucketName, keyName)) {
                    return flag = false;
                }
                objectMetadata.setContentEncoding("UTF-8");
                client.putObject(bucketName, keyName, fileInputStream, objectMetadata);
                log.info("Uploading a new object to {" + bucketName + "/" + keyName + "}");
            }
        } catch (AmazonServiceException ase) {
            log.error("upload object error  {" + bucketName + "/" + keyName + "}", ase.getErrorCode() + " " + ase.getMessage());
            System.out.println("upload object error  {" + bucketName + "/" + keyName + "} " + ase.getErrorCode() + " " + ase.getMessage());
        } catch (AmazonClientException ace) {
            flag = false;
            log.error("upload object error with AmazonS3Client :" + ace.getMessage());
        }
        return flag;
    }

    /**
     * create folder
     *
     * @param bucketName
     * @param folderName eg:abc/111.txt
     * @return
     */
    public Boolean createFolder(String bucketName, String folderName) {
        boolean flag = true;
        try {
            AmazonS3Client client = getAmazonS3Client();
            if (folderName.endsWith("/")) {
                client.putObject(new PutObjectRequest(bucketName, folderName, ""));
                log.info("create a new folder : { " + bucketName + "/" + folderName + " }");
            } else {
                client.putObject(new PutObjectRequest(bucketName, folderName + "/", ""));
                log.info("create a new folder : { " + bucketName + "/" + folderName + " }");
            }
        } catch (AmazonServiceException ase) {
            log.error("create folder error  {" + bucketName + "/" + folderName + "}", ase.getErrorCode() + " " + ase.getMessage());
        } catch (AmazonClientException ace) {
            flag = false;
            log.error("create folder error with AmazonS3Client :" + ace.getMessage());
        }
        return flag;
    }

    /**
     * list all objects in bucket
     *
     * @param bucketName
     * @param prefix     when list specified folder use this; list all set to "" or null
     * @return
     */
    public List<String> listObjects(String bucketName, String prefix) {
        List<String> keys = new ArrayList<>();
        try {
            AmazonS3Client client = getAmazonS3Client();
            final ListObjectsV2Request req = new ListObjectsV2Request().withBucketName(bucketName).withPrefix(prefix);
            ListObjectsV2Result result;
            do {
                result = client.listObjectsV2(req);
                for (S3ObjectSummary objectSummary : result.getObjectSummaries()) {
                    keys.add(objectSummary.getKey());
                }
                req.setContinuationToken(result.getNextContinuationToken());
            } while (result.isTruncated() == true);
        } catch (AmazonServiceException ase) {
            log.error("list bucket keys error " + ase.getErrorCode() + " : " + ase.getMessage());
        } catch (AmazonClientException ace) {
            log.error("list bucket keys error with AmazonS3Client");
        }
        return keys;
    }

    /**
     * list all objects in bucket return with object size
     *
     * @param bucketName
     * @param prefix     when list specified folder use this; list all set to "" or null
     * @return
     */
    public Map<String, Object> listObjectsWithSize(String bucketName, String prefix) {
        Map<String, Object> keys = new HashMap<>();
        try {
            AmazonS3Client client = getAmazonS3Client();
            final ListObjectsV2Request req = new ListObjectsV2Request().withBucketName(bucketName).withPrefix(prefix);
            ListObjectsV2Result result;
            do {
                result = client.listObjectsV2(req);
                for (S3ObjectSummary objectSummary : result.getObjectSummaries()) {
                    keys.put(objectSummary.getKey(), objectSummary.getSize());
                }
                req.setContinuationToken(result.getNextContinuationToken());
            } while (result.isTruncated() == true);
        } catch (AmazonServiceException ase) {
            log.error("list bucket keys error " + ase.getErrorCode() + " : " + ase.getMessage());
        } catch (AmazonClientException ace) {
            log.error("list bucket keys error with AmazonS3Client");
        }
        return keys;
    }

    public static void main(String[] args) throws IOException {
        boolean result = QingObjStoreAWS3.getInstance().createBucket("/hello");
        System.out.println(result);
    }

}

在执行多个删除时会报错：

Exception in thread "main" com.amazonaws.services.s3.model.AmazonS3Exception: The request body is invalid. (Service: Amazon S3; Status Code: 400; Error Code: InvalidRequest; Request ID: f527450ca62111e69d36525458f671ab), S3 Extended Request ID: null
    at com.amazonaws.http.AmazonHttpClient.handleErrorResponse(AmazonHttpClient.java:1341)
    at com.amazonaws.http.AmazonHttpClient.executeOneRequest(AmazonHttpClient.java:959)
    at com.amazonaws.http.AmazonHttpClient.executeHelper(AmazonHttpClient.java:736)
    at com.amazonaws.http.AmazonHttpClient.doExecute(AmazonHttpClient.java:487)
    at com.amazonaws.http.AmazonHttpClient.executeWithTimer(AmazonHttpClient.java:448)
    at com.amazonaws.http.AmazonHttpClient.execute(AmazonHttpClient.java:397)
    at com.amazonaws.http.AmazonHttpClient.execute(AmazonHttpClient.java:378)
    at com.amazonaws.services.s3.AmazonS3Client.invoke(AmazonS3Client.java:4039)
    at com.amazonaws.services.s3.AmazonS3Client.deleteObjects(AmazonS3Client.java:1955)
    at com.tscloud.common.tool.objectstoretool.QingObjStoreAWS3.deleteMultipleObjects(QingObjStoreAWS3.java:147)
    at com.tscloud.common.tool.objectstoretool.QingObjStoreAWS3.main(QingObjStoreAWS3.java:323)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

目前没有找到解决办法，应该是青云暂时不兼容导致。