Spring Boot 4.0 与 Spring Cloud Alibaba 2025 整合指南

第二步：配置文件

2.1 bootstrap.yml (应用启动配置)

spring:
  application:
    name: demo-service
  profiles:
    active: dev
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        file-extension: yaml
        namespace: dev-namespace
        group: DEFAULT_GROUP
        extension-configs:
          - data-id: shared-config.yaml
            group: SHARED_GROUP
            refresh: true
      discovery:
        server-addr: localhost:8848
        namespace: dev-namespace
        group: DEFAULT_GROUP
        metadata:
          version: 1.0
    sentinel:
      transport:
        dashboard: localhost:8080
      eager: true
      datasource:
        ds1:
            nacos:
              server-addr: localhost:8848
              data-id: ${spring.application.name}-sentinel
              group-id: DEFAULT_GROUP
              data-type: json
              rule-type: flow

2.2 application.yml (应用配置)

server:
  port: 8081
  servlet:
    context-path: /demo
spring:
  main:
    allow-bean-definition-overriding: true
  mvc:
    throw-exception-if-no-handler-found: true
  web:
    resources:
      add-mappings: false
  management:
    endpoints:
      web:
        exposure:
          include: health,info,metrics
    endpoint:
      health:
        show-details: always
  feign:
    sentinel:
      enabled: true
    client:
      config:
        default:
          connect-timeout: 5000
          read-timeout: 5000
          logger-level: basic
logging:
  level:
    com.example: debug
    com.alibaba.nacos: warn

第三步：主应用类

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient // 启用服务发现
@EnableFeignClients(basePackages = "com.example.service") // 启用 Feign 客户端
public class Springboot4ScAlibabaApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot4ScAlibabaApplication.class, args);
    }
}

第四步：Nacos 服务注册与发现

4.1 服务提供者示例

package com.example.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class DemoController {
    @Value("${server.port}")
    private String port;

    @GetMapping("/hello")
    public String hello(@RequestParam String name) {
        return String.format("Hello %s, from port: %s", name, port);
    }

    @GetMapping("/health")
    public String health() {
        return "Service is healthy";
    }
}

4.2 服务消费者示例（使用 OpenFeign）

4.2.1 创建 Feign 客户端接口

package com.example.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(name = "demo-service", path = "/demo/api")
public interface DemoServiceClient {
    @GetMapping("/hello")
    String sayHello(@RequestParam String name);

    @GetMapping("/health")
    String healthCheck();
}

4.2.2 创建 Fallback 类

package com.example.service;

import org.springframework.stereotype.Component;

@Component
public class DemoServiceFallback implements DemoServiceClient {
    @Override
    public String sayHello(String name) {
        return "Fallback: Hello " + name;
    }

    @Override
    public String healthCheck() {
        return "Fallback: Service unavailable";
    }
}

4.2.3 更新 Feign 客户端配置 Fallback

@FeignClient(
    name = "demo-service",
    path = "/demo/api",
    fallback = DemoServiceFallback.class
)
public interface DemoServiceClient {
    // 接口方法保持不变
}

4.2.4 消费者控制器

package com.example.controller;

import com.example.service.DemoServiceClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Autowired
    private DemoServiceClient demoServiceClient;

    @GetMapping("/call-hello")
    public String callHello(@RequestParam String name) {
        return demoServiceClient.sayHello(name);
    }
}

第五步：Nacos 配置管理

5.1 动态配置示例

package com.example.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/config")
@RefreshScope // 支持配置动态刷新
public class ConfigController {
    @Value("${app.config.demo:defaultValue}")
    private String demoConfig;

    @Value("${app.feature.enabled:false}")
    private boolean featureEnabled;

    @GetMapping("/demo")
    public String getDemoConfig() {
        return "Current config: " + demoConfig + ", Feature enabled: " + featureEnabled;
    }
}

5.2 在 Nacos 中创建配置

在 Nacos 控制台创建 Data ID: demo-service-dev.yaml，配置内容：

app:
  config:
    demo: "This is dynamic config from Nacos"
  feature:
    enabled: true
server:
  port: 8081
logging:
  level:
    com.example: info

第六步：Sentinel 流量控制

6.1 Sentinel 配置类

package com.example.config;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class SentinelConfig {
    @Bean
    public BlockExceptionHandler sentinelBlockExceptionHandler() {
        return new CustomBlockExceptionHandler();
    }

    static class CustomBlockExceptionHandler implements BlockExceptionHandler {
        @Override
        public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
            Map<String, Object> result = new HashMap<>();
            if (e instanceof FlowException) {
                result.put("code", 1001);
                result.put("message", "接口限流");
            } else if (e instanceof DegradeException) {
                result.put("code", 1002);
                result.put("message", "服务降级");
            } else if (e instanceof ParamFlowException) {
                result.put("code", 1003);
                result.put("message", "热点参数限流");
            } else if (e instanceof SystemBlockException) {
                result.put("code", 1004);
                result.put("message", "系统规则限制");
            } else if (e instanceof AuthorityException) {
                result.put("code", 1005);
                result.put("message", "授权规则不通过");
            } else {
                result.put("code", 1000);
                result.put("message", "未知限流");
            }
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.setCharacterEncoding("UTF-8");
            response.setContentType(MediaType.APPLICATION_JSON_VALUE);
            new ObjectMapper().writeValue(response.getWriter(), result);
        }
    }
}

6.2 使用 Sentinel 注解进行资源保护

package com.example.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/sentinel")
public class SentinelController {
    @GetMapping("/resource")
    @SentinelResource(
        value = "protectedResource",
        blockHandler = "handleBlock",
        fallback = "handleFallback"
    )
    public String protectedResource() {
        return "This is a protected resource";
    }

    // 限流处理
    public String handleBlock(BlockException ex) {
        return "请求过于频繁，请稍后重试";
    }

    // 降级处理
    public String handleFallback(Throwable ex) {
        return "服务暂时不可用，请稍后重试";
    }
}

第七步：高级配置

7.1 自定义 Ribbon 配置（负载均衡）

package com.example.config;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Flux;

import java.util.Arrays;
import java.util.List;

@Configuration
public class LoadBalancerConfig {
    @Bean
    public ServiceInstanceListSupplier serviceInstanceListSupplier() {
        return new DemoServiceInstanceListSupplier("demo-service");
    }

    static class DemoServiceInstanceListSupplier implements ServiceInstanceListSupplier {
        private final String serviceId;

        public DemoServiceInstanceListSupplier(String serviceId) {
            this.serviceId = serviceId;
        }

        @Override
        public String getServiceId() {
            return serviceId;
        }

        @Override
        public Flux<List<ServiceInstance>> get() {
            // 这里可以自定义服务实例发现逻辑
            return Flux.just(Arrays.asList());
        }
    }
}

7.2 全局异常处理

package com.example.config;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Map<String, Object> handleException(Exception e) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 500);
        result.put("message", "系统异常：" + e.getMessage());
        return result;
    }
}

第八步：部署和测试

8.1 启动 Nacos 和 Sentinel Dashboard

# 启动 Nacos (需要提前下载)
sh nacos/bin/startup.sh -m standalone

# 启动 Sentinel Dashboard (需要提前下载)
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -jar sentinel-dashboard.jar

8.2 应用启动类增强

package com.example;

import org.springframework.boot.Banner;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.core.env.Environment;

import java.util.Objects;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.example.service")
public class Springboot4ScAlibabaApplication {
    public static void main(String[] args) {
        new SpringApplicationBuilder(Springboot4ScAlibabaApplication.class).bannerMode(Banner.Mode.CONSOLE).run(args);
    }

    public void printInfo(Environment env) {
        String port = env.getProperty("server.port");
        String contextPath = Objects.requireNonNullElse(env.getProperty("server.servlet.context-path"), "");
        System.out.println("\n----------------------------------------------------------");
        System.out.println("Application is running! Access URLs:");
        System.out.println("Local: \t\thttp://localhost:" + port + contextPath);
        System.out.println("External: \thttp://" + getHostAddress() + ":" + port + contextPath);
        System.out.println("Profile(s): \t" + String.join(",", env.getActiveProfiles()));
        System.out.println("----------------------------------------------------------\n");
    }

    private String getHostAddress() {
        try {
            return java.net.InetAddress.getLocalHost().getHostAddress();
        } catch (Exception e) {
            return "127.0.0.1";
        }
    }
}

8.3 测试端点

package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/actuator")
public class ActuatorController {
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/services")
    public List<String> getServices() {
        return discoveryClient.getServices().stream()
                .map(service -> service + ": " + discoveryClient.getInstances(service))
                .collect(Collectors.toList());
    }

    @GetMapping("/info")
    public String info() {
        return "Spring Boot 4.0 with Spring Cloud Alibaba 2025";
    }
}

第九步：Docker 部署配置

9.1 Dockerfile

FROM openjdk:21-jdk-slim

# 设置工作目录
WORKDIR /app

# 复制 JAR 文件
COPY target/springboot4-sc-alibaba-demo-1.0.0.jar app.jar

# 暴露端口
EXPOSE 8080

# 设置 JVM 参数
ENV JAVA_OPTS="-Xmx512m -Xms256m -Djava.security.egd=file:/dev/./urandom"

# 启动应用
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

9.2 docker-compose.yml

version: '3.8'
services:
  nacos:
    image: nacos/nacos-server:latest
    container_name: nacos-server
    environment:
      - MODE=standalone
    ports:
      - "8848:8848"
    networks:
      - sc-alibaba-net

  sentinel:
    image: bladex/sentinel-dashboard:latest
    container_name: sentinel-dashboard
    ports:
      - "8080:8080"
    networks:
      - sc-alibaba-net

  demo-app:
    build: .
    container_name: demo-service
    ports:
      - "8081:8081"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - SPRING_CLOUD_NACOS_CONFIG_SERVER-ADDR=nacos:8848
      - SPRING_CLOUD_NACOS_DISCOVERY_SERVER-ADDR=nacos:8848
      - SPRING_CLOUD_SENTINEL_TRANSPORT_DASHBOARD=sentinel:8080
    depends_on:
      - nacos
      - sentinel
    networks:
      - sc-alibaba-net

networks:
  sc-alibaba-net:
    driver: bridge

总结

本文详细介绍了 Spring Boot 4.0 与 Spring Cloud Alibaba 2025 最新版本的完整整合方案，包括：

1. 项目搭建和依赖配置
2. Nacos 服务注册与发现
3. Nacos 配置中心集成
4. Sentinel 流量控制与熔断降级
5. OpenFeign 声明式服务调用
6. 高级配置和最佳实践
7. Docker 容器化部署

通过这套完整的微服务解决方案，您可以快速构建高可用、可扩展的分布式应用系统。记得根据实际生产环境需求调整配置参数和安全设置。