在开始构建微服务项目之前，需要首先准备好完整的开发环境。本章将详细介绍如何搭建Spring Cloud Alibaba微服务开发环境，包括JDK安装、Maven配置、Docker环境准备等。磨刀不误砍柴工，一个完善的开发环境能够大大提高后续的开发效率。

JDK建议使用JDK 17或JDK 21，这两个版本都是长期支持版本（LTS），能够很好地支持Spring Boot 3.x的新特性。在Windows环境下，建议使用Spring全家桶官方推荐的Eclipse Temurin JDK，或者从Adoptium官网下载。安装完成后，需要配置JAVA_HOME环境变量，并将JDK的bin目录添加到PATH中。可以通过在命令行执行java -version来验证JDK是否安装成功。

Maven建议使用3.9.x版本，这个版本在性能和新特性支持方面都有不错的表现。如果网络环境访问国外Maven中央仓库较慢，建议配置阿里云镜像加速。在Maven的settings.xml文件中，需要在mirrors节点下添加阿里云镜像配置，这样在后续创建项目和下载依赖时会快很多。另外，建议配置MAVEN_OPTS环境变量，设置-Xms512m -Xmx1024m来避免大项目构建时的内存溢出问题。

Docker是运行基础设施组件的必备工具，包括Nacos、Sentinel、MySQL、Redis等都通过Docker容器来运行。在Windows上使用Docker Desktop时，需要确保WSL2后端已正确配置，这能够提供更好的性能和资源占用。如果Docker Desktop启动时提示需要开启Hyper-V或WSL2，按照提示进行配置即可。Docker安装完成后，可以通过docker ps命令验证Docker守护进程是否正常运行。

关于IDEA开发工具，建议使用IntelliJ IDEA Ultimate版本，这个版本对Spring Boot和微服务开发提供了最好的支持。如果使用社区版，部分高级功能将不可用。IDEA需要安装几个关键的插件：Spring Boot Assistant插件能够识别Spring Boot应用并提供智能提示，Lombok插件支持Lombok注解处理，Maven Helper插件方便查看依赖冲突。在创建项目时，建议使用Spring Initializr来快速生成项目骨架。

微服务项目通常采用多模块结构，父工程负责统一管理依赖版本和公共配置。本节将详细介绍如何创建父工程，并在父工程中配置Spring Boot、Spring Cloud Alibaba以及相关组件的版本依赖。

首先在IDEA中创建新的Maven项目，项目名称可以命名为microservice-llm-parent。在创建过程中，需要注意选择正确的Maven版本和JDK版本。项目创建完成后，删除src目录，因为父工程本身不需要业务代码。修改pom.xml文件，将packaging设置为pom，这表明这是一个聚合工程。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>microservice-llm-parent</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>microservice-llm-parent</name>
    <description>微服务整合大模型父工程</description>
    <modules>
        <module>microservice-common</module>
        <module>microservice-gateway</module>
        <module>microservice-ai</module>
        <module>microservice-business</module>
    </modules>
</project>

在properties节点中定义所有依赖的版本号，这是Maven版本管理的最佳实践。集中管理版本号能够避免子模块版本不一致的问题，也便于后续统一升级。

<properties>
    <java.version>17</java.version>
    <spring-boot.version>3.2.5</spring-boot.version>
    <spring-cloud.version>2023.0.1.0</spring-cloud.version>
    <spring-cloud-alibaba.version>2023.0.3.2</spring-cloud-alibaba.version>
    <mybatis-plus.version>3.5.6</mybatis-plus.version>
    <druid.version>1.2.23</druid.version>
    <hutool.version>5.8.26</hutool.version>
    <lombok.version>1.18.32</lombok.version>
    <mapstruct.version>1.5.5.Final</mapstruct.version>
</properties>

在dependencyManagement节点中管理所有依赖的版本，这个节点下的依赖不会自动引入，只是声明版本。子模块在引入这些依赖时不需要指定版本号，Maven会从父工程继承版本。

<dependencyManagement>
    <dependencies>
        <!-- Spring Boot Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- Spring Cloud -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- Spring Cloud Alibaba -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

还需要在build节点中配置Maven插件，包括spring-boot-maven-plugin用于打包可执行JAR，maven-compiler-plugin用于编译配置。配置build-plugin-management节点来统一管理插件版本。

微服务项目按照功能划分成多个子模块，每个子模块承担特定的职责。本节介绍如何设计和创建各个子模块，包括公共模块、网关模块、AI服务模块和业务服务模块。

microservice-common是公共模块，包含其他所有模块都会用到的公共组件。这个模块应该尽可能保持轻量，只包含必要的公共代码。主要包括以下内容：通用工具类，如日期处理、字符串工具、JSON序列化等；通用响应结果类，用于统一API返回格式；异常定义和异常处理，如业务异常、系统异常等；通用配置类，如跨域配置、Swagger配置等；公共依赖，如Lombok、Hutool等工具库。

package com.example.common.result;
@Data
public class Result<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer code;
    private String message;
    private T data;
    private Long timestamp;
    public static <T> Result<T> success() {
        return success(null);
    }
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("操作成功");
        result.setData(data);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    public static <T> Result<T> error(String message) {
        Result<T> result = new Result<>();
        result.setCode(500);
        result.setMessage(message);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
    public static <T> Result<T> error(Integer code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        result.setTimestamp(System.currentTimeMillis());
        return result;
    }
}

microservice-gateway是网关模块，作为整个微服务系统的统一入口。网关模块负责请求的路由转发、身份认证、限流熔断等功能。在Spring Cloud架构中，网关是外部请求进入系统的第一道关卡，其性能和稳定性至关重要。

server:
  port: 8080
spring:
  application:
    name: microservice-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      routes:
        - id: ai-service
          uri: lb://microservice-ai
          predicates:
            - Path=/api/ai/**
          filters:
            - StripPrefix=1
        - id: business-service
          uri: lb://microservice-business
          predicates:
            - Path=/api/business/**
          filters:
            - StripPrefix=1
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true

microservice-ai是AI服务模块，封装对各大模型提供商的调用。这个模块是整个系统的核心创新点，需要精心设计其架构。后面的章节会详细介绍AI服务的实现细节。

microservice-business是业务服务模块，包含具体的业务逻辑处理。在实际项目中，这个模块可能根据业务领域进一步拆分成多个更细粒度的服务，如用户服务、订单服务、客服服务等。为了保持演示项目的简洁，我们暂时将其作为一个模块来处理。

每个子模块都需要创建独立的pom.xml文件，并在其中声明对父工程的继承以及自身需要的依赖。以microservice-common为例：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>microservice-llm-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-common</artifactId>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>
</project>

微服务架构需要多个基础设施组件支持，包括服务注册中心、配置中心、数据库、缓存等。本节介绍如何使用Docker Compose一键启动所有基础设施组件。

首先创建docker-compose.yml文件，这个文件定义了所有需要启动的容器服务。在开发环境中，我们使用Docker Compose来管理所有基础设施组件，避免手动安装配置的繁琐。

version: '3.8'
services:
  # MySQL数据库
  mysql:
    image: mysql:8.0
    container_name: microservice-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root123456
      MYSQL_DATABASE: microservice_llm
      TZ: Asia/Shanghai
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
      - ./docker/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --default-authentication-plugin=mysql_native_password
    networks:
      - microservice-network
  # Redis缓存
  redis:
    image: redis:7-alpine
    container_name: microservice-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - microservice-network
  # Nacos注册中心
  nacos:
    image: nacos/nacos-server:v2.3.2
    container_name: microservice-nacos
    environment:
      MODE: standalone
      SPRING_DATASOURCE_PLATFORM: mysql
      MYSQL_SERVICE_HOST: mysql
      MYSQL_SERVICE_DB_NAME: nacos_config
      MYSQL_SERVICE_PORT: 3306
      MYSQL_SERVICE_USER: root
      MYSQL_SERVICE_PASSWORD: root123456
      MYSQL_SERVICE_DB_PARAM: characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useSSL=false
    ports:
      - "8848:8848"
      - "9848:9848"
    volumes:
      - nacos-data:/home/nacos/data
    depends_on:
      - mysql
    networks:
      - microservice-network
  # Sentinel控制台
  sentinel:
    image: bladex/sentinel-dashboard:1.8.8
    container_name: microservice-sentinel
    environment:
      JAVA_OPTS: -Dserver.port=8858 -Dcsp.sentinel.dashboard.server=localhost:8858
    ports:
      - "8858:8858"
    networks:
      - microservice-network
volumes:
  mysql-data:
  redis-data:
  nacos-data:
networks:
  microservice-network:
    driver: bridge

MySQL初始化脚本用于创建数据库和表结构。在实际项目中，应该将数据库脚本纳入版本管理，并使用Flyway或Liquibase等工具管理数据库迁移。

-- 创建微服务数据库
CREATE DATABASE IF NOT EXISTS microservice_llm DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE microservice_llm;
-- 用户表
CREATE TABLE IF NOT EXISTS t_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(100) NOT NULL,
    email VARCHAR(100),
    status TINYINT DEFAULT 1 COMMENT '1-启用 0-禁用',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
-- 对话记录表
CREATE TABLE IF NOT EXISTS t_chat_session (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    session_id VARCHAR(64) NOT NULL UNIQUE,
    user_id BIGINT,
    title VARCHAR(200),
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='对话会话表';
-- 消息记录表
CREATE TABLE IF NOT EXISTS t_chat_message (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    session_id VARCHAR(64) NOT NULL,
    role VARCHAR(20) NOT NULL COMMENT 'user/assistant/system',
    content TEXT NOT NULL,
    model VARCHAR(50) COMMENT '使用的模型',
    tokens INT COMMENT '消耗的token数',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='聊天消息表';

启动所有基础设施组件非常简单，只需要执行docker-compose up -d命令即可。首次启动时，Docker会自动下载所需的镜像，这可能需要一些时间。启动完成后，可以通过docker ps命令查看所有运行中的容器，并通过docker logs -f container_name查看某个容器的日志。

网关服务是微服务架构的统一入口，承担着路由转发、身份认证、限流熔断等核心功能。本节详细介绍Spring Cloud Gateway的配置和使用，包括动态路由、过滤器链、全局过滤器等。

Spring Cloud Gateway基于WebFlux的响应式编程范式，相比基于Servlet的Zuul有更好的性能表现。Gateway的工作原理是：请求到达网关后，首先被匹配器（RoutePredicateHandlerMapping）根据断言（Predicate）匹配到对应的路由（Route），然后经过过滤器链（GatewayFilterChain）处理，最后转发到目标URI。

动态路由是网关的重要特性，路由信息可以存储在Nacos配置中心中，修改配置后无需重启网关服务即可生效。这种设计非常适合生产环境，能够实现路由的动态调整。

spring:
  cloud:
    gateway:
      # 路由配置
      routes:
        # AI服务路由
        - id: ai-service-route
          uri: lb://microservice-ai
          predicates:
            - name: Path
              args:
                pattern: /api/ai/**
          filters:
            - name: StripPrefix
              args:
                parts: 1
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
                key-resolver: '#{@remoteAddrKeyResolver}'
        # 业务服务路由
        - id: business-service-route
          uri: lb://microservice-business
          predicates:
            - name: Path
              args:
                pattern: /api/business/**
          filters:
            - name: StripPrefix
              args:
                parts: 1
      # 服务发现配置
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true
          predicates:
            - name: Path
              args:
                pattern: '/services/**'
          filters:
            - name: RewritePath
              args:
                regexp: '/services/(?<remaining>.*)'
                replacement: '/${remaining}'

全局过滤器用于实现统一的认证、鉴权、日志等功能。自定义全局过滤器需要实现GlobalFilter接口，并添加@Component注解使其被Spring管理。

@Component
@Slf4j
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    private final JwtUtil jwtUtil;
    public AuthGlobalFilter(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getURI().getPath();
        // 放行登录和注册接口
        if (path.contains("/auth/login") || path.contains("/auth/register")) {
            return chain.filter(exchange);
        }
        // 放行AI服务中的部分公开接口
        if (path.startsWith("/ai/public")) {
            return chain.filter(exchange);
        }
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (StringUtils.hasText(token) && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                Claims claims = jwtUtil.parseToken(token);
                String userId = claims.getSubject();
                // 将用户信息传递到后续服务
                ServerHttpRequest modifiedRequest = exchange.getRequest().mutate()
                        .header("X-User-Id", userId)
                        .build();
                return chain.filter(exchange.mutate().request(modifiedRequest).build());
            } catch (Exception e) {
                log.error("Token验证失败: {}", e.getMessage());
                return unauthorized(exchange);
            }
        } else {
            log.warn("请求缺少Authorization头: {}", path);
            return unauthorized(exchange);
        }
    }
    @Override
    public int getOrder() {
        return -100; // 优先级，数字越小越先执行
    }
    private Mono<Void> unauthorized(ServerWebExchange exchange) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
        String body = "{\"code\":401,\"message\":\"未授权访问\"}";
        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(body.getBytes());
        return exchange.getResponse().writeWith(Mono.just(buffer));
    }
}

除了自定义过滤器，还可以使用Spring Cloud Gateway内置的多种过滤器，如熔断过滤器（CircuitBreaker）、限流过滤器（RequestRateLimiter）、重试过滤器（Retry）等。这些过滤器可以通过配置或注解的方式使用，非常方便。

微服务之间的通信方式主要分为两类：同步通信和异步通信。同步通信通常使用HTTP REST或gRPC，异步通信则使用消息队列。本节介绍如何在Spring Cloud环境中配置服务间通信，包括RestTemplate、WebClient、Feign等客户端。

Ribbon是Spring Cloud早期的负载均衡组件，虽然目前已进入维护模式，但其核心思想仍然值得了解。在Spring Cloud 2020之后，建议使用Spring Cloud LoadBalancer作为替代方案。LoadBalancer默认集成在Spring Cloud中，无需额外添加依赖。

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

WebClient是Spring 5引入的响应式HTTP客户端，相比RestTemplate有更好的性能和非阻塞特性。在高并发场景下，WebClient能够更好地利用系统资源。

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder
                .baseUrl("http://microservice-ai")
                .clientConnector(new ReactorClientHttpConnector(
                        HttpClient.create().responseTimeout(Duration.ofSeconds(30))
                ))
                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .build();
    }
}

OpenFeign是声明式的HTTP客户端，能够通过接口定义来调用远程服务，大大简化了HTTP调用的代码编写。OpenFeign与Spring Cloud深度集成，支持负载均衡、熔断降级等特性。

@FeignClient(name = "microservice-ai", path = "/chat")
public interface AiServiceClient {
    @PostMapping("/completions")
    ChatResponse chat(@RequestBody ChatRequest request);
    @GetMapping("/models")
    List<ModelInfo> getAvailableModels();
}

在实际项目中，需要注意服务间通信的超时配置、重试策略、熔断处理等。这些配置直接影响到系统的稳定性和用户体验。建议对所有外部调用都设置合理的超时时间，并配置重试机制来应对临时性的网络故障。

spring:
  cloud:
    openfeign:
      client:
        config:
          default:
            connectTimeout: 5000
            readTimeout: 30000
            loggerLevel: basic
          microservice-ai:
            connectTimeout: 10000
            readTimeout: 60000
    loadbalancer:
      ribbon:
        enabled: false

微服务架构中，服务数量的增长会导致运维复杂度的上升。为了保证系统的可观测性，需要配置完善的健康检查和监控机制。本节介绍如何配置Spring Boot Actuator、Spring Boot Admin等监控组件。

Spring Boot Actuator提供了丰富的端点用于监控应用状态。启用Actuator非常简单，只需要在依赖中添加spring-boot-starter-actuator，然后配置暴露哪些端点。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
      base-path: /actuator
  endpoint:
    health:
      show-details: always
  metrics:
    tags:
      application: ${spring.application.name}

健康检查是微服务架构中的重要机制，用于让注册中心判断服务实例是否可用。Nacos默认会定期向服务实例发送心跳，如果实例连续几次心跳失败，就会将其从服务列表中移除。可以通过配置调整心跳间隔和超时时间。

spring:
  cloud:
    nacos:
      discovery:
        heart-beat-interval: 5000
        heart-beat-timeout: 15000
        ip-delete-timeout: 30000
        metadata:
          management:
            context-path: ${server.servlet.context-path:/}

如果需要更专业的监控方案，可以引入Spring Boot Admin。Spring Boot Admin分为服务端和客户端，服务端提供一个Web界面集中展示所有注册服务的状态。

@SpringBootApplication
@EnableAdminServer
public class AdminServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(AdminServerApplication.class, args);
    }
}

server:
  port: 9000
spring:
  application:
    name: admin-server
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        enabled: true
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

本章详细介绍了Spring Cloud微服务基础架构的搭建过程。首先进行了开发环境的准备工作，包括JDK、Maven、Docker等工具的安装和配置。然后创建了父工程，统一管理依赖版本，这是微服务多模块项目的标准做法。接着详细讲解了子模块的设计，包括公共模块、网关模块、AI服务模块和业务服务模块的职责划分。

在基础设施部分，使用Docker Compose一键启动了MySQL、Redis、Nacos和Sentinel等组件，大大简化了开发环境的搭建。网关服务配置部分重点介绍了Spring Cloud Gateway的路由配置、全局过滤器和认证鉴权功能。服务间通信部分演示了RestTemplate、WebClient和OpenFeign的使用方法。最后讨论了健康检查和监控配置的必要性。

通过本章的学习，读者应该能够搭建起一个完整的微服务开发骨架。后续章节将在这个骨架基础上逐步添加AI服务集成、服务治理等高级特性。一个设计良好的基础架构是构建复杂系统的前提，希望读者能够深入理解本章内容，为后续的学习打下坚实基础。

附录：完整父工程pom.xml参考

以下是本章创建的父工程的完整pom.xml配置，包含所有依赖的版本管理和插件配置，可作为读者实践的参考起点：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>microservice-llm-parent</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>microservice-llm-parent</name>
    <description>微服务整合大模型父工程</description>
    <modules>
        <module>microservice-common</module>
        <module>microservice-gateway</module>
        <module>microservice-ai</module>
        <module>microservice-business</module>
    </modules>
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.2.5</spring-boot.version>
        <spring-cloud.version>2023.0.1.0</spring-cloud.version>
        <spring-cloud-alibaba.version>2023.0.3.2</spring-cloud-alibaba.version>
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
        <druid.version>1.2.23</druid.version>
        <hutool.version>5.8.26</hutool.version>
        <lombok.version>1.18.32</lombok.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud Alibaba -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- MyBatis Plus -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>
            <!-- Druid连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-3-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!-- Hutool工具库 -->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.11.0</version>
                    <configuration>
                        <source>17</source>
                        <target>17</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>