AudioLDM-S一键部署教程：Java开发者快速入门指南

胡匪

146人浏览 · 2026-02-23 00:15:45

胡匪 · 2026-02-23 00:15:45 发布

AudioLDM-S一键部署教程：Java开发者快速入门指南

你是不是也遇到过这样的场景：项目里需要一个特定的音效，比如“森林里的雨声”或者“科幻设备的嗡鸣”，但翻遍素材库也找不到合适的，自己录制又太麻烦？或者，你的应用需要根据用户输入实时生成语音播报，但传统的TTS方案听起来太机械，不够自然？

如果你是个Java开发者，可能还会觉得这类AI音频生成技术离自己有点远——是不是得懂Python、会调PyTorch、还得折腾GPU环境？其实没那么复杂。今天我就带你用最熟悉的Java技术栈，快速把AudioLDM-S这个强大的音效生成模型集成到你的项目里。

AudioLDM-S是个挺有意思的模型，它能把一段文字描述直接变成对应的音频。你告诉它“海浪拍打礁石的声音”，它就能生成一段逼真的环境音效；你说“欢快的电子游戏背景音乐”，它也能给你创作出来。而且这个模型对硬件要求不高，甚至用消费级显卡就能跑起来。

下面我就手把手带你走一遍完整的流程：从环境准备、镜像部署，到用Java代码调用API生成音频，最后还会给一个SpringBoot的集成示例。整个过程就像搭积木一样简单，咱们一步步来。

1. 环境准备：Java开发者的舒适区

在开始之前，我们先看看需要准备些什么。放心，都是Java开发者熟悉的东西。

1.1 基础环境要求

首先，你需要一个能运行Docker的环境。AudioLDM-S已经打包成了Docker镜像，这让我们省去了配置Python环境、安装依赖的麻烦。如果你的开发机是Windows，建议用WSL2；如果是Mac或Linux，直接用原生的Docker就行。

硬件方面，AudioLDM-S对显卡的要求比较友好。根据我实际测试的经验，GTX 1650或者RTX 3050这样的消费级显卡就能流畅运行。当然，如果你有更好的显卡，生成速度会更快。内存建议8GB以上，毕竟模型本身和生成过程都需要一定的内存空间。

软件方面，你需要安装：

Docker Desktop（或者Docker Engine）
Java 11或更高版本（咱们Java开发者肯定已经有了）
Maven或Gradle（看你习惯用哪个）
一个顺手的IDE，比如IntelliJ IDEA或Eclipse

1.2 快速检查环境

在终端里运行下面几个命令，确认环境都准备好了：

# 检查Docker是否安装成功
docker --version

# 检查Java版本
java -version

# 检查Maven（如果用Maven的话）
mvn -version

如果都能正常输出版本信息，说明基础环境没问题。接下来咱们进入正题，开始部署AudioLDM-S。

2. 一键部署AudioLDM-S镜像

这是整个流程里最简单的一步。AudioLDM-S的镜像已经在CSDN星图平台上线了，我们直接用Docker拉取运行就行。

2.1 拉取并运行镜像

打开终端，执行下面这条命令：

docker run -d \
  --name audioldm-s \
  -p 7860:7860 \
  --gpus all \
  registry.cn-hangzhou.aliyuncs.com/csdn_mirror/audioldm-s:latest

我来解释一下这个命令的各个部分：

docker run -d：在后台运行容器
--name audioldm-s：给容器起个名字，方便后面管理
-p 7860:7860：把容器的7860端口映射到主机的7860端口，这样我们就能通过本地地址访问了
--gpus all：让容器能使用所有可用的GPU（如果你没有GPU，可以去掉这个参数，但生成速度会慢很多）
最后是镜像地址，这是CSDN星图平台提供的预置镜像

执行命令后，Docker会自动下载镜像并启动容器。第一次运行需要下载镜像，可能会花几分钟时间，取决于你的网速。下载完成后，容器就会在后台运行起来。

2.2 验证部署是否成功

等容器启动后，我们可以检查一下运行状态：

# 查看容器是否在运行
docker ps | grep audioldm-s

# 查看容器日志，确认服务正常启动
docker logs audioldm-s

如果看到日志里有类似“Running on local URL: http://0.0.0.0:7860”的信息，说明服务已经启动成功了。

现在打开浏览器，访问 http://localhost:7860，你应该能看到AudioLDM-S的Web界面。这个界面是Gradio搭建的，你可以直接在页面上输入文字描述，点击生成按钮，就能实时听到生成的音频了。

不过，作为Java开发者，我们更关心的是如何用代码来调用这个服务。别急，接下来就教你如何通过API来操作。

3. 通过API调用生成音频

AudioLDM-S的Web界面背后，其实是一个HTTP API服务。我们可以用任何能发送HTTP请求的客户端来调用它，对于Java来说，用HttpClient或者RestTemplate都很方便。

3.1 了解API接口

首先，我们看看AudioLDM-S提供了哪些API端点。通过查看容器日志或者访问 http://localhost:7860/docs（如果支持的话），可以找到API文档。不过根据我的经验，AudioLDM-S通常提供以下几个主要接口：

文本生成音频：把文字描述转换成音频
音频风格转换：给现有音频换个风格
音频超分辨率：提升音频质量

今天我们先聚焦在最常用的文本生成音频功能上。这个接口通常接收一个JSON请求，包含文字描述和一些可选参数，然后返回生成的音频文件。

3.2 第一个Java API调用示例

我们来写一个简单的Java程序，调用AudioLDM-S生成一段音频。这里我用Java 11的HttpClient，因为它是标准库自带的，不需要额外依赖。

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;

public class AudioLDMClient {
    private static final String API_URL = "http://localhost:7860/api/generate";
    
    public static void main(String[] args) throws Exception {
        // 创建HTTP客户端
        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(30))
                .build();
        
        // 准备请求体：一段描述音效的文字
        String requestBody = """
            {
                "prompt": "海浪轻轻拍打沙滩的声音，远处有海鸥鸣叫",
                "duration": 10,
                "guidance_scale": 3.5,
                "num_inference_steps": 200
            }
            """;
        
        // 创建HTTP请求
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();
        
        // 发送请求并获取响应
        HttpResponse<byte[]> response = client.send(
                request, 
                HttpResponse.BodyHandlers.ofByteArray()
        );
        
        // 检查响应状态
        if (response.statusCode() == 200) {
            // 保存生成的音频文件
            Path outputPath = Path.of("generated_audio.wav");
            Files.write(outputPath, response.body());
            System.out.println("音频生成成功，已保存到: " + outputPath.toAbsolutePath());
        } else {
            System.out.println("请求失败，状态码: " + response.statusCode());
            System.out.println("响应内容: " + new String(response.body()));
        }
    }
}

这个示例里，我们向AudioLDM-S发送了一个JSON请求，描述想要生成的音效。参数说明：

prompt：文字描述，越详细越好
duration：音频时长（秒），建议5-30秒
guidance_scale：引导系数，控制生成内容与描述的贴合程度，一般3-5之间
num_inference_steps：推理步数，影响生成质量，200左右效果就不错了

运行这个程序，如果一切正常，你会在当前目录下得到一个generated_audio.wav文件，双击播放就能听到AI生成的海浪声了。

3.3 处理更复杂的场景

实际项目中，我们可能需要处理更复杂的情况，比如批量生成、错误重试、进度监控等。下面我写一个更健壮的版本：

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class AdvancedAudioLDMClient {
    private final HttpClient client;
    private final String baseUrl;
    private final ScheduledExecutorService scheduler;
    
    public AdvancedAudioLDMClient(String baseUrl) {
        this.baseUrl = baseUrl;
        this.client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(30))
                .executor(Executors.newFixedThreadPool(4))
                .build();
        this.scheduler = Executors.newScheduledThreadPool(2);
    }
    
    public CompletableFuture<Path> generateAudioAsync(
            String prompt, 
            int duration,
            Path outputPath
    ) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                String requestBody = String.format("""
                    {
                        "prompt": "%s",
                        "duration": %d,
                        "guidance_scale": 3.5,
                        "num_inference_steps": 200
                    }
                    """, prompt, duration);
                
                HttpRequest request = HttpRequest.newBuilder()
                        .uri(URI.create(baseUrl + "/api/generate"))
                        .header("Content-Type", "application/json")
                        .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                        .build();
                
                // 带重试机制的请求
                HttpResponse<byte[]> response = sendWithRetry(request, 3);
                
                if (response.statusCode() == 200) {
                    Files.write(outputPath, response.body());
                    return outputPath;
                } else {
                    throw new IOException("API请求失败，状态码: " + response.statusCode());
                }
            } catch (Exception e) {
                throw new RuntimeException("生成音频失败: " + e.getMessage(), e);
            }
        });
    }
    
    private HttpResponse<byte[]> sendWithRetry(HttpRequest request, int maxRetries) 
            throws IOException, InterruptedException {
        IOException lastException = null;
        
        for (int i = 0; i < maxRetries; i++) {
            try {
                return client.send(request, HttpResponse.BodyHandlers.ofByteArray());
            } catch (IOException e) {
                lastException = e;
                if (i < maxRetries - 1) {
                    System.out.println("请求失败，第" + (i + 1) + "次重试...");
                    Thread.sleep(1000 * (i + 1)); // 指数退避
                }
            }
        }
        
        throw lastException;
    }
    
    public void shutdown() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    
    // 使用示例
    public static void main(String[] args) throws Exception {
        AdvancedAudioLDMClient client = new AdvancedAudioLDMClient("http://localhost:7860");
        
        // 异步生成多个音频
        CompletableFuture<Path> future1 = client.generateAudioAsync(
                "森林里的鸟鸣声，清晨的氛围",
                8,
                Path.of("forest_birds.wav")
        );
        
        CompletableFuture<Path> future2 = client.generateAudioAsync(
                "咖啡馆背景音，轻柔的爵士乐，人们的低语",
                15,
                Path.of("coffee_shop.wav")
        );
        
        // 等待所有任务完成
        CompletableFuture.allOf(future1, future2).join();
        
        System.out.println("所有音频生成完成！");
        client.shutdown();
    }
}

这个进阶版本增加了异步处理、错误重试和线程池管理，更适合在生产环境中使用。你可以根据实际需求调整线程池大小、重试策略等参数。

4. SpringBoot集成实战

在实际的Java项目中，我们通常会用SpringBoot来构建服务。下面我展示如何把AudioLDM-S集成到SpringBoot应用里，做成一个可用的音效生成服务。

4.1 创建SpringBoot项目

首先，用你习惯的方式创建一个SpringBoot项目。如果你用Spring Initializr，可以选择：

Spring Boot 2.7+ 或 3.0+
Web依赖（Spring Web）
可能还需要Validation、Configuration Processor等

或者直接用Maven命令：

<!-- pom.xml 关键依赖 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

4.2 定义请求和响应对象

我们先定义一些DTO（数据传输对象）来规范API的输入输出：

import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Min;
import javax.validation.constraints.Max;

@Data
public class AudioGenerationRequest {
    @NotBlank(message = "描述不能为空")
    private String prompt;
    
    @NotNull(message = "时长不能为空")
    @Min(value = 1, message = "时长至少1秒")
    @Max(value = 30, message = "时长最多30秒")
    private Integer duration;
    
    @Min(value = 1, message = "引导系数至少为1")
    @Max(value = 10, message = "引导系数最多为10")
    private Float guidanceScale = 3.5f;
    
    @Min(value = 50, message = "推理步数至少50")
    @Max(value = 500, message = "推理步数最多500")
    private Integer numInferenceSteps = 200;
}

@Data
public class AudioGenerationResponse {
    private boolean success;
    private String message;
    private String audioUrl;
    private String audioId;
    private Long fileSize;
}

4.3 实现服务层

接下来实现核心的服务类，负责调用AudioLDM-S的API：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.ResourceAccessException;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.UUID;

@Service
public class AudioGenerationService {
    
    @Value("${audioldm.api.url:http://localhost:7860/api/generate}")
    private String apiUrl;
    
    @Value("${audioldm.output.dir:./generated-audio}")
    private String outputDir;
    
    private final RestTemplate restTemplate;
    
    public AudioGenerationService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public AudioGenerationResponse generateAudio(AudioGenerationRequest request) {
        try {
            // 准备请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            
            // 构建请求体
            String requestBody = buildRequestBody(request);
            HttpEntity<String> entity = new HttpEntity<>(requestBody, headers);
            
            // 发送请求到AudioLDM-S
            ResponseEntity<byte[]> response = restTemplate.postForEntity(
                    apiUrl, 
                    entity, 
                    byte[].class
            );
            
            if (response.getStatusCode().is2xxSuccessful() && response.getBody() != null) {
                // 保存音频文件
                String audioId = UUID.randomUUID().toString();
                Path outputPath = saveAudioFile(audioId, response.getBody());
                
                // 构建响应
                AudioGenerationResponse result = new AudioGenerationResponse();
                result.setSuccess(true);
                result.setMessage("音频生成成功");
                result.setAudioId(audioId);
                result.setAudioUrl("/audio/" + audioId);
                result.setFileSize(Files.size(outputPath));
                
                return result;
            } else {
                throw new RuntimeException("AudioLDM-S API返回错误状态: " + response.getStatusCode());
            }
            
        } catch (HttpClientErrorException e) {
            throw new RuntimeException("API请求错误: " + e.getStatusCode() + " - " + e.getResponseBodyAsString(), e);
        } catch (ResourceAccessException e) {
            throw new RuntimeException("无法连接到AudioLDM-S服务，请检查服务是否启动", e);
        } catch (IOException e) {
            throw new RuntimeException("保存音频文件失败", e);
        }
    }
    
    private String buildRequestBody(AudioGenerationRequest request) {
        return String.format("""
            {
                "prompt": "%s",
                "duration": %d,
                "guidance_scale": %.1f,
                "num_inference_steps": %d
            }
            """, 
            request.getPrompt().replace("\"", "\\\""),
            request.getDuration(),
            request.getGuidanceScale(),
            request.getNumInferenceSteps()
        );
    }
    
    private Path saveAudioFile(String audioId, byte[] audioData) throws IOException {
        // 确保输出目录存在
        Path outputPath = Paths.get(outputDir);
        if (!Files.exists(outputPath)) {
            Files.createDirectories(outputPath);
        }
        
        // 保存文件
        Path filePath = outputPath.resolve(audioId + ".wav");
        Files.write(filePath, audioData);
        
        return filePath;
    }
    
    public byte[] getAudioFile(String audioId) throws IOException {
        Path filePath = Paths.get(outputDir, audioId + ".wav");
        if (Files.exists(filePath)) {
            return Files.readAllBytes(filePath);
        }
        throw new IOException("音频文件不存在: " + audioId);
    }
}

4.4 创建控制器

最后，我们创建一个REST控制器来暴露API：

import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.io.IOException;

@RestController
@RequestMapping("/api/audio")
@Validated
public class AudioController {
    
    private final AudioGenerationService audioService;
    
    public AudioController(AudioGenerationService audioService) {
        this.audioService = audioService;
    }
    
    @PostMapping("/generate")
    public ResponseEntity<AudioGenerationResponse> generateAudio(
            @Valid @RequestBody AudioGenerationRequest request
    ) {
        AudioGenerationResponse response = audioService.generateAudio(request);
        return ResponseEntity.ok(response);
    }
    
    @GetMapping("/{audioId}")
    public ResponseEntity<Resource> getAudio(@PathVariable String audioId) {
        try {
            byte[] audioData = audioService.getAudioFile(audioId);
            ByteArrayResource resource = new ByteArrayResource(audioData);
            
            return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, 
                            "attachment; filename=\"" + audioId + ".wav\"")
                    .contentType(MediaType.parseMediaType("audio/wav"))
                    .contentLength(audioData.length)
                    .body(resource);
            
        } catch (IOException e) {
            return ResponseEntity.notFound().build();
        }
    }
    
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<AudioGenerationResponse> handleException(RuntimeException e) {
        AudioGenerationResponse response = new AudioGenerationResponse();
        response.setSuccess(false);
        response.setMessage(e.getMessage());
        return ResponseEntity.badRequest().body(response);
    }
}

4.5 配置RestTemplate和属性

在配置类中配置RestTemplate，并添加一些应用属性：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import java.time.Duration;

@Configuration
public class AppConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

在application.yml或application.properties中添加配置：

# application.yml
server:
  port: 8080

audioldm:
  api:
    url: http://localhost:7860/api/generate
  output:
    dir: ./generated-audio

spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB

4.6 运行和测试

现在，启动你的SpringBoot应用：

mvn spring-boot:run

应用启动后，你可以用curl或者Postman测试API：

# 生成音频
curl -X POST http://localhost:8080/api/audio/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "下雨的声音，雨滴打在窗户上",
    "duration": 10,
    "guidanceScale": 3.5,
    "numInferenceSteps": 200
  }'

# 响应示例
# {
#   "success": true,
#   "message": "音频生成成功",
#   "audioUrl": "/audio/123e4567-e89b-12d3-a456-426614174000",
#   "audioId": "123e4567-e89b-12d3-a456-426614174000",
#   "fileSize": 882000
# }

# 下载音频
curl -O http://localhost:8080/api/audio/123e4567-e89b-12d3-a456-426614174000

5. 实际应用中的优化建议

在实际项目中使用AudioLDM-S时，有几个地方可以优化，让系统更稳定、更高效。

5.1 连接池和超时设置

AudioLDM-S生成音频可能需要几秒到几十秒的时间，所以HTTP连接的超时设置很重要。我们可以定制RestTemplate的配置：

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import okhttp3.OkHttpClient;
import java.util.concurrent.TimeUnit;

@Configuration
public class RestTemplateConfig {
    
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(30, TimeUnit.SECONDS)
                .readTimeout(120, TimeUnit.SECONDS)  // 音频生成可能较慢
                .writeTimeout(30, TimeUnit.SECONDS)
                .connectionPool(new ConnectionPool(20, 5, TimeUnit.MINUTES))
                .build();
        
        return builder
                .requestFactory(() -> new OkHttp3ClientHttpRequestFactory(okHttpClient))
                .build();
    }
}

5.2 异步处理和队列

如果并发请求较多，可以考虑用异步处理和消息队列：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncAudioService {
    
    private final AudioGenerationService audioService;
    
    public AsyncAudioService(AudioGenerationService audioService) {
        this.audioService = audioService;
    }
    
    @Async("taskExecutor")
    public CompletableFuture<AudioGenerationResponse> generateAudioAsync(
            AudioGenerationRequest request
    ) {
        return CompletableFuture.completedFuture(
                audioService.generateAudio(request)
        );
    }
}

// 配置线程池
@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean("taskExecutor")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("audio-gen-");
        executor.initialize();
        return executor;
    }
}

5.3 缓存和限流

为了提升性能和防止滥用，可以添加缓存和限流：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CacheConfig;

@Service
@CacheConfig(cacheNames = "audioCache")
public class CachedAudioService {
    
    private final AudioGenerationService audioService;
    
    public CachedAudioService(AudioGenerationService audioService) {
        this.audioService = audioService;
    }
    
    @Cacheable(key = "#request.prompt + '-' + #request.duration")
    public AudioGenerationResponse generateAudioWithCache(AudioGenerationRequest request) {
        return audioService.generateAudio(request);
    }
}

对于限流，可以用Spring Boot的Actuator或者Resilience4j：

import io.github.resilience4j.ratelimiter.annotation.RateLimiter;

@Service
public class RateLimitedAudioService {
    
    @RateLimiter(name = "audioGenerationRateLimiter", fallbackMethod = "fallback")
    public AudioGenerationResponse generateAudioWithRateLimit(AudioGenerationRequest request) {
        return audioService.generateAudio(request);
    }
    
    public AudioGenerationResponse fallback(AudioGenerationRequest request, Throwable t) {
        AudioGenerationResponse response = new AudioGenerationResponse();
        response.setSuccess(false);
        response.setMessage("系统繁忙，请稍后再试");
        return response;
    }
}

5.4 监控和日志

添加详细的日志和监控，方便排查问题：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class MonitoredAudioService {
    
    private static final Logger logger = LoggerFactory.getLogger(MonitoredAudioService.class);
    private final AudioGenerationService audioService;
    
    public MonitoredAudioService(AudioGenerationService audioService) {
        this.audioService = audioService;
    }
    
    public AudioGenerationResponse generateAudioWithMonitoring(AudioGenerationRequest request) {
        long startTime = System.currentTimeMillis();
        logger.info("开始生成音频，描述: {}", request.getPrompt());
        
        try {
            AudioGenerationResponse response = audioService.generateAudio(request);
            
            long duration = System.currentTimeMillis() - startTime;
            logger.info("音频生成成功，ID: {}, 耗时: {}ms", 
                    response.getAudioId(), duration);
            
            // 可以在这里发送监控指标
            // metrics.recordGenerationTime(duration);
            // metrics.recordSuccess();
            
            return response;
            
        } catch (Exception e) {
            logger.error("音频生成失败，描述: {}", request.getPrompt(), e);
            // metrics.recordFailure();
            throw e;
        }
    }
}

6. 常见问题与解决方案

在实际部署和使用过程中，你可能会遇到一些问题。这里我整理了一些常见问题及其解决方法。

6.1 容器启动失败

问题：运行docker run命令后，容器立即退出。

可能原因和解决：

GPU驱动问题：如果你用了--gpus all参数但没安装NVIDIA容器工具包，可以试试：

# 安装NVIDIA容器工具包
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker