FireRedASR Pro Java集成开发指南：SpringBoot微服务语音处理实战

如果你是一个Java后端开发者，最近接到了要给系统加上语音识别功能的需求，比如处理用户上传的客服录音，或者分析会议纪要，那你可能正在寻找一个既稳定又好集成的方案。FireRedASR Pro作为一个高性能的语音识别服务，正好能派上用场。但怎么把它优雅地塞进你的SpringBoot微服务里，让它既能处理短语音快速响应，又能搞定长音频不超时，还能和现有的消息队列、数据库玩到一起，这里面确实有些门道。

这篇文章，我就以一个过来人的身份，跟你聊聊怎么一步步把FireRedASR Pro集成到SpringBoot项目里。我们不谈空洞的理论，直接上代码，从最简单的HTTP调用开始，到设计异步任务处理长文件，再到用消息队列做流式处理，最后打包成Docker镜像。跟着走一遍，你就能得到一个生产可用的语音处理微服务模块。

1. 项目初始化与基础依赖

首先，我们得把项目架子搭起来。这里假设你已经有SpringBoot的开发经验，我们创建一个标准的SpringBoot Web项目。

打开你的IDE或者直接用Spring Initializr，选择这些依赖：

• Spring Web：用于提供RESTful API接口。
• Spring Boot DevTools：开发工具，可选，但推荐。
• Lombok：减少样板代码，让@Data、@Slf4j这些注解来帮忙。

当然，我们还需要一些额外的库来处理HTTP请求、JSON解析和可能的gRPC通信。在pom.xml里，除了SpringBoot的starter，手动加上这些：

<dependencies>
    <!-- Spring Boot Starters -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- HTTP客户端 - 我们使用OkHttp，你也可以用RestTemplate或WebClient -->
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.12.0</version>
    </dependency>

    <!-- JSON处理 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

项目结构大概长这样：

src/main/java/com/yourcompany/asr/
├── Application.java
├── config/
├── controller/
├── service/
│   ├── impl/
│   └── AsrService.java
├── client/
│   └── FireRedAsrClient.java
├── task/
├── entity/
└── dto/

基础框架准备好后，我们来配置一下FireRedASR Pro服务的基本信息。在application.yml里加一段配置：

# FireRedASR Pro 服务配置
fire-red:
  asr:
    # HTTP API 端点 (根据你的实际部署地址修改)
    http-endpoint: http://your-firered-asr-server:8000/v1/recognize
    # gRPC 服务地址 (如果使用gRPC)
    grpc-endpoint: your-firered-asr-server:50051
    # API密钥或认证令牌 (如果需要)
    api-key: your-api-key-here
    # 默认识别语言
    default-language: zh-CN
    # 连接超时时间(毫秒)
    connect-timeout: 10000
    # 读取超时时间(毫秒)
    read-timeout: 30000

2. 构建语音识别HTTP客户端

FireRedASR Pro通常提供HTTP API，这是我们最常用的集成方式。我们来创建一个客户端，封装所有与识别服务交互的细节。

首先，定义两个简单的DTO（数据传输对象）来映射请求和响应。

// src/main/java/com/yourcompany/asr/dto/AsrRequest.java
package com.yourcompany.asr.dto;

import lombok.Data;

@Data
public class AsrRequest {
    /**
     * 音频文件的Base64编码字符串
     */
    private String audioData;
    /**
     * 音频格式，如 wav, mp3, pcm
     */
    private String audioFormat = "wav";
    /**
     * 识别语言，如 zh-CN, en-US
     */
    private String language;
    /**
     * 是否启用标点
     */
    private Boolean enablePunctuation = true;
    // 其他可能的参数，如说话人分离、热词等
}

// src/main/java/com/yourcompany/asr/dto/AsrResponse.java
package com.yourcompany.asr.dto;

import lombok.Data;
import java.util.List;

@Data
public class AsrResponse {
    /**
     * 识别状态码，0表示成功
     */
    private Integer code;
    /**
     * 状态消息
     */
    private String message;
    /**
     * 识别出的文本结果
     */
    private String text;
    /**
     * 识别置信度 (0-1)
     */
    private Double confidence;
    /**
     * 如果启用了说话人分离，这里会是分段的文本
     */
    private List<Segment> segments;
    /**
     * 处理耗时(毫秒)
     */
    private Long processTime;

    @Data
    public static class Segment {
        private String speaker;
        private String text;
        private Long startTime;
        private Long endTime;
    }
}

接下来是核心的客户端类。我们使用OkHttp，因为它简单高效。

// src/main/java/com/yourcompany/asr/client/FireRedAsrClient.java
package com.yourcompany.asr.client;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.yourcompany.asr.dto.AsrRequest;
import com.yourcompany.asr.dto.AsrResponse;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class FireRedAsrClient {

    @Value("${fire-red.asr.http-endpoint}")
    private String httpEndpoint;

    @Value("${fire-red.asr.api-key:}")
    private String apiKey;

    @Value("${fire-red.asr.connect-timeout:10000}")
    private int connectTimeout;

    @Value("${fire-red.asr.read-timeout:30000}")
    private int readTimeout;

    private OkHttpClient httpClient;
    private final ObjectMapper objectMapper = new ObjectMapper();
    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    @PostConstruct
    public void init() {
        // 初始化HTTP客户端，配置超时时间
        this.httpClient = new OkHttpClient.Builder()
                .connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
                .readTimeout(readTimeout, TimeUnit.MILLISECONDS)
                .build();
        log.info("FireRedASR HTTP客户端初始化完成，端点: {}", httpEndpoint);
    }

    /**
     * 同步识别短音频（适合60秒以内的音频）
     */
    public AsrResponse recognizeShortAudio(AsrRequest request) throws IOException {
        // 构建请求体
        String requestJson = objectMapper.writeValueAsString(request);
        RequestBody body = RequestBody.create(requestJson, JSON);

        // 构建请求
        Request.Builder requestBuilder = new Request.Builder()
                .url(httpEndpoint)
                .post(body);

        // 添加认证头（如果需要）
        if (apiKey != null && !apiKey.trim().isEmpty()) {
            requestBuilder.addHeader("Authorization", "Bearer " + apiKey);
        }

        Request httpRequest = requestBuilder.build();

        // 发送请求并处理响应
        try (Response response = httpClient.newCall(httpRequest).execute()) {
            if (!response.isSuccessful()) {
                log.error("ASR请求失败，状态码: {}, 消息: {}", response.code(), response.message());
                throw new IOException("ASR服务请求失败: " + response.code());
            }

            String responseBody = response.body().string();
            return objectMapper.readValue(responseBody, AsrResponse.class);
        } catch (IOException e) {
            log.error("调用ASR服务时发生IO异常", e);
            throw e;
        }
    }

    /**
     * 一个更简单的工具方法：直接传入Base64音频数据和语言
     */
    public String recognizeSimple(String audioBase64, String language) {
        try {
            AsrRequest request = new AsrRequest();
            request.setAudioData(audioBase64);
            request.setLanguage(language);
            request.setAudioFormat("wav"); // 假设是wav格式

            AsrResponse response = recognizeShortAudio(request);
            if (response != null && response.getCode() == 0) {
                return response.getText();
            } else {
                log.warn("识别失败，响应: {}", response);
                return null;
            }
        } catch (Exception e) {
            log.error("语音识别异常", e);
            return null;
        }
    }
}

这个客户端类做了几件事：读取配置、初始化HTTP连接池、封装请求/响应的序列化与反序列化，并提供了一个简单的同步调用方法。对于短音频（比如一分钟以内的语音消息），这种方式直接又高效。

3. 设计异步任务处理长音频

现实场景中，你遇到的更多是长达半小时的会议录音或者一小时的访谈音频。让HTTP请求同步等待这么长时间是不现实的，会超时，也会阻塞服务线程。所以，我们必须引入异步任务机制。

Spring Boot提供了@Async注解，可以很方便地实现异步方法调用。我们先来配置一个异步任务执行器。

// src/main/java/com/yourcompany/asr/config/AsyncConfig.java
package com.yourcompany.asr.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean(name = "asrTaskExecutor")
    public Executor asrTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数，即使空闲也保留的线程数
        executor.setCorePoolSize(5);
        // 最大线程数
        executor.setMaxPoolSize(20);
        // 队列容量
        executor.setQueueCapacity(100);
        // 线程名前缀
        executor.setThreadNamePrefix("AsrAsync-");
        // 当队列满时，调用者线程直接执行该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

接下来，我们需要一个地方来存储和管理这些异步任务的状态和结果。简单起见，我们可以用一个内存中的ConcurrentHashMap，但对于生产环境，你肯定需要用到数据库（比如MySQL）或者分布式缓存（比如Redis）。这里我们先展示内存版本，并给出数据库版本的思路。

首先，定义一个任务状态枚举和实体。

// src/main/java/com/yourcompany/asr/entity/AsrTask.java
package com.yourcompany.asr.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class AsrTask {
    /**
     * 任务ID
     */
    private String taskId;
    /**
     * 任务状态
     */
    private TaskStatus status;
    /**
     * 提交的音频文件标识（如OSS的URL或文件路径）
     */
    private String audioSource;
    /**
     * 识别结果文本
     */
    private String resultText;
    /**
     * 错误信息
     */
    private String errorMsg;
    /**
     * 任务创建时间
     */
    private LocalDateTime createTime;
    /**
     * 任务完成时间
     */
    private LocalDateTime finishTime;

    public enum TaskStatus {
        PENDING,   // 等待中
        PROCESSING, // 处理中
        SUCCESS,   // 成功
        FAILED     // 失败
    }
}

然后，创建服务层。这个服务负责提交任务、查询任务状态，并包含真正的异步识别逻辑。

// src/main/java/com/yourcompany/asr/service/AsrService.java
package com.yourcompany.asr.service;

import com.yourcompany.asr.entity.AsrTask;

public interface AsrService {
    /**
     * 提交一个长音频识别任务（异步）
     */
    String submitLongAudioTask(String audioUrl, String language);
    /**
     * 查询任务状态和结果
     */
    AsrTask getTaskStatus(String taskId);
}

// src/main/java/com/yourcompany/asr/service/impl/AsrServiceImpl.java
package com.yourcompany.asr.service.impl;

import com.yourcompany.asr.client.FireRedAsrClient;
import com.yourcompany.asr.dto.AsrRequest;
import com.yourcompany.asr.dto.AsrResponse;
import com.yourcompany.asr.entity.AsrTask;
import com.yourcompany.asr.service.AsrService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Service
public class AsrServiceImpl implements AsrService {

    @Autowired
    private FireRedAsrClient asrClient;

    // 内存存储任务信息（生产环境请替换为数据库）
    private final Map<String, AsrTask> taskStore = new ConcurrentHashMap<>();

    @PostConstruct
    public void init() {
        log.info("ASR服务初始化完成，使用异步任务处理长音频。");
    }

    @Override
    public String submitLongAudioTask(String audioUrl, String language) {
        // 生成唯一任务ID
        String taskId = "ASR_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);
        AsrTask task = new AsrTask();
        task.setTaskId(taskId);
        task.setAudioSource(audioUrl);
        task.setStatus(AsrTask.TaskStatus.PENDING);
        task.setCreateTime(LocalDateTime.now());

        // 存储任务
        taskStore.put(taskId, task);
        log.info("提交长音频识别任务，ID: {}, 音频: {}", taskId, audioUrl);

        // 触发异步处理
        processAudioAsync(taskId, audioUrl, language);

        return taskId;
    }

    /**
     * 核心的异步处理方法
     * 使用自定义的线程池执行器
     */
    @Async("asrTaskExecutor")
    public void processAudioAsync(String taskId, String audioUrl, String language) {
        AsrTask task = taskStore.get(taskId);
        if (task == null) {
            log.error("任务不存在: {}", taskId);
            return;
        }

        task.setStatus(AsrTask.TaskStatus.PROCESSING);
        log.info("开始处理长音频任务: {}", taskId);

        try {
            // 1. 从 audioUrl 下载音频文件（这里需要你实现下载逻辑）
            // byte[] audioBytes = downloadAudio(audioUrl);
            // 2. 将音频转为Base64（如果是文件流，可能需要分片或使用其他API）
            // String audioBase64 = Base64.getEncoder().encodeToString(audioBytes);
            // 3. 调用ASR服务
            // AsrRequest request = new AsrRequest();
            // request.setAudioData(audioBase64);
            // request.setLanguage(language);
            // AsrResponse response = asrClient.recognizeShortAudio(request);

            // 模拟一个长时间处理过程
            Thread.sleep(10000); // 模拟10秒处理时间
            AsrResponse mockResponse = new AsrResponse();
            mockResponse.setCode(0);
            mockResponse.setText("这是模拟识别出的长音频文本内容。音频来自: " + audioUrl);

            // 4. 更新任务结果
            task.setResultText(mockResponse.getText());
            task.setStatus(AsrTask.TaskStatus.SUCCESS);
            task.setFinishTime(LocalDateTime.now());
            log.info("长音频任务处理成功: {}", taskId);

        } catch (Exception e) {
            log.error("处理长音频任务失败: {}", taskId, e);
            task.setStatus(AsrTask.TaskStatus.FAILED);
            task.setErrorMsg(e.getMessage());
            task.setFinishTime(LocalDateTime.now());
        }
    }

    @Override
    public AsrTask getTaskStatus(String taskId) {
        return taskStore.get(taskId);
    }

    // 生产环境需要实现的方法
    // private byte[] downloadAudio(String url) { ... }
}

最后，我们提供一个简单的REST API控制器，让外部可以提交任务和查询结果。

// src/main/java/com/yourcompany/asr/controller/AsrController.java
package com.yourcompany.asr.controller;

import com.yourcompany.asr.dto.AsrRequest;
import com.yourcompany.asr.dto.AsrResponse;
import com.yourcompany.asr.entity.AsrTask;
import com.yourcompany.asr.service.AsrService;
import com.yourcompany.asr.client.FireRedAsrClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.io.IOException;

@Slf4j
@RestController
@RequestMapping("/api/asr")
public class AsrController {

    @Autowired
    private FireRedAsrClient asrClient;
    @Autowired
    private AsrService asrService;

    /**
     * 同步识别接口（适合短音频）
     */
    @PostMapping("/recognize")
    public AsrResponse recognize(@RequestBody AsrRequest request) {
        log.info("收到同步识别请求，格式: {}, 语言: {}", request.getAudioFormat(), request.getLanguage());
        try {
            return asrClient.recognizeShortAudio(request);
        } catch (IOException e) {
            AsrResponse errorResp = new AsrResponse();
            errorResp.setCode(500);
            errorResp.setMessage("识别服务调用失败: " + e.getMessage());
            return errorResp;
        }
    }

    /**
     * 提交长音频异步识别任务
     */
    @PostMapping("/task/submit")
    public String submitTask(@RequestParam String audioUrl,
                             @RequestParam(defaultValue = "zh-CN") String language) {
        log.info("提交异步识别任务，音频URL: {}", audioUrl);
        return asrService.submitLongAudioTask(audioUrl, language);
    }

    /**
     * 查询异步任务状态
     */
    @GetMapping("/task/status/{taskId}")
    public AsrTask getTaskStatus(@PathVariable String taskId) {
        return asrService.getTaskStatus(taskId);
    }
}

这样，一个支持同步短音频识别和异步长音频任务处理的微服务骨架就搭好了。用户上传长音频后，立即得到一个任务ID，然后可以通过轮询这个ID来获取识别结果。

4. 集成消息队列实现流式处理

当语音识别的量上来之后，比如来自多个客服渠道的实时语音流，单纯的HTTP请求和内存队列可能就不够用了。这时，引入消息队列（比如Kafka）来做解耦和缓冲是个好主意。架构会变成这样：语音流先被推送到Kafka，然后我们的识别服务作为消费者从Kafka拉取任务进行处理，再把结果写回另一个结果主题。

首先，在pom.xml中加入Kafka的依赖。

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

在application.yml中配置Kafka。

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: asr-service-group
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

# 自定义主题
asr:
  kafka:
    topic:
      audio-input: asr.audio.input
      result-output: asr.result.output

然后，我们创建一个Kafka消费者服务，监听音频输入主题。

// src/main/java/com/yourcompany/asr/service/impl/KafkaAsrConsumerService.java
package com.yourcompany.asr.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.yourcompany.asr.client.FireRedAsrClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import java.util.Map;

@Slf4j
@Service
public class KafkaAsrConsumerService {

    @Autowired
    private FireRedAsrClient asrClient;
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    @Autowired
    private ObjectMapper objectMapper;

    @Value("${asr.kafka.topic.result-output}")
    private String resultTopic;

    /**
     * 监听音频输入主题，进行识别处理
     */
    @KafkaListener(topics = "${asr.kafka.topic.audio-input}")
    public void consumeAudioMessage(ConsumerRecord<String, String> record) {
        String messageKey = record.key();
        String messageValue = record.value();
        log.info("收到音频处理消息，Key: {}, Partition: {}", messageKey, record.partition());

        try {
            // 解析消息，假设消息体是JSON，包含audioData和language
            Map<String, String> audioMsg = objectMapper.readValue(messageValue, Map.class);
            String audioBase64 = audioMsg.get("audioData");
            String language = audioMsg.getOrDefault("language", "zh-CN");

            // 调用识别服务
            String recognizedText = asrClient.recognizeSimple(audioBase64, language);

            // 构建结果消息
            Map<String, Object> resultMsg = Map.of(
                    "messageId", messageKey,
                    "status", "SUCCESS",
                    "recognizedText", recognizedText,
                    "timestamp", System.currentTimeMillis()
            );
            String resultJson = objectMapper.writeValueAsString(resultMsg);

            // 将识别结果发送到结果主题
            kafkaTemplate.send(resultTopic, messageKey, resultJson);
            log.info("语音识别完成，结果已发送。消息Key: {}", messageKey);

        } catch (Exception e) {
            log.error("处理Kafka音频消息失败: {}", messageKey, e);
            // 可以发送一个错误状态的结果消息
            Map<String, Object> errorMsg = Map.of(
                    "messageId", messageKey,
                    "status", "FAILED",
                    "error", e.getMessage()
            );
            try {
                kafkaTemplate.send(resultTopic, messageKey, objectMapper.writeValueAsString(errorMsg));
            } catch (Exception ex) {
                log.error("发送错误结果消息失败", ex);
            }
        }
    }
}

同时，你也可以提供一个生产者控制器，接收HTTP请求并将任务发布到Kafka。

// src/main/java/com/yourcompany/asr/controller/AsrStreamController.java
package com.yourcompany.asr.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
import java.util.UUID;

@Slf4j
@RestController
@RequestMapping("/api/asr/stream")
public class AsrStreamController {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    @Autowired
    private ObjectMapper objectMapper;

    @Value("${asr.kafka.topic.audio-input}")
    private String audioInputTopic;

    @PostMapping("/submit")
    public String submitToStream(@RequestBody Map<String, Object> request) {
        String messageId = "MSG_" + UUID.randomUUID().toString().substring(0, 8);
        try {
            String messageJson = objectMapper.writeValueAsString(request);
            // 发送到Kafka主题
            kafkaTemplate.send(audioInputTopic, messageId, messageJson).get(); // 使用get()确保发送成功
            log.info("语音识别任务已提交至消息队列，MessageId: {}", messageId);
            return messageId;
        } catch (Exception e) {
            log.error("提交任务到消息队列失败", e);
            return "error: " + e.getMessage();
        }
    }
}

这样一来，你的服务就具备了流式处理能力，能够应对更高的并发和更稳定的任务处理流程。

5. 容器化部署与配置

最后，我们来谈谈怎么把这个服务部署出去。Docker是目前最流行的方式。首先，在项目根目录创建一个Dockerfile。

# 使用官方的OpenJDK 11作为基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 将Maven构建好的jar包复制到容器中
# 假设你的jar包名为 asr-service-0.0.1-SNAPSHOT.jar
COPY target/asr-service-0.0.1-SNAPSHOT.jar app.jar

# 暴露端口（Spring Boot默认8080）
EXPOSE 8080

# 设置JVM参数，例如堆内存大小
ENV JAVA_OPTS="-Xms512m -Xmx1024m -Dspring.profiles.active=prod"

# 启动应用
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

然后，我们可以用一个docker-compose.yml文件来定义服务以及它可能依赖的组件，比如Kafka。这特别适合本地开发测试。

version: '3.8'
services:
  # 我们的ASR微服务
  asr-service:
    build: .
    container_name: asr-service
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - FIRE_RED_ASR_HTTP_ENDPOINT=http://host.docker.internal:8000/v1/recognize # 假设ASR服务在宿主机
      - SPRING_KAFKA_BOOTSTRAP_SERVERS=kafka:9092
    depends_on:
      - kafka
    networks:
      - asr-network

  # Zookeeper (Kafka依赖)
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - "22181:2181"
    networks:
      - asr-network

  # Kafka
  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    networks:
      - asr-network

networks:
  asr-network:
    driver: bridge

你需要一个对应docker环境的配置文件application-docker.yml。

# application-docker.yml
fire-red:
  asr:
    http-endpoint: ${FIRE_RED_ASR_HTTP_ENDPOINT:http://localhost:8000/v1/recognize}

spring:
  kafka:
    bootstrap-servers: ${SPRING_KAFKA_BOOTSTRAP_SERVERS:localhost:9092}
    consumer:
      group-id: asr-service-docker-group

现在，只需要几条命令就能让整个服务栈跑起来：

# 1. 打包项目
mvn clean package -DskipTests

# 2. 构建Docker镜像
docker-compose build

# 3. 启动所有服务
docker-compose up -d

你的语音识别微服务就会在http://localhost:8080上运行，并连接到Kafka等待处理任务了。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。