SpringBoot整合AWS S3_springboot 集成aws s3

SpringBoot整合AWS S3

---

---

前言

一、AWS S3是什么？

amazon (S3) 是一个公开的服务，Web 应用程序开发人员可以使用它存储数字资产，包括图片、视频、音乐和文档。 S3 提供一个 RESTful API 以编程方式实现与该服务的交互。（来源百度百科）

简单来说就是所有支持S3协议的都可以使用这个进行文件上传或者下载等操作。
本文使用开源的MinIO进行演示

二、使用步骤

1、准备工作

1、MinIO搭建与配置

搭建按照官方操作即可

搭建完成之后需要创建一个用户

拿到对应的信息

2、引入依赖

 <!-- aws-java-sdk-s3 -->
 <dependency>
     <groupId>com.amazonaws</groupId>
     <artifactId>aws-java-sdk-s3</artifactId>
     <version>1.12.362</version>
 </dependency>
 
 <!-- commons-io -->
 <dependency>
     <groupId>commons-io</groupId>
     <artifactId>commons-io</artifactId>
     <version>2.11.0</version>
 </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13

2、补充配置

在配置文件中添加配置
一个是S3的配置，一个是文件上传文件大小限制

#AWS S3配置
aws:
  s3:
    accessKey: 配置的信息
    secretKey: 配置的信息
    url: http://你的ip:端口
    bucket: 桶名称
#    文件上传限制
spring:
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
1
2
3
4
5
6
7
8
9
10
11
12
13

3、封装工具类

1 、配置类

@Data
@Configuration
@ConfigurationProperties(prefix = "aws.s3")
public class AwzS3Config {
    private String accessKey;
    private String secretKey;
    private String url;
    private String bucket;
}
1
2
3
4
5
6
7
8
9

2 、文件工具类

@Component
public class AwzS3Util {

    @Resource
    private AwzS3Config injectAwzS3Config;

    private static AwzS3Config awzS3Config;

    private static AmazonS3 amazonS3;


    @PostConstruct
    public void init() {
        awzS3Config = this.injectAwzS3Config;
        AWSCredentials credentials = new BasicAWSCredentials(awzS3Config.getAccessKey(), awzS3Config.getSecretKey());
        AWSCredentialsProvider credentialsProvider = new AWSStaticCredentialsProvider(credentials);
        AwsClientBuilder.EndpointConfiguration endpointConfig =
                new AwsClientBuilder.EndpointConfiguration(awzS3Config.getUrl(), Regions.CN_NORTH_1.getName());
        ClientConfiguration config = new ClientConfiguration();
        config.setSignerOverride("S3SignerType");
        config.setProtocol(Protocol.HTTP);
        config.withUseExpectContinue(false);
        config.disableSocketProxy();
        amazonS3 = AmazonS3Client.builder()
                .withEndpointConfiguration(endpointConfig)
                .withClientConfiguration(config)
                .withCredentials(credentialsProvider)
                .disableChunkedEncoding()
                .withPathStyleAccessEnabled(true)
                .withForceGlobalBucketAccessEnabled(true)
                .build();
    }


    /**
     * 创建桶
     *
     * @return boolean
     * @params * @param bucket
     * @author susj
     * @date 2022/12/12 16:39
     */
    public static boolean createBucket(String bucket) {
        if (StringUtils.isNullOrEmpty(bucket)) {
            throw new IllegalArgumentException("桶名称不能为空!");
        }
        try {
            amazonS3.createBucket(bucket);
        } catch (SdkClientException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 删除桶
     *
     * @return boolean
     * @params * @param bucket
     * @author susj
     * @date 2022/12/12 16:39
     */
    public static boolean deleteBucket(String bucket) {
        if (StringUtils.isNullOrEmpty(bucket)) {
            throw new IllegalArgumentException("桶名称不能为空!");
        }
        try {
            amazonS3.deleteBucket(bucket);
        } catch (SdkClientException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 上传文件
     *
     * @param bucket 桶名称
     * @return boolean
     * @params * @param file
     * @author susj
     * @date 2022/12/12 16:33
     */
    public static boolean upload(MultipartFile file, String bucket) {
        if (Objects.isNull(file)) {
            throw new IllegalArgumentException("文件不能为空!");
        }
        String fileName = file.getOriginalFilename();
        ObjectMetadata objectMetadata = new ObjectMetadata();
        objectMetadata.setContentType(file.getContentType());
        objectMetadata.setContentLength(file.getSize());
        bucket = StringUtils.isNullOrEmpty(bucket) ? awzS3Config.getBucket() : bucket;
        try {
            PutObjectRequest request = new PutObjectRequest(bucket, fileName, file.getInputStream(), objectMetadata)
                    // 设置文件访问权限
                    .withCannedAcl(CannedAccessControlList.BucketOwnerFullControl);
            PutObjectResult result = amazonS3.putObject(request);
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }


    /**
     * 通过文件名称下载
     *
     * @param fileName
     * @return org.springframework.http.ResponseEntity<byte [ ]>
     * @params * @param bucket
     * @author susj
     * @date 2022/12/12 16:56
     */
    public static ResponseEntity<byte[]>    downloadByName(String bucket, String fileName) throws IOException {
        if (StringUtils.isNullOrEmpty(bucket)) {
            throw new IllegalArgumentException("文件名称不能为空!");
        }
        bucket = StringUtils.isNullOrEmpty(bucket) ? awzS3Config.getBucket() : bucket;
        GetObjectRequest getObjectRequest = new GetObjectRequest(bucket, fileName);
        S3Object s3Object = amazonS3.getObject(getObjectRequest);
        S3ObjectInputStream objectInputStream = s3Object.getObjectContent();
        byte[] bytes = IOUtils.toByteArray(objectInputStream);
        // 替换中文
        String showFileName = URLEncoder.encode(fileName, "UTF-8").replaceAll("\\+", "%20");
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        httpHeaders.setContentLength(bytes.length);
        httpHeaders.setContentDispositionFormData("attachment", showFileName);
        return new ResponseEntity<>(bytes, httpHeaders, HttpStatus.OK);
    }


    /**
     * 删除单个文件
     *
     * @param fileName
     * @return boolean
     * @params * @param bucket
     * @author susj
     * @date 2022/12/12 17:04
     */
    public static boolean deleteFile(String bucket, String fileName) {
        if (StringUtils.isNullOrEmpty(fileName)) {
            throw new IllegalArgumentException("文件名称不能为空!");
        }
        bucket = StringUtils.isNullOrEmpty(bucket) ? awzS3Config.getBucket() : bucket;
        try {
            amazonS3.deleteObject(bucket, fileName);
        } catch (SdkClientException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 获取文件信息
     *
     * @param fileName
     * @return com.amazonaws.services.s3.model.ObjectMetadata
     * @params * @param bucket
     * @author susj
     * @date 2022/12/12 17:08
     */
    public static ObjectMetadata getFileInfo(String bucket, String fileName) {
        if (StringUtils.isNullOrEmpty(fileName)) {
            throw new IllegalArgumentException("文件名称不能为空!");
        }
        bucket = StringUtils.isNullOrEmpty(bucket) ? awzS3Config.getBucket() : bucket;
        ObjectMetadata objectMetadata = null;
        try {
            objectMetadata = amazonS3.getObjectMetadata(bucket, fileName);
        } catch (SdkClientException e) {
            e.printStackTrace();
        }
        return objectMetadata;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

3 、测试类

@RestController
@RequestMapping("awz/s3")
public class S3Controller {


    @PostMapping(value = "/uploadObject")
    public ResponseEntity uploadObject(MultipartFile file, String bucket) {
        try {
            AwzS3Util.upload(file, bucket);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new ResponseEntity("上传成功!", HttpStatus.OK);
    }

    @PostMapping(value = "/downloadObject")
    public ResponseEntity downloadObject(String bucket, String fileName) {
        ResponseEntity<byte[]> download = null;
        try {
            download = AwzS3Util.downloadByName(bucket, fileName);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return download;
    }

    @PostMapping(value = "/getFileInfo")
    public ObjectMetadata getFileInfo(String bucket, String fileName) {
        return AwzS3Util.getFileInfo(bucket, fileName);
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4、测试

1、上传测试

上传成功在管理页面也看到了文件

2、下载测试

下载成功

7、仓库地址

https://gitee.com/xyzissj/minio.git

6、总结

这里只是简单封装一下，具体实际使用需要根据实际需求处理

这边网上有一个个人的开源项目：X Spring File Storage
由于是个人的开源项目，所以是否使用请自己甄别，如有任何问题与本人无关。