Windows环境下Docker部署YOLOv8并集成Spring Boot的完整步骤记录

docker pull ultralytics/ultralytics:latest

docker run -it --rm -v /d/yolo_test:/yolo_data ultralytics/ultralytics:latest

yolo detect predict model=yolov8n.pt source=/yolo_data/test.jpg save=True

image 1/1 /yolo_data/test.jpg: 640x480 1 cup, 1 tv, 1 mouse, 1 refrigerator, 1 book, 63.4ms
Speed: 4.6ms preprocess, 63.4ms inference, 8.6ms postprocess per image at shape (1, 3, 640, 480)
Results saved to /yolo_data/runs/detect

<!-- 新增依赖版本定义 -->
<properties>
    <commons-io.version>2.15.1</commons-io.version>
    <commons-lang3.version>3.14.0</commons-lang3.version>
</properties>

<!-- 新增依赖 -->
<dependencies>
    <!-- 文件操作工具类 -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>${commons-io.version}</version>
    </dependency>
    
    <!-- 字符串/日期工具类 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>${commons-lang3.version}</version>
    </dependency>
    
    <!-- 命令执行相关 -->
    <dependency>
        <groupId>ch.ethz.ganymed</groupId>
        <artifactId>ganymed-ssh2</artifactId>
        <version>262</version>
    </dependency>
</dependencies>

# 新增 YOLO 配置
yolo:
  # Docker 本地挂载目录（对应本地 D:\yolo_test）
  docker-mount-path: D:\yolo_test
  # 容器内挂载路径
  container-mount-path: /yolo_data
  # YOLO 模型名称（默认 yolov8n.pt）
  model-name: yolov8n.pt
  # 检测结果保存目录（容器内）
  container-result-path: /yolo_data/runs/detect
  # 本地临时文件存储目录
  local-temp-path: D:\yolo_test\temp
  # Docker 镜像名称
  docker-image: ultralytics/ultralytics:latest

# 原有配置保留，补充文件上传配置
spring:
  servlet:
    multipart:
      max-file-size: 10MB  # 单文件最大10MB
      max-request-size: 50MB  # 总请求最大50MB

package com.ruoyi.config;

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

/**
 * YOLO 配置类，读取 application.yml 中的 yolo 相关配置
 */
@Data
@Component
@ConfigurationProperties(prefix = "yolo")
public class YoloConfig {
    /**
     * Docker 本地挂载目录
     */
    private String dockerMountPath;

    /**
     * 容器内挂载路径
     */
    private String containerMountPath;

    /**
     * YOLO 模型名称
     */
    private String modelName;

    /**
     * 容器内检测结果保存路径
     */
    private String containerResultPath;

    /**
     * 本地临时文件存储目录
     */
    private String localTempPath;

    /**
     * Docker 镜像名称
     */
    private String dockerImage;
}

package com.ruoyi.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

/**
 * YOLO 检测结果返回实体，用于接口返回 JSON 格式数据
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class YoloDetectResult {
    /**
     * 检测是否成功
     */
    private boolean success;

    /**
     * 错误信息（失败时返回）
     */
    private String errorMsg;

    /**
     * 检测到的目标列表
     */
    private List<DetectObject> detectObjects;

    /**
     * 检测耗时（毫秒）
     */
    private long costTime;

    /**
     * 检测结果图片路径（本地）
     */
    private String resultImagePath;

    /**
     * 检测目标实体（单个物体的信息）
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class DetectObject {
        /**
         * 目标类别（如 cup、tv、mouse）
         */
        private String className;

        /**
         * 目标数量
         */
        private int count;

        /**
         * 置信度（0-1），越大越精准
         */
        private float confidence;
    }
}

package com.ruoyi.util;

import com.ruoyi.config.YoloConfig;
import com.ruoyi.entity.YoloDetectResult;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * YOLO 图片检测工具类，封装 Docker 命令调用、结果解析逻辑
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class YoloDetectUtil {
    private final YoloConfig yoloConfig;

    // 匹配检测结果的正则表达式（如：1 cup, 1 tv, 1 mouse）
    private static final Pattern DETECT_PATTERN = Pattern.compile("(\\d+)\\s+([a-zA-Z_]+)");

    /**
     * 上传图片并执行 YOLO 检测
     * @param file 上传的图片文件
     * @return 检测结果（包含识别的物体、耗时、结果路径）
     */
    public YoloDetectResult detectImage(MultipartFile file) {
        long startTime = System.currentTimeMillis();
        try {
            // 1. 校验文件是否为空
            if (file.isEmpty()) {
                return YoloDetectResult.builder()
                        .success(false)
                        .errorMsg("上传的图片文件为空")
                        .build();
            }

            // 2. 校验图片格式（仅支持 jpg/jpeg/png/bmp）
            String originalFilename = file.getOriginalFilename();
            if (originalFilename == null || !originalFilename.matches(".*\\.(jpg|jpeg|png|bmp)$")) {
                return YoloDetectResult.builder()
                        .success(false)
                        .errorMsg("仅支持 jpg/jpeg/png/bmp 格式的图片")
                        .build();
            }

            // 3. 创建临时目录（用于存储上传的图片）
            File tempDir = new File(yoloConfig.getLocalTempPath());
            if (!tempDir.exists()) {
                boolean mkdirs = tempDir.mkdirs();
                if (!mkdirs) {
                    log.error("创建临时目录失败：{}", yoloConfig.getLocalTempPath());
                    return YoloDetectResult.builder()
                            .success(false)
                            .errorMsg("创建临时目录失败")
                            .build();
                }
            }

            // 4. 保存上传的图片到本地挂载目录（Docker 可访问）
            String fileName = UUID.randomUUID() + "_" + originalFilename;
            String localImagePath = yoloConfig.getDockerMountPath() + File.separator + fileName;
            File localImageFile = new File(localImagePath);
            file.transferTo(localImageFile);
            log.info("上传的图片已保存到：{}", localImagePath);

            // 5. 构建 Docker 命令（调用 YOLO 检测）
            String containerImagePath = yoloConfig.getContainerMountPath() + "/" + fileName;
            String dockerCmd = String.format(
                    "docker run --rm -v %s:%s %s yolo detect predict model=%s source=%s save=True project=%s name=detect",
                    yoloConfig.getDockerMountPath().replace("\\", "/"), // Windows 路径转换为 Docker 可识别格式
                    yoloConfig.getContainerMountPath(),
                    yoloConfig.getDockerImage(),
                    yoloConfig.getModelName(),
                    containerImagePath,
                    yoloConfig.getContainerResultPath()
            );
            log.info("执行 Docker 命令：{}", dockerCmd);

            // 6. 执行 Docker 命令，获取输出结果
            Process process = Runtime.getRuntime().exec(new String[]{"cmd", "/c", dockerCmd});
            int exitCode = process.waitFor();
            if (exitCode != 0) {
                // 读取错误信息，返回失败结果
                String errorMsg = new String(process.getErrorStream().readAllBytes());
                log.error("执行 YOLO 检测失败，错误码：{}，错误信息：{}", exitCode, errorMsg);
                return YoloDetectResult.builder()
                        .success(false)
                        .errorMsg("执行检测失败：" + errorMsg)
                        .build();
            }

            // 7. 解析命令输出，提取检测到的物体信息
            String output = new String(process.getInputStream().readAllBytes());
            log.info("YOLO 检测命令输出：{}", output);
            List<YoloDetectResult.DetectObject> detectObjects = parseDetectResult(output);

            // 8. 拼接检测结果图片路径（本地可访问）
            String resultImagePath = yoloConfig.getDockerMountPath() + File.separator + "runs" + File.separator + "detect" + File.separator + "detect" + File.separator + fileName;
            long costTime = System.currentTimeMillis() - startTime;

            // 9. 返回成功结果
            return YoloDetectResult.builder()
                    .success(true)
                    .detectObjects(detectObjects)
                    .costTime(costTime)
                    .resultImagePath(resultImagePath)
                    .build();

        } catch (IOException e) {
            log.error("图片检测 IO 异常", e);
            return YoloDetectResult.builder()
                    .success(false)
                    .errorMsg("IO 异常：" + e.getMessage())
                    .build();
        } catch (InterruptedException e) {
            log.error("检测命令执行被中断", e);
            Thread.currentThread().interrupt();
            return YoloDetectResult.builder()
                    .success(false)
                    .errorMsg("检测被中断：" + e.getMessage())
                    .build();
        } catch (Exception e) {
            log.error("图片检测异常", e);
            return YoloDetectResult.builder()
                    .success(false)
                    .errorMsg("检测异常：" + e.getMessage())
                    .build();
        }
    }

    /**
     * 解析 YOLO 检测命令输出，提取目标信息（类别、数量）
     * @param output 命令输出字符串
     * @return 检测目标列表
     */
    private List<YoloDetectResult.DetectObject> parseDetectResult(String output) {
        List<YoloDetectResult.DetectObject> result = new ArrayList<>();
        if (output == null || output.isEmpty()) {
            return result;
        }

        // 匹配 "1 cup, 1 tv, 1 mouse" 格式的字符串
        Matcher matcher = DETECT_PATTERN.matcher(output);
        Map<String, Integer> countMap = new HashMap<>();

        while (matcher.find()) {
            int count = Integer.parseInt(matcher.group(1));
            String className = matcher.group(2);
            countMap.put(className, countMap.getOrDefault(className, 0) + count);
        }

        // 转换为 DetectObject 列表（置信度默认 0.9，可根据实际输出优化）
        for (Map.Entry<String, Integer> entry : countMap.entrySet()) {
            result.add(YoloDetectResult.DetectObject.builder()
                    .className(entry.getKey())
                    .count(entry.getValue())
                    .confidence(0.9f)
                    .build());
        }

        return result;
    }
}

package com.ruoyi.controller;

import com.ruoyi.entity.YoloDetectResult;
import com.ruoyi.util.YoloDetectUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

/**
 * YOLO 图片检测控制器，提供 HTTP 接口供前端调用
 */
@Slf4j
@RestController
@RequestMapping("/api/yolo")
@RequiredArgsConstructor
public class YoloController {
    private final YoloDetectUtil yoloDetectUtil;

    /**
     * 图片目标检测接口
     * @param file 上传的图片文件
     * @return 检测结果（JSON 格式）
     */
    @PostMapping("/detect")
    public ResponseEntity<YoloDetectResult> detectImage(@RequestParam("file") MultipartFile file) {
        try {
            YoloDetectResult result = yoloDetectUtil.detectImage(file);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            log.error("图片检测接口异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(YoloDetectResult.builder()
                            .success(false)
                            .errorMsg("接口异常：" + e.getMessage())
                            .build());
        }
    }
}

package com.ruoyi;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

@Slf4j
@SpringBootApplication(scanBasePackages = "com.ruoyi") // 扫描 com.ruoyi 下所有组件
@EnableConfigurationProperties
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        log.info("Spring Boot 应用启动成功，端口：8889");
    }
}

{
    "success": true,
    "errorMsg": null,
    "detectObjects": [
        {
            "className": "cup",
            "count": 1,
            "confidence": 0.9
        },
        {
            "className": "tv",
            "count": 1,
            "confidence": 0.9
        },
        {
            "className": "mouse",
            "count": 1,
            "confidence": 0.9
        }
    ],
    "costTime": 1200,
    "resultImagePath": "D:\\yolo_test\\runs\\detect\\detect\\xxx_test.jpg"
}