这里使用新版的SDK2进行开发：
    pom依赖：

    1. <dependency>
    2.   <groupId>software.amazon.awssdk</groupId>
    3.   <artifactId>s3</artifactId>
    4.   <version>2.17.64</version>
    5. </dependency>

    官方SDK文档：https://docs.aws.amazon.com/zh_cn/sdk-for-java/latest/developer-guide/home.html

    S3Config封装

    1. public class S3Config {
    3.     private String accessKeyId;
    5.     private String secretAccessKey;
    7.     private String region;
    9.     private String defaultBucket;
    11.     public S3Config() {
    12.     }
    14.     public S3Config(String accessKeyId, String secretAccessKey, String region, String defaultBucket) {
    15.         this.accessKeyId = accessKeyId;
    16.         this.secretAccessKey = secretAccessKey;
    17.         this.region = region;
    18.         this.defaultBucket = defaultBucket;
    19.     }
    21.     public String getAccessKeyId() {
    22.         return accessKeyId;
    23.     }
    25.     public void setAccessKeyId(String accessKeyId) {
    26.         this.accessKeyId = accessKeyId;
    27.     }
    29.     public String getSecretAccessKey() {
    30.         return secretAccessKey;
    31.     }
    33.     public void setSecretAccessKey(String secretAccessKey) {
    34.         this.secretAccessKey = secretAccessKey;
    35.     }
    37.     public String getRegion() {
    38.         return region;
    39.     }
    41.     public void setRegion(String region) {
    42.         this.region = region;
    43.     }
    45.     public String getDefaultBucket() {
    46.         return defaultBucket;
    47.     }
    49.     public void setDefaultBucket(String defaultBucket) {
    50.         this.defaultBucket = defaultBucket;
    51.     }
    52. }

    Util封装：

    1. /**
    2.  * AWS S3（simple storage service）工具类
    3.  *
    4.  * @author mori
    5.  * @date 2021/10/21
    6.  */
    7. public class AmazonS3Util {
    9.     private static final Logger log = LoggerFactory.getLogger(AmazonS3Util.class);
    11.     private static S3Client s3Client;
    13.     private static S3Config s3Config;
    15.     /**
    16.      * 初始化s3 client
    17.      *
    18.      * @param config config
    19.      */
    20.     private static void init(S3Config config) {
    21.         try {
    22.             log.info("AWS S3 S3Client init...");
    23.             s3Config = config;
    24.             AwsBasicCredentials awsBasicCredentials = AwsBasicCredentials.create(
    25.                     config.getAccessKeyId(), config.getSecretAccessKey());
    26.             s3Client = S3Client.builder()
    27.                     .region(Region.of(config.getRegion()))
    28.                     .credentialsProvider(StaticCredentialsProvider.create(awsBasicCredentials))
    29.                     .build();
    30.             List<Bucket> buckets = listBucket();
    31.             String defaultBucket = s3Config.getDefaultBucket();
    32.             if (CollectionUtils.isNotEmpty(buckets)) {
    33.                 Bucket bucket = buckets.stream()
    34.                         .filter(b -> Objects.equals(defaultBucket, b.name())).findFirst().orElse(null);
    35.                 if (Objects.nonNull(bucket)) {
    36.                     log.info("default bucket '{}' already exists.", defaultBucket);
    37.                     return;
    38.                 }
    39.             }
    40.             log.info("default bucket '{}' does not exist, start to create...", defaultBucket);
    41.             boolean res = createBucket(defaultBucket);
    42.             if (!res) {
    43.                 throw new RuntimeException("create default bucket failed.");
    44.             }
    45.         } catch (Exception e) {
    46.             log.error("AWS S3Client init failed, error message: {}", e.getMessage());
    47.             throw new RuntimeException("AWS S3Client init failed,", e);
    48.         }
    49.     }
    51.     /**
    52.      * 构建存储对象请求
    53.      *
    54.      * @param bucket 对象桶
    55.      * @param key    对象key
    56.      * @return {@link PutObjectRequest}
    57.      */
    58.     private static PutObjectRequest createPutObjectRequest(String bucket, String key) {
    59.         return PutObjectRequest.builder()
    60.                 .bucket(bucket)
    61.                 .key(key)
    62.                 .build();
    63.     }
    65.     /**
    66.      * 存储对象到默认设置的桶中
    67.      *
    68.      * @param key         对象key
    69.      * @param requestBody 需要存储的对象
    70.      * @return boolean
    71.      */
    72.     public static boolean putObject(String key, RequestBody requestBody) {
    73.         return putObject(s3Config.getDefaultBucket(), key, requestBody);
    74.     }
    76.     /**
    77.      * 存储对象到默认设置的桶中
    78.      *
    79.      * @param key  对象key
    80.      * @param path 路径
    81.      * @return boolean
    82.      */
    83.     public static boolean putObject(String key, Path path) {
    84.         return putObject(s3Config.getDefaultBucket(), key, path);
    85.     }
    87.     /**
    88.      * 获取对象输入流, 默认桶
    89.      *
    90.      * @param key 对象key
    91.      * @return {@link GetObjectResponse}
    92.      */
    93.     public static ResponseInputStream<GetObjectResponse> getObject(String key) {
    94.         return getObject(s3Config.getDefaultBucket(), key);
    95.     }
    97.     /**
    98.      * 获取对象字节数组, 默认桶
    99.      *
    100.      * @param key 对象key
    101.      * @return {@link GetObjectResponse}
    102.      */
    103.     public static ResponseBytes<GetObjectResponse> getObjectAsBytes(String key) {
    104.         return getObjectAsBytes(s3Config.getDefaultBucket(), key);
    105.     }
    107.     /**
    108.      * 删除对象, 默认桶
    109.      *
    110.      * @param key 对象key
    111.      * @return boolean
    112.      */
    113.     public static boolean deleteObject(String key) {
    114.         return deleteObject(s3Config.getDefaultBucket(), key);
    115.     }
    117.     /**
    118.      * 删除桶中的对象列表,默认桶
    119.      *
    120.      * @param objectNames 对象名称列表
    121.      * @return true表示删除成功
    122.      */
    123.     public static boolean deleteObjects(List<String> objectNames) {
    124.         return deleteObjects(s3Config.getDefaultBucket(), objectNames);
    125.     }
    127.     /**
    128.      * 当前桶对象列表
    129.      *
    130.      * @return 对象列表 {@link S3Object}>
    131.      */
    132.     public static List<S3Object> listCurrentBucketObjects() {
    133.         return listBucketObjects(s3Config.getDefaultBucket());
    134.     }
    136.     /**
    137.      * 创建存储桶
    138.      *
    139.      * @param bucketName 存储桶名称
    140.      * @return true表示创建成功
    141.      */
    142.     public static boolean createBucket(String bucketName) {
    143.         try {
    144.             log.info("AWS S3 create bucket..., bucketName: '{}'", bucketName);
    145.             S3Waiter s3Waiter = s3Client.waiter();
    146.             CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
    147.                     .bucket(bucketName)
    148.                     .build();
    149.             s3Client.createBucket(bucketRequest);
    150.             HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
    151.                     .bucket(bucketName)
    152.                     .build();
    153.             WaiterResponse<HeadBucketResponse> waiterResponse = s3Waiter.waitUntilBucketExists(bucketRequestWait);
    154.             waiterResponse.matched().response().ifPresent(res -> log.info(res.toString()));
    155.             log.info("AWS S3 bucket {} is ready", bucketName);
    156.             return true;
    157.         } catch (S3Exception e) {
    158.             log.error("AWS S3 create bucket failed, bucketName: {}, error detail message: {}",
    159.                     bucketName, e.awsErrorDetails().errorMessage());
    160.             return false;
    161.         }
    162.     }
    164.     /**
    165.      * 列出所有存储桶
    166.      *
    167.      * @return 存储桶列表，通过name函数可以获得桶名称
    168.      */
    169.     public static List<Bucket> listBucket() {
    170.         try {
    171.             ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder().build();
    172.             ListBucketsResponse listBucketsResponse = s3Client.listBuckets(listBucketsRequest);
    173.             return listBucketsResponse.buckets();
    174.         } catch (S3Exception e) {
    175.             log.error("AWS S3 list bucket failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    176.             return null;
    177.         }
    178.     }
    180.     /**
    181.      * 删除存储桶
    182.      *
    183.      * @param bucketName 存储桶名称
    184.      * @return true表示删除成功
    185.      */
    186.     public static boolean deleteBucket(String bucketName) {
    187.         try {
    188.             log.info("AWS S3 delete bucket..., bucketName: '{}'", bucketName);
    189.             DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build();
    190.             s3Client.deleteBucket(deleteBucketRequest);
    191.             log.info("AWS S3 delete bucket complete, bucketName: '{}'", bucketName);
    192.             return true;
    193.         } catch (S3Exception e) {
    194.             log.error("AWS S3 deleted bucket failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    195.             return false;
    196.         }
    197.     }
    199.     /**
    200.      * 删除桶中的对象列表
    201.      *
    202.      * @param bucketName  存储桶名称
    203.      * @param objectNames 对象名称列表
    204.      * @return true表示删除成功
    205.      */
    206.     public static boolean deleteObjects(String bucketName, List<String> objectNames) {
    207.         try {
    208.             String objects = Arrays.toString(objectNames.toArray());
    209.             log.info("AWS S3 delete multiple objects..., bucketName: '{}', keys: '{}'",
    210.                     bucketName, objects);
    211.             ArrayList<ObjectIdentifier> keys = new ArrayList<>();
    212.             for (String objectName : objectNames) {
    213.                 keys.add(ObjectIdentifier.builder().key(objectName).build());
    214.             }
    215.             DeleteObjectsRequest multiObjectDeleteRequest = DeleteObjectsRequest.builder()
    216.                     .bucket(bucketName)
    217.                     .delete(Delete.builder().objects(keys).build())
    218.                     .build();
    219.             s3Client.deleteObjects(multiObjectDeleteRequest);
    220.             log.info("AWS S3 delete multiple objects complete, bucketName: '{}', keys: '{}'", bucketName, objects);
    221.             return true;
    222.         } catch (S3Exception e) {
    223.             log.error("AWS S3 deleted multiple objects failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    224.             return false;
    225.         }
    226.     }
    228.     /**
    229.      * 存储对象
    230.      *
    231.      * @param bucketName  bucket名称
    232.      * @param key         对象key
    233.      * @param requestBody 需要存储的对象
    234.      * @return boolean
    235.      */
    236.     public static boolean putObject(String bucketName, String key, RequestBody requestBody) {
    237.         try {
    238.             log.info("AWS S3 uploading object..., bucketName: '{}', key: '{}'", bucketName, key);
    239.             PutObjectRequest putObjectRequest = createPutObjectRequest(bucketName, key);
    240.             s3Client.putObject(putObjectRequest, requestBody);
    241.             log.info("AWS S3 upload object complete, bucketName: '{}', key: '{}'", bucketName, key);
    242.             return true;
    243.         } catch (S3Exception e) {
    244.             log.error("AWS S3 put object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    245.             return false;
    246.         }
    247.     }
    249.     /**
    250.      * 存储对象
    251.      *
    252.      * @param bucketName bucket名称
    253.      * @param key        对象key
    254.      * @param path       路径
    255.      * @return boolean
    256.      */
    257.     public static boolean putObject(String bucketName, String key, Path path) {
    258.         try {
    259.             log.info("AWS S3 uploading object..., bucketName: '{}', key: '{}'", bucketName, key);
    260.             PutObjectRequest putObjectRequest = createPutObjectRequest(bucketName, key);
    261.             s3Client.putObject(putObjectRequest, path);
    262.             log.info("AWS S3 upload object complete, bucketName: '{}', key: '{}'", bucketName, key);
    263.             return true;
    264.         } catch (S3Exception e) {
    265.             log.error("AWS S3 put object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    266.             return false;
    267.         }
    268.     }
    271.     /**
    272.      * 获取对象输入流
    273.      *
    274.      * @param bucketName bucket名称
    275.      * @param key        对象key
    276.      * @return {@link GetObjectResponse}
    277.      */
    278.     public static ResponseInputStream<GetObjectResponse> getObject(String bucketName, String key) {
    279.         try {
    280.             GetObjectRequest getObjectRequest = GetObjectRequest.builder()
    281.                     .bucket(bucketName)
    282.                     .key(key)
    283.                     .build();
    284.             return s3Client.getObject(getObjectRequest);
    285.         } catch (S3Exception e) {
    286.             log.error("AWS S3 get object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    287.             return null;
    288.         }
    289.     }
    291.     /**
    292.      * 获取对象字节数组
    293.      *
    294.      * @param bucketName bucket名称
    295.      * @param key        对象key
    296.      * @return {@link GetObjectResponse}
    297.      */
    298.     public static ResponseBytes<GetObjectResponse> getObjectAsBytes(String bucketName, String key) {
    299.         try {
    300.             GetObjectRequest getObjectRequest = GetObjectRequest.builder()
    301.                     .bucket(bucketName)
    302.                     .key(key)
    303.                     .build();
    304.             return s3Client.getObjectAsBytes(getObjectRequest);
    305.         } catch (S3Exception e) {
    306.             log.error("AWS S3 get object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    307.             return null;
    308.         }
    309.     }
    311.     /**
    312.      * 删除对象
    313.      *
    314.      * @param bucketName bucket名称
    315.      * @param key        对象key
    316.      * @return boolean
    317.      */
    318.     public static boolean deleteObject(String bucketName, String key) {
    319.         try {
    320.             log.info("AWS S3 delete object..., bucketName: '{}', key: '{}'", bucketName, key);
    321.             DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder()
    322.                     .bucket(bucketName)
    323.                     .key(key)
    324.                     .build();
    325.             s3Client.deleteObject(deleteObjectRequest);
    326.             log.info("AWS S3 delete object complete, bucketName: '{}', key: '{}'", bucketName, key);
    327.             return true;
    328.         } catch (S3Exception e) {
    329.             log.error("AWS S3 delete object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    330.             return false;
    331.         }
    332.     }
    334.     /**
    335.      * 复制桶中的对象到另一个桶
    336.      *
    337.      * @param fromBucket 对象存放的原始桶，一个 URL 编码的字符串值（请参阅 URlenCoder.code 方法）
    338.      * @param objectKey  对象的key
    339.      * @param toBucket   另一个桶
    340.      * @return 复制结果
    341.      */
    342.     public static String copyBucketObject(String fromBucket, String objectKey, String toBucket) {
    343.         try {
    344.             log.info("AWS S3 copy object..., fromBucket: '{}', objectKey: '{}', toBucket: '{}'",
    345.                     fromBucket, objectKey, toBucket);
    346.             CopyObjectRequest copyObjectRequest = CopyObjectRequest.builder()
    347.                     .sourceBucket(fromBucket)
    348.                     .sourceKey(objectKey)
    349.                     .destinationBucket(toBucket)
    350.                     .destinationKey(objectKey)
    351.                     .build();
    352.             CopyObjectResponse res = s3Client.copyObject(copyObjectRequest);
    353.             log.info("AWS S3 copy object complete, fromBucket: '{}', objectKey: '{}', toBucket: '{}'",
    354.                     fromBucket, objectKey, toBucket);
    355.             return res.copyObjectResult().toString();
    356.         } catch (S3Exception e) {
    357.             log.error("AWS S3 copy bucket object failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    358.             return "";
    359.         }
    360.     }
    362.     /**
    363.      * 列出桶中的对象
    364.      *
    365.      * @param bucketName 桶名称
    366.      * @return {@link List}<{@link S3Object}>
    367.      */
    368.     public static List<S3Object> listBucketObjects(String bucketName) {
    369.         try {
    370.             ListObjectsRequest listObjectsRequest = ListObjectsRequest
    371.                     .builder()
    372.                     .bucket(bucketName)
    373.                     .build();
    374.             ListObjectsResponse res = s3Client.listObjects(listObjectsRequest);
    375.             return res.contents();
    376.         } catch (S3Exception e) {
    377.             log.error("AWS S3 list bucket objects failed, error detail message: {}", e.awsErrorDetails().errorMessage());
    378.             return null;
    379.         }
    380.     }
    382. }

    configuration：

    1. @Configuration
    2. public class AmazonS3Config {
    4.     @Value("${amazon.s3.accessKeyId}")
    5.     private String accessKeyId;
    7.     @Value("${amazon.s3.secretAccessKey}")
    8.     private String secretAccessKey;
    10.     @Value("${amazon.s3.region}")
    11.     private String region;
    13.     @Value("${amazon.s3.defaultBucket}")
    14.     private String defaultBucket;
    16.     @Bean
    17.     public S3Config s3Config() {
    18.         return new S3Config(accessKeyId, secretAccessKey, region, defaultBucket);
    19.     }
    21.     @Bean
    22.     public MethodInvokingFactoryBean s3ClientInit(S3Config config) {
    23.         MethodInvokingFactoryBean invokingFactoryBean = new MethodInvokingFactoryBean();
    24.         invokingFactoryBean.setTargetClass(AmazonS3Util.class);
    25.         invokingFactoryBean.setTargetMethod("init");
    26.         invokingFactoryBean.setArguments(config);
    27.         return invokingFactoryBean;
    28.     }
    29. }