Java集成七牛云

Love The Way You Lie 2023-01-01 05:57 248阅读 0赞

本博客代码下载地下：https://github.com/hcitlife/QiNiuDemo

准备工作

注册之后登录，然后按如下步骤操作：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  1. 接下来到开发者中心--SDK下载--Java SDK，参考里面的文档编写代码就可以了。

服务器端代码示例

第一步：创建SpringBoot项目，添加依赖：

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.projectlombok</groupId>
  7.     <artifactId>lombok</artifactId>
  8.     <optional>true</optional>
  9. </dependency>
  10. <dependency>
  11.     <groupId>org.springframework.boot</groupId>
  12.     <artifactId>spring-boot-starter-test</artifactId>
  13.     <scope>test</scope>
  14. </dependency>
  15. <dependency>
  16.     <groupId>com.qiniu</groupId>
  17.     <artifactId>qiniu-java-sdk</artifactId>
  18.     <version>7.4.0</version>
  19. </dependency>
  20. <dependency>
  21.     <groupId>com.qiniu</groupId>
  22.     <artifactId>happy-dns-java</artifactId>
  23.     <version>0.1.6</version>
  24. </dependency>
  25. <dependency>
  26.     <groupId>com.squareup.okhttp3</groupId>
  27.     <artifactId>okhttp</artifactId>
  28.     <version>3.14.8</version>
  29.     <scope>compile</scope>
  30. </dependency>
  31. <dependency>
  32.     <groupId>com.google.code.gson</groupId>
  33.     <artifactId>gson</artifactId>
  34.     <version>2.8.6</version>
  35.     <scope>compile</scope>
  36. </dependency>

第二步：在resources目录创建七牛属性配置文件qiniu.properties：

  1. qiniu.access-key=AW8tBsAy-uXXdYCO6E0ZDWMYJhY5HOEBboD_MtcH
  2. qiniu.secret-key=kezs7Q_FlHIvwxx6nnslmhoVlh8kqStSarpISjmF
  3. qiniu.bucket=hcstore
  4. # [{ 'region0':'华东'}, { 'region1':'华北'},{ 'region2':'华南'},{ 'regionNa0':'北美'},{ 'regionAs0':''}]
  5. qiniu.region=region2
  6. qiniu.domain-of-bucket=http://qm6ralq5f.hn-bkt.clouddn.com/
  7. # 链接过期时间，单位是秒，3600代表1小时，-1代表永不过期
  8. qiniu.expire-in-seconds=-1

第三步：创建七牛配置文件QiNiuConfig.java：

  1. @Data
  2. public class QiNiuConfig { 
  3.     private String accessKey;
  4.     private String secretKey;
  5.     private String bucket;
  6.     private Region region;
  7.     private String domainOfBucket;
  8.     private long expireInSeconds;
  10.     private QiNiuConfig(){  //单例设计模式
  11.         Properties prop = new Properties();
  12.         try { 
  13.  prop.load(QiNiuConfig.class.getResourceAsStream("/qiniu.properties"));
  14.             accessKey = prop.getProperty("qiniu.access-key");
  15.             secretKey = prop.getProperty("qiniu.secret-key");
  16.             bucket = prop.getProperty("qiniu.bucket");
  17.             domainOfBucket = prop.getProperty("qiniu.domain-of-bucket");
  18.             expireInSeconds = Long.parseLong(prop.getProperty("qiniu.expire-in-seconds"));
  19.             String zoneName = prop.getProperty("qiniu.region");
  20.             if(zoneName.equals("region0")){ 
  21.                 region = Region.region0();
  22.             }else if(zoneName.equals("region1")){ 
  23.                 region = Region.region1();
  24.             }else if(zoneName.equals("region2")){ 
  25.                 region = Region.region2();
  26.             }else if(zoneName.equals("regionAs0")){ 
  27.                 region = Region.regionAs0();
  28.             }else if(zoneName.equals("regionNa0")){ 
  29.                 region = Region.regionNa0();
  30.             }else{ 
  31.                 throw new Exception("Region对象配置错误！");
  32.             }
  33.         } catch (Exception e) { 
  34.             e.printStackTrace();
  35.         }
  36.     }
  37.     private static QiNiuConfig instance = new QiNiuConfig();
  38.     public static QiNiuConfig getInstance() { 
  39.         return instance;
  40.     }
  41. }

第三步：编写七牛工具类：

  1. public class QiNiuUtil { 
  2.     private static final String secretKey = QiNiuConfig.getInstance().getSecretKey();
  3.     private static final String bucket = QiNiuConfig.getInstance().getBucket();
  4.     private static final Region region = QiNiuConfig.getInstance().getRegion();
  5.     private static String accessKey = QiNiuConfig.getInstance().getAccessKey();
  6.     /** * 上传本地文件 * * @param localFilePath 本地文件完整路径 * @param key 文件云端存储的名称，值为null时生成随机的文件名，同名文件会发生覆盖 * @return */
  7.     public static String upload(String localFilePath, String key) { 
  8.         UploadManager uploadManager = getUploadManager();
  9.         //...生成上传凭证，然后准备上传
  10.         Auth auth = Auth.create(accessKey, secretKey);
  11.         String upToken;
  12.         if (key != null) { 
  13.             upToken = auth.uploadToken(bucket, key);//覆盖上传凭证
  14.         } else { 
  15.             upToken = auth.uploadToken(bucket);
  16.         }
  17.         try { 
  18.             Response response = uploadManager.put(localFilePath, key, upToken);
  19.             //解析上传成功的结果
  20.             DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
  21.             return putRet.key;
  22.         } catch (QiniuException ex) { 
  23.             ex.printStackTrace();
  24.             return null;
  25.         }
  26.     }
  27.     /** * 上传MultipartFile * * @param file * @param key 文件云端存储的名称，值为null时生成随机的文件名，同名文件会发生覆盖 * @return * @throws IOException */
  28.     public static String uploadMultipartFile(MultipartFile file,String key) { 
  29.         UploadManager uploadManager = getUploadManager();
  30.         //把文件转化为字节数组
  31.         InputStream is = null;
  32.         ByteArrayOutputStream bos = null;
  34.         try { 
  35.             is = file.getInputStream();
  36.             bos = new ByteArrayOutputStream();
  37.             byte[] b = new byte[1024];
  38.             int len = -1;
  39.             while ((len = is.read(b)) != -1) { 
  40.                 bos.write(b, 0, len);
  41.             }
  42.             byte[] uploadBytes = bos.toByteArray();
  44.             Auth auth = getAuth();
  45.             String upToken;
  46.             if (key != null) { 
  47.                 upToken = auth.uploadToken(bucket, key);//覆盖上传凭证
  48.             } else { 
  49.                 upToken = auth.uploadToken(bucket);
  50.             }
  51.             //默认上传接口回复对象
  52.             DefaultPutRet putRet;
  53.             //进行上传操作，传入文件的字节数组，文件名，上传空间，得到回复对象
  54.             Response response = uploadManager.put(uploadBytes, key, upToken);
  55.             putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
  56.             return putRet.key;
  57.         } catch (QiniuException e) { 
  58.             e.printStackTrace();
  59.             return null;
  60.         } catch (IOException e) { 
  61.             e.printStackTrace();
  62.             return null;
  63.         }
  64.     }
  65.     /** * 获取所有的bucket */
  66.     public static String[] getBucketsInfo() { 
  67.         try { 
  68.             BucketManager bucketManager = getBucketManager();
  69.             //获取所有的bucket信息
  70.             String[] buckets = bucketManager.buckets();
  71.             return buckets;
  72.         } catch (Exception e) { 
  73.             e.printStackTrace();
  74.         }
  75.         return null;
  76.     }
  77.     /** * 获取文件访问地址 * * @param fileName 文件云端存储的名称 * @return * @throws UnsupportedEncodingException */
  78.     public static String fileUrl(String fileName) throws UnsupportedEncodingException { 
  79.         String encodedFileName = URLEncoder.encode(fileName, "utf-8");
  80.         String publicUrl = String.format("%s/%s", bucket, encodedFileName);
  81.         Auth auth = getAuth();
  82.         long expireInSeconds = QiNiuConfig.getInstance().getExpireInSeconds();
  83.         if (-1 == expireInSeconds) { 
  84.             return auth.privateDownloadUrl(publicUrl);
  85.         }
  86.         return auth.privateDownloadUrl(publicUrl, expireInSeconds);
  87.     }
  89.     /** * 获取bucket里面所有文件的信息 */
  90.     public static FileInfo[] getFileInfo() { 
  91.         try { 
  92.             BucketManager bucketManager = getBucketManager();
  93.             //文件名前缀
  94.             String prefix = "";
  95.             //每次迭代的长度限制，最大1000，推荐值 1000
  96.             int limit = 1000;
  97.             //指定目录分隔符，列出所有公共前缀（模拟列出目录效果）。缺省值为空字符串
  98.             String delimiter = "";
  100.             //列举空间文件列表
  101.             BucketManager.FileListIterator fileListIterator = bucketManager.createFileListIterator(bucket, prefix, limit, delimiter);
  102.             while (fileListIterator.hasNext()) { 
  103.                 //处理获取的file list结果
  104.                 FileInfo[] items = fileListIterator.next();
  105.                 return items;
  106.             }
  107.         } catch (Exception e) { 
  108.             e.printStackTrace();
  109.         }
  110.         return null;
  111.     }
  113.     /** * 删除多个文件 * * @param keys 文件名称数组 * @return */
  114.     public static Map<String, String> deletes(String... keys) { 
  115.         Map<String, String> map = new HashMap<>();
  116.         try { 
  117.             //设定删除的数据
  118.             BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
  119.             batchOperations.addDeleteOp(bucket, keys);
  120.             BucketManager bucketManager = getBucketManager();
  121.             //发送请求
  122.             Response response = bucketManager.batch(batchOperations);
  124.             //返回数据
  125.             BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
  126.             for (int i = 0; i < keys.length; i++) { 
  127.                 BatchStatus status = batchStatusList[i];
  128.                 String key = keys[i];
  129.                 if (status.code == 200) { 
  130.                     map.put(key, "delete success");
  131.                 } else { 
  132.                     map.put(key, "delete failed");
  133.                 }
  134.             }
  135.         } catch (Exception e) { 
  136.         }
  137.         return map;
  138.     }
  140.     /** * 删除bucket中的文件名称 * * @param key 文件名称 * @return */
  141.     public static boolean delete(String key) { 
  142.         try { 
  143.             BucketManager mg = getBucketManager();
  144.             mg.delete(bucket, key);
  145.             return true;
  146.         } catch (Exception e) { 
  147.             return false;
  148.         }
  149.     }
  151.     public static Auth getAuth() { 
  152.         Auth auth = Auth.create(accessKey, secretKey);
  153.         return auth;
  154.     }
  156.     /** * 获取上传管理器 * * @return */
  157.     public static UploadManager getUploadManager() { 
  158.         //构造一个带指定Zone对象的配置类
  159.         Configuration cfg = new Configuration(region);
  160.         //...其他参数参考类注释
  161.         UploadManager uploadManager = new UploadManager(cfg);
  162.         return uploadManager;
  163.     }
  165.     /** * 获取Bucket的管理对象 * * @return */
  166.     public static BucketManager getBucketManager() { 
  167.         Configuration cfg = new Configuration(region);
  168.         Auth auth = Auth.create(accessKey, secretKey);
  169.         BucketManager bucketManager = new BucketManager(auth, cfg);
  170.         return bucketManager;
  171.     }
  173. }

工具类测试代码：

  1. @SpringBootTest
  2. class QiNiuUtilTest { 
  4.     @Test
  5.     void upload1() { 
  6.         String res = QiNiuUtil.upload("E:\\我的文档\\重要文档\\照片\\DSC_0645.jpg", "aaaa");
  7.         System.out.println(res);
  8.     }
  10.     @Test
  11.     void upload2() { 
  12.         String res = QiNiuUtil.upload("E:\\我的文档\\重要文档\\照片\\DSC_0645.jpg", null);
  13.         System.out.println(res);
  14.     }
  17.     @Test
  18.     void fileUrl() throws UnsupportedEncodingException { 
  19.         String url = QiNiuUtil.fileUrl("asdf");
  20.         System.out.println(url);
  21.     }
  23.     @Test
  24.     void uploadMultipartFile() { 
  26.     }
  28.     @Test
  29.     void getAuth() { 
  30.         Auth auth = QiNiuUtil.getAuth();
  31.         System.out.println(auth);
  32.     }
  34.     @Test
  35.     void getUploadManager() { 
  36.         BucketManager bucketManager = QiNiuUtil.getBucketManager();
  37.         System.out.println(bucketManager);
  38.     }
  40.     @Test
  41.     void getFileInfo() { 
  42.         FileInfo[] infos = QiNiuUtil.getFileInfo();
  43.         for (FileInfo item : infos) { 
  44.             System.out.println(item.key);
  45.             System.out.println(item.hash);
  46.             System.out.println(item.fsize);
  47.             System.out.println(item.mimeType);
  48.             System.out.println(item.putTime);
  49.             System.out.println(item.endUser);
  50.             System.out.println();
  51.         }
  52.     }
  54.     @Test
  55.     void getBucketsInfo() { 
  56.         String[] buckets = QiNiuUtil.getBucketsInfo();
  57.         for (String bucket : buckets) { 
  58.             System.out.println(bucket);
  59.         }
  60.     }
  62.     @Test
  63.     void deletes() { 
  64.         Map<String, String> map = QiNiuUtil.deletes("bbbb", "asdf");
  65.         map.forEach((k, v) -> System.out.println(k + "\t" + v));
  66.     }
  68.     @Test
  69.     void delete() { 
  70.         boolean res = QiNiuUtil.delete("FvSQe8DCKNTZcoc-pqmmRRVfn3ba");
  71.         System.out.println(res);
  72.     }
  73. }

第四步：创建Controller：

  1. @RestController
  2. @RequestMapping("/fileController")
  3. public class FileController { 
  4.     @PostMapping("/upload")
  5.     public String upload(@RequestParam("file") MultipartFile multipartFile) { 
  6.         String res = QiNiuUtil.uploadMultipartFile(multipartFile, null);
  7.         return res;
  8.     }
  9. }

第五步：启动项目，采用Postman进行测试：

在这里插入图片描述
结果：
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，248人围观）

还没有评论，来说两句吧...

相关阅读

    相关 七牛云面试

    Vue中的懒加载 方式一： Vue工厂函数异步解析组件，Vue 只有在这个组件需要被渲染的时候才会触发该工厂函数，且会把结果缓存起来供将来重新渲染使用。 V

    电玩女神电玩女神/ 0 赞/ 82 阅读

    相关 七牛云工具类

    七牛云是国内领先的企业级公有云服务商，致力于打造以数据为核心的场景化PaaS服务 以下工具类采用了两种方式进行文件上传（图片）以及根据文件名称删除文件 impor

    快来打我*快来打我*/ 0 赞/ 242 阅读

    相关 Java--七牛云存储图片示例

    项目中会用到大量的图片和小视频，为了分担服务器压力，将文件都放在七牛云。这里的思路很简单，就是移动端、pc端把文件上传到服务器，服务器做一个临时缓存，保存必要的信息到数据库后，

    不念不忘少年蓝@不念不忘少年蓝@/ 0 赞/ 339 阅读

    相关 Java 实现七牛云回调

    有这样一个需求：android将文件上传到七牛云，并将文件在七牛云存储的信息返回业务服务器处理。七牛云的sdk上有一个模型解决这种需求，这是原理图： ![这里写图片描述][S

    女爷i女爷i/ 0 赞/ 302 阅读