精华内容
下载资源
问答
  • oss云存储

    2020-12-08 18:56:13
    oss使用阿里服务器申请java常见调用oss方法 阿里服务器申请 注册一个阿里账号,注册后在控制台申请一个oss对象存储bucket,这个可以在阿里提供的界面创建,我的已经是创建好的,看下图 ,也可以在代码中创建 ...

    阿里云服务器申请

    居然收费了,日····
    注册一个阿里账号,注册后在控制台申请一个oss对象存储bucket,这个可以在阿里提供的界面创建,我的已经是创建好的,看下图
    在这里插入图片描述
    ,也可以在代码中创建
    在这里插入图片描述
    这个链接厂家的参数,见图
    在这里插入图片描述
    我打了码的位置是keyid和私匙,也可以说是登录的用户名相关的信息,在你创建一个Bucket 的时候就在右侧提示你创建一个,我这里已经有了就不会提示了,当把Bucket 删除的时候,你在创建Bucket 位置旁就有的,这个keyid和密匙也是创建的,你也可以修改和删除,手机短信验证,不会就操作几遍

    说明:
    这个是个对象存储服务器,不是免费的,不过我目前用的还没收取费用,阿里提供的文件管理界面看似和文件夹一样的结构,但是实际是个对象存储的方式,就是key-value,所以上次的而压缩包不支持解压的

    java常见调用oss方法

    使用前的基本配置
    我采用的是springcloud来做的,说简单点就是springboot,配置信息就是上面的yml截图内容,配置文件类

    package com.jysp.file.config;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
     * @version 0.0.1
     * @program: fuse-system
     * @description: oss属性读取
     * @author: huangzq
     * @create: 2020-12-07 09:15
     */
    @Data
    @Component
    @ConfigurationProperties(prefix = "oos")
    public class ConstantProperties {
    
        /**
         * 地域节点
         */
        private String endpoint;
    
        /**
         * accessKeyId
         */
        private String keyId;
    
        /**
         * accessKeySecret
         */
        private String keySecret;
    
        /**
         * bucket名称
         */
        private String bucketName;
    
        /**
         * bucket域名
         */
        private String fileHost;
    
        /**
         * xml文件临时存放目录
         */
        private String temporary;
    }
    
    

    上传包含裁剪
    生成两份文件,一个是原文件一个是裁剪文件,其中两个压缩方法,生成oss存放位置我可以指定,文件名可以指定,多层文件夹阿里api帮我创建

      /**
         * oss单张文件上传
         *
         * @param file            前台传的文件
         * @param fileUrl         oss文件存放路劲
         * @param endpoint
         * @param accessKeyId
         * @param accessKeySecret
         * @param bucketName
         * @param fileHost
         * @param thumUrl         oss缩略图存放路径
         * @return
         */
        public static Map<String, Object> uploadPicOss(MultipartFile file, String fileUrl,
                                                       String endpoint, String accessKeyId,
                                                       String accessKeySecret, String bucketName,
                                                       String fileHost, String thumUrl) {
            Map<String, Object> resultMap = new HashMap<>(6);
            String fileName = file.getOriginalFilename();
            //缩略图使用
            resultMap.put("oldImgName", fileName);
            String suffix = fileName.substring(fileName.lastIndexOf("."));
            resultMap.put("imgType", suffix);
            String fileUrl1 = fileUrl;
            resultMap.put("newImgName", fileUrl1.substring(fileUrl1.lastIndexOf("/")));
    //        resultMap.put("imgUrl", "http://" + fileHost + "/" + fileUrl);
            resultMap.put("imgUrl", fileUrl);
            BufferedImage bufferedImage = null;
            try {
                bufferedImage = ImageIO.read(file.getInputStream());
            } catch (IOException e) {
                log.error("图片文件读取宽高失败:", e);
            }
            resultMap.put("imgWidth", bufferedImage.getWidth());
            resultMap.put("imgHeight", bufferedImage.getHeight());
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            try {
                //容器不存在,就创建
                if (!ossClient.doesBucketExist(bucketName)) {
                    ossClient.createBucket(bucketName);
                    CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName);
                    ossClient.createBucket(createBucketRequest);
                }
                //设置权限 这里是公开读
                ossClient.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
                if (!"".equals(fileName.trim())) {
                    File newFile = new File(fileName);
                    FileOutputStream os = new FileOutputStream(newFile);
                    os.write(file.getBytes());
                    os.close();
                    file.transferTo(newFile);
                    PutObjectResult result = ossClient.putObject(bucketName, fileUrl, newFile);
                    //设置返回的url有效期为10年
    //                Date expiration = new Date(System.currentTimeMillis() + 10 * 365 * 24 * 60 * 60 * 1000);
    //                GeneratePresignedUrlRequest req = new GeneratePresignedUrlRequest(bucketName, fileUrl, HttpMethod.GET);
    //                req.setExpiration(expiration);
    //                //回显url
    //                URL url = ossClient.generatePresignedUrl(req);
    //                System.err.println("req获取的url上传的文件回显:" + url.toString());
                    log.info("地址栏直接访问该文件路径:" + resultMap.get("imgUrl"));
                    //缩略图生成
    //                toImg(ossClient,resultMap.get("imgUrl").toString(),bucketName, "2/2020-12-09/thum/jieguotup.jpg");
                    //thum  "2/2020-12-09/thum/jieguotup.jpg"
                    Thum(ossClient, "http://" + fileHost + "/" + resultMap.get("imgUrl").toString(), bucketName, thumUrl);
                    if (result != null) {
                        return resultMap;
                    }
                }
            } catch (OSSException oe) {
                log.error(oe.getMessage());
                log.info("keyId或secret无效");
            } catch (ClientException ce) {
                log.error(ce.getMessage());
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //关闭
                ossClient.shutdown();
            }
            return null;
        }
    
        /**
         * AffineTransform方式缩略图
         *
         * @param sourceUrl  原图的网络访问路径
         * @param bucketName
         * @param thumUrl    上传路径
         * @return
         */
        public static void toImg(OSS ossClient, String sourceUrl, String bucketName, String thumUrl) {
            try {
                //缩放比例
                int nw = 280;
                /*
                 * AffineTransform 类表示 2D 仿射变换,它执行从 2D 坐标到其他 2D 坐标的线性映射,保留了线的“直线性”和“平行性”。可以使用一系
                 * 列平移、缩放、翻转、旋转和剪切来构造仿射变换。
                 */
                URL url = new URL(sourceUrl);
                // 打开链接
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                // 设置请求方式为"GET"
                conn.setRequestMethod("GET");
                // 超时响应时间为5秒
                conn.setConnectTimeout(5 * 1000);
                // 通过输入流获取图片数据
                InputStream inStream = conn.getInputStream();
                AffineTransform transform = new AffineTransform();
                // 读取图片
                BufferedImage bis = ImageIO.read(inStream);
                int w = bis.getWidth();
                int h = bis.getHeight();
                // double scale = (double)w/h;
                int nh = (nw * h) / w;
                double sx = (double) nw / w;
                double sy = (double) nh / h;
                // setToScale(double sx, double sy) 将此变换设置为缩放变换。
                transform.setToScale(sx, sy);
                System.out.println(w + " " + h);
                /*
                 * AffineTransformOp类使用仿射转换来执行从源图像或 Raster 中 2D 坐标到目标图像或 Raster 中 2D
                 * 坐标的线性映射。所使用的插值类型由构造方法通过 一个 RenderingHints 对象或通过此类中定义的整数插值类型之一来指定。 如果在构造方法中指定了
                 * RenderingHints 对象,则使用插值提示和呈现 的质量提示为此操作设置插值类型。要求进行颜色转换时,可以使用颜色 呈现提示和抖动提示。
                 * 注意,务必要满足以下约束:源图像与目标图像 必须不同。 对于 Raster 对象,源图像中的 band 数必须等于目标图像中 的 band 数。
                 */
                AffineTransformOp ato = new AffineTransformOp(transform, null);
                BufferedImage bid = new BufferedImage(nw, nh, BufferedImage.TYPE_3BYTE_BGR);
                /*
                 * TYPE_3BYTE_BGR 表示一个具有 8 位 RGB 颜色分量的图像, 对应于 Windows 风格的 BGR 颜色模型,具有用 3 字节存 储的
                 * Blue、Green 和 Red 三种颜色。
                 */
                ato.filter(bis, bid);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ImageIO.write(bid, "jpeg", bos);
                InputStream input2 = new ByteArrayInputStream(bos.toByteArray());
                ossClient.putObject(bucketName, thumUrl, input2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * Thumbnails方式压缩图片
         *
         * @param ossClient
         * @param sourceUrl
         * @param bucketName
         * @param thumUrl
         */
        public static void Thum(OSS ossClient, String sourceUrl, String bucketName, String thumUrl) {
            try {
                URL url = new URL(sourceUrl);
                //网络方式或流方式都可以
                //Thumbnails 允许通过传入文件名、文件、网络图的URL、图片流、图片缓存多种方式来初始化构造器
                Thumbnails.Builder<URL> builder = Thumbnails.of(url);
                //在调整尺寸时保持比例
                //默认为true,如果要剪裁到特定的比例,设为false即可
    //            builder.keepAspectRatio(true);
                //根据宽度和高度进行缩放
                //如果设置了keepAspectRatio(true),将按比例进行缩放,否则将强制按尺寸输出
                //缩放策略:
                //如果宽度缩放比>高度缩放比就以宽度来缩放,反之以高度缩放
                builder.size(170, 160);
                //写入内存中
                BufferedImage bufferedImage = builder.asBufferedImage();
                InputStream inputStream = bufferedImageToInputStream(bufferedImage);
                if (inputStream == null) {
                    throw new JyspException(ExceptionEnum.FILE_HANDLE_ERROR);
                }
                ossClient.putObject(bucketName, thumUrl, inputStream);
            } catch (IOException e) {
                log.error("文件处理异常:", e);
                throw new JyspException(ExceptionEnum.FILE_HANDLE_ERROR);
            }
    
        }
    
        /**
         * 将BufferedImage转换为InputStream
         *
         * @param image
         * @return
         */
        public static InputStream bufferedImageToInputStream(BufferedImage image) {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            try {
                ImageIO.write(image, "jpg", os);
                InputStream input = new ByteArrayInputStream(os.toByteArray());
                return input;
            } catch (IOException e) {
                log.error("提示:", e);
            }
            return null;
        }
    
    

    简单的文件上传方法

     /**
         * oss文件上传xml文件
         *
         * @param file
         * @param temporary  xml临时存放文件夹路径
         * @param endpoint
         * @param accessKeyId
         * @param accessKeySecret
         * @param bucketName
         * @param fileHost
         * @return
         */
        public static Map<String, Object> uploadXmlOss(MultipartFile file, String temporary, String endpoint, String accessKeyId, String accessKeySecret, String bucketName, String fileHost) {
            Map<String, Object> resultMap = new HashMap<>();
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            try {
                //设置权限 这里是公开读
                ossClient.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
                String originalFilename = file.getOriginalFilename();
                if (!"".equals(originalFilename.trim())) {
                    resultMap.put("xmlType", FilenameUtils.getExtension(originalFilename).toLowerCase());
                    File newFile = new File(originalFilename);
                    FileOutputStream os = new FileOutputStream(newFile);
                    os.write(file.getBytes());
                    os.close();
                    file.transferTo(newFile);
                    PutObjectResult result = ossClient.putObject(bucketName, temporary, newFile);
                    log.info("地址栏直接访问该xml文件路径:" + fileHost + "/" + temporary);
                    if (result != null) {
                        return resultMap;
                    }
                }
            } catch (OSSException oe) {
                log.error(oe.getMessage());
                log.info("keyId或secret无效");
            } catch (ClientException ce) {
                log.error(ce.getMessage());
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //关闭
                ossClient.shutdown();
            }
            return null;
        }
    

    下载压缩包(文件形式到客户端 a标签)
    ···这里提供压缩包下载到客户端,简单的下载看下官方文档就可以了

      /**
         * 不建临时目录,上传流
         * https://blog.csdn.net/qq_31594647/article/details/93121229
         *
         * @param request
         * @param response
         * @return
         */
        @GetMapping("/api/downlownd")
        public void getOssFile(HttpServletRequest request, HttpServletResponse response) {
            // endpoint以杭州为例,其它region请按实际情况填写,1改为自己的
            String endpoint = constantProperties.getEndpoint();
            // 云账号AccessKey有所有API访问权限,建议遵循阿里云安全最佳实践,创建并使用RAM子账号进行API访问或日常运维,请登录 https://ram.console.aliyun.com 创建
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
            String bucketName = constantProperties.getBucketName();
            //要下载的文件名(Object Name)字符串,中间用‘,’间隔。文件名从bucket目录开始.5改为自己的
            // String key = "wxmall/ssy/imgUrl/612353.jpg,wxmall/ssy/imgUrl/612354.jpg";
            List<String> objectList = aliyunOSSUtil.getObjectList(bucketName);
            try {
                // 创建OSSClient实例。
                OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
                //6改为自己的名称
                String fileName = "压缩包.zip";
                // 创建临时文件
                File zipFile = File.createTempFile("压缩包", ".zip");
                FileOutputStream f = new FileOutputStream(zipFile);
                /**
                 * 作用是为任何OutputStream产生校验和
                 * 第一个参数是制定产生校验和的输出流,第二个参数是指定Checksum的类型 (Adler32(较快)和CRC32两种)
                 */
                CheckedOutputStream csum = new CheckedOutputStream(f, new Adler32());
                // 用于将数据压缩成Zip文件格式
                ZipOutputStream zos = new ZipOutputStream(csum);
    
                for (String ossfile : objectList) {
                    // 获取Object,返回结果为OSSObject对象
                    OSSObject ossObject = ossClient.getObject(bucketName, ossfile);
                    // 读去Object内容  返回
                    InputStream inputStream = ossObject.getObjectContent();
                    // 对于每一个要被存放到压缩包的文件,都必须调用ZipOutputStream对象的putNextEntry()方法,确保压缩包里面文件不同名
                    zos.putNextEntry(new ZipEntry(ossfile.split("/")[2]));
                    int bytesRead = 0;
                    // 向压缩文件中输出数据
                    while ((bytesRead = inputStream.read()) != -1) {
                        zos.write(bytesRead);
                    }
                    inputStream.close();
                    zos.closeEntry(); // 当前文件写完,定位为写入下一条项目
                }
                zos.close();
                String header = request.getHeader("User-Agent").toUpperCase();
                if (header.contains("MSIE") || header.contains("TRIDENT") || header.contains("EDGE")) {
                    fileName = URLEncoder.encode(fileName, "utf-8");
                    fileName = fileName.replace("+", "%20");    //IE下载文件名空格变+号问题
                } else {
                    fileName = new String(fileName.getBytes(), "ISO8859-1");
                }
                response.reset();
                response.setContentType("text/plain");
                response.setContentType("application/octet-stream; charset=utf-8");
                response.setHeader("Location", fileName);
                response.setHeader("Cache-Control", "max-age=0");
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
    
                FileInputStream fis = new FileInputStream(zipFile);
                BufferedInputStream buff = new BufferedInputStream(fis);
                BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
                byte[] car = new byte[1024];
                int l = 0;
                while (l < zipFile.length()) {
                    int j = buff.read(car, 0, 1024);
                    l += j;
                    out.write(car, 0, j);
                }
                // 关闭流
                fis.close();
                buff.close();
                out.close();
    
                ossClient.shutdown();
                // 删除临时文件
                zipFile.delete();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    

    ···下载zip到临时文件夹,并删除原文件

      /**
         * 从OSS服务中下载所需文件到本地临时文件,并将文件以ZIP格式进行压缩
         *
         * @param endpoint        oss对外服务的域名
         * @param accessKeyId     用户身份认证标识
         * @param accessKeySecret 用于加密签名字符串,oss用来验证签名字符串的秘钥
         * @param bucketName      要访问的存储空间
         * @param objectNames     要下载的对象/文件
         * @param zipName         zip文件名
         * @throws Exception
         */
        @GetMapping("/oss_zip")
        public static void fileToZip(String endpoint, String accessKeyId, String accessKeySecret, String bucketName, List<String> objectNames, String zipName) throws Exception {
            File file = null;
            try {
                //调用方法货物OSS中的文件
                String fileName = AliyunOSSUtil.downloadOSS(endpoint, accessKeyId, accessKeySecret, bucketName, objectNames);
                //获取待压缩文件源
                file = new File(fileName);
                //指定压缩文件存放路径
                String zipFileName = "src/main/resources/zipFiles/" + zipName + ".zip";
                File zipFile = new File(zipFileName);
                //构建输出流
                FileOutputStream fout = new FileOutputStream(zipFile);
                //构建压缩输出流
                ArchiveOutputStream aos = new ArchiveStreamFactory().createArchiveOutputStream(ArchiveStreamFactory.ZIP, fout);
                //判断获取的压缩实例是否为zip格式
                if (aos instanceof ZipArchiveOutputStream) {
                    //进行压缩实例强转
                    ZipArchiveOutputStream zipos = (ZipArchiveOutputStream) aos;
    
                    //将指定文件封装成压缩项,添加到压缩流中
                    //判断文件是否存在
                    if (file.exists()) {
                        //判断文件类型,调用文件处理方法
                        AliyunOSSUtil.zipDir(zipos, file, "");
                    }
                }
                //关闭流
                aos.flush();
                aos.close();
            } catch (Exception e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            } finally {
                //删除文件源,只保留zip文件
                if (file.exists()) {
                    //判断文件类型
                    if (file.isDirectory()) {
                        //对文件夹进行处理递归删除(有内容的文件夹不能直接被删除)
                        AliyunOSSUtil.deleteFile(file);
                        file.delete();//删除空文件夹
                    } else {
                        file.delete();//文件直接删除
                    }
                }
            }
        }
    

    上面两种压缩使用到的方法

     /**
         * 从OSS服务中下载所需文件到本地临时文件
         *
         * @param endponit        oss对外服务的域名
         * @param accessKeyId     用户身份认证标识
         * @param accessKeySecret 用于加密签名字符串,oss用来验证签名字符串的秘钥
         * @param bucketName      要访问的存储空间
         * @param objectNames     要下载的对象/文件
         * @return
         */
        public static String downloadOSS(String endponit, String accessKeyId, String accessKeySecret, String bucketName, List<String> objectNames) {
            String basePath = "src/main/resources/files";
            OSS ossClient = null;
            try {
                //创建OSSClient实例,用于操作oss空间
                ossClient = new OSSClientBuilder().build(endponit, accessKeyId, accessKeySecret);
                for (String objectName : objectNames) {
                    //指定文件保存路径
                    String filePath = basePath + "/" + objectName.substring(0, objectName.lastIndexOf("/"));
                    //判断文件目录是否存在,不存在则创建
                    File file = new File(filePath);
                    if (!file.exists()) {
                        file.mkdirs();
                    }
                    //判断保存文件名是否加后缀
                    if (objectName.contains(".")) {
                        //指定文件保存名称
                        filePath = filePath + "/" + objectName.substring(objectName.lastIndexOf("/") + 1);
                    }
    
                    //获取OSS文件并保存到本地指定路径中,此文件路径一定要存在,若保存目录不存在则报错,若保存文件名已存在则覆盖本地文件
                    ossClient.getObject(new GetObjectRequest(bucketName, objectName), new File(filePath));
                }
            } catch (Exception e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            } finally {
                //关闭oss连接
                if (ossClient != null) {
                    ossClient.shutdown();
                }
            }
            return basePath;
        }
    
        /**
         * 对压缩文件夹进行循环处理
         *
         * @param zipos   压缩流
         * @param file    要处理的文件
         * @param baseDir 要处理的文件的文件夹路径
         * @throws IOException
         */
        public static void zipDir(ZipArchiveOutputStream zipos, File file, String baseDir) throws IOException {
            if (file.isDirectory()) {
                File[] files = file.listFiles();
                for (File f : files) {
                    //对文件进行递归判断
                    zipDir(zipos, f, baseDir + file.getName() + File.separator);
                }
            } else {
                //将文件封装成压缩项
                //根据文件创建zip内容实体
                ZipArchiveEntry zipArchiveEntry = new ZipArchiveEntry(file, baseDir + file.getName());
                //将根据文件创建的实体保存到压缩流中
                zipos.putArchiveEntry(zipArchiveEntry);
                //将内容输出到压缩文件中
                zipos.write(FileUtils.readFileToByteArray(file));
                zipos.closeArchiveEntry();
            }
        }
    
        /**
         * 文件及文件夹的递归删除
         *
         * @param file
         */
        public static void deleteFile(File file) {
            if (file.isDirectory()) {
                File[] files = file.listFiles();
                for (File f : files) {
                    deleteFile(f);
                    //将循环后的空文件夹删除
                    if (f.exists()) {
                        f.delete();
                    }
                }
            } else {
                file.delete();
            }
        }
    

    下载压缩包流的形式导出页面

     public static ResponseEntity<String> downloadZip(HttpServletResponse response, DownloadFileResult downloadFileResult) {
            try {
                response.reset();
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/octet-stream");
                response.setHeader("Content-Disposition", "attachment;filename=" +  new String(downloadFileResult.getZipFileName().getBytes("utf-8"), "ISO8859-1")+".zip");
                ZipOutputStream zos = new ZipOutputStream(response.getOutputStream());
                zipFile(downloadFileResult.getSrcFiles(), zos);
            } catch (IOException e) {
                log.error("导出图片到本地失败,错误信息:",e);
                throw new JyspException(ExceptionEnum.FILE_DOWNLOAD_ERROR);
            }
            return ResponseEntity.ok("success");
        }
    
        /**
         * 文件下载
         *
         * @param filePaths
         * @param zos
         */
        public static void zipFile(List<String> filePaths, ZipOutputStream zos) {
            byte[] buffer = new byte[4096];
            try {
                for (String filePath : filePaths) {
                    File inputFile = new File(filePath);
                    if (inputFile.exists()) {
                        if (inputFile.isFile()) {
                            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(inputFile));
                            zos.putNextEntry(new ZipEntry(inputFile.getName()));
                            int size = 0;
                            while ((size = bis.read(buffer)) > 0) {
                                zos.write(buffer, 0, size);
                            }
                            zos.closeEntry();
                            bis.close();
                        } else {
                            File[] files = inputFile.listFiles();
                            List<String> filePathsTem = new ArrayList<String>();
                            for (File fileTem : files) {
                                filePathsTem.add(fileTem.toString());
                            }
                            zipFile(filePathsTem, zos);
                        }
                    }
                }
            } catch (IOException e) {
                log.error("导出图片到本地失败,错误信息:",e);
                throw new JyspException(ExceptionEnum.FILE_DOWNLOAD_ERROR);
            } finally {
                if (null != zos) {
                    try {
                        zos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    

    复制
    赋值方法有三个,常用的第一个方法

    /**
         * 简单拷贝
         * <p>
         * 注意点:
         * 用户有源文件的读写权限。
         * 不支持跨地域拷贝。例如,不支持将杭州存储空间里的文件拷贝到青岛。
         * 文件的大小不能超过1GB。
         */
        public void copySmallFile() {
            // Endpoint以杭州为例,其它Region请按实际情况填写。
            String endpoint = constantProperties.getEndpoint();
            // 阿里云主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维,请登录 https://ram.console.aliyun.com 创建RAM账号。
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
    
            String sourceBucketName = constantProperties.getBucketName();
            String sourceObjectName = getObjectList(sourceBucketName).get(0);
            String destinationBucketName = sourceBucketName;
            String destinationObjectName = "huangzouqiang-huangzouqiang.oss-cn-beijing.aliyuncs.com/2020-12-09/result.jpg";
    
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
    
            // 拷贝文件。
            CopyObjectResult result = ossClient.copyObject(sourceBucketName, sourceObjectName, destinationBucketName, destinationObjectName);
            System.out.println("ETag: " + result.getETag() + " LastModified: " + result.getLastModified());
    
            // 关闭OSSClient。
            ossClient.shutdown();
        }
    
    
        /**
         * 通过CopyObjectRequest拷贝小文件
         * <p>
         * 注意点:
         * 用户有源文件的读写权限。
         * 不支持跨地域拷贝。例如,不支持将杭州存储空间里的文件拷贝到青岛。
         * 文件的大小不能超过1GB。
         */
        public void copyObjectRequest() {
            // Endpoint以杭州为例,其它Region请按实际情况填写。
            String endpoint = constantProperties.getEndpoint();
            // 阿里云主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维,请登录 https://ram.console.aliyun.com 创建RAM账号。
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
    
            String sourceBucketName = constantProperties.getBucketName();
            String sourceObjectName = getObjectList(sourceBucketName).get(0);
            String destinationBucketName = sourceBucketName;
            String destinationObjectName = "huangzouqiang-huangzouqiang.oss-cn-beijing.aliyuncs.com/2020-12-09/result1.jpg";
    
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
    
            // 创建CopyObjectRequest对象。
            CopyObjectRequest copyObjectRequest = new CopyObjectRequest(sourceBucketName, sourceObjectName, destinationBucketName, destinationObjectName);
    
            // 设置新的文件元信息。
            ObjectMetadata meta = new ObjectMetadata();
            meta.setContentType("text/html");
            copyObjectRequest.setNewObjectMetadata(meta);
    
            // 复制文件。
            CopyObjectResult result = ossClient.copyObject(copyObjectRequest);
            System.out.println("ETag: " + result.getETag() + " LastModified: " + result.getLastModified());
    
            // 关闭OSSClient。
            ossClient.shutdown();
    
        }
    
        /**
         * 拷贝大文件(大于1个g)需要使用分片拷贝(UploadPartCopy)
         * 分片拷贝分为三步:
         * <p>
         * 通过ossClient.initiateMultipartUpload初始化分片拷贝任务。
         * 通过ossClient.uploadPartCopy进行分片拷贝。除最后一个分片外,其它分片都要大于100KB。
         * 通过ossClient.completeMultipartUpload提交分片拷贝任务。
         */
        public void copyBigFile() {
            // Endpoint以杭州为例,其它Region请按实际情况填写。
            String endpoint = constantProperties.getEndpoint();
            // 阿里云主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM账号进行API访问或日常运维,请登录 https://ram.console.aliyun.com 创建RAM账号。
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
    
            String sourceBucketName = constantProperties.getBucketName();
            String sourceObjectName = getObjectList(sourceBucketName).get(0);
            String destinationBucketName = sourceBucketName;
            String destinationObjectName = "huangzouqiang-huangzouqiang.oss-cn-beijing.aliyuncs.com/2020-12-09/result1.jpg";
    
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
    
            ObjectMetadata objectMetadata = ossClient.getObjectMetadata(sourceBucketName, sourceObjectName);
            // 获取被拷贝文件的大小。
            long contentLength = objectMetadata.getContentLength();
    
            // 设置分片大小为10MB。
            long partSize = 1024 * 1024 * 10;
    
            // 计算分片总数。
            int partCount = (int) (contentLength / partSize);
            if (contentLength % partSize != 0) {
                partCount++;
            }
            System.out.println("total part count:" + partCount);
    
            // 初始化拷贝任务。可以通过InitiateMultipartUploadRequest指定目标文件元信息。
            InitiateMultipartUploadRequest initiateMultipartUploadRequest = new InitiateMultipartUploadRequest(destinationBucketName, destinationObjectName);
            InitiateMultipartUploadResult initiateMultipartUploadResult = ossClient.initiateMultipartUpload(initiateMultipartUploadRequest);
            String uploadId = initiateMultipartUploadResult.getUploadId();
    
            // 分片拷贝。
            List<PartETag> partETags = new ArrayList<PartETag>();
            for (int i = 0; i < partCount; i++) {
                // 计算每个分片的大小。
                long skipBytes = partSize * i;
                long size = partSize < contentLength - skipBytes ? partSize : contentLength - skipBytes;
                // 创建UploadPartCopyRequest。可以通过UploadPartCopyRequest指定限定条件。
                UploadPartCopyRequest uploadPartCopyRequest = new UploadPartCopyRequest(sourceBucketName, sourceObjectName, destinationBucketName, destinationObjectName);
                uploadPartCopyRequest.setUploadId(uploadId);
                uploadPartCopyRequest.setPartSize(size);
                uploadPartCopyRequest.setBeginIndex(skipBytes);
                uploadPartCopyRequest.setPartNumber(i + 1);
                UploadPartCopyResult uploadPartCopyResult = ossClient.uploadPartCopy(uploadPartCopyRequest);
                // 将返回的分片ETag保存到partETags中。
                partETags.add(uploadPartCopyResult.getPartETag());
            }
            // 提交分片拷贝任务。
            CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest(destinationBucketName, destinationObjectName, uploadId, partETags);
            ossClient.completeMultipartUpload(completeMultipartUploadRequest);
    
            // 关闭OSSClient。
            ossClient.shutdown();
        }
    
    

    查询bucket下的所有文件名列表

     /**
         * 查询bucket下的所有文件名列表
         *
         * @param bucketName
         * @return
         */
        public List<String> getObjectList(String bucketName) {
            List<String> listRe = new ArrayList<>();
            String endpoint = constantProperties.getEndpoint();
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
            try {
                log.info("===========>查询文件名列表");
                OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
                ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
                //列出11111目录下今天所有文件
                listObjectsRequest.setPrefix("huangzouqiang-huangzouqiang.oss-cn-beijing.aliyuncs.com/" + format.format(new Date()) + "/");
                ObjectListing list = ossClient.listObjects(listObjectsRequest);
                for (OSSObjectSummary objectSummary : list.getObjectSummaries()) {
                    System.out.println(objectSummary.getKey());
                    listRe.add(objectSummary.getKey());
                }
                return listRe;
            } catch (Exception ex) {
                log.info("==========>查询列表失败", ex);
                return new ArrayList<>();
            }
        }
    

    判断文件是否存在

      /**
         * 判断文件是否存在
         *
         * @param ossClient
         * @param bucketName bucketName名称
         * @param targetUrl 查看的文件路径 "temporary/3/0106_24.xml"
         * @return true文件存在 false不存在
         */
        public static boolean findFileExist(OSS ossClient,String bucketName,String targetUrl){
            // 判断文件是否存在。doesObjectExist还有一个参数isOnlyInOSS,如果为true则忽略302重定向或镜像;如果
            //为false,则考虑302重定向或镜像。
            return ossClient.doesObjectExist(bucketName, targetUrl);
        }
    

    在线生成xml文件并上传到oss服务器
    我这里用的微服务调用了,中间有些我自己的业务,你是使用的话看着用

    
    
        /**
         * oss 生成一个流文件用于写入oss储存服务器
         *
         * @param picInfo
         * @param productionXmlFileVos
         * @throws Exception
         */
        public static ByteArrayInputStream handleXmlToInputStream(PicInfo picInfo, List<ProductionXmlFileVo> productionXmlFileVos) {
            //读取信息生成xml
            org.dom4j.Document document = DocumentHelper.createDocument();
            Element root = document.addElement("annotation");
            Element fileName = root.addElement("filename");
            Element stationname = root.addElement("stationname");
            Element time = root.addElement("time");
            fileName.setText(picInfo.getNewImgName());
            stationname.setText(picInfo.getUploadType().toString());
            time.setText(DateUtils.dateToStr(new Date()));
    
            Element size = root.addElement("size");
            Element height = size.addElement("height");
            Element width = size.addElement("width");
            Element depth = size.addElement("depth");
            height.setText(picInfo.getImgHeight());
            width.setText(picInfo.getImgWidth());
            depth.setText(picInfo.getDepth());
    
            Element segmented = root.addElement("segmented");
            segmented.setText("0");
            if (!org.apache.commons.collections.CollectionUtils.isEmpty(productionXmlFileVos)) {
                //循环复用生成三级小标签
                for (ProductionXmlFileVo productionXmlFileVo : productionXmlFileVos) {
                    Element object = root.addElement("object");
                    if (productionXmlFileVo.getAlgId() != null) {
                        Element algo = object.addElement("algo");
                        algo.setText(productionXmlFileVo.getAlgId().toString());
                    }
                    if (StringUtils.isNotEmpty(productionXmlFileVo.getMinX())) {
                        Element name = object.addElement("name");
                        Element pose = object.addElement("pose");
                        Element truncated = object.addElement("truncated");
                        Element difficult = object.addElement("difficult");
                        name.setText(productionXmlFileVo.getName());
                        pose.setText("Unspecified");
                        truncated.setText("0");
                        difficult.setText("0");
                        Element bndbox = object.addElement("bndbox");
                        //标注矩形的左上角坐标
                        Element xmin = bndbox.addElement("xmin");
                        Element ymin = bndbox.addElement("ymin");
                        //标注矩形的右下角坐标
                        Element xmax = bndbox.addElement("xmax");
                        Element ymax = bndbox.addElement("ymax");
                        xmin.setText(productionXmlFileVo.getMinX());
                        ymin.setText(productionXmlFileVo.getMinY());
                        xmax.setText(productionXmlFileVo.getMaxX());
                        ymax.setText(productionXmlFileVo.getMaxY());
                    }
                }
            }
            //xml-document转字符串
            String text = document.asXML();
            //字符串转字节流
            ByteArrayInputStream tInputStringStream = new ByteArrayInputStream(text.getBytes(UTF_8));
            return tInputStringStream;
    //        ossCline.putObject(bucketname, xmlFileName, tInputStringStream, (long) tInputStringStream.available(), "application/xml");
    //        ossCline.putObject(bucketname, xmlFileName, tInputStringStream);
    //        tInputStringStream.close();
        }
    
    //================这个是文件流转换的方法,中间有点我自己的业务========start=========
    //有效生成xml文件并上传到oss服务器
                    try {
                        //存储路径
                        String xmlUrl = picInfo.getImgUrl().replace("pic", "xml").replace("jpg", "xml");
                        ByteArrayInputStream byteArrayInputStream = XmlUtils.handleXmlToInputStream(picInfo, xmlInfoResult);
                        MultipartFile file = new MockMultipartFile("result.xml","old.xml", MediaType.MULTIPART_FORM_DATA_VALUE, byteArrayInputStream);
                        byteArrayInputStream.close();
                        ResponseEntity<Integer> responseEntity = uploadApi.createXmlFileUploadOss(file,xmlUrl);
                        Integer body = responseEntity.getBody();
                        if (body == 0) {
                            log.info("xml文件生成并存储成功");
                        }
                    } catch (Exception e) {
                        log.error("xml文件生成异常:", e);
                        throw new JyspException(ExceptionEnum.FILE_PRODUCTION_ERROR);
                    }
    //==============================================end=============================
    
     /**
         * 生成xml文件并上传指oss服务器
         *
         * @param file
         * @param xmlUrl
         * @return 0失败 1成功
         */
        @Override
        public ResponseEntity<Integer> createXmlFileUploadOss(MultipartFile file, String xmlUrl) {
            String endpoint = constantProperties.getEndpoint();
            String accessKeyId = constantProperties.getKeyId();
            String accessKeySecret = constantProperties.getKeySecret();
            String bucketName = constantProperties.getBucketName();
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            try {
                File newFile = new File(file.getOriginalFilename());
                FileOutputStream os = new FileOutputStream(newFile);
                os.write(file.getBytes());
                os.close();
                file.transferTo(newFile);
                PutObjectResult result = ossClient.putObject(bucketName, xmlUrl, newFile);
                if (result != null) {
                    return ResponseEntity.ok(1);
                }
            } catch (Exception e) {
                log.error("在线生成xml并上传失败:", e);
                throw new JyspException(ExceptionEnum.FILE_HANDLE_ERROR);
            } finally {
                // 关闭OSSClient。
                ossClient.shutdown();
            }
            return ResponseEntity.ok(0);
        }
    

    参考官方文档:https://help.aliyun.com/document_detail/84842.html

    需要的jar包

    	    <!--oss文件存储-->
            <dependency>
                <groupId>com.aliyun.oss</groupId>
                <artifactId>aliyun-sdk-oss</artifactId>
                <version>3.10.2</version>
            </dependency>
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>1.3.1</version>
            </dependency>
            <!--文件压缩-->
            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-compress -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-compress</artifactId>
                <version>1.14</version>
            </dependency>
            <!--解析xml	-->
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
    
    展开全文
  • 阿里云OSS云存储方案.docx阿里云OSS云存储方案.docx阿里云OSS云存储方案.docx阿里云OSS云存储方案.docx阿里云OSS云存储方案.docx阿里云OSS云存储方案.docx
  • 阿里云OSS云存储平台

    2020-09-30 15:16:38
    阿里云OSS云存储平台 一、需求分析 使用SpringBoot和OSS实现图片的上传、下载和删除功能, 具体要求如下 可以使用postman 发送上传请求 /oss/upload ,实现图片上传到OSS对应的Bucket中 类型检查:必须为 jpg、png...

    阿里云OSS云存储平台实战——图片上传/下载/删除



    一、OSS实战要求

    使用SpringBoot和OSS实现图片的上传、下载和删除功能, 具体要求如下:

    	可以使用postman  发送上传请求 /pic/upload ,实现图片上传到OSS对应的Bucket中
    	
    	可以使用postman 发送下载请求  /pic/download,实现图片下载
    	可以根据图片名进行文件的下载
    	
    	可以使用postman 发送删除请求  /pic/delete,实现图片删除
    	可以根据图片名进行文件的删除
    


    二、OSS功能介绍和平台搭建

    基本功能

    使用阿里云管理控制台来完成 OSS 基本操作的流程如下
    在这里插入图片描述

    2.1 开通OSS服务器

    前提条件

    	在使用阿里云 OSS 服务之前,请确保您已经注册了阿里云账号并完成实名认证。如果您还没有创建阿
    	里云账号,系统会在您开通 OSS 时提示您注册账号。
    

    在这里插入图片描述

    操作步骤

    • 1.登录阿里云官网。
    • 2.将鼠标移至产品,单击对象存储 OSS,打开 OSS 产品详情页面。
    • 3.在 OSS 产品详情页,单击立即开通。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    2.2 创建存储空间

    • 1.登录OSS管理控制台。
    • 2.单击Bucket列表,之后单击创建Bucket。
      您也可以单击概览,之后单击右侧的创建Bucket。
    • 3.在创建Bucket页面配置Bucket参数。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述


    2.3 上传文件

    • 1.登录OSS管理控制台。
    • 2.单击Bucket列表,之后单击目标Bucket名称。
    • 3.单击文件管理 > 上传文件。
    • 4.在上传文件页面,设置上传文件的参数。
    • 5.在上传任务页面等待任务完成,之后关闭对话框。

    在这里插入图片描述


    2.4 下载文件

    • 1.登录OSS管理控制台。
    • 2.进入目标Bucket。
      单击Bucket列表,之后单击目标Bucket名称。
    • 3.单击文件管理页签,您可以进行以下操作:

    在这里插入图片描述

    2.5 删除文件/删除存储空间

    • 1.登录OSS管理控制台。
    • 2.进入目标Bucket。
      单击Bucket列表,之后单击目标Bucket名称。
    • 3.选择一个或多个文件,选择批量操作 > 删除。
      您也可以选择目标文件右侧的更多 > 删除来删除单个文件。
    • 4.在删除文件对话框中,单击确定。

    在这里插入图片描述


    三、SpringBoot操作OSS实战

    3.1 获取aliyun.accessKeyId和aliyun.accessKeySecret

    在这里插入图片描述

    3.2 上传图片:

    在这里插入图片描述
    在这里插入图片描述

    3.3 下载图片:

    在这里插入图片描述


    3.4 删除图片:

    在这里插入图片描述

    执行删除操作:
    在这里插入图片描述

    删除成功:

    在这里插入图片描述

    3.5 下载图片:

    在这里插入图片描述



    示例代码:

    OSS示例代码下载地址 提取码:d8qw

    展开全文
  • 配置阿里云oss云存储

    2021-03-30 17:35:49
    配置阿里云oss云存储 /** * .--, .--, * ( ( \.---./ ) ) * '.__/o o\__.' * {= ^ =} * > - < * / \ * // \\ * //| . |\\ * "'\ /'"_.-~^`'-.

    配置阿里云oss云存储

    /**
         *       .--,       .--,
         *   ( (  \.---./  ) )
         *    '.__/o   o\__.'
         *       {=  ^  =}
         *        >  -  <
         *       /       \
         *      //       \\
         *     //|   .   |\\
         *     "'\       /'"_.-~^`'-.
         *        \  _  /--'         `
         *      ___)( )(___
         *     (((__) (__))) 
         * $srcPath就是你要上传文件的地址
         * $desPath就是你上传到OSS的文件名,或路径+文件名
         */
        public function ossUpload($srcPath,$desPath)
        {
            require_once(base_path() . '/app/Helpers/OSS/autoload.php');
            $bucket = Config::OSS_TEST_BUCKET;
            $accessKeyId = Config::OSS_ACCESS_ID;
            $accessKeySecret = Config::OSS_ACCESS_KEY;
            $endpoint = Config::OSS_ENDPOINT;
            $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
            $ossRequestUrl = $ossClient->uploadFile($bucket, $desPath, $srcPath);
            $ossFileUrl = isset($ossRequestUrl['oss-request-url']) ? $ossRequestUrl['oss-request-url'] : '';
            return $ossFileUrl;
        } 
    

    使用时记得配置命名空间
    链接:https://pan.baidu.com/s/11_24_S__8TQvWHs1Jo2odg
    提取码:f6kq
    composer安装

    composer require aliyuncs/oss-sdk-php
    

    转载地址:https://blog.csdn.net/phper23/article/details/115331387

    展开全文
  • OSS云存储方法

    2018-05-18 15:58:18
    OSS云存储通常用来存储视频步骤: |___&gt;&gt; 申请注册开通并购买阿里云oss云存储服务! |___&gt;&gt; 1.新建一个bucket,起一个名字,选择一个地区,标准存储,权限选择公共读。 |___&gt;&...
    OSS云存储通常用来存储视频

    步骤:

    |___>> 申请注册开通并购买阿里云oss云存储服务!
    |___>> 1.新建一个bucket,起一个名字,选择一个地区,标准存储,权限选择公共读。
    |___>> 2.点开基础设置,往下拉,跨域设置,创建一个规则,把allowed methods选项全部勾选
    |___>> 3.通过js上传视频,肯定需要权限,找到右上角的访问控制,选择用户管理,添加新用户,创建成功后,将创建用户的accesskey参数保存起来,并给该用户赋予权限.
    |___>> 4.找到oss,将外网域名保存起来
    |
    |___>> AccessKeyID: XXXXXXX
    |___>> AccessKeySecret: XXXXXXXXXXXXXXXXXXXXXXXXXXX
    |___>> 外网访问域名: XXXXXXXXXXXXXXXXXXXXXX


    xxxxxxxx需要自己替换

    展开全文
  • 阿里云oss云存储

    2017-06-21 17:08:30
    阿里云oss云存储一 pom.xml配置<!-- 阿里云相关 --> <groupId>com.aliyun</groupId> <artifactId>aliyun-java-sdk-core <version>2.1.9
  • 删除阿里云OSS云存储bucket的步骤 1、登录阿里云,进入到OSS存储管理页面, 2、在页面左侧菜单栏里点击bucket名称进入你已经创建的bucket, 3、然后点击左侧菜单栏进入基础设置, 4、在基础设置的最下面就是删除...
  • 百度云OSS云存储上传及获取

    千次阅读 2019-04-27 11:36:21
    百度云OSS云存储上传及获取 需要的小伙们自行获取不懂得可留言 dome地址: 百度云oss上传下载.
  • 阿里云 OSS 云存储服务器使用 参考:https://blog.csdn.net/leipan919134/article/details/101538542 https://blog.csdn.net/github_36086968/article/details/53113274 阿里云官方java文档 OSS项目集成 项目集成了...
  • 阿里云STS临时令牌操作OSS云存储 参考:官方文档1官方文档2 STS获取临时令牌操作OSS云存储 项目集成了swagger2自动接口文档,如未集成,需要将@Api、@ApiOperation等注解去掉 为什么要使用sts去操作? 直接使用账号...
  • OSS云存储网关是什么 https://help.aliyun.com/document_detail/53972.html?spm=5176.doc54944.6.539.SXIU1s 安装使用OSS云存储网关步骤 部署OSS云存储网关 ...
  • 两步带你JAVA搞定阿里云Oss云存储,赶紧点开来看一看吧!!!
  • 20160826 OSS云存储技术

    2017-08-31 11:16:35
    OSS 云存储技术 将大的文件资源存入第三方,云存储,半分布式 阿里云存储 七牛云存储 用web程序进行访问 例如:阿里云存储 产品 -> 存储 -> 对象存储OSS 获取Bucket信息 访问域名 上传文件:简单上传,表单上传,断点续...
  • SpringBoot整合阿里云OSS云存储

    千次阅读 2018-09-12 17:58:13
    SpringBoot整合阿里云OSS云存储 重中之重 就是要在pom配置文件中导入 JAR 包 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;com.aliyun.oss&amp;lt;/groupId&amp;gt; &amp;...
  • OSS云存储管理实践 场景体验目标 开始实验后,系统会自动去创建一台Linux ECS。其中,创建的ECS中已经部署了web应用和OSS python SDK。在本实验中,已创建的ECS作为web服务器,浏览器中直接访问其IP地址会显示包含四...
  • 最近工作中用到阿里云OSS云存储系统;部门的服务器中大量冷数据长期不使用,但是又占据了大量存储空间,硬盘屡屡报错;因此有必要把服务器上面的冷数据备份一下。 流程规划 具体流程规划如下表 数据类型 数据特点 ...
  • oss云存储API

    2015-04-26 18:01:48
    阿里云存储服务(Open Storage Service,简称OSS),是阿里云对外提供的海量,安全,低成本,高可靠的 云存储服务。用户可以通过本文档提供的简单的REST接口,在任何时间、任何地点、任何互联网设备上进行上 传和...
  • 阿里云OSS云存储文件上传模板——基于Springboot 这两天在搞阿里云的AI训练营,在实践过程中发现了自己对于前端传入图片传入阿里云OSS,并且提取出相应的url不熟,在这里对代码进行总结,以后使用时就复制就行 ...
  • 阿里云OSS,最大的特点就是便宜,可能还没大规模商用,所以价格非常便宜,如果现在购买一年的OSS,40G不限流量的OSS产品包,价格才9元,但估计续费价格会有点贵。阿里云OSS的WordPress插件也是可以从WordPress管理...
  • Oss云存储案例

    2021-03-06 11:11:46
    将本地文件上传到aliyun.com的oss对象存储中 在使用oss之前要创建一个bucket桶,申请你的accesskey accesskeyId和记住endpoint 文件上传成功后网络访问地址组成:http://bucketName.endpoint/文件夹路径/文件名 文件...
  • java上传图片到阿里云oss云存储中,返回url链接地址

    万次阅读 热门讨论 2017-11-01 14:21:37
    前言:最近要做一个门户网站,图片较多,所以要采用图片服务器,我这里采用的是阿里云的oss云存储,1.个数无限制,2.阿里云备份3,性能也不错. oss对于图片的处理,也有api,但是我这里上传的图片只需要加个水印,所以只需要在...
  • 阿里云OSS云存储

    2020-10-21 04:14:23
    package com.atguigu.oss;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.autoconfigure.jdbc.DataSou

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,665
精华内容 1,466
关键字:

oss云存储