图片服务器架构是什么图片服务器oss

转载

mob64ca1405d568 2023-12-11 17:37:32

文章标签 图片服务器架构是什么上传应用服务器 java 文章分类 架构后端开发

关于文件上传，我们一般使用OSS服务器。大致为两种上传方式：

本文主要介绍如何基于POST Policy的使用规则在服务端通过各种语言代码完成签名，并且设置上传回调，然后通过表单直传数据到OSS。

背景

采用服务端签名后直传方案有个问题：大多数情况下，用户上传数据后，应用服务器需要知道用户上传了哪些文件以及文件名；如果上传了图片，还需要知道图片的大小等，为此OSS提供了上传回调方案。

原理介绍

图片服务器架构是什么图片服务器oss_图片服务器架构是什么

服务端签名后直传的原理如下：

用户发送上传Policy请求到应用服务器。
应用服务器返回上传Policy和签名给用户。
用户直接上传数据到OSS。

本示例中，Web端向服务端请求签名，然后直接上传，不会对服务端产生压力，而且安全可靠。但本示例中的服务端无法实时了解用户上传了多少文件，上传了什么文件。如果想实时了解用户上传了什么文件，可以采用服务端签名直传并设置上传回调。

以Java语言为例，讲解在服务端通过Java代码完成签名，并且设置上传回调，然后通过表单直传数据到OSS。

前提条件

应用服务器对应的域名可通过公网访问。
确保应用服务器已经安装Java 1.6以上版本（执行命令java -version进行查看）。
确保PC端浏览器支持JavaScript。

步骤1：配置应用服务器

下载应用服务器源码（Java版本）。
本示例中以Ubuntu 16.04为例，将下载的文件解压到/home/aliyun/aliyun-oss-appserver-java目录下。
进入该目录，找到并打开源码文件CallbackServer.java，修改如下的代码片段：

String accessId = "<yourAccessKeyId>";      
String accessKey = "<yourAccessKeySecret>"; 
String endpoint = "oss-cn-hangzhou.aliyuncs.com"; 
String bucket = "bucket-name";                    
String host = "https://" + bucket + "." + endpoint; 
String callbackUrl = "http://88.88.88.88:8888";
String dir = "user-dir-prefix/";

View Code

accessId ：设置您的AccessKeyId。
accessKey ：设置您的AessKeySecret。
host：格式为https://bucketname.endpoint，例如https://bucket-name.oss-cn-hangzhou.aliyuncs.com。关于Endpoint的介绍，请参见Endpoint访问域名。
callbackUrl：设置上传回调URL，即回调服务器地址，用于处理应用服务器与OSS之间的通信。OSS会在文件上传完成后，把文件上传信息通过此回调URL发送给应用服务器。本例中修改为：String callbackUrl ="http://11.22.33.44:1234";。
dir：若要设置上传到OSS文件的前缀则需要配置此项，否则置空即可。

步骤2：配置客户端

下载客户端源码。
将文件解压，本例中以解压到D:\aliyun\aliyun-oss-appserver-js目录为例。
进入该目录，打开upload.js文件，找到下面的代码语句：

// serverUrl是 用户获取 '签名和Policy' 等信息的应用服务器的URL，请将下面的IP和Port配置为您自己的真实信息。
serverUrl = 'http://88.88.88.88:8888'

View Code
将severUrl改成应用服务器的地址，客户端可以通过它获取签名直传Policy等信息。如本例中可修改为：serverUrl = 'http://11.22.33.44:1234'。

步骤3：修改CORS

客户端进行表单直传到OSS时，会从浏览器向OSS发送带有Origin的请求消息。OSS对带有Origin头的请求消息会进行跨域规则（CORS）的验证。因此需要为Bucket设置跨域规则以支持Post方法。

登录OSS管理控制台。
单击Bucket列表，之后单击目标Bucket名称。
单击权限管理 > 跨域设置，在跨域设置区域单击设置。
单击创建规则，配置如下图所示。

图片服务器架构是什么图片服务器oss_应用服务器_02

说明为了您的数据安全，实际使用时，来源栏建议您填写自己需要的域名。更多配置信息请参见设置跨域访问。

步骤4：体验上传回调

启动应用服务器。在/home/aliyun/aliyun-oss-appserver-java目录下，执行mvn package命令编译打包，然后执行java -jar target/appservermaven-1.0.0.jar 1234命令启动应用服务器。

说明请将IP和端口改成您配置的应用服务器的IP和端口。

您也可以在PC端使用Eclipse/Intellij IDEA等IDE工具导出jar包，然后将jar包拷贝到应用服务器，再执行jar包启动应用服务器。
启动客户端。

在PC端的客户端源码目录中，打开index.html文件。

图片服务器架构是什么图片服务器oss_上传_03

单击选择文件，选择指定类型的文件，单击开始上传。

上传成功后，显示回调服务器返回的内容。

应用服务器核心代码解析

应用服务器源码包含了签名直传服务和上传回调服务两个功能。

签名直传服务签名直传服务响应客户端发送给应用服务器的GET消息，代码片段如下：

protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        String accessId = "<yourAccessKeyId>"; // 请填写您的AccessKeyId。
        String accessKey = "<yourAccessKeySecret>"; // 请填写您的AccessKeySecret。
        String endpoint = "oss-cn-hangzhou.aliyuncs.com"; // 请填写您的 endpoint。
        String bucket = "bucket-name"; // 请填写您的 bucketname 。
        String host = "https://" + bucket + "." + endpoint; // host的格式为 bucketname.endpoint
        // callbackUrl为 上传回调服务器的URL，请将下面的IP和Port配置为您自己的真实信息。
        String callbackUrl = "http://88.88.88.88:8888";
        String dir = "user-dir-prefix/"; // 用户上传文件时指定的前缀。

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessId, accessKey);
        try {
            long expireTime = 30;
            long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
            Date expiration = new Date(expireEndTime);
            // PostObject请求最大可支持的文件大小为5 GB，即CONTENT_LENGTH_RANGE为5*1024*1024*1024。
            PolicyConditions policyConds = new PolicyConditions();
            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 1048576000);
            policyConds.addConditionItem(MatchMode.StartWith, PolicyConditions.COND_KEY, dir);

            String postPolicy = ossClient.generatePostPolicy(expiration, policyConds);
            byte[] binaryData = postPolicy.getBytes("utf-8");
            String encodedPolicy = BinaryUtil.toBase64String(binaryData);
            String postSignature = ossClient.calculatePostSignature(postPolicy);

            Map<String, String> respMap = new LinkedHashMap<String, String>();
            respMap.put("accessid", accessId);
            respMap.put("policy", encodedPolicy);
            respMap.put("signature", postSignature);
            respMap.put("dir", dir);
            respMap.put("host", host);
            respMap.put("expire", String.valueOf(expireEndTime / 1000));
            // respMap.put("expire", formatISO8601Date(expiration));

            JSONObject jasonCallback = new JSONObject();
            jasonCallback.put("callbackUrl", callbackUrl);
            jasonCallback.put("callbackBody",
                    "filename=${object}&size=${size}&mimeType=${mimeType}&height=${imageInfo.height}&width=${imageInfo.width}");
            jasonCallback.put("callbackBodyType", "application/x-www-form-urlencoded");
            String base64CallbackBody = BinaryUtil.toBase64String(jasonCallback.toString().getBytes());
            respMap.put("callback", base64CallbackBody);

            JSONObject ja1 = JSONObject.fromObject(respMap);
            // System.out.println(ja1.toString());
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "GET, POST");
            response(request, response, ja1.toString());

        } catch (Exception e) {
            // Assert.fail(e.getMessage());
            System.out.println(e.getMessage());
        } finally { 
            ossClient.shutdown();
        }
    }

View Code
上传回调服务上传回调服务响应OSS发送给应用服务器的POST消息，代码片段如下：

protected boolean VerifyOSSCallbackRequest(HttpServletRequest request, String ossCallbackBody)
            throws NumberFormatException, IOException {
        boolean ret = false;
        String autorizationInput = new String(request.getHeader("Authorization"));
        String pubKeyInput = request.getHeader("x-oss-pub-key-url");
        byte[] authorization = BinaryUtil.fromBase64String(autorizationInput);
        byte[] pubKey = BinaryUtil.fromBase64String(pubKeyInput);
        String pubKeyAddr = new String(pubKey);
        if (!pubKeyAddr.startsWith("https://gosspublic.alicdn.com/")
                && !pubKeyAddr.startsWith("https://gosspublic.alicdn.com/")) {
            System.out.println("pub key addr must be oss addrss");
            return false;
        }
        String retString = executeGet(pubKeyAddr);
        retString = retString.replace("-----BEGIN PUBLIC KEY-----", "");
        retString = retString.replace("-----END PUBLIC KEY-----", "");
        String queryString = request.getQueryString();
        String uri = request.getRequestURI();
        String decodeUri = java.net.URLDecoder.decode(uri, "UTF-8");
        String authStr = decodeUri;
        if (queryString != null && !queryString.equals("")) {
            authStr += "?" + queryString;
        }
        authStr += "\n" + ossCallbackBody;
        ret = doCheck(authStr, authorization, retString);
        return ret;
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String ossCallbackBody = GetPostBody(request.getInputStream(),
                Integer.parseInt(request.getHeader("content-length")));
        boolean ret = VerifyOSSCallbackRequest(request, ossCallbackBody);
        System.out.println("verify result : " + ret);
        // System.out.println("OSS Callback Body:" + ossCallbackBody);
        if (ret) {
            response(request, response, "{\"Status\":\"OK\"}", HttpServletResponse.SC_OK);
        } else {
            response(request, response, "{\"Status\":\"verify not ok\"}", HttpServletResponse.SC_BAD_REQUEST);
        }
    }

View Code

在SpringBoot上使用

导入依赖包，在pox文件中加入maven依赖

<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.11.2</version>
</dependency>

在resources包下面的新建一个aliyun.properties文件用来存放oss需要用到的参数配置

#阿里云OSS配置
#原服务器地址
aliyun.bucketUrl=https://bucketName.oss-cn-shenzhen.aliyuncs.com
#自定义解析后服务器地址
aliyun.baseUrl=https://cnc.520tech.com
#可以选择其他的地址
aliyun.endpoint=https://oss-cn-qingdao.aliyuncs.com
#已经在控制台创建的bucket
aliyun.bucketName=bucketName
#你上传文件的保存路径，如果bucket中不存在则创建（其实原理并不是文件夹，只是文件名，详情请先阅读官方文档）
aliyun.picLocation=Flie/image/
#相应的id和key值，请填写你具体的值，这里不方便展示我自己的。
aliyun.accessKeyId=阿里云OSS的accessKeyId
aliyun.accessKeySecret=阿里云OSS的accessKeySecret

创建一个aliyun参数模型

@Data
@Component
@ConfigurationProperties(prefix = "aliyun")
public class OssConfigModel {
    @ApiModelProperty("原图片服务器地址")
    private  String bucketUrl;
    @ApiModelProperty("自定义解析后的图片服务器地址")
    private  String baseUrl;
    @ApiModelProperty("连接区域地址")
    private  String endpoint;
    @ApiModelProperty("连接keyId")
    private  String accessKeyId;
    @ApiModelProperty("连接秘钥")
    private  String accessKeySecret;
    @ApiModelProperty("需要存储的bucketName")
    private  String bucketName;
    @ApiModelProperty("图片保存路径")
    private  String picLocation;
}

OssUtil工具类

图片服务器架构是什么图片服务器oss_图片服务器架构是什么_04

图片服务器架构是什么图片服务器oss_应用服务器_05

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSSClient;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.*;
import com.lb.farm.model.OssConfigModel;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;

public class OssUtil {

    private static OssConfigModel config = null;

    /**
     *
     * @MethodName: uploadFile
     * @Description: OSS单文件上传
     * @param file
     * @param fileType 文件后缀
     * @return String 文件地址
     */
    public static String uploadFile(File file, String fileType){
        config = config == null ? new OssConfigModel():config;
        //通过UUID生成文件名
        String fileName = config.getPicLocation()
                + UUID.randomUUID().toString().toUpperCase()
                .replace("-", "")
                +"."+fileType;
        return putFile(file,fileType,fileName);
    }

    /**
     *
     * @MethodName: updateFile
     * @Description: 更新文件:只更新内容，不更新文件名和文件地址。
     *      (因为地址没变，可能存在浏览器原数据缓存，不能及时加载新数据，例如图片更新，请注意)
     * @param file
     * @param fileType
     * @param oldUrl
     * @return String
     */
    public static String updateFile(File file,String fileType,String oldUrl){
        String fileName = getFileName(oldUrl);
        if(fileName==null) {
            return null;
        }
        return putFile(file,fileType,fileName);
    }

    /**
     *
     * @MethodName: replaceFile
     * @Description: 替换文件:删除原文件并上传新文件，文件名和地址同时替换
     *      解决原数据缓存问题，只要更新了地址，就能重新加载数据)
     * @param file
     * @param fileType 文件后缀
     * @param oldUrl 需要删除的文件地址
     * @return String 文件地址
     */
    public static String replaceFile(File file,String fileType,String oldUrl){
        boolean flag = deleteFile(oldUrl);      //先删除原文件
        if(!flag){
            //更改文件的过期时间，让他到期自动删除。
        }
        return uploadFile(file, fileType);
    }

    /**
     *
     * @MethodName: deleteFile
     * @Description: 单文件删除
     * @param fileUrl 需要删除的文件url
     * @return boolean 是否删除成功
     */
    public static boolean deleteFile(String fileUrl){
        config = config == null ? new OssConfigModel():config;
        //根据url获取bucketName
        String bucketName = OssUtil.getBucketName(fileUrl);
        //根据url获取fileName
        String fileName = OssUtil.getFileName(fileUrl);           
        if(bucketName==null||fileName==null){
            return false;
        }
        OSSClient ossClient = null;
        try {
            ossClient = new OSSClient(config.getEndpoint(), config.getAccessKeyId(), config.getAccessKeySecret());
            GenericRequest request = new DeleteObjectsRequest(bucketName).withKey(fileName);
            ossClient.deleteObject(request);
        } catch (Exception oe) {
            oe.printStackTrace();
            return false;
        } finally {
            ossClient.shutdown();
        }
        return true;
    }

    /**
     *
     * @MethodName: batchDeleteFiles
     * @Description: 批量文件删除(较快)：适用于相同endPoint和BucketName
     * @param fileUrls 需要删除的文件url集合
     * @return int 成功删除的个数
     */
    public static int deleteFile(List<String> fileUrls){
        //成功删除的个数
        int deleteCount = 0;
        //根据url获取bucketName
        String bucketName = OssUtil.getBucketName(fileUrls.get(0));
        //根据url获取fileName
        List<String> fileNames = OssUtil.getFileName(fileUrls);           
        if(bucketName==null||fileNames.size()<=0) {
            return 0;
        }
        OSSClient ossClient = null;
        try {
            ossClient = new OSSClient(config.getEndpoint(), config.getAccessKeyId(), config.getAccessKeySecret());
            DeleteObjectsRequest request = new DeleteObjectsRequest(bucketName).withKeys(fileNames);
            DeleteObjectsResult result = ossClient.deleteObjects(request);
            deleteCount = result.getDeletedObjects().size();
        } catch (OSSException oe) {
            oe.printStackTrace();
            throw new RuntimeException("OSS服务异常:", oe);
        } catch (ClientException ce) {
            ce.printStackTrace();
            throw new RuntimeException("OSS客户端异常:", ce);
        } finally {
            ossClient.shutdown();
        }
        return deleteCount;

    }

    /**
     *
     * @MethodName: batchDeleteFiles
     * @Description: 批量文件删除(较慢)：适用于不同endPoint和BucketName
     * @param fileUrls 需要删除的文件url集合
     * @return int 成功删除的个数
     */
    public static int deleteFiles(List<String> fileUrls){
        int count = 0;
        for (String url : fileUrls) {
            if(deleteFile(url)){
                count++;
            }
        }
        return count;
    }

    /**
     *
     * @MethodName: putFile
     * @Description: 上传文件
     * @param file
     * @param fileType
     * @param fileName
     * @return String
     */
    private static String putFile(File file, String fileType, String fileName){
        config = config==null?new OssConfigModel():config;
        String url = null;      //默认null
        OSSClient ossClient = null;
        try {
            ossClient = new OSSClient(config.getEndpoint(), config.getAccessKeyId(), config.getAccessKeySecret());
            InputStream input = new FileInputStream(file);
            ObjectMetadata meta = new ObjectMetadata();             // 创建上传Object的Metadata
            meta.setContentType(OssUtil.contentType(fileType));       // 设置上传内容类型
            meta.setCacheControl("no-cache");                   // 被下载时网页的缓存行为
            PutObjectRequest request = new PutObjectRequest(config.getBucketName(), fileName,input,meta);           //创建上传请求
            ossClient.putObject(request);
            Date expiration = new Date(new Date().getTime() + 3600L * 1000 * 24 * 365 * 10); // 设置URL过期时间为10年  3600L* 1000*24*365*10
            //上传成功再返回的文件路径
            url = ossClient.generatePresignedUrl(config.getBucketName(), fileName, expiration)
                    .toString()
                    .replaceFirst(config.getBucketUrl(), config.getBaseUrl());
        } catch (OSSException | FileNotFoundException | ClientException oe) {
            oe.printStackTrace();
            return null;
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        return url;
    }

    /**
     *
     * @MethodName: contentType
     * @Description: 获取文件类型
     * @param fileType
     * @return String
     */
    private static String contentType(String fileType){
        fileType = fileType.toLowerCase();
        String contentType = "";
        switch (fileType) {
            case "bmp": contentType = "image/bmp";
                break;
            case "gif": contentType = "image/gif";
                break;
            case "png":
            case "jpeg":
            case "jpg": contentType = "image/jpeg";
                break;
            case "html":contentType = "text/html";
                break;
            case "txt": contentType = "text/plain";
                break;
            case "vsd": contentType = "application/vnd.visio";
                break;
            case "ppt":
            case "pptx":contentType = "application/vnd.ms-powerpoint";
                break;
            case "doc":
            case "docx":contentType = "application/msword";
                break;
            case "xml":contentType = "text/xml";
                break;
            case "mp4":contentType = "video/mp4";
                break;
            default: contentType = "application/octet-stream";
                break;
        }
        return contentType;
    }

    /**
     *
     * @MethodName: getBucketName
     * @Description: 根据url获取bucketName
     * @param fileUrl 文件url
     * @return String bucketName
     */
    private static String getBucketName(String fileUrl){
        String http = "http://";
        String https = "https://";
        int httpIndex = fileUrl.indexOf(http);
        int httpsIndex = fileUrl.indexOf(https);
        int startIndex  = 0;
        if(httpIndex==-1){
            if(httpsIndex==-1){
                return null;
            }else{
                startIndex = httpsIndex+https.length();
            }
        }else{
            startIndex = httpIndex+http.length();
        }
        int endIndex = fileUrl.indexOf(".oss-");
        return fileUrl.substring(startIndex, endIndex);
    }

    /**
     *
     * @MethodName: getFileName
     * @Description: 根据url获取fileName
     * @param fileUrl 文件url
     * @return String fileName
     */
    private static String getFileName(String fileUrl){
        String str = "aliyuncs.com/";
        int beginIndex = fileUrl.indexOf(str);
        if(beginIndex==-1) {
            return null;
        }
        return fileUrl.substring(beginIndex+str.length());
    }

    /**
     *
     * @MethodName: getFileName
     * @Description: 根据url获取fileNames集合
     * @param fileUrls 文件url
     * @return List<String>  fileName集合
     */
    private static List<String> getFileName(List<String> fileUrls){
        List<String> names = new ArrayList<>();
        for (String url : fileUrls) {
            names.add(getFileName(url));
        }
        return names;
    }

    private static File transferToFile(MultipartFile multipartFile) {
//        选择用缓冲区来实现这个转换即使用java 创建的临时文件 使用 MultipartFile.transferto()方法 。
        File file = null;
        try {
            String originalFilename = multipartFile.getOriginalFilename();
            String[] filename = originalFilename.split("\\.");
            file=File.createTempFile(filename[0], filename[1]);
            multipartFile.transferTo(file);
            file.deleteOnExit();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return file;
    }
}

View Code

现场可以开始测试一波啦

@Api(description = "oss文件上传")
@RestController
@RequestMapping("/oss")
public class OssController {


    @ApiOperation("上传文件")
    @PostMapping("/upload")
    public Object uploadArticleImg(MultipartFile file, HttpServletRequest request) {
        if (file == null || file.isEmpty() || file.getSize() == 0) {
            throw new RuntimeException("CODE_UPLOAD_FAIL");
        }
        if (file.getSize() > 10 * 1024 * 1024) {
            return new RuntimeException("UPLOAD_FILE_LIMIT");
        }
        Map<String, String> map = new HashMap<>();
        // 文件类型
        String fileType = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
        //OSS单文件上传,返回上传成功后的oss存储服务器中的url
        String url = OssUtil.uploadFile(OssUtil.transferToFile(file), fileType);
        map.put(file.getName(), url);
        return map;
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。