一、技术选型与前期准备

1.1 技术栈解析

本方案采用Spring Boot 3.x作为后端框架，结合Ollama提供的本地化LLM服务能力，通过RESTful API与DeepSeek模型交互。关键组件包括：

• Spring Boot Web模块：构建HTTP服务接口
• Ollama Java SDK：提供模型调用封装
• DeepSeek系列模型：支持R1/V3等版本
• Netty异步框架：优化高并发场景

1.2 环境配置要求

组件	版本要求	配置建议
JDK	17+	推荐OpenJDK 17 LTS
Spring Boot	3.2.0+	包含Web和Validation模块
Ollama	0.3.0+	预留10GB以上磁盘空间
模型文件	DeepSeek-R1	7B/13B参数版本按需选择

1.3 部署架构设计

采用”微服务+本地化模型”架构，系统分为：

1. API网关层：Spring Cloud Gateway处理路由
2. 业务服务层：Spring Boot核心服务
3. 模型服务层：Ollama容器化部署
4. 监控层：Prometheus+Grafana

二、Ollama服务部署指南

2.1 容器化部署流程

# Dockerfile示例
FROM ollama/ollama:latest
LABEL maintainer="dev@example.com"
RUN ollama pull deepseek-r1:7b
EXPOSE 11434
CMD ["ollama", "run", "deepseek-r1"]

部署命令：

docker build -t deepseek-service .
docker run -d --name ollama-service -p 11434:11434 deepseek-service

2.2 性能调优参数

关键配置项：

# ollama配置示例
num_gpu: 1
num_thread: 8
f16_kv: true
rope_scaling:
  type: "linear"
  factor: 1.0

建议参数组合：

• 7B模型：4核CPU + 8GB内存
• 13B模型：8核CPU + 16GB内存 + V100 GPU

三、Spring Boot集成实现

3.1 项目初始化

使用Spring Initializr创建项目，添加依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.tomakehurst</groupId>
        <artifactId>wiremock-jre8</artifactId>
        <version>3.3.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

3.2 核心服务实现

3.2.1 配置类

@Configuration
public class OllamaConfig {
    @Value("${ollama.base-url}")
    private String baseUrl;
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplateBuilder()
            .setConnectTimeout(Duration.ofSeconds(10))
            .setReadTimeout(Duration.ofSeconds(30))
            .build();
    }
    @Bean
    public OllamaClient ollamaClient(RestTemplate restTemplate) {
        return new OllamaClient(baseUrl, restTemplate);
    }
}

3.2.2 客户端封装

public class OllamaClient {
    private final String baseUrl;
    private final RestTemplate restTemplate;
    public OllamaClient(String baseUrl, RestTemplate restTemplate) {
        this.baseUrl = baseUrl;
        this.restTemplate = restTemplate;
    }
    public String generateText(String prompt, int maxTokens) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        Map<String, Object> request = Map.of(
            "model", "deepseek-r1",
            "prompt", prompt,
            "options", Map.of(
                "temperature", 0.7,
                "top_p", 0.9,
                "max_tokens", maxTokens
            )
        );
        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(request, headers);
        ResponseEntity<Map> response = restTemplate.postForEntity(
            baseUrl + "/api/generate", 
            entity, 
            Map.class
        );
        return (String) response.getBody().get("response");
    }
}

3.3 控制器实现

@RestController
@RequestMapping("/api/ai")
public class AiController {
    private final OllamaClient ollamaClient;
    @PostMapping("/generate")
    public ResponseEntity<AiResponse> generateText(
            @RequestBody @Valid GenerateRequest request) {
        String result = ollamaClient.generateText(
            request.getPrompt(),
            request.getMaxTokens()
        );
        return ResponseEntity.ok(
            new AiResponse(result, LocalDateTime.now())
        );
    }
}

四、高级功能实现

4.1 流式响应处理

public class StreamingOllamaClient {
    // 使用SSE实现流式响应
    public Flux<String> streamGenerate(String prompt) {
        WebClient client = WebClient.create(baseUrl);
        return client.post()
            .uri("/api/chat")
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(Map.of(
                "model", "deepseek-r1",
                "messages", List.of(Map.of(
                    "role", "user",
                    "content", prompt
                ))
            ))
            .retrieve()
            .bodyToFlux(String.class)
            .map(json -> {
                // 解析SSE事件
                JsonNode node = new ObjectMapper().readTree(json);
                return node.get("response").asText();
            });
    }
}

4.2 上下文管理实现

@Service
public class ChatContextService {
    private final Map<String, List<ChatMessage>> contexts = new ConcurrentHashMap<>();
    public void addMessage(String sessionId, ChatMessage message) {
        contexts.computeIfAbsent(sessionId, k -> new ArrayList<>())
            .add(message);
    }
    public String buildPrompt(String sessionId, String userInput) {
        List<ChatMessage> history = contexts.getOrDefault(sessionId, Collections.emptyList());
        return history.stream()
            .map(m -> m.getRole() + ": " + m.getContent())
            .collect(Collectors.joining("\n")) + 
            "\nUser: " + userInput + "\nAssistant:";
    }
}

五、生产级优化方案

5.1 性能优化策略

1. 连接池管理：

   @Bean
   public HttpComponentsClientHttpRequestFactory httpRequestFactory() {
    PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
    manager.setMaxTotal(200);
    manager.setDefaultMaxPerRoute(20);
    CloseableHttpClient httpClient = HttpClients.custom()
        .setConnectionManager(manager)
        .build();
    return new HttpComponentsClientHttpRequestFactory(httpClient);
   }

2. 缓存层设计：

   @Cacheable(value = "aiResponses", key = "#prompt.hashCode()")
   public String getCachedResponse(String prompt) {
    return ollamaClient.generateText(prompt, 512);
   }

5.2 异常处理机制

@ControllerAdvice
public class AiExceptionHandler {
    @ExceptionHandler(OllamaException.class)
    public ResponseEntity<ErrorResponse> handleOllamaError(OllamaException ex) {
        ErrorResponse error = new ErrorResponse(
            "AI_SERVICE_ERROR",
            ex.getMessage(),
            HttpStatus.SERVICE_UNAVAILABLE.value()
        );
        return new ResponseEntity<>(error, HttpStatus.SERVICE_UNAVAILABLE);
    }
}

六、完整示例项目结构

src/
├── main/
│   ├── java/
│   │   └── com/example/ai/
│   │       ├── config/
│   │       │   └── OllamaConfig.java
│   │       ├── controller/
│   │       │   └── AiController.java
│   │       ├── model/
│   │       │   ├── GenerateRequest.java
│   │       │   └── AiResponse.java
│   │       ├── service/
│   │       │   ├── OllamaClient.java
│   │       │   └── ChatContextService.java
│   │       └── AiApplication.java
│   └── resources/
│       ├── application.yml
│       └── logback-spring.xml
└── test/
    └── java/
        └── com/example/ai/
            └── controller/
                └── AiControllerTest.java

七、部署与监控方案

7.1 Docker Compose配置

version: '3.8'
services:
  ai-service:
    build: .
    ports:
      - "8080:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama-service:11434
    depends_on:
      - ollama-service
  ollama-service:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    command: ollama run deepseek-r1
volumes:
  ollama-data:

7.2 Prometheus监控配置

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: prometheus
  metrics:
    export:
      prometheus:
        enabled: true

八、最佳实践建议

1. 模型选择策略：

   • 7B模型：适合实时交互场景（<500ms响应）
   • 13B模型：适合复杂任务处理
   • 量化版本：降低显存需求（需测试精度损失）

2. 安全防护措施：

   • 实现输入内容过滤
   • 设置请求速率限制
   • 启用HTTPS加密

3. 成本控制方案：

   • 实现结果缓存
   • 优化提示词工程
   • 设置最大令牌限制

本方案通过完整的代码示例和配置说明，提供了从环境搭建到生产部署的全流程指导。实际开发中，建议结合具体业务场景进行参数调优和功能扩展，特别是要注意异常处理和性能监控的完善实施。