Pu Zhibing
1 天以前 a3698ecb84be4192754d7b2092491e727dbccec7
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
package com.stylefeng.guns.modular.system.util.qianyuntong;
 
import com.heredata.hos.HOS;
import com.heredata.hos.HOSClientBuilder;
import com.heredata.hos.model.CreateBucketRequest;
import com.heredata.hos.model.HOSObject;
import com.heredata.hos.model.PutObjectRequest;
import com.heredata.hos.model.PutObjectResult;
import com.heredata.hos.model.bucket.Bucket;
import com.heredata.model.VoidResult;
import lombok.extern.slf4j.Slf4j;
 
import java.io.InputStream;
 
/**
 * OSS 工具类
 * @author zhibing.pu
 * @Date 2025/6/23 17:50
 */
@Slf4j
public class NCOSSUtil {
 
    /**
     * 创建桶
     * @param bucketName
     * @return
     */
    public static Boolean createBucket(String bucketName) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            // 创建请求对象,并且设置创建桶名为"example"的桶
            CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName);
            VoidResult result = hos.createBucket(createBucketRequest);
            if (result.getResponse().isSuccessful()) {
                log.info("创建桶成功:" + bucketName);
                return true;
            }
        } catch (Exception e){
            log.info("创建桶失败:" + bucketName);
            e.printStackTrace();
        }
        return false;
    }
 
 
    /**
     * 查询桶详情
     * @param bucketName
     * @return
     */
    public static Bucket getBucketInfo(String bucketName) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            // 查询桶名为"example"的详情
            Bucket bucket = hos.getBucketInfo(bucketName);
            return bucket;
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
 
 
    /**
     * 删除桶
     * @param bucketName
     * @return
     */
    public static Boolean deleteBucket(String bucketName) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            VoidResult result = hos.deleteBucket(bucketName);
            if (result.getResponse().isSuccessful()) {
                log.info("删除桶成功:" + bucketName);
                return true;
            }
        } catch (Exception e){
            log.info("删除桶成功:" + bucketName);
            e.printStackTrace();
        }
        return false;
    }
 
 
    /**
     * 设置桶策略
     * @param bucketName    桶名
     * @param policyText    策略规则字符串
     * {
     *   // 策略配置的版本号,由用户定义
     *   "Version": "2012-10-17",
     *   //  策略规则配置,可指定多条策略规则
     *   "Statement": [{
     *     // 策略规则ID,可用户指定,如不指定则服务自动生成一条
     *     "Sid": "sid",
     *     // 策略规则指定的HOS API接口标识,可参照下表填写
     *     "Action": [
     *       "action"
     *     ],
     *     // 策略规则效果,具体表现为允许或拒绝,有效值为Allow(允许),Deny(拒绝);
     *     "Effect": "Allow",
     *     // 策略规则指定的资源参照下面resource配置
     *     "Resource": "resource",
     *     // 策略规则指定的授权人 参照下面Principal配置
     *     "Principal": {
     *       "HWS": [
     *         "account_id:root"
     *       ]
     *     }
     *   }
     *   ]
     * }
     * @return
     */
    public static Boolean setBucketPolicy(String bucketName, String policyText) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        // 桶策略字符串
        try {
            VoidResult result = hos.setBucketPolicy(bucketName, policyText);
            if (result.getResponse().isSuccessful()) {
                log.info("设置桶策略成功:" + bucketName);
                return true;
            }
        } catch (Exception e) {
            log.info("设置桶策略失败:" + bucketName);
            e.printStackTrace();
        }
        return false;
    }
 
 
    /**
     * 上传对象
     * @param bucketName    桶名称
     * @param key           存储文件名
     * @param inputStream      上传文件流
     * @return  对象唯一标识
     */
    public static String putObject(String bucketName, String key, InputStream inputStream) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key , inputStream);
            PutObjectResult example = hos.putObject(putObjectRequest);
            if (example.getResponse().isSuccessful()) {
                log.info("上传对象成功:" + bucketName + "--->" + key);
                return example.getETag();
            }
        } catch (Exception e) {
            log.info("上传对象成功:" + bucketName);
            e.printStackTrace();
        }
        return null;
    }
 
 
    /**
     * 查询对象
     * @param bucketName    桶名称
     * @param key           存储文件名
     * @return
     */
    public static HOSObject getObject(String bucketName, String key) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            HOSObject example = hos.getObject(bucketName, key);
            if (example.getResponse().isSuccessful()) {
                log.info("查询对象成功:" + bucketName + "--->" + key);
                return example;
            }
        } catch (Exception e) {
            log.info("查询对象失败:" + bucketName);
            e.printStackTrace();
        }
        return null;
    }
 
 
    /**
     * 删除对象
     * @param bucketName     桶名称
     * @param key          存储文件名
     * @return
     */
    public static Boolean deleteObject(String bucketName, String key) {
        /**
         * endPoint:HOS的基础路径(公共前缀)
         * account:账户的ID
         * accessKey:向UAAS服务请求到的access_key
         * secretKey:向UAAS服务请求到的secret_key
         */
        HOS hos = new HOSClientBuilder().build(QianYunTongProperties.endPoint, QianYunTongProperties.account, QianYunTongProperties.accessKey, QianYunTongProperties.secretKey);
        try {
            VoidResult example = hos.deleteObject(bucketName, key);
            if (example.getResponse().isSuccessful()) {
                log.info("删除对象成功:" + bucketName + "--->" + key);
                return true;
            }
        } catch (Exception e) {
            log.info("删除对象失败:" + bucketName + "--->" + key);
            e.printStackTrace();
        }
        return false;
    }
}