从零到一搭建Spring Cloud Alibbaba项目

IT橘子皮
253 阅读7分钟

Spring Cloud Alibaba 是一套基于 Spring Cloud 的微服务开发工具集，它整合了阿里巴巴在分布式应用服务领域的核心组件，为构建微服务架构提供了一站式解决方案。下面我将详细介绍其核心组件，并结合一个电商下单场景，指导你从零开始搭建一个完整的微服务项目。

🌟 Spring Cloud Alibaba 核心组件精解

在开始搭建项目之前，我们需要先了解 Spring Cloud Alibaba 的核心组件及其职责，这些组件共同构成了微服务架构的基石。

1. 核心组件架构

​Nacos​：作为服务注册中心和配置中心的双重角色，是微服务架构的"中枢神经系统"。它负责服务的注册与发现，同时集中管理所有微服务的配置信息，支持配置的动态刷新。

​Sentinel​：担任流量防护卫士，提供实时的熔断、降级、限流和系统保护功能。当系统遇到突发流量或依赖服务不稳定时，Sentinel 能够防止雪崩效应，保障核心业务的稳定性。

​Seata​：分布式事务解决方案，确保跨多个微服务的数据操作保持原子性。在电商下单等需要保持数据一致性的场景中，Seata 提供了可靠的事务保障。

​Spring Cloud Gateway​：作为统一的API网关，是所有外部请求的入口。它负责路由转发、权限验证、监控和限流等功能。

​RocketMQ​：消息队列组件，用于实现系统解耦、异步通信和流量削峰填谷。在高并发场景下，RocketMQ 能有效缓冲请求压力。

下面的表格清晰地展示了这些组件的协同工作关系：

组件角色定位核心功能与其他组件关系
Nacos服务治理中心服务注册发现、配置管理为Gateway提供路由信息，为Sentinel存储规则
Sentinel流量防护层限流、熔断、降级保护Gateway和后端微服务
Seata数据一致性保障分布式事务管理协调多个微服务的事务
Gateway统一入口路由、过滤、认证从Nacos获取服务列表
RocketMQ异步通信枢纽消息传递、流量削峰与业务微服务解耦

2. 版本兼容性说明

Spring Cloud Alibaba 的版本需要与 Spring Boot 和 Spring Cloud 版本严格对应，这是项目成功搭建的关键前提。以下是推荐的版本组合：

  • Spring Boot 2.7.x
  • Spring Cloud 2021.0.x
  • Spring Cloud Alibaba 2021.0.5.0

🛠️ 环境准备与项目初始化

1. 开发环境要求

确保你的开发环境满足以下要求：

  • JDK 1.8 或更高版本（推荐JDK 17）
  • Maven 3.6+ 或 Gradle
  • IntelliJ IDEA 或 Eclipse IDE
  • Docker（用于容器化部署Nacos等组件）

2. 使用Spring Initializr创建项目骨架

我们首先创建一个Maven父工程，用于统一管理所有微服务的依赖版本。

<?xml version="1.0" encoding="UTF-8"?>
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>spring-cloud-alibaba-demo</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <spring-boot.version>2.7.18</spring-boot.version>
        <spring-cloud.version>2021.0.8</spring-cloud.version>
        <spring-cloud-alibaba.version>2021.0.5.0</spring-cloud-alibaba.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>
        </dependencies>
    </dependencyManagement>
</project>

3. 启动Nacos服务器

使用Docker快速启动Nacos服务器（单机模式）：

docker run -d --name nacos-server \
  -e MODE=standalone \
  -p 8848:8848 \
  nacos/nacos-server:latest

启动后访问 http://localhost:8848/nacos（用户名/密码：nacos/nacos）即可进入Nacos控制台。

📦 电商下单场景微服务实现

我们将实现一个典型的电商下单流程，涉及用户下单、库存扣减、账户余额扣减和订单生成等步骤。

1. 项目结构规划

spring-cloud-alibaba-demo/
├── api-gateway/          # 网关服务
├── order-service/        # 订单服务
├── inventory-service/    # 库存服务
├── account-service/      # 账户服务
├── common/              # 公共模块
└── pom.xml              # 父POM

2. 网关服务实现

在api-gateway模块的pom.xml中添加依赖：

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
    </dependency>
</dependencies>

配置application.yml：

server:
  port: 8080

spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=1
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
        - id: inventory-service
          uri: lb://inventory-service
          predicates:
            - Path=/api/inventory/**
          filters:
            - StripPrefix=1
      sentinel:
        enabled: true

logging:
  level:
    org.springframework.cloud.gateway: DEBUG

创建网关主类：

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

3. 订单服务实现

订单服务负责处理用户下单请求，并协调库存服务和账户服务完成分布式事务。

在order-service的pom.xml中添加依赖：

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.2</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

配置application.yml：

spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yaml
        namespace: ${NACOS_NAMESPACE:}
  datasource:
    url: jdbc:mysql://localhost:3306/order_db?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.orderservice.model

seata:
  tx-service-group: my_test_tx_group
  service:
    vgroup-mapping:
      my_test_tx_group: default
    grouplist:
      default: localhost:8091
  config:
    type: nacos
    nacos:
      server-addr: localhost:8848
      namespace:
      group: SEATA_GROUP
  registry:
    type: nacos
    nacos:
      application: seata-server
      server-addr: localhost:8848
      namespace:

创建订单实体和Mapper：

@Data
@TableName("t_order")
public class Order {
    private Long id;
    private String orderNo;
    private Long userId;
    private Long productId;
    private Integer count;
    private BigDecimal amount;
    private Integer status;
    private Date createTime;
}

@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}

实现订单服务核心逻辑：

public interface OrderService {
    /**
     * 创建订单
     */
    Boolean createOrder(Long productId, Integer count, BigDecimal amount);
}

@Service
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private AccountService accountService;
    
    @GlobalTransactional(name = "create-order-tx", timeoutMills = 300000)
    @Override
    public Boolean createOrder(Long productId, Integer count, BigDecimal amount) {
        // 1. 扣减库存
        Boolean inventoryResult = inventoryService.deductInventory(productId, count);
        if (!inventoryResult) {
            throw new RuntimeException("库存不足");
        }
        
        // 2. 扣减账户余额
        Boolean accountResult = accountService.deductBalance(1L, amount); // 假设用户ID为1
        if (!accountResult) {
            throw new RuntimeException("余额不足");
        }
        
        // 3. 创建订单
        Order order = new Order();
        order.setOrderNo(UUID.randomUUID().toString());
        order.setUserId(1L);
        order.setProductId(productId);
        order.setCount(count);
        order.setAmount(amount);
        order.setStatus(1);
        order.setCreateTime(new Date());
        
        int result = orderMapper.insert(order);
        if (result <= 0) {
            throw new RuntimeException("创建订单失败");
        }
        
        return true;
    }
}

创建订单控制器：

@RestController
@RequestMapping("/orders")
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    @PostMapping
    public ResponseEntity<String> createOrder(@RequestParam Long productId, 
                                             @RequestParam Integer count,
                                             @RequestParam BigDecimal amount) {
        try {
            Boolean result = orderService.createOrder(productId, count, amount);
            return result ? ResponseEntity.ok("订单创建成功") : 
                          ResponseEntity.badRequest().body("订单创建失败");
        } catch (Exception e) {
            return ResponseEntity.badRequest().body("订单创建失败: " + e.getMessage());
        }
    }
}

订单服务主类：

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@MapperScan("com.example.orderservice.mapper")
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

4. 库存服务实现

库存服务负责商品库存管理，提供库存查询和扣减功能。

InventoryService接口（Feign客户端）：

@FeignClient(name = "inventory-service", path = "/inventory")
public interface InventoryService {
    
    @PostMapping("/deduct")
    Boolean deductInventory(@RequestParam Long productId, 
                           @RequestParam Integer count);
}

@Service
public class InventoryServiceImpl {
    
    @Autowired
    private InventoryMapper inventoryMapper;
    
    @Transactional
    public Boolean deductInventory(Long productId, Integer count) {
        Inventory inventory = inventoryMapper.selectByProductId(productId);
        if (inventory == null || inventory.getStock() < count) {
            return false;
        }
        
        int result = inventoryMapper.deductStock(productId, count);
        return result > 0;
    }
}

5. 账户服务实现

账户服务负责用户账户余额管理，提供余额查询和扣减功能。

AccountService接口（Feign客户端）：

@FeignClient(name = "account-service", path = "/accounts")
public interface AccountService {
    
    @PostMapping("/deduct")
    Boolean deductBalance(@RequestParam Long userId, 
                         @RequestParam BigDecimal amount);
}

@Service
public class AccountServiceImpl {
    
    @Autowired
    private AccountMapper accountMapper;
    
    @Transactional
    public Boolean deductBalance(Long userId, BigDecimal amount) {
        Account account = accountMapper.selectByUserId(userId);
        if (account == null || account.getBalance().compareTo(amount) < 0) {
            return false;
        }
        
        int result = accountMapper.deductBalance(userId, amount);
        return result > 0;
    }
}

🔧 关键配置与业务一致性保障

1. Nacos配置中心设置

在Nacos控制台中创建订单服务的配置文件order-service.yaml：

# 订单服务相关配置
order:
  default:
    timeout: 30000
    retry:
      count: 3

# 数据库连接配置
database:
  url: jdbc:mysql://localhost:3306/order_db
  username: root
  password: 123456

# Seata分布式事务配置
seata:
  enabled: true

2. Sentinel流控规则配置

在网关层配置Sentinel规则，保护系统免受过载请求影响：

@Configuration
public class GatewayConfiguration {

    @PostConstruct
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        
        // 订单服务流控规则：每秒钟最多处理50个请求
        GatewayFlowRule orderRule = new GatewayFlowRule("order-service")
            .setCount(50)
            .setIntervalSec(1)
            .setBurst(100);
        rules.add(orderRule);
        
        GatewayRuleManager.loadRules(rules);
    }
    
    @Bean
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
}

3. 分布式事务一致性保障

在电商下单场景中，我们使用Seata的AT模式保证数据一致性。以下是关键的事务协调配置：

@Configuration
public class SeataConfiguration {
    
    @Bean
    public GlobalTransactionScanner globalTransactionScanner() {
        return new GlobalTransactionScanner("order-service", "my_test_tx_group");
    }
}

当订单创建过程中任何一个微服务出现异常时，Seata会自动回滚全局事务，确保数据一致性。

🚀 部署与运维最佳实践

1. 服务启动顺序建议

为了保证系统正常启动，请按以下顺序启动服务：

  1. ​基础设施服务​：Nacos、Seata Server、数据库
  2. ​业务基础服务​：账户服务、库存服务
  3. ​核心业务服务​：订单服务
  4. ​网关服务​：API网关

2. 生产环境配置建议

​Nacos集群配置​：

# 生产环境建议使用Nacos集群
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.101:8848,192.168.1.102:8848,192.168.1.103:8848
      config:
        server-addr: 192.168.1.101:8848,192.168.1.102:8848,192.168.1.103:8848

​Sentinel规则持久化​：

// 将流控规则持久化到Nacos，避免重启丢失
public class SentinelPersistenceConfig {
    
    @Bean
    public DataSource nacosDataSource() {
        return new NacosDataSource("127.0.0.1:8848", "DEFAULT_GROUP", 
            "sentinel-order-service-rules", 
            new Converter<List<FlowRule>>() {
                // 规则转换逻辑
            });
    }
}

💡 常见问题与解决方案

1. Nacos连接失败

​问题描述​：服务无法连接到Nacos服务器

​解决方案​：

  • 检查Nacos服务是否正常启动：docker ps | grep nacos
  • 验证防火墙设置，确保8848端口可访问
  • 检查Nacos配置的namespace和group是否正确

2. Feign调用超时

​问题描述​：服务间调用超时

​解决方案​：

# 调整Feign和Ribbon的超时配置
feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 30000
ribbon:
  ReadTimeout: 30000
  ConnectTimeout: 5000

3. Seata分布式事务失败

​问题描述​：分布式事务无法正常提交或回滚

​解决方案​：

  • 确认Seata Server正常运行
  • 检查undo_log表是否正确创建
  • 验证各参与服务的数据库兼容性

📈 总结与扩展方向

通过以上步骤，我们成功搭建了一个基于Spring Cloud Alibaba的完整微服务系统，实现了电商下单这一典型业务场景。这个系统具备了服务发现、配置管理、流量防护、分布式事务等微服务架构的核心能力。

​生产环境进阶考虑​：

  1. ​监控体系​：集成Prometheus + Grafana实现系统监控
  2. ​日志收集​：使用ELK或Loki进行分布式日志管理
  3. ​安全防护​：集成Spring Security + OAuth2实现安全控制
  4. ​容器化部署​：使用Docker + Kubernetes进行容器编排

Spring Cloud Alibaba提供了一站式的微服务解决方案，让开发者能够专注于业务逻辑的实现，而无需过多关注底层技术复杂性。随着业务的增长，你可以根据实际需求逐步引入更多SCA组件，构建更加健壮和高效的分布式系统。

avatar
文章
阅读
粉丝