1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <groupId>com.nacl</groupId>
8
    <artifactId>cs</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10
<parent>
11
    <groupId>org.springframework.boot</groupId>
12
    <artifactId>spring-boot-starter-parent</artifactId>
13
    <version>2.7.2</version>
14
</parent>
15
    <properties>
16
        <maven.compiler.source>11</maven.compiler.source>
17
        <maven.compiler.target>11</maven.compiler.target>
18
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
19
        <javacv.version>1.5.4</javacv.version>
20
        <ffmpeg.version>4.3.1-1.5.4</ffmpeg.version>
21
    </properties>
22
    <dependencies>
23

24
        <dependency>
25
            <groupId>commons-lang</groupId>
26
            <artifactId>commons-lang</artifactId>
27
            <version>2.6</version>
28
        </dependency>
29

30
        <dependency>
31
            <groupId>commons-fileupload</groupId>
32
            <artifactId>commons-fileupload</artifactId>
33
            <version>1.2.2</version>
34
        </dependency>
35
        <dependency>
36
            <groupId>commons-io</groupId>
37
            <artifactId>commons-io</artifactId>
38
            <version>2.5</version>
39
        </dependency>
40

41
        <!--web 模块 -->
42
        <dependency>
43
            <groupId>org.springframework.boot</groupId>
44
            <artifactId>spring-boot-starter-web</artifactId>
45
            <exclusions>
46
                <!--排除tomcat依赖 -->
47
                <exclusion>
48
                    <artifactId>spring-boot-starter-tomcat</artifactId>
49
                    <groupId>org.springframework.boot</groupId>
50
                </exclusion>
51
            </exclusions>
52
        </dependency>
53

54
        <!--undertow容器 -->
55
        <dependency>
56
            <groupId>org.springframework.boot</groupId>
57
            <artifactId>spring-boot-starter-undertow</artifactId>
58
        </dependency>
59

60
        <dependency>
61
            <groupId>org.springframework.boot</groupId>
62
            <artifactId>spring-boot-starter-test</artifactId>
63
            <scope>test</scope>
64
        </dependency>
65

66
        <!--      javacv 和 ffmpeg的依赖包      -->
67
        <dependency>
68
            <groupId>org.bytedeco</groupId>
69
            <artifactId>javacv</artifactId>
70
            <version>${javacv.version}</version>
71
            <exclusions>
72
                <exclusion>
73
                    <groupId>org.bytedeco</groupId>
74
                    <artifactId>*</artifactId>
75
                </exclusion>
76
            </exclusions>
77
        </dependency>
78

79
        <dependency>
80
            <groupId>org.bytedeco</groupId>
81
            <artifactId>ffmpeg-platform</artifactId>
82
            <version>${ffmpeg.version}</version>
83
        </dependency>
84

85
        <dependency>
86
            <groupId>cn.hutool</groupId>
87
            <artifactId>hutool-all</artifactId>
88
            <version>5.6.5</version>
89
        </dependency>
90

91
        <dependency>
92
            <groupId>log4j</groupId>
93
            <artifactId>log4j</artifactId>
94
            <version>1.2.17</version>
95
        </dependency>
96

97
        <dependency>
98
            <groupId>org.springframework.boot</groupId>
99
            <artifactId>spring-boot-starter-test</artifactId>
100
            <scope>test</scope>
101
        </dependency>
102

103
        <dependency>
104
            <groupId>org.junit.vintage</groupId>
105
            <artifactId>junit-vintage-engine</artifactId>
106
            <scope>test</scope>
107
        </dependency>
108

109
        <dependency>
110
            <groupId>org.springframework.boot</groupId>
111
            <artifactId>spring-boot-starter-web</artifactId>
112
            <exclusions>
113
                <exclusion>
114
                    <groupId>org.springframework.boot</groupId>
115
                    <artifactId>spring-boot-starter-tomcat</artifactId>
116
                </exclusion>
117
            </exclusions>
118
        </dependency>
119

120
        <dependency>
121
            <groupId>org.springframework.boot</groupId>
122
            <artifactId>spring-boot-starter-undertow</artifactId>
123
        </dependency>
124

125
        <dependency>
126
            <groupId>commons-codec</groupId>
127
            <artifactId>commons-codec</artifactId>
128
        </dependency>
129

130
        <dependency>
131
            <groupId>com.google.code.gson</groupId>
132
            <artifactId>gson</artifactId>
133
        </dependency>
134
        <dependency>
135
            <groupId>org.projectlombok</groupId>
136
            <artifactId>lombok</artifactId>
137
        </dependency>
138
    </dependencies>
139
    <build>
140
        <finalName>${project.artifactId}</finalName>
141
        <plugins>
142
            <plugin>
143
                <groupId>org.springframework.boot</groupId>
144
                <artifactId>spring-boot-maven-plugin</artifactId>
145
                <configuration>
146
                    <executable>true</executable>
147
                </configuration>
148
            </plugin>
149
        </plugins>
150
    </build>
151
</project>

1
server:
2
  port: 8086
3

4
app:
5
  # 存储转码视频的文件夹
6
  video-folder: D:\ffmpegVedio\
7

8
spring:
9
  servlet:
10
    multipart:
11
      enabled: true
12
      # 不限制文件大小
13
      max-file-size: -1
14
      # 不限制请求体大小
15
      max-request-size: -1
16
      # 临时IO目录
17
      location: "${java.io.tmpdir}"
18
      # 不延迟解析
19
      resolve-lazily: false
20
      # 超过1Mb，就IO到临时目录
21
      file-size-threshold: 1MB
22
  web:
23
    resources:
24
      static-locations:
25
        - "classpath:/static/"
26
        - "file:${app.video-folder}" # 把视频文件夹目录，添加到静态资源目录列表

1
package com.nacl.util;
2

3
import java.util.List;
4

5
import com.google.gson.annotations.SerializedName;
6
/**
7
 * @author HAOYANG
8
 * @create 2023-07-29 10:31
9
 */
10
public class MediaInfo {
11
    public static class Format {
12
        @SerializedName("bit_rate")
13
        private String bitRate;
14
        public String getBitRate() {
15
            return bitRate;
16
        }
17
        public void setBitRate(String bitRate) {
18
            this.bitRate = bitRate;
19
        }
20
    }
21

22
    public static class Stream {
23
        @SerializedName("index")
24
        private int index;
25

26
        @SerializedName("codec_name")
27
        private String codecName;
28

29
        @SerializedName("codec_long_name")
30
        private String codecLongame;
31

32
        @SerializedName("profile")
33
        private String profile;
34
    }
35

36
    @SerializedName("streams")
37
    private List<Stream> streams;
38

39
    @SerializedName("format")
40
    private Format format;
41

42
    public List<Stream> getStreams() {
43
        return streams;
44
    }
45

46
    public void setStreams(List<Stream> streams) {
47
        this.streams = streams;
48
    }
49

50
    public Format getFormat() {
51
        return format;
52
    }
53

54
    public void setFormat(Format format) {
55
        this.format = format;
56
    }
57
}

1
package com.nacl.util;
2

3
import lombok.Data;
4
/**
5
 * @author HAOYANG
6
 * @create 2023-07-29 10:32
7
 */
8
@Data
9
public class TranscodeConfig {
10

11
    private String poster = "00:00:00.001";        // 截取封面的时间      HH:mm:ss.[SSS]
12
    private String tsSeconds = "15";      // ts分片大小，单位是秒
13
    private String cutStart;      // 视频裁剪，开始时间    HH:mm:ss.[SSS]
14
    private String cutEnd;        // 视频裁剪，结束时间    HH:mm:ss.[SSS]
15
    public String getPoster() {
16
        return poster;
17
    }
18

19
    public void setPoster(String poster) {
20
        this.poster = poster;
21
    }
22

23
    public String getTsSeconds() {
24
        return tsSeconds;
25
    }
26

27
    public void setTsSeconds(String tsSeconds) {
28
        this.tsSeconds = tsSeconds;
29
    }
30

31
    public String getCutStart() {
32
        return cutStart;
33
    }
34

35
    public void setCutStart(String cutStart) {
36
        this.cutStart = cutStart;
37
    }
38

39
    public String getCutEnd() {
40
        return cutEnd;
41
    }
42

43
    public void setCutEnd(String cutEnd) {
44
        this.cutEnd = cutEnd;
45
    }
46

47
    @Override
48
    public String toString() {
49
        return "TranscodeConfig [poster=" + poster + ", tsSeconds=" + tsSeconds + ", cutStart=" + cutStart + ", cutEnd="
50
                + cutEnd + "]";
51
    }
52
}

1
package com.nacl.util;
2

3
import java.io.BufferedReader;
4
import java.io.File;
5
import java.io.IOException;
6
import java.io.InputStreamReader;
7
import java.nio.charset.StandardCharsets;
8
import java.nio.file.Files;
9
import java.nio.file.Path;
10
import java.nio.file.Paths;
11
import java.nio.file.StandardOpenOption;
12
import java.security.NoSuchAlgorithmException;
13
import java.time.LocalDate;
14
import java.time.format.DateTimeFormatter;
15
import java.util.*;
16

17
import javax.crypto.KeyGenerator;
18

19
import org.apache.commons.codec.binary.Hex;
20
import org.slf4j.Logger;
21
import org.slf4j.LoggerFactory;
22
import org.springframework.http.HttpStatus;
23
import org.springframework.http.ResponseEntity;
24
import org.springframework.util.StringUtils;
25

26
import com.google.gson.Gson;
27
import org.springframework.web.bind.annotation.RequestPart;
28
import org.springframework.web.multipart.MultipartFile;
29
/**
30
 * @author HAOYANG
31
 * @create 2023-07-29 10:33
32
 */
33

34
public class FFmpegUtils {
35

36
    private static final Logger LOGGER = LoggerFactory.getLogger(FFmpegUtils.class);
37

38
    // 跨平台换行符
39
    private static final String LINE_SEPARATOR = System.getProperty("line.separator");
40

41
    /**
42
     * 生成随机16个字节的AESKEY
43
     * @return
44
     */
45
    private static byte[] genAesKey ()  {
46
        try {
47
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
48
            keyGenerator.init(128);
49
            return keyGenerator.generateKey().getEncoded();
50
        } catch (NoSuchAlgorithmException e) {
51
            return null;
52
        }
53
    }
54

55
    /**
56
     * 在指定的目录下生成key_info, key文件，返回key_info文件
57
     * @param folder
58
     * @throws IOException
59
     */
60
    private static Path genKeyInfo(String folder) throws IOException {
61
        // AES 密钥
62
        byte[] aesKey = genAesKey();
63
        // AES 向量
64
        String iv = Hex.encodeHexString(genAesKey());
65

66
        // key 文件写入
67
        Path keyFile = Paths.get(folder, "key");
68
        Files.write(keyFile, aesKey, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
69

70
        // key_info 文件写入
71
        StringBuilder stringBuilder = new StringBuilder();
72
        stringBuilder.append("key").append(LINE_SEPARATOR);          // m3u8加载key文件网络路径
73
        stringBuilder.append(keyFile.toString()).append(LINE_SEPARATOR);  // FFmeg加载key_info文件路径
74
        stringBuilder.append(iv);                      // ASE 向量
75

76
        Path keyInfo = Paths.get(folder, "key_info");
77

78
        Files.write(keyInfo, stringBuilder.toString().getBytes(), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
79

80
        return keyInfo;
81
    }
82

83
    /**
84
     * 指定的目录下生成 master index.m3u8 文件
85
     * @param file      master m3u8文件地址
86
     * @param indexPath      访问子index.m3u8的路径
87
     * @param bandWidth      流码率
88
     * @throws IOException
89
     */
90
    private static void genIndex(String file, String indexPath, String bandWidth) throws IOException {
91
        StringBuilder stringBuilder = new StringBuilder();
92
        stringBuilder.append("#EXTM3U").append(LINE_SEPARATOR);
93
        stringBuilder.append("#EXT-X-STREAM-INF:BANDWIDTH=" + bandWidth).append(LINE_SEPARATOR);  // 码率
94
        stringBuilder.append(indexPath);
95
        Files.write(Paths.get(file), stringBuilder.toString().getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
96
    }
97

98
    /**
99
     * 转码视频为m3u8
100
     * @param source        源视频
101
     * @param destFolder      目标文件夹
102
     * @param config        配置信息
103
     * @throws IOException
104
     * @throws InterruptedException
105
     */
106
    public static void transcodeToM3u8(String source, String destFolder, TranscodeConfig config) throws IOException, InterruptedException {
107

108
        // 判断源视频是否存在
109
        if (!Files.exists(Paths.get(source))) {
110
            throw new IllegalArgumentException("文件不存在：" + source);
111
        }
112

113
        // 创建工作目录
114
        Path workDir = Paths.get(destFolder, "ts");
115
        Files.createDirectories(workDir);
116

117
        // 在工作目录生成KeyInfo文件
118
        Path keyInfo = genKeyInfo(workDir.toString());
119

120
        // 构建命令
121
        List<String> commands = new ArrayList<>();
122
        commands.add("ffmpeg");
123
        commands.add("-i")            ;commands.add(source);          // 源文件
124
        commands.add("-c:v")          ;commands.add("libx264");        // 视频编码为H264
125
        commands.add("-c:a")          ;commands.add("copy");          // 音频直接copy
126
        commands.add("-hls_key_info_file")    ;commands.add(keyInfo.toString());    // 指定密钥文件路径
127
        commands.add("-hls_time")        ;commands.add(config.getTsSeconds());  // ts切片大小
128
        commands.add("-hls_playlist_type")    ;commands.add("vod");          // 点播模式
129
        commands.add("-hls_segment_filename")  ;commands.add("%06d.ts");        // ts切片文件名称
130

131
        if (StringUtils.hasText(config.getCutStart())) {
132
            commands.add("-ss")          ;commands.add(config.getCutStart());  // 开始时间
133
        }
134
        if (StringUtils.hasText(config.getCutEnd())) {
135
            commands.add("-to")          ;commands.add(config.getCutEnd());    // 结束时间
136
        }
137
        commands.add("index.m3u8");                            // 生成m3u8文件
138

139
        // 构建进程
140
        Process process = new ProcessBuilder()
141
                .command(commands)
142
                .directory(workDir.toFile())
143
                .start()
144
                ;
145

146
        // 读取进程标准输出
147
        new Thread(() -> {
148
            try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
149
                String line = null;
150
                while ((line = bufferedReader.readLine()) != null) {
151
                    LOGGER.info(line);
152
                }
153
            } catch (IOException e) {
154
            }
155
        }).start();
156

157
        // 读取进程异常输出
158
        new Thread(() -> {
159
            try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
160
                String line = null;
161
                while ((line = bufferedReader.readLine()) != null) {
162
                    LOGGER.info(line);
163
                }
164
            } catch (IOException e) {
165
            }
166
        }).start();
167

168

169
        // 阻塞直到任务结束
170
        if (process.waitFor() != 0) {
171
            throw new RuntimeException("视频切片异常");
172
        }
173

174
        // 切出封面
175
        if (!screenShots(source, String.join(File.separator, destFolder, "poster.jpg"), config.getPoster())) {
176
            throw new RuntimeException("封面截取异常");
177
        }
178

179
        // 获取视频信息
180
        final MediaInfo[] mediaInfo = {getMediaInfo(source)};
181
        if (mediaInfo[0] == null) {
182
            throw new RuntimeException("获取媒体信息异常");
183
        }
184

185
        // 生成index.m3u8文件
186
        genIndex(String.join(File.separator, destFolder, "index.m3u8"), "ts/index.m3u8", mediaInfo[0].getFormat().getBitRate());
187

188
        // 删除keyInfo文件
189
        Files.delete(keyInfo);
190
    }
191

192
    /**
193
     * 获取视频文件的媒体信息
194
     * @param source
195
     * @return
196
     * @throws IOException
197
     * @throws InterruptedException
198
     */
199
    public static MediaInfo getMediaInfo(String source) throws IOException, InterruptedException {
200
        List<String> commands = new ArrayList<>();
201
        commands.add("ffprobe");
202
        commands.add("-i")        ;commands.add(source);
203
        commands.add("-show_format");
204
        commands.add("-show_streams");
205
        commands.add("-print_format")  ;commands.add("json");
206

207
        Process process = new ProcessBuilder(commands)
208
                .start();
209

210
        MediaInfo mediaInfo = null;
211

212
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
213
            mediaInfo = new Gson().fromJson(bufferedReader, MediaInfo.class);
214
        } catch (IOException e) {
215
            e.printStackTrace();
216
        }
217

218
        if (process.waitFor() != 0) {
219
            return null;
220
        }
221

222
        return mediaInfo;
223
    }
224

225
    /**
226
     * 截取视频的指定时间帧，生成图片文件
227
     * @param source    源文件
228
     * @param file      图片文件
229
     * @param time      截图时间 HH:mm:ss.[SSS]
230
     * @throws IOException
231
     * @throws InterruptedException
232
     */
233
    public static boolean screenShots(String source, String file, String time) throws IOException, InterruptedException {
234

235
        List<String> commands = new ArrayList<>();
236
        commands.add("ffmpeg");
237
        commands.add("-i")        ;commands.add(source);
238
        commands.add("-ss")        ;commands.add(time);
239
        commands.add("-y");
240
        commands.add("-q:v")      ;commands.add("1");
241
        commands.add("-frames:v")    ;commands.add("1");
242
        commands.add("-f");        ;commands.add("image2");
243
        commands.add(file);
244

245
        Process process = new ProcessBuilder(commands)
246
                .start();
247

248
        // 读取进程标准输出
249
        new Thread(() -> {
250
            try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
251
                String line = null;
252
                while ((line = bufferedReader.readLine()) != null) {
253
                    LOGGER.info(line);
254
                }
255
            } catch (IOException e) {
256
            }
257
        }).start();
258

259
        // 读取进程异常输出
260
        new Thread(() -> {
261
            try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
262
                String line = null;
263
                while ((line = bufferedReader.readLine()) != null) {
264
                    LOGGER.error(line);
265
                }
266
            } catch (IOException e) {
267
            }
268
        }).start();
269

270
        return process.waitFor() == 0;
271
    }
272
}

1
package com.nacl.controller;
2

3
/**
4
 * @author HAOYANG
5
 * @create 2023-07-29 10:33
6
 */
7
import java.io.IOException;
8
import java.nio.file.Files;
9
import java.nio.file.Path;
10
import java.nio.file.Paths;
11
import java.time.LocalDate;
12
import java.time.format.DateTimeFormatter;
13
import java.util.HashMap;
14
import java.util.Map;
15
import java.util.UUID;
16

17
import lombok.extern.slf4j.Slf4j;
18
import org.slf4j.Logger;
19
import org.slf4j.LoggerFactory;
20
import org.springframework.beans.factory.annotation.Value;
21
import org.springframework.http.HttpStatus;
22
import org.springframework.http.ResponseEntity;
23
import org.springframework.web.bind.annotation.*;
24
import org.springframework.web.multipart.MultipartFile;
25
import com.nacl.util.TranscodeConfig;
26
import  com.nacl.util.FFmpegUtils;
27

28
import static com.nacl.util.FFmpegUtils.transcodeToM3u8;
29

30
@Slf4j
31
@RestController
32
@RequestMapping("/uploadController")
33
public class UploadController {
34

35
    @Value("${app.video-folder}")
36
    private String videoFolder;
37

38
    private Path tempDir = Paths.get(System.getProperty("java.io.tmpdir"));
39

40
    /**
41
     * 上传视频进行切片处理，返回访问路径
42
     * @param video
43
     * @param transcodeConfig
44
     * @return
45
     * @throws IOException
46
     */
47
    @PostMapping("/upload")
48
    @CrossOrigin
49
    public Object upload (@RequestPart(name = "file", required = true) MultipartFile video,
50
                          @RequestPart(name = "config", required = true) TranscodeConfig transcodeConfig) throws IOException {
51
        log.info("文件信息：title={}, size={}", video.getOriginalFilename(), video.getSize());
52
        log.info("转码配置：{}", transcodeConfig);
53

54
        // 原始文件名称，也就是视频的标题
55
        String title = video.getOriginalFilename();
56

57
        // io到临时文件
58
        Path tempFile = tempDir.resolve(title);
59
        log.info("io到临时文件：{}", tempFile.toString());
60

61
        try {
62
            video.transferTo(tempFile);
63

64
            // 删除后缀
65
            title = title.substring(0, title.lastIndexOf(".")) + "-" + UUID.randomUUID().toString().replaceAll("-", "");
66

67
            // 按照日期生成子目录
68
            String today = DateTimeFormatter.ofPattern("yyyyMMdd").format(LocalDate.now());
69

70
            // 尝试创建视频目录
71
            Path targetFolder = Files.createDirectories(Paths.get(videoFolder, today, title));
72

73
            log.info("创建文件夹目录：{}", targetFolder);
74
            Files.createDirectories(targetFolder);
75

76
            // 执行转码操作
77
            log.info("开始转码");
78
            try {
79
                transcodeToM3u8(tempFile.toString(), targetFolder.toString(), transcodeConfig);
80
            } catch (Exception e) {
81
                log.error("转码异常：{}", e.getMessage());
82
                Map<String, Object> result = new HashMap<>();
83
                result.put("success", false);
84
                result.put("message", e.getMessage());
85
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
86
            }
87

88
            // 封装结果
89
            Map<String, Object> videoInfo = new HashMap<>();
90
            videoInfo.put("title", title);
91
            videoInfo.put("m3u8", String.join("/", "", today, title, "index.m3u8"));
92
            videoInfo.put("poster", String.join("/", "", today, title, "poster.jpg"));
93

94
            //返回数据
95
            Map<String, Object> result = new HashMap<>();
96
            result.put("success", true);
97
            result.put("data", videoInfo);
98
            return result;
99
        } finally {
100
            // 始终删除临时文件
101
            Files.delete(tempFile);
102
        }
103
    }
104
}

1
  <parent>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-parent</artifactId>
4
    <version>2.5.4</version>
5
    <relativePath /> <!-- lookup parent from repository -->
6
  </parent>
7

8
  <properties>
9
    <java.version>1.8</java.version>
10
    <javacv.version>1.5.4</javacv.version>
11
    <ffmpeg.version>4.3.1-1.5.4</ffmpeg.version>
12
  </properties>
13

14
  <dependencies>
15

16
    <dependency>
17
      <groupId>commons-lang</groupId>
18
      <artifactId>commons-lang</artifactId>
19
      <version>2.6</version>
20
    </dependency>
21

22
    <dependency>
23
      <groupId>commons-fileupload</groupId>
24
      <artifactId>commons-fileupload</artifactId>
25
      <version>1.2.2</version>
26
    </dependency>
27
    <dependency>
28
      <groupId>commons-io</groupId>
29
      <artifactId>commons-io</artifactId>
30
      <version>2.5</version>
31
    </dependency>
32

33
    <!--web 模块 -->
34
    <dependency>
35
      <groupId>org.springframework.boot</groupId>
36
      <artifactId>spring-boot-starter-web</artifactId>
37
      <exclusions>
38
        <!--排除tomcat依赖 -->
39
        <exclusion>
40
          <artifactId>spring-boot-starter-tomcat</artifactId>
41
          <groupId>org.springframework.boot</groupId>
42
        </exclusion>
43
      </exclusions>
44
    </dependency>
45

46
    <!--undertow容器 -->
47
    <dependency>
48
      <groupId>org.springframework.boot</groupId>
49
      <artifactId>spring-boot-starter-undertow</artifactId>
50
    </dependency>
51

52
    <dependency>
53
      <groupId>org.springframework.boot</groupId>
54
      <artifactId>spring-boot-starter-test</artifactId>
55
      <scope>test</scope>
56
    </dependency>
57

58
    <!--      javacv 和 ffmpeg的依赖包      -->
59
    <dependency>
60
      <groupId>org.bytedeco</groupId>
61
      <artifactId>javacv</artifactId>
62
      <version>${javacv.version}</version>
63
      <exclusions>
64
        <exclusion>
65
          <groupId>org.bytedeco</groupId>
66
          <artifactId>*</artifactId>
67
        </exclusion>
68
      </exclusions>
69
    </dependency>
70

71
    <dependency>
72
      <groupId>org.bytedeco</groupId>
73
      <artifactId>ffmpeg-platform</artifactId>
74
      <version>${ffmpeg.version}</version>
75
    </dependency>
76

77
    <dependency>
78
      <groupId>cn.hutool</groupId>
79
      <artifactId>hutool-all</artifactId>
80
      <version>5.6.5</version>
81
    </dependency>
82

83
    <dependency>
84
      <groupId>log4j</groupId>
85
      <artifactId>log4j</artifactId>
86
      <version>1.2.17</version>
87
    </dependency>
88

89
    <dependency>
90
      <groupId>org.springframework.boot</groupId>
91
      <artifactId>spring-boot-starter-test</artifactId>
92
      <scope>test</scope>
93
    </dependency>
94

95
    <dependency>
96
      <groupId>org.junit.vintage</groupId>
97
      <artifactId>junit-vintage-engine</artifactId>
98
      <scope>test</scope>
99
    </dependency>
100

101
    <dependency>
102
      <groupId>org.springframework.boot</groupId>
103
      <artifactId>spring-boot-starter-web</artifactId>
104
      <exclusions>
105
        <exclusion>
106
          <groupId>org.springframework.boot</groupId>
107
          <artifactId>spring-boot-starter-tomcat</artifactId>
108
        </exclusion>
109
      </exclusions>
110
    </dependency>
111

112
    <dependency>
113
      <groupId>org.springframework.boot</groupId>
114
      <artifactId>spring-boot-starter-undertow</artifactId>
115
    </dependency>
116

117
    <dependency>
118
      <groupId>commons-codec</groupId>
119
      <artifactId>commons-codec</artifactId>
120
    </dependency>
121

122
    <dependency>
123
      <groupId>com.google.code.gson</groupId>
124
      <artifactId>gson</artifactId>
125
    </dependency>
126
  </dependencies>
127
  <build>
128
    <finalName>${project.artifactId}</finalName>
129
    <plugins>
130
      <plugin>
131
        <groupId>org.springframework.boot</groupId>
132
        <artifactId>spring-boot-maven-plugin</artifactId>
133
        <configuration>
134
          <executable>true</executable>
135
        </configuration>
136
      </plugin>
137
    </plugins>
138
  </build>