❤️springboot阿里云视频点播服务实现上传视频和删除功能

package com.stu.vod.test;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.exceptions.ClientException;

public class InitAcsClint {
    public static DefaultAcsClient initVodClient(String accessKeyId, String accessKeySecret) throws ClientException {
        String regionId = "cn-shanghai";  // 点播服务接入区域,固定的
        DefaultProfile profile = DefaultProfile.getProfile(regionId, accessKeyId, accessKeySecret);
        DefaultAcsClient client = new DefaultAcsClient(profile);
        return client;
    }
}

package com.stu.vod.test;

import com.aliyun.vod.upload.impl.UploadVideoImpl;
import com.aliyun.vod.upload.req.UploadVideoRequest;
import com.aliyun.vod.upload.resp.UploadVideoResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.vod.model.v20170321.GetPlayInfoRequest;
import com.aliyuncs.vod.model.v20170321.GetPlayInfoResponse;
import com.aliyuncs.vod.model.v20170321.GetVideoPlayAuthRequest;
import com.aliyuncs.vod.model.v20170321.GetVideoPlayAuthResponse;

import java.util.List;


public class TestVod {
    public static void main(String[] args) throws Exception {
        testUploadVideo();
    }

    /**
     * 本地文件上传接口
     *
     */
    private static void testUploadVideo() {
        String accessKeyId ="xxxxxxxQWzbRYStXv";
        String accessKeySecret = "xxxxx7gc6i";
        //视频标题(必选)
        String title = "3 - How Does Project Submission Work - upload by sdk";
        //本地文件上传和文件流上传时，文件名称为上传文件绝对路径，如:/User/sample/文件名称.mp4 (必选)
        //文件名必须包含扩展名
        String fileName = "F:/aa.mp4";
        //本地文件上传
        UploadVideoRequest request = new UploadVideoRequest(accessKeyId, accessKeySecret, title, fileName);
        /* 可指定分片上传时每个分片的大小，默认为2M字节 */
        request.setPartSize(2 * 1024 * 1024L);
        /* 可指定分片上传时的并发线程数，默认为1，(注：该配置会占用服务器CPU资源，需根据服务器情况指定）*/
        request.setTaskNum(1);

        UploadVideoImpl uploader = new UploadVideoImpl();
        UploadVideoResponse response = uploader.uploadVideo(request);
        System.out.print("RequestId=" + response.getRequestId() + "\n");  //请求视频点播服务的请求ID
        if (response.isSuccess()) {
            System.out.print("VideoId=" + response.getVideoId() + "\n");
        } else {
            /* 如果设置回调URL无效，不影响视频上传，可以返回VideoId同时会返回错误码。其他情况上传失败时，VideoId为空，此时需要根据返回错误码分析具体错误原因 */
            System.out.print("VideoId=" + response.getVideoId() + "\n");
            System.out.print("ErrorCode=" + response.getCode() + "\n");
            System.out.print("ErrorMessage=" + response.getMessage() + "\n");
        }
    }

    public static void getPlayAuth() throws Exception {
        //1根据视频id获取视频播放凭证

        //1.1创建初始化对象
        DefaultAcsClient client = InitAcsClint.initVodClient("ddddddQWzbRYStXv","xxxxxxxx9GRqdWDns17gc6i");
        //1.2创建获取视频地址response和request对象
        GetVideoPlayAuthRequest request = new GetVideoPlayAuthRequest();
        GetVideoPlayAuthResponse response = new GetVideoPlayAuthResponse();

        //1.3向request对象里面设置视频id
        request.setVideoId("0aff5247d80d4ff1bbddcfc6a5c8e6a1");
        //1.4调用初始化对象里的方法，取得凭证
        response = client.getAcsResponse(request);
        System.out.println(response.getPlayAuth());

    }
    public static void getPlayUrl() throws Exception {
        //1根据视频id获取视频播放地址

        //1.1创建初始化对象
        DefaultAcsClient client = InitAcsClint.initVodClient("ddddddQWzbRYStXv","xxxxxxxx9GRqdWDns17gc6i");
        //1.2创建获取视频地址response和request对象
        GetPlayInfoRequest request = new GetPlayInfoRequest();
        GetPlayInfoResponse response = new GetPlayInfoResponse();

        //1.3向request对象里面设置视频id
        request.setVideoId("0aff5247d80d4ff1bbddcfc6a5c8e6a1");
        //1.4调用初始化对象里的方法，传递request，获取数据
        response = client.getAcsResponse(request);

        List<GetPlayInfoResponse.PlayInfo> playInfoList = response.getPlayInfoList();
        //1.5播放地址
        for (GetPlayInfoResponse.PlayInfo playInfo : playInfoList) {
            System.out.print("PlayInfo.PlayURL = " + playInfo.getPlayURL() + "\n");
        }
        //Base信息
        System.out.print("VideoBase.Title = " + response.getVideoBase().getTitle() + "\n");

    }
}

package com.stu.vod.utils;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//项目启动，spring接口，spring加载之后，执行接口一个方法
@Component
public class ConstantVodUtils implements InitializingBean {

    //通过@value注解读取属性文件里的值，赋值给keyId
    @Value("${aliyun.vod.file.keyid}")
    private String keyId;
    @Value("${aliyun.vod.file.keysecret}")
    private String keysecret;

    //定义一些静态常量
    public  static String KEY_ID;
    public  static String KEY_SECRET;

    //上边赋值完成后，会执行afterPropertiesSet方法，这是spring机制
    @Override
    public void afterPropertiesSet() throws Exception {
        KEY_ID = keyId;
        KEY_SECRET = keysecret;

    }
}

package com.stu.service.vod.utils;

import lombok.Data;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/******************************
 * 用途说明:视频点播常量
 * 作者姓名: Administrator
 * 创建时间: 2022-06-07 21:48
 ******************************/
@Data
@Component
@ConfigurationProperties(prefix = "aliyun.vod")
public class ConstantVodIInit implements InitializingBean {

    private String keyId;
    private String keySecret;

    //定义静态常量
    public static String KEY_ID;
    public static String KEY_SECRET;

    private ConstantVodIInit(){}

    //上边赋值完成后，会执行afterPropertiesSet方法，这是spring机制
    @Override
    public void afterPropertiesSet() throws Exception {
        KEY_ID = this.keyId;
        KEY_SECRET = this.keySecret;
    }
}

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;
    client_max_body_size 1024m;
    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       81;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}
    server {
        listen       9001;
        server_name  localhost;

        location ~ /eduservice/ {           
             proxy_pass http://localhost:8001;
        }
        location ~ /eduOss/ {           
             proxy_pass http://localhost:8002;
        }
        location ~ /eduvod/ {           
            proxy_pass http://localhost:8003;
        }
    }


}

package com.stu.vod.controller;

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.vod.model.v20170321.GetVideoPlayAuthRequest;
import com.aliyuncs.vod.model.v20170321.GetVideoPlayAuthResponse;
import com.stu.commonutils.ResultData;
import com.stu.servicebase.exceptionHandler.GuliException;
import com.stu.vod.service.VodService;
import com.stu.vod.utils.ConstantVodUtils;
import com.stu.vod.utils.InitVodClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController
@RequestMapping("/eduvod/video")

//@CrossOrigin
public class VodController {

    @Autowired
    private VodService vodService;

    //上传视频到阿里云
    @PostMapping("uploadAlyVideo")
    public ResultData uploadAlyVideo(MultipartFile file){
        //返回视频id
        String videoId = vodService.uploadAlyVideo(file);
        return ResultData.success().data("videoId",videoId);
    }
    //根据id删除阿里云视频
    @DeleteMapping("removeVideo/{id}")
    public ResultData removeVideo(@PathVariable String id){
        //返回视频id
        String videoId = vodService.removeVideo(id);
        return ResultData.success();
    }
    //根据id批量删除阿里云视频
    @DeleteMapping("removeVideoBatch")
    public ResultData removeVideoBatch(@RequestParam("videoIdList") List<String> videoIdList){
        //返回视频id
        vodService.removeVideoBatch(videoIdList);
        return ResultData.success();
    }

    //根据视频id获取视频的播放凭证
    @GetMapping("getAlyVideoAuth/{id}")
    public ResultData getAlyVideoAuth(@PathVariable String id){

        try {
            //1.1创建初始化对象
            //创建初始化对象
            DefaultAcsClient client = InitVodClient.initVodClient(ConstantVodUtils.KEY_ID,ConstantVodUtils.KEY_SECRET);
            //1.2创建获取视频地址response和request对象
            GetVideoPlayAuthRequest request = new GetVideoPlayAuthRequest();
            GetVideoPlayAuthResponse response = new GetVideoPlayAuthResponse();
            //1.3向request对象里面设置视频id
            request.setVideoId(id);
            //1.4调用初始化对象里的方法，取得凭证
            response = client.getAcsResponse(request);
            String playAuth = response.getPlayAuth();
            return ResultData.success().data("playAuth",playAuth);
        } catch (ClientException e) {
            throw new GuliException(20001,"获取凭证失败");
        }

    }
}

package com.stu.vod.service;

import org.springframework.web.multipart.MultipartFile;

import java.util.List;

public interface VodService {
    String uploadAlyVideo(MultipartFile file);

    String removeVideo(String id);

    void removeVideoBatch(List<String> videoIdList);
}

package com.stu.vod.service.impl;

import com.aliyun.vod.upload.impl.UploadVideoImpl;
import com.aliyun.vod.upload.req.UploadStreamRequest;
import com.aliyun.vod.upload.resp.UploadStreamResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.vod.model.v20170321.DeleteVideoRequest;
import com.stu.servicebase.exceptionHandler.GuliException;
import com.stu.vod.service.VodService;
import com.stu.vod.utils.ConstantVodUtils;
import com.stu.vod.utils.InitVodClient;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class VodServiceImpl implements VodService {

    @Override
    public String uploadAlyVideo(MultipartFile file) {
        try {
            //accessKeyId, accessKeySecret
            //fileName：上传文件原始名称
            // 01.03.09.mp4
            String fileName = file.getOriginalFilename();
            //title：上传之后显示名称
            String title = fileName.substring(0, fileName.lastIndexOf("."));
            //inputStream：上传文件输入流
            InputStream inputStream = file.getInputStream();
            UploadStreamRequest request = new UploadStreamRequest(ConstantVodUtils.KEY_ID,ConstantVodUtils.KEY_SECRET, title, fileName, inputStream);

            UploadVideoImpl uploader = new UploadVideoImpl();
            UploadStreamResponse response = uploader.uploadStream(request);

            String videoId = null;
            if (response.isSuccess()) {
                videoId = response.getVideoId();
            } else { //如果设置回调URL无效，不影响视频上传，可以返回VideoId同时会返回错误码。其他情况上传失败时，VideoId为空，此时需要根据返回错误码分析具体错误原因
                videoId = response.getVideoId();
            }
            return videoId;
        }catch(Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String removeVideo(String id) {
        try {

            //1初始化对象
            DefaultAcsClient client = InitVodClient.initVodClient(ConstantVodUtils.KEY_ID,
                    ConstantVodUtils.KEY_SECRET);
            //2创建删除视频request对象
            DeleteVideoRequest request = new DeleteVideoRequest();
            //3向request设置视频id
            request.setVideoIds(id);
            //4调用初始化对象的方法删除视频
            client.getAcsResponse(request);

            return id;
        } catch (Exception e) {
            e.printStackTrace();
            throw new GuliException(20001,"删除视频失败");
        }
    }

    @Override
    public void removeVideoBatch(List<String> videoIdList) {
        try {

            /*//方式1Java 8使用String.join()函数
            String str1 = String.join(",", videoIdList);
            System.out.println("str1 =" +str1);

            //方式2 使用org.apache.commons.lang.StringUtils.join
            String str2 = org.apache.commons.lang.StringUtils.join(videoIdList.toArray(), ",");
            System.out.println("str2="+str2);*/
            //将集合转换为分割的字符串，比如A,B,C,D,E格式
            String idsStr = String.join(",", videoIdList.stream().distinct().collect(Collectors.toList()));
            //1初始化对象
            DefaultAcsClient client = InitVodClient.initVodClient(ConstantVodUtils.KEY_ID,
                    ConstantVodUtils.KEY_SECRET);
            //2创建删除视频request对象
            DeleteVideoRequest request = new DeleteVideoRequest();
            //3向request设置视频id
            request.setVideoIds(idsStr);
            //4调用初始化对象的方法删除视频
            client.getAcsResponse(request);

        } catch (Exception e) {
            e.printStackTrace();
            throw new GuliException(20001,"删除视频失败");
        }
    }
}

package com.stu.service.vod.service.impl;

import com.aliyun.vod.upload.impl.UploadVideoImpl;
import com.aliyun.vod.upload.req.UploadStreamRequest;
import com.aliyun.vod.upload.resp.UploadStreamResponse;
import com.stu.service.base.exception.CustomException;
import com.stu.service.base.result.ResultCodeEnum;
import com.stu.service.vod.service.VodService;
import com.stu.service.vod.utils.ConstantVodIInit;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;

/******************************
 * 用途说明:
 * 作者姓名: Administrator
 * 创建时间: 2022-06-07 22:01
 ******************************/
@Service
@Slf4j
public class VodServiceImpl implements VodService {


    /***********************************
     * 用途说明:视频点播
     * @param file
     * 返回值说明:
     * @return java.lang.String
     ***********************************/
    @Override
    public String uploadVideo(MultipartFile file) {

        final String keyId = ConstantVodIInit.KEY_ID;
        final String keySecret = ConstantVodIInit.KEY_SECRET;
        try {
            //文件的原始名称 test.mp4
            String originalFileName = file.getOriginalFilename();
            //inputStream：上传文件输入流
            InputStream inputStream = file.getInputStream();
            //文件的标题 test
            String title = originalFileName.substring(0, originalFileName.lastIndexOf("."));

            UploadStreamRequest request = new UploadStreamRequest(keyId, keySecret, title, originalFileName, inputStream);
            UploadVideoImpl uploader = new UploadVideoImpl();
            UploadStreamResponse response = uploader.uploadStream(request);
        
            String videoId = response.getVideoId();  //请求视频点播服务的请求ID
            if (StringUtils.isEmpty(videoId)) {
                log.error("视频上传失败: " + response.getMessage() + "-" + response.getMessage());
                throw new CustomException(ResultCodeEnum.VIDEO_UPLOAD_ALIYUN_ERROR);
            }
            return videoId;
        } catch (IOException e) {
            e.printStackTrace();
            log.error("视频上传失败: " + e.getMessage());
        }
        return null;
    }
}