1. package com.soyuan.mh.srs.util;
    3. import com.google.common.base.Stopwatch;
    4. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    5. import com.soyuan.mh.srs.config.child.MinIoConfig;
    6. import io.minio.*;
    7. import io.minio.errors.*;
    9. import java.io.*;
    10. import java.security.InvalidKeyException;
    11. import java.security.NoSuchAlgorithmException;
    12. import java.time.Duration;
    13. import java.util.ArrayList;
    14. import java.util.List;
    15. import java.util.concurrent.*;
    16. import java.util.function.Consumer;
    18. /**
    19.  * @author tangwx@soyuan.com.cn
    20.  * @date 2021/4/2 上午11:46
    21.  */
    22. public class MinIoUtil {
    23.     /**
    24.      * 用于上传视频
    25.      */
    26.     private static final ExecutorService es = Executors.newFixedThreadPool(5,
    27.             new ThreadFactoryBuilder().setNameFormat("mh.srs.upload-minio-%d").build());
    29.     private MinioClient client;
    30.     private String bucketName;
    32.     public MinIoUtil(MinIoConfig config) {
    33.         this(config.getEndPoint(), config.getAccessKey(), config.getSecretKey(),config.getBucketName());
    34.     }
    36.     public MinIoUtil(String endPoint, String accessKey, String secretKey,String bucketName) {
    37.         this.bucketName=bucketName;
    38.         this.client = MinioClient.builder()
    39.                 .endpoint(endPoint)
    40.                 .credentials(accessKey, secretKey)
    41.                 .build();
    42.     }
    44.     /**
    45.      * 初始化创建桶和子文件夹
    46.      */
    47.     public void init() {
    48.         createBucket();
    49.         //makeDir("image/");
    50.         //makeDir("video/");
    51.     }
    53.     private boolean createBucket() {
    54.         try {
    55.             boolean isExist = client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    56.             if (isExist) {
    57.                 return false;
    58.             }else{
    59.                 client.makeBucket(MakeBucketArgs.builder()
    60.                         .bucket(bucketName)
    61.                         .objectLock(false)
    62.                         .build());
    63.                 return true;
    64.             }
    65.         } catch (ErrorResponseException e) {
    66.             e.printStackTrace();
    67.         } catch (InsufficientDataException e) {
    68.             e.printStackTrace();
    69.         } catch (InternalException e) {
    70.             e.printStackTrace();
    71.         } catch (InvalidBucketNameException e) {
    72.             e.printStackTrace();
    73.         } catch (InvalidKeyException e) {
    74.             e.printStackTrace();
    75.         } catch (InvalidResponseException e) {
    76.             e.printStackTrace();
    77.         } catch (IOException e) {
    78.             e.printStackTrace();
    79.         } catch (NoSuchAlgorithmException e) {
    80.             e.printStackTrace();
    81.         } catch (ServerException e) {
    82.             e.printStackTrace();
    83.         } catch (XmlParserException e) {
    84.             e.printStackTrace();
    85.         } catch (RegionConflictException e) {
    86.             e.printStackTrace();
    87.         }
    88.         return false;
    89.     }
    91.     public boolean deleteBucket(String bucketName){
    92.         try {
    93.             client.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    94.             return true;
    95.         } catch (ErrorResponseException e) {
    96.             e.printStackTrace();
    97.         } catch (InsufficientDataException e) {
    98.             e.printStackTrace();
    99.         } catch (InternalException e) {
    100.             e.printStackTrace();
    101.         } catch (InvalidBucketNameException e) {
    102.             e.printStackTrace();
    103.         } catch (InvalidKeyException e) {
    104.             e.printStackTrace();
    105.         } catch (InvalidResponseException e) {
    106.             e.printStackTrace();
    107.         } catch (IOException e) {
    108.             e.printStackTrace();
    109.         } catch (NoSuchAlgorithmException e) {
    110.             e.printStackTrace();
    111.         } catch (ServerException e) {
    112.             e.printStackTrace();
    113.         } catch (XmlParserException e) {
    114.             e.printStackTrace();
    115.         }
    116.         return false;
    117.     }
    119.     public boolean download(String bucketName, String objectName, String output) {
    120.         final InputStream is = getObject(bucketName, objectName);
    121.         if (is != null) {
    122.             try {
    123.                 OutputStream os = new FileOutputStream(new File(output));
    124.                 byte[] arr = new byte[1024];
    125.                 int len;
    126.                 while ((len=is.read(arr))!=-1){
    127.                     os.write(arr,0,len);
    128.                 }
    129.                 os.close();
    130.                 is.close();
    131.             } catch (FileNotFoundException e) {
    132.                 e.printStackTrace();
    133.             } catch (IOException e) {
    134.                 e.printStackTrace();
    135.             }
    136.             return true;
    137.         }
    138.         return false;
    139.     }
    141.     public InputStream getObject(String bucketName,String objectName) {
    142.         try {
    143.             return client.getObject(GetObjectArgs.builder()
    144.             .bucket(bucketName)
    145.             .object(objectName)
    146.             .build());
    147.         } catch (ErrorResponseException e) {
    148.             e.printStackTrace();
    149.         } catch (InsufficientDataException e) {
    150.             e.printStackTrace();
    151.         } catch (InternalException e) {
    152.             e.printStackTrace();
    153.         } catch (InvalidBucketNameException e) {
    154.             e.printStackTrace();
    155.         } catch (InvalidKeyException e) {
    156.             e.printStackTrace();
    157.         } catch (InvalidResponseException e) {
    158.             e.printStackTrace();
    159.         } catch (IOException e) {
    160.             e.printStackTrace();
    161.         } catch (NoSuchAlgorithmException e) {
    162.             e.printStackTrace();
    163.         } catch (ServerException e) {
    164.             e.printStackTrace();
    165.         } catch (XmlParserException e) {
    166.             e.printStackTrace();
    167.         }
    168.         return null;
    169.     }
    171.     /**
    172.      * 上传jpg图片
    173.      * @param imageName 图片名称
    174.      * @param inputPath 图片路径
    175.      * @return
    176.      */
    177.     public boolean putImage(String imageName, String inputPath) {
    178.         try {
    179.             InputStream ins = new FileInputStream(inputPath);
    180.             return putObject(bucketName, imageName, ContentType.JPEG, ins);
    181.         } catch (FileNotFoundException e) {
    182.             e.printStackTrace();
    183.         }
    184.         return false;
    185.     }
    187.     /**
    188.      * 异步上传MP4
    189.      * @param videoName 视频名称
    190.      * @param inputPath 视频路径
    191.      * @param consumer 回调接口
    192.      * @return
    193.      */
    194.     public void putVideoAsy(final String videoName, final String inputPath, Consumer<Boolean> consumer){
    195.         es.submit(() -> {
    196.             try {
    197.                 InputStream ins = new FileInputStream(inputPath);
    198.                 boolean res = putObject(bucketName, videoName, ContentType.MP4, ins);
    199.                 consumer.accept(res);
    200.             } catch (FileNotFoundException e) {
    201.                 e.printStackTrace();
    202.             }
    203.         });
    204.     }
    206.     /**
    207.      * 创建目录
    208.      * @param dir
    209.      */
    210.     public void makeDir(String dir){
    211.         try {
    212.             client.putObject(PutObjectArgs.builder()
    213.                 .bucket(bucketName)
    214.                 .object(dir)
    215.                 .stream(new ByteArrayInputStream(new byte[] {}), 0, -1)
    216.                 .build());
    217.         } catch (ErrorResponseException e) {
    218.             e.printStackTrace();
    219.         } catch (InsufficientDataException e) {
    220.             e.printStackTrace();
    221.         } catch (InternalException e) {
    222.             e.printStackTrace();
    223.         } catch (InvalidBucketNameException e) {
    224.             e.printStackTrace();
    225.         } catch (InvalidKeyException e) {
    226.             e.printStackTrace();
    227.         } catch (InvalidResponseException e) {
    228.             e.printStackTrace();
    229.         } catch (IOException e) {
    230.             e.printStackTrace();
    231.         } catch (NoSuchAlgorithmException e) {
    232.             e.printStackTrace();
    233.         } catch (ServerException e) {
    234.             e.printStackTrace();
    235.         } catch (XmlParserException e) {
    236.             e.printStackTrace();
    237.         }
    238.     }
    240.     private boolean putObject(String bucket,String objName,ContentType contentType,InputStream ins) {
    241.         try {
    242.             client.putObject(PutObjectArgs.builder()
    243.                     .bucket(bucket)
    244.                     .object(objName)
    245.                     .stream(ins, ins.available(), -1)
    246.                     .contentType(contentType.type)
    247.                     .build());
    248.             return true;
    249.         } catch (ErrorResponseException e) {
    250.             e.printStackTrace();
    251.         } catch (InsufficientDataException e) {
    252.             e.printStackTrace();
    253.         } catch (InternalException e) {
    254.             e.printStackTrace();
    255.         } catch (InvalidBucketNameException e) {
    256.             e.printStackTrace();
    257.         } catch (InvalidKeyException e) {
    258.             e.printStackTrace();
    259.         } catch (InvalidResponseException e) {
    260.             e.printStackTrace();
    261.         } catch (IOException e) {
    262.             e.printStackTrace();
    263.         } catch (NoSuchAlgorithmException e) {
    264.             e.printStackTrace();
    265.         } catch (ServerException e) {
    266.             e.printStackTrace();
    267.         } catch (XmlParserException e) {
    268.             e.printStackTrace();
    269.         }
    270.         return false;
    271.     }
    273.     public enum ContentType {
    274.         DEFAULT("application/octet-stream"),
    275.         JPEG("image/jpeg"),
    276.         PNG("image/png"),
    277.         MP4("video/mp4"),
    278.         CSV("text/csv");
    280.         private String type;
    282.         ContentType(String type) {
    283.             this.type = type;
    284.         }
    285.     }
    287. }