productDev/parkBike.git

package com.doumee.core.utils.aliyun;
 
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSSClient;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.*;
import com.doumee.core.utils.FileDigest;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.multipart.MultipartFile;
 
import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
public class ALiYunUtil {
    private OSSClient client;
 
    // public static final String ENDPOINT = "oss-cn-shanghai.aliyuncs.com";
 
    public ALiYunUtil(String endpoint, String ACCESS_ID, String ACCESS_KEY) {
        client = new OSSClient(endpoint, ACCESS_ID, ACCESS_KEY);
    }
 
    /**
     * 上传文件
     *
     * @param bucketName 云端存放bucket名称
     * @param key        重新命名的文件名
     * @param filename   将要上传的文件名称
     * @param mime       超文本标记语言文本 .html,.html text/html 普通文本 .txt text/plain RTF文本
     *                   .rtf application/rtf GIF图形 .gif image/gif JPEG图形 .ipeg,.jpg
     *                   image/jpeg au声音文件 .au audio/basic MIDI音乐文件 mid,.midi
     *                   audio/midi,audio/x-midi RealAudio音乐文件 .ra, .ram
     *                   audio/x-pn-realaudio MPEG文件 .mpg,.mpeg video/mpeg AVI文件 .avi
     *                   video/x-msvideo GZIP文件 .gz application/x-gzip TAR文件 .tar
     *                   application/x-tar
     * @throws OSSException
     * @throws ClientException
     * @throws FileNotFoundException
     */
 
    public void uploadObject(String bucketName, String key, String filename,
                             String mime) throws OSSException, ClientException,
            FileNotFoundException {
        File file = new File(filename);
        // 判断是否存在，不存在创建
        isExistBucket(bucketName);
 
        ObjectMetadata objectMeta = new ObjectMetadata();
        objectMeta.setContentLength(file.length());
        // 可以在metadata中标记文件类型
        if (StringUtils.isNotBlank(mime)) {
            objectMeta.setContentType(mime);
        }
 
        InputStream input = new FileInputStream(file);
        client.putObject(bucketName, key, input, objectMeta);
 
    }
 
 
    /**
     * 关闭
     *
     * @throws OSSException
     * @throws ClientException
     * @throws FileNotFoundException
     */
 
    public void shutDown()
            throws OSSException, ClientException, FileNotFoundException {
        if (client != null) {
            // 关闭client
            client.shutdown();
        }
    }
 
    /**
     * 批量删除文件
     *
     * @param bucketName
     * @param keys
     * @throws OSSException
     * @throws ClientException
     * @throws FileNotFoundException
     */
 
    public void deleteObjects(String bucketName, List<String> keys)
            throws OSSException, ClientException, FileNotFoundException {
        if (keys == null || keys.size() > 0) {
            return;
        }
        DeleteObjectsResult deleteObjectsResult = client
                .deleteObjects(new DeleteObjectsRequest(bucketName)
                        .withKeys(keys));
        List<String> deletedObjects = deleteObjectsResult.getDeletedObjects();
        // 关闭client
        client.shutdown();
    }
 
    /**
     * 上传文件
     *
     * @param bucketName 云端存放bucket名称
     *                   将要上传的文件名称
     * @param mime       超文本标记语言文本 .html,.html text/html 普通文本 .txt text/plain RTF文本
     *                   .rtf application/rtf GIF图形 .gif image/gif JPEG图形 .ipeg,.jpg
     *                   image/jpeg au声音文件 .au audio/basic MIDI音乐文件 mid,.midi
     *                   audio/midi,audio/x-midi RealAudio音乐文件 .ra, .ram
     *                   audio/x-pn-realaudio MPEG文件 .mpg,.mpeg video/mpeg AVI文件 .avi
     *                   video/x-msvideo GZIP文件 .gz application/x-gzip TAR文件 .tar
     *                   application/x-tar
     * @throws OSSException
     * @throws ClientException
     * @throws FileNotFoundException
     */
 
    public void uploadFiles(String bucketName, Map<String, File> ossFiles,
                            String mime) throws OSSException, ClientException,
            FileNotFoundException {
        // 判断是否存在，不存在创建
        isExistBucket(bucketName);
 
        // 可以在metadata中标记文件类型
        if (ossFiles != null && ossFiles.size() > 0) {
            for (Map.Entry<String, File> entry : ossFiles.entrySet()) {
                ObjectMetadata objectMeta = new ObjectMetadata();
                objectMeta.setContentLength(entry.getValue().length());
                if (StringUtils.isNotBlank(mime)) {
                    objectMeta.setContentType(mime);
                }
                InputStream input = new FileInputStream(entry.getValue());
                client.putObject(bucketName, entry.getKey(), input, objectMeta);
                // 上传图片
            }
        }
 
        client.shutdown();
    }
 
    /**
     * 上传文件
     *
     * @param bucketName 云端存放bucket名称
     * @param key        将要上传的文件名称
     * @param mime       超文本标记语言文本 .html,.html text/html 普通文本 .txt text/plain RTF文本
     *                   .rtf application/rtf GIF图形 .gif image/gif JPEG图形 .ipeg,.jpg
     *                   image/jpeg au声音文件 .au audio/basic MIDI音乐文件 mid,.midi
     *                   audio/midi,audio/x-midi RealAudio音乐文件 .ra, .ram
     *                   audio/x-pn-realaudio MPEG文件 .mpg,.mpeg video/mpeg AVI文件 .avi
     *                   video/x-msvideo GZIP文件 .gz application/x-gzip TAR文件 .tar
     *                   application/x-tar
     * @throws OSSException
     * @throws ClientException
     * @throws FileNotFoundException
     */
 
    public void uploadFile(String bucketName, String key, File file, String mime)
            throws OSSException, ClientException, FileNotFoundException {
        // 判断是否存在，不存在创建
        isExistBucket(bucketName);
 
        ObjectMetadata objectMeta = new ObjectMetadata();
        objectMeta.setContentLength(file.length());
        // 可以在metadata中标记文件类型
        if (StringUtils.isNotBlank(mime)) {
            objectMeta.setContentType(mime);
        }
 
        InputStream input = new FileInputStream(file);
        client.putObject(bucketName, key, input, objectMeta);
 
    }
 
    /**
     * 上传文件
     *
     * @param bucketName 云端存放bucket名称
     * @param key        将要上传的文件名称
     * @param mime       超文本标记语言文本 .html,.html text/html 普通文本 .txt text/plain RTF文本
     *                   .rtf application/rtf GIF图形 .gif image/gif JPEG图形 .ipeg,.jpg
     *                   image/jpeg au声音文件 .au audio/basic MIDI音乐文件 mid,.midi
     *                   audio/midi,audio/x-midi RealAudio音乐文件 .ra, .ram
     *                   audio/x-pn-realaudio MPEG文件 .mpg,.mpeg video/mpeg AVI文件 .avi
     *                   video/x-msvideo GZIP文件 .gz application/x-gzip TAR文件 .tar
     *                   application/x-tar
     * @throws OSSException
     * @throws ClientException
     * @throws IOException
     */
 
    public boolean uploadObject(MultipartFile file, String bucketName,
                                String key, String mime) throws OSSException, ClientException,
            IOException {
        if (file != null) {
            // 判断是否存在，不存在创建
            isExistBucket(bucketName);
 
            ObjectMetadata objectMeta = new ObjectMetadata();
            objectMeta.setContentLength(file.getSize());
            // 可以在metadata中标记文件类型
            if (StringUtils.isNotBlank(mime)) {
                objectMeta.setContentType(mime);
            }
            PutObjectRequest putObjectRequest = new PutObjectRequest(
                    bucketName, key, file.getInputStream());
            // 上传回调参数
            /*
             * Callback callback = new Callback();
             * callback.setCallbackUrl("http://www.doumee.com");
             * callback.setCallbackHost("oss-cn-hangzhou.aliyuncs.com");
             * callback.setCallbackBody(
             * "{\\\"mimeType\\\":${mimeType},\\\"size\\\":${size}}"); //
             * callback.setCallbackBodyType(CallbackBodyType.JSON);
             * callback.addCallbackVar("x:var1", "value1");
             * callback.addCallbackVar("x:var2", "value2");
             * putObjectRequest.setCallback(callback);
             */
            try {
                PutObjectResult putObjectResult = client
                        .putObject(putObjectRequest);
                return true;
            } catch (Exception e) {
                // TODO: handle exception
                System.err.println(e.getMessage());
            }
            /*
             * // 读取上传回调返回的消息内容 byte[] buffer = new byte[1024];
             * putObjectResult.getCallbackResponseBody().read(buffer);
             *
             * // 一定要close，否则会造成连接资源泄漏
             * putObjectResult.getCallbackResponseBody().close();
             */
 
            file.getInputStream().close();
            client.shutdown();
 
        }
 
        return false;
 
    }
 
    /**
     * 分块上传文件
     *
     * @param bucketName
     * @param key
     * @param filename
     * @param mime
     * @throws IOException
     */
    public String partUploadObject(String bucketName, String key,
                                   String filename, String mime) throws IOException {
        // 开始Multipart Upload
        InitiateMultipartUploadRequest initiateMultipartUploadRequest = new InitiateMultipartUploadRequest(
                bucketName, key);
        InitiateMultipartUploadResult initiateMultipartUploadResult = client
                .initiateMultipartUpload(initiateMultipartUploadRequest);
 
        // 设置每块为 5M
        final int partSize = 1024 * 1024 * 5;
 
        File partFile = new File(filename);
 
        // 计算分块数目
        int partCount = (int) (partFile.length() / partSize);
        if (partFile.length() % partSize != 0) {
            partCount++;
        }
 
        // 新建一个List保存每个分块上传后的ETag和PartNumber
        List<PartETag> partETags = new ArrayList<PartETag>();
 
        for (int i = 0; i < partCount; i++) {
            // 获取文件流
            FileInputStream fis = new FileInputStream(partFile);
 
            // 跳到每个分块的开头
            long skipBytes = partSize * i;
            fis.skip(skipBytes);
 
            // 计算每个分块的大小
            long size = partSize < partFile.length() - skipBytes ? partSize
                    : partFile.length() - skipBytes;
 
            // 创建UploadPartRequest，上传分块
            UploadPartRequest uploadPartRequest = new UploadPartRequest();
            uploadPartRequest.setBucketName(bucketName);
            uploadPartRequest.setKey(key);
            uploadPartRequest.setUploadId(initiateMultipartUploadResult
                    .getUploadId());
            uploadPartRequest.setInputStream(fis);
            uploadPartRequest.setPartSize(size);
            uploadPartRequest.setPartNumber(i + 1);
            UploadPartResult uploadPartResult = client
                    .uploadPart(uploadPartRequest);
 
            // 将返回的PartETag保存到List中。
            partETags.add(uploadPartResult.getPartETag());
 
            // 关闭文件
            fis.close();
        }
 
        CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest(
                bucketName, key, initiateMultipartUploadResult.getUploadId(),
                partETags);
 
        // 完成分块上传
        CompleteMultipartUploadResult completeMultipartUploadResult = client
                .completeMultipartUpload(completeMultipartUploadRequest);
 
        // 校验MD5
        if (StringUtils.equals(FileDigest.getFileMD5(new File(filename)),
                completeMultipartUploadResult.getETag())) {
            // 如果一致
            return "上传成功";
        }
        return "上传失败";
 
    }
 
    /**
     * 判断是否存在bucket，如果不存在创建
     */
    @SuppressWarnings("deprecation")
    public void isExistBucket(String bucketName) {
        // 获取Bucket的存在信息
        boolean exists = client.doesBucketExist(bucketName);
        // 输出结果
        if (!exists) {
            // 不存在创建它
            client.createBucket(bucketName);
            // 修改权限
            client.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
        }
 
        // 列举bucket
        // List<Bucket> buckets = client.listBuckets();
        // for (Bucket bucket : buckets) {
        // System.out.println(" - " + bucket.getName());
        // }
    }
 
    /**
     * 删除bucket
     *
     * @param bucketName
     * @return
     */
    @SuppressWarnings("deprecation")
    public boolean deleteBucket(String bucketName) {
        // 判断有没有
        if (client.doesBucketExist(bucketName)) {
            // 判断bucket是否为空
            ObjectListing listObjects = client.listObjects(bucketName);
            // 遍历所有Object
            for (OSSObjectSummary objectSummary : listObjects
                    .getObjectSummaries()) {
                // 删除object
                client.deleteObject(bucketName, objectSummary.getKey());
            }
            // 删除Bucket
            client.deleteBucket(bucketName);
        }
        return true;
    }
 
    /**
     * 递归列出目录下所有文件
     *
     * @param bucketName
     * @return
     */
    public long getAllBuckets(String bucketName, String prefix) {
        long totalSize = 0;
        // 构造ListObjectsRequest请求
 
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(
                bucketName);
        listObjectsRequest.setPrefix(prefix);
        listObjectsRequest.withMaxKeys(1000);
        // 递归列出fun目录下的所有文件
        ObjectListing listing = null;
        String nextMarker = null;
        do {
            listObjectsRequest.withMarker(nextMarker);
            listing = client.listObjects(listObjectsRequest);
 
            for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
                totalSize += objectSummary.getSize();
                System.out.println(objectSummary.getKey() + ":"
                        + objectSummary.getSize());
            }
            nextMarker = listing.getNextMarker();
        } while (listing.isTruncated());
        // 遍历所有Object
        System.out.println("Objects:");
 
        return totalSize;
    }
 
    /**
     * 下载文件
     *
     * @param bucketName 云端存放bucket名称
     * @param key        云端已存在文件
     * @param filename   本地待写入文件
     * @throws OSSException
     * @throws ClientException
     * @throws IOException
     */
    public String downloadFile(String bucketName, String key, String filename)
            throws OSSException, ClientException, IOException {
 
        // 首先检查是否存在目录
        if (StringUtils.isBlank(filename)) {
            // 待写入文件为空
            return "ERROR_FILENAME_IS_NULL";
        }
 
        File file = new File(filename);
        if (!file.exists()) {
            file.createNewFile();
        }
 
        client.getObject(new GetObjectRequest(bucketName, key), file);
        return filename;
    }
 
    public static void main(String[] args) throws OSSException,
            ClientException, IOException {
        ALiYunUtil aLiYunUtil = new ALiYunUtil("", "uc4nnpsqep1i9fijqr37nokh",
                "/rp41xCx/XdGEVCptdH6v7xpc9w=");
        // aLiYunUtil.uploadObject("pongto", "work/li2.txt", "D://哈.txt",
        // ".html,.html text/html");D://装机软件/办公学习
        // aLiYunUtil.partUploadObject("pongto", "work/ps.exe",
        // "D://装机软件/办公学习/Adobe_Illustrator_CS6_XiaZaiBa.exe",
        // ".html,.html text/html");
        // aLiYunUtil.deleteBucket("pongto");
    }
 
    /**
     * 上传网络文件
     *
     * @param bucketName 云端存放bucket名称
     * @param key        重新命名的文件名
     *                   将要上传的文件名称
     * @param mime       超文本标记语言文本 .html,.html text/html 普通文本 .txt text/plain RTF文本
     *                   .rtf application/rtf GIF图形 .gif image/gif JPEG图形 .ipeg,.jpg
     *                   image/jpeg au声音文件 .au audio/basic MIDI音乐文件 mid,.midi
     *                   audio/midi,audio/x-midi RealAudio音乐文件 .ra, .ram
     *                   audio/x-pn-realaudio MPEG文件 .mpg,.mpeg video/mpeg AVI文件 .avi
     *                   video/x-msvideo GZIP文件 .gz application/x-gzip TAR文件 .tar
     *                   application/x-tar
     * @throws OSSException
     * @throws ClientException
     * @throws IOException
     */
 
    public boolean uploadOnlineObject(String url, String bucketName, String key,
                                      String mime) throws OSSException, ClientException, IOException {
        InputStream inputStream = new URL(url).openStream();
        if (inputStream != null) {
            // 判断是否存在，不存在创建
            isExistBucket(bucketName);
 
            ObjectMetadata objectMeta = new ObjectMetadata();
            objectMeta.setContentLength(inputStream.available());
            // 可以在metadata中标记文件类型
            if (StringUtils.isNotBlank(mime)) {
                objectMeta.setContentType(mime);
            }
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key,
                    inputStream);
            // 上传回调参数
            /*    Callback callback = new Callback();
            callback.setCallbackUrl("http://www.doumee.com");
            callback.setCallbackHost("oss-cn-hangzhou.aliyuncs.com");
            callback.setCallbackBody("{\\\"mimeType\\\":${mimeType},\\\"size\\\":${size}}");
//            callback.setCallbackBodyType(CallbackBodyType.JSON);
            callback.addCallbackVar("x:var1", "value1");
            callback.addCallbackVar("x:var2", "value2");
            putObjectRequest.setCallback(callback);*/
            try {
                PutObjectResult putObjectResult = client.putObject(putObjectRequest);
                return true;
            } catch (Exception e) {
                // TODO: handle exception
            }
            /*// 读取上传回调返回的消息内容
            byte[] buffer = new byte[1024];
            putObjectResult.getCallbackResponseBody().read(buffer);
            
            // 一定要close，否则会造成连接资源泄漏
            putObjectResult.getCallbackResponseBody().close();*/
 
            inputStream.close();
            client.shutdown();
 
        }
 
        return false;
 
    }
 
    public boolean uploadOnlineObject(InputStream inputStream, String bucketName, String key,
                                      String mime) throws OSSException, ClientException, IOException {
        if (inputStream != null) {
            // 判断是否存在，不存在创建
            isExistBucket(bucketName);
 
            ObjectMetadata objectMeta = new ObjectMetadata();
            objectMeta.setContentLength(inputStream.available());
            // 可以在metadata中标记文件类型
            if (StringUtils.isNotBlank(mime)) {
                objectMeta.setContentType(mime);
            }
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key,
                    inputStream);
            // 上传回调参数
            /*    Callback callback = new Callback();
            callback.setCallbackUrl("http://www.doumee.com");
            callback.setCallbackHost("oss-cn-hangzhou.aliyuncs.com");
            callback.setCallbackBody("{\\\"mimeType\\\":${mimeType},\\\"size\\\":${size}}");
//            callback.setCallbackBodyType(CallbackBodyType.JSON);
            callback.addCallbackVar("x:var1", "value1");
            callback.addCallbackVar("x:var2", "value2");
            putObjectRequest.setCallback(callback);*/
            try {
                PutObjectResult putObjectResult = client.putObject(putObjectRequest);
                return true;
            } catch (Exception e) {
                // TODO: handle exception
            }
            /*// 读取上传回调返回的消息内容
            byte[] buffer = new byte[1024];
            putObjectResult.getCallbackResponseBody().read(buffer);
            
            // 一定要close，否则会造成连接资源泄漏
            putObjectResult.getCallbackResponseBody().close();*/
 
            inputStream.close();
            client.shutdown();
 
        }
 
        return false;
 
    }
 
 
}