随着业务复杂度的爆炸式增长，单体应用架构已无法满足现代互联网企业的需求。本文将通过一个完整的电商项目实战，详细讲解如何基于Spring Cloud Alibaba生态体系，从零构建高可用、可扩展的微服务架构。内容涵盖服务治理、配置管理、流量控制、分布式事务等核心场景，并提供完整的性能优化和故障排查方案。

一、 为什么微服务架构成为必然选择？​​

​1.1 单体架构的痛点分析​

传统单体电商应用架构示例：

// 单体应用代码结构
ecommerce-monolith/
├── src/
│   └── main/
│       └── java/
│           └── com/
│               └── ecommerce/
│                   ├── controller/     // 控制层
│                   ├── service/        // 业务层  
│                   ├── dao/           // 数据层
│                   └── entity/        // 实体类
├── pom.xml          // 所有依赖在一个pom中
└── application.yml  // 统一配置

// 典型问题：代码耦合严重
@Service
public class OrderService {
    // 订单服务包含用户、商品、支付等所有逻辑
    public Order createOrder(OrderDTO orderDTO) {
        // 用户验证
        User user = userDao.findById(orderDTO.getUserId());
        // 库存检查
        Product product = productDao.findById(orderDTO.getProductId());
        // 风控检查
        RiskResult risk = riskService.check(orderDTO);
        // 创建订单
        Order order = new Order();
        // 支付处理
        PaymentResult payment = paymentService.pay(order);
        // 库存扣减
        inventoryService.deduct(order);
        // 消息通知
        notificationService.send(order);
        return order;
    }
}

​单体架构的典型问题：​​

  • ​技术栈僵化：​​ 所有模块使用相同技术栈，难以引入新技术
  • ​扩展困难：​​ 只能整体扩展，无法针对热点服务单独扩容
  • ​开发协作困难：​​ 数十人开发同一个代码库，冲突频繁
  • ​发布风险高：​​ 微小修改需要全量发布，风险不可控
  • ​故障隔离性差：​​ 某个模块Bug可能导致整个系统崩溃

​1.2 微服务架构的优势​

微服务化后的电商架构：

前端应用
    ↓
API网关
    ↓
┌─────────────┬─────────────┬─────────────┐
│  用户服务    │  商品服务    │  订单服务    │  支付服务
│ UserService │ ProductSvc  │ OrderService│ PaymentSvc
└─────────────┴─────────────┴─────────────┘
    ↓
统一配置中心 ← 服务注册发现 ← 分布式事务管理

​微服务核心优势对比：​​

维度单体架构微服务架构
开发效率初期快，后期慢持续高效，并行开发
技术多样性技术栈统一可按服务选择合适技术栈
可扩展性整体扩展，资源浪费细粒度扩展，资源利用率高
容错能力单点故障影响全局故障隔离，影响范围小
部署频率发布周期长独立部署，发布频繁
​二、 Spring Cloud Alibaba生态体系详解​

​2.1 核心组件架构图​

┌─────────────────────────────────────────────────┐
│                前端应用/移动端                    │
└─────────────────────────────────────────────────┘
         ↓
┌─────────────────────────────────────────────────┐
│                API网关 (Spring Cloud Gateway)   │
└─────────────────────────────────────────────────┘
         ↓
┌─────────────┬─────────────┬─────────────┬─────────────┐
│  用户服务    │  商品服务    │  订单服务    │  支付服务    │
│ (Nacos客户端)│ (Nacos客户端)│ (Nacos客户端)│ (Nacos客户端)│
└─────────────┴─────────────┴─────────────┴─────────────┘
         │             │             │             │
         └─────────────┼─────────────┼─────────────┘
                       ↓
    ┌─────────────────────────────────────┐
    │     Spring Cloud Alibaba 生态        │
    ├─────────────────────────────────────┤
    │  ▪ Nacos(服务发现/配置)               │
    │  ▪ Sentinel(流量控制)                │
    │  ▪ Seata(分布式事务)                 │
    │  ▪ RocketMQ(消息队列)               │
    └─────────────────────────────────────┘

​2.2 版本兼容性选择​

<!-- 父pom.xml - 依赖管理 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.12</version>
</parent>

<properties>
    <spring-cloud.version>2021.0.5</spring-cloud.version>
    <spring-cloud-alibaba.version>2021.0.5.0</spring-cloud-alibaba.version>
    <java.version>1.8</java.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- 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>
​三、 服务治理核心组件实战​

​3.1 Nacos - 服务注册与发现​

​服务提供者配置：​​

# user-service/src/main/resources/application.yml
server:
  port: 8081

spring:
  application:
    name: user-service  # 服务名称
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.100:8848  # Nacos服务器地址
        namespace: dev                   # 命名空间(环境隔离)
        group: DEFAULT_GROUP            # 分组管理
      config:
        server-addr: 192.168.1.100:8848
        file-extension: yaml            # 配置文件格式

# 服务实例配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

​服务消费者配置：​​

@Service
@Slf4j
public class OrderService {
    
    // 使用LoadBalancerClient进行服务调用
    @Autowired
    private LoadBalancerClient loadBalancer;
    
    @Autowired
    private RestTemplate restTemplate;
    
    public UserDTO getUserInfo(Long userId) {
        // 1. 根据服务名选择实例
        ServiceInstance instance = loadBalancer.choose("user-service");
        
        // 2. 构造请求URL
        String url = String.format("http://%s:%s/users/%d", 
            instance.getHost(), instance.getPort(), userId);
        
        // 3. 发起调用
        ResponseEntity<UserDTO> response = restTemplate.getForEntity(url, UserDTO.class);
        return response.getBody();
    }
    
    // 使用OpenFeign声明式调用（推荐）
    @Autowired
    private UserFeignClient userFeignClient;
    
    public UserDTO getUserInfoByFeign(Long userId) {
        return userFeignClient.getUserById(userId);
    }
}

// Feign客户端接口
@FeignClient(name = "user-service", path = "/users")
public interface UserFeignClient {
    
    @GetMapping("/{userId}")
    UserDTO getUserById(@PathVariable("userId") Long userId);
    
    @PostMapping("/")
    UserDTO createUser(@RequestBody UserDTO userDTO);
}

​3.2 Nacos配置中心实战​

​动态配置管理：​​

# 在Nacos控制台创建 Data ID: user-service-dev.yaml
user:
  config:
    maxLoginAttempts: 5
    sessionTimeout: 1800
    whiteList:
      - 192.168.1.100
      - 192.168.1.101

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/user_db
    username: ${DB_USERNAME:root}
    password: ${DB_PASSWORD:123456}

​配置动态刷新：​​

@RefreshScope
@RestController
@Slf4j
public class UserConfigController {
    
    // 动态获取配置值
    @Value("${user.config.maxLoginAttempts:3}")
    private Integer maxLoginAttempts;
    
    @Value("${user.config.whiteList}")
    private List<String> whiteList;
    
    @Autowired
    private UserConfig userConfig;
    
    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("maxLoginAttempts", maxLoginAttempts);
        config.put("whiteList", whiteList);
        config.put("sessionTimeout", userConfig.getSessionTimeout());
        return config;
    }
    
    // 监听配置变更事件
    @EventListener
    public void handleRefreshEvent(EnvironmentChangeEvent event) {
        log.info("配置发生变化: {}", event.getKeys());
        // 执行配置变更后的逻辑
        reloadWhiteList();
    }
}

// 类型安全的配置类
@Component
@ConfigurationProperties(prefix = "user.config")
@Data
public class UserConfig {
    private Integer maxLoginAttempts;
    private Integer sessionTimeout;
    private List<String> whiteList;
}
​四、 服务容错与流量控制​

​4.1 Sentinel流量控制实战​

​Sentinel配置：​​

# 应用配置
spring:
  cloud:
    sentinel:
      transport:
        dashboard: 192.168.1.100:8080  # Sentinel控制台
        port: 8719
      eager: true  # 立即初始化
      filter:
        enabled: true

# Sentinel数据源配置（支持文件、Nacos、Apollo等）
      datasource:
        ds1:
          nacos:
            server-addr: 192.168.1.100:8848
            dataId: user-service-sentinel
            groupId: DEFAULT_GROUP
            rule-type: flow

​流量控制规则：​​

@Service
@Slf4j
public class OrderService {
    
    // 1. 使用@SentinelResource定义资源
    @SentinelResource(
        value = "createOrder",
        blockHandler = "createOrderBlockHandler",     // 流控处理
        fallback = "createOrderFallback",            // 降级处理
        exceptionsToIgnore = {IllegalArgumentException.class}
    )
    public OrderDTO createOrder(OrderRequest request) {
        // 业务逻辑
        if (request.getAmount() <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
        return orderMapper.create(request);
    }
    
    // 2. 流控处理函数（参数和返回值要与原方法一致）
    public OrderDTO createOrderBlockHandler(OrderRequest request, 
                                           BlockException ex) {
        log.warn("订单创建被限流: {}", ex.getMessage());
        throw new BusinessException("系统繁忙，请稍后重试");
    }
    
    // 3. 降级处理函数
    public OrderDTO createOrderFallback(OrderRequest request, Throwable ex) {
        log.error("订单创建失败，执行降级逻辑", ex);
        // 返回兜底数据或执行备用方案
        return OrderDTO.createDefaultOrder();
    }
}

// 全局异常处理
@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BlockException.class)
    @ResponseBody
    public ResponseEntity<Object> handleBlockException(BlockException e) {
        return ResponseEntity.status(429)
            .body(Result.error("请求被限流，请稍后重试"));
    }
}

​热点参数限流：​​

@RestController
@Slf4j
public class ProductController {
    
    @GetMapping("/products/{id}")
    @SentinelResource(
        value = "getProductDetail",
        blockHandler = "getProductBlockHandler"
    )
    public ProductDTO getProductDetail(@PathVariable Long id) {
        return productService.getDetail(id);
    }
    
    // 热点参数限流规则（通过控制台或代码配置）
    @PostConstruct
    public void initHotParamRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        FlowRule rule = new FlowRule();
        rule.setResource("getProductDetail");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(100); // 总体阈值
        
        // 设置热点参数规则（针对特定参数值限流）
        ParamFlowRule paramRule = new ParamFlowRule("getProductDetail")
            .setParamIdx(0)  // 第一个参数（productId）
            .setCount(50);   // 针对单个商品的QPS限制
            
        ParamFlowItem item = new ParamFlowItem();
        item.setObject(String.valueOf(12345L));  // 热门商品ID
        item.setClassType(Long.class.getName());
        item.setCount(10);   // 热门商品单独限制
        
        paramRule.setParamFlowItemList(Collections.singletonList(item));
        ParamFlowRuleManager.loadRules(Collections.singletonList(paramRule));
    }
}

​4.2 熔断降级策略​

@Service
@Slf4j
public class PaymentService {
    
    @SentinelResource(
        value = "processPayment",
        fallback = "paymentFallback",
        blockHandler = "paymentBlockHandler"
    )
    public PaymentResult processPayment(PaymentRequest request) {
        // 模拟外部支付接口调用
        return externalPaymentService.pay(request);
    }
    
    // 熔断降级策略配置
    @PostConstruct
    public void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();
        
        DegradeRule rule = new DegradeRule();
        rule.setResource("processPayment");
        rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO); // 异常比例模式
        rule.setCount(0.5);   // 异常比例阈值50%
        rule.setTimeWindow(10); // 熔断时间窗口10秒
        rule.setMinRequestAmount(5); // 最小请求数
        rule.setStatIntervalMs(60000); // 统计窗口1分钟
        
        rules.add(rule);
        DegradeRuleManager.loadRules(rules);
    }
    
    public PaymentResult paymentFallback(PaymentRequest request, Throwable ex) {
        log.warn("支付服务降级，执行备用方案", ex);
        
        // 1. 记录支付请求，后续补偿处理
        paymentRecordService.savePendingPayment(request);
        
        // 2. 返回降级结果
        return PaymentResult.builder()
            .success(false)
            .message("支付系统繁忙，已记录支付请求，请稍后查看结果")
            .fallback(true)
            .build();
    }
}
​五、 分布式事务解决方案​

​5.1 Seata分布式事务实战​

​全局事务配置：​​

# seata配置
seata:
  enabled: true
  application-id: order-service
  tx-service-group: my_tx_group
  service:
    vgroup-mapping:
      my_tx_group: default
    grouplist:
      default: 192.168.1.100:8091
  registry:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      namespace: dev
  config:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      namespace: dev

​AT模式事务示例：​​

@Service
@Slf4j
public class OrderBusinessService {
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private AccountFeignClient accountFeignClient;
    
    @Autowired
    private StorageFeignClient storageFeignClient;
    
    // 开启全局事务
    @GlobalTransactional(name = "create-order-tx", timeoutMills = 300000)
    public OrderDTO createOrder(OrderRequest request) {
        log.info("开始创建订单全局事务");
        
        // 1. 创建订单（本地事务）
        OrderDTO order = createLocalOrder(request);
        
        // 2. 扣减库存（远程服务）
        Boolean storageResult = storageFeignClient.deduct(
            request.getProductId(), request.getQuantity());
        if (!Boolean.TRUE.equals(storageResult)) {
            throw new RuntimeException("库存扣减失败");
        }
        
        // 3. 扣减余额（远程服务）
        Boolean accountResult = accountFeignClient.decrease(
            request.getUserId(), request.getAmount());
        if (!Boolean.TRUE.equals(accountResult)) {
            throw new RuntimeException("余额扣减失败");
        }
        
        // 4. 更新订单状态
        updateOrderStatus(order.getId(), OrderStatus.COMPLETED);
        
        log.info("订单创建成功");
        return order;
    }
    
    private OrderDTO createLocalOrder(OrderRequest request) {
        OrderDTO order = OrderDTO.builder()
            .userId(request.getUserId())
            .productId(request.getProductId())
            .quantity(request.getQuantity())
            .amount(request.getAmount())
            .status(OrderStatus.CREATED)
            .build();
        orderMapper.insert(order);
        return order;
    }
}

​TCC模式事务示例：​​

@Service
@Slf4j
public class AccountTccService {
    
    @Autowired
    private AccountMapper accountMapper;
    
    // TCC模式 - Try阶段
    @Transactional
    @TwoPhaseBusinessAction(name = "accountService", commitMethod = "commit", 
                           rollbackMethod = "rollback")
    public boolean prepareDecrease(BusinessActionContext actionContext, 
                                  Long userId, BigDecimal amount) {
        String xid = actionContext.getXid();
        
        // 检查余额是否充足
        Account account = accountMapper.selectById(userId);
        if (account.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("余额不足");
        }
        
        // 冻结金额
        accountMapper.freezeBalance(userId, amount);
        
        // 记录事务日志
        accountMapper.insertTransactionLog(xid, userId, amount, "TRY");
        
        return true;
    }
    
    // TCC模式 - Confirm阶段
    @Transactional
    public boolean commit(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        Long userId = Long.valueOf(actionContext.getActionContext("userId").toString());
        BigDecimal amount = new BigDecimal(actionContext.getActionContext("amount").toString());
        
        log.info("确认扣减余额: xid={}, userId={}, amount={}", xid, userId, amount);
        
        // 扣减已冻结金额
        accountMapper.decreaseBalance(userId, amount);
        
        // 更新事务状态
        accountMapper.updateTransactionLog(xid, "COMMIT");
        
        return true;
    }
    
    // TCC模式 - Cancel阶段
    @Transactional
    public boolean rollback(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        Long userId = Long.valueOf(actionContext.getActionContext("userId").toString());
        BigDecimal amount = new BigDecimal(actionContext.getActionContext("amount").toString());
        
        log.info("回滚余额扣减: xid={}, userId={}, amount={}", xid, userId, amount);
        
        // 释放冻结金额
        accountMapper.unfreezeBalance(userId, amount);
        
        // 更新事务状态
        accountMapper.updateTransactionLog(xid, "ROLLBACK");
        
        return true;
    }
}
​六、 微服务监控与运维​

​6.1 链路追踪集成​

# 链路追踪配置
spring:
  zipkin:
    base-url: http://192.168.1.100:9411
  sleuth:
    sampler:
      probability: 1.0  # 采样率100%

# 自定义链路标签
management:
  tracing:
    sampling:
      probability: 1.0
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

​自定义业务追踪：​​

@Service
@Slf4j
public class OrderService {
    
    @Autowired
    private Tracer tracer;
    
    public OrderDTO createOrderWithTrace(OrderRequest request) {
        // 创建自定义Span
        ScopedSpan span = tracer.startScopedSpan("order.create");
        try {
            span.tag("order.userId", request.getUserId().toString());
            span.tag("order.amount", request.getAmount().toString());
            
            // 业务逻辑
            OrderDTO order = processOrder(request);
            
            span.event("order.created");
            return order;
            
        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.end();
        }
    }
}

​6.2 监控告警配置​

# Spring Boot Actuator配置
management:
  endpoint:
    health:
      show-details: always
      show-components: always
    metrics:
      enabled: true
    prometheus:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles:
        - 0.5
        - 0.95
        - 0.99

# 自定义健康检查
endpoints:
  health:
    defaults:
      enabled: true
    custom:
      enabled: true
@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Autowired
    private DataSource dataSource;
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Override
    public Health health() {
        // 检查数据库连接
        boolean dbHealthy = checkDatabaseHealth();
        // 检查Redis连接
        boolean redisHealthy = checkRedisHealth();
        // 检查外部服务
        boolean externalHealthy = checkExternalService();
        
        if (dbHealthy && redisHealthy && externalHealthy) {
            return Health.up()
                .withDetail("database", "available")
                .withDetail("redis", "available")
                .withDetail("externalService", "available")
                .build();
        } else {
            return Health.down()
                .withDetail("database", dbHealthy ? "available" : "unavailable")
                .withDetail("redis", redisHealthy ? "available" : "unavailable")
                .withDetail("externalService", externalHealthy ? "available" : "unavailable")
                .build();
        }
    }
}
​七、 性能优化实战经验​

​7.1 服务调优参数​

# 应用性能优化配置
server:
  tomcat:
    max-connections: 10000      # 最大连接数
    max-threads: 200            # 最大线程数
    min-spare-threads: 20       # 最小空闲线程
    connection-timeout: 10000   # 连接超时时间

spring:
  main:
    banner-mode: off           # 关闭Banner提升启动速度
  servlet:
    multipart:
      max-file-size: 10MB      # 文件上传大小限制
      max-request-size: 10MB

# 线程池配置
async:
  thread:
    core-size: 10
    max-size: 50
    queue-capacity: 1000

​7.2 缓存优化策略​

@Service
@Slf4j
public class ProductService {
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private RedisTemplate<String, ProductDTO> redisTemplate;
    
    // 多级缓存策略
    @Cacheable(value = "products", key = "#productId", 
               unless = "#result == null")
    public ProductDTO getProductWithCache(Long productId) {
        // 1. 先查本地缓存（Caffeine）
        // 2. 再查Redis缓存
        // 3. 最后查数据库
        return getProductWithMultiLevelCache(productId);
    }
    
    private ProductDTO getProductWithMultiLevelCache(Long productId) {
        // 本地缓存
        ProductDTO product = localCache.get(productId);
        if (product != null) {
            return product;
        }
        
        // Redis缓存
        String redisKey = "product:" + productId;
        product = redisTemplate.opsForValue().get(redisKey);
        if (product != null) {
            localCache.put(productId, product);
            return product;
        }
        
        // 数据库查询
        product = productMapper.selectById(productId);
        if (product != null) {
            // 异步更新缓存
            CompletableFuture.runAsync(() -> {
                redisTemplate.opsForValue().set(redisKey, product, 
                    Duration.ofMinutes(30));
                localCache.put(productId, product);
            });
        }
        
        return product;
    }
}
​八、 真实案例：电商平台微服务架构演进​

​8.1 架构演进历程​

阶段1：单体架构（月订单<1万）
    ↓
阶段2：垂直拆分（月订单<10万）  
    ↓
阶段3：服务化架构（月订单<100万）
    ↓
阶段4：领域驱动设计（月订单>100万）

​8.2 性能对比数据​

指标单体架构微服务架构提升效果
系统吞吐量100 TPS1000+ TPS10倍提升
部署频率每周1次每天多次部署效率提升
故障恢复小时级分钟级可用性提升
资源利用率30%60%成本降低

​8.3 典型问题解决方案​

​数据一致性问题：​​

@Component
public class SagaOrchestrator {
    
    // Saga编排器解决长事务问题
    public void createOrderSaga(OrderRequest request) {
        Saga saga = Saga.create()
            .activity("创建订单", () -> orderService.create(request))
            .activity("扣减库存", () -> inventoryService.deduct(request))
            .activity("扣减余额", () -> accountService.decrease(request))
            .compensation("补偿订单", () -> orderService.cancel(request))
            .compensation("恢复库存", () -> inventoryService.restore(request))
            .compensation("恢复余额", () -> accountService.restore(request));
            
        saga.execute();
    }
}
​九、 总结与最佳实践​

​9.1 微服务拆分原则​

  1. ​单一职责原则：​​ 每个服务只负责一个业务领域
  2. ​自治性原则：​​ 服务可以独立开发、测试、部署、扩展
  3. ​轻量级通信：​​ 使用RESTful API或轻量级RPC框架
  4. ​弹性设计：​​ 具备容错、降级、熔断能力

​9.2 技术选型建议​

  • ​中小团队：​​ Spring Cloud Alibaba + Nacos + Sentinel
  • ​大型企业：​​ 自研注册中心 + Apollo配置中心 + 全链路监控
  • ​云原生：​​ Kubernetes + Istio + 云服务

​9.3 成功关键因素​

  1. ​组织架构匹配：​​ 康威定律，架构反映组织沟通结构
  2. ​基础设施完善：​​ CI/CD、监控、告警等配套设施
  3. ​团队技术能力：​​ 分布式系统开发运维经验
  4. ​渐进式演进：​​ 从单体逐步拆分，避免一步到位

微服务架构不是银弹，需要根据团队规模、业务场景、技术实力等因素综合考虑。希望本文的实战经验能为你的微服务之旅提供有价值的参考。

# 架构 # spring cloud # 微服务
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区