Mastering the Spring Cloud Alibaba Microservice Ecosystem: From Nacos to XXL‑JOB

In the era of the internet, complex business logic is best handled by splitting a monolithic system into multiple microservices, each with a single responsibility and the ability to scale vertically.

However, isolated microservices become islands; to unlock their full value they must be connected through a microservice ecosystem.

The ecosystem includes the following core modules:

Service registration and discovery : providers register themselves, and callers obtain service instances from a registry using load‑balancing algorithms.

Service invocation : various protocols (e.g., HTTP) are used to call target services.

Load balancing : multiple algorithms support different business scenarios.

Service stability : circuit breaking, rate limiting, and degradation mechanisms.

Distributed configuration center : unified management of configuration items with dynamic hot‑reload.

Message queue : decouples non‑core logic from synchronous flows, enabling asynchronous processing.

Gateway : centralizes common concerns such as rate limiting, authentication, black/white lists, and gray releases.

Monitoring : health checks of services.

Distributed tracing : visualizes call chains for performance tuning and troubleshooting.

Automated deployment : CI/CD pipelines for rapid application rollout.

Spring Cloud Alibaba provides a one‑stop solution for these capabilities, requiring only a few Spring annotations and yaml configurations.

1. Spring Boot (service base)

Spring Boot extends the Spring framework with rich annotations, follows the "convention over configuration" principle, and offers Starter and AutoConfiguration mechanisms to simplify component integration via simple JAR dependencies.

Features:

Rich annotations eliminate the need for XML bean definitions.

Embedded web containers (Tomcat default, Jetty, Undertow).

Automatic configuration of mainstream open‑source frameworks based on project dependencies.

2. Nacos (registration & distributed configuration)

Nacos (Naming Configuration Service) from Alibaba focuses on service discovery and configuration management, replacing Eureka, Spring Cloud Config, and Spring Cloud Bus.

It supports Java, Go, Python, C#, and C++ clients.

Open source address: https://github.com/alibaba/nacos

Nacos provides a console for managing services and monitoring configurations.

Cluster deployment: Nacos is a single‑node service; to achieve high availability, a cluster mode with multiple nodes is required.

Example cluster.conf (place under nacos/conf):

# ip:port
200.8.9.16:8848
200.8.9.17:8848
200.8.9.18:8848

Clients only need to configure the leader node; the leader synchronizes data to other nodes, ensuring consistency.

For load balancing, Nginx or OpenResty can be used in the upstream module to list Nacos cluster IPs. Nginx health checks automatically bypass failed Nacos instances. To avoid a single point of failure for OpenResty, Keepalived can be added.

3. RestTemplate + Ribbon (remote call)

Spring Cloud Ribbon wraps Netflix Ribbon, providing multiple load‑balancing algorithms (random, round‑robin, etc.) and integrates with the registration center to fetch provider addresses automatically.

Ribbon also offers extension points for custom load‑balancing strategies.

public class CustomRule extends AbstractLoadBalancerRule {
    private AtomicInteger count = new AtomicInteger(0);
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }
    private Server choose(ILoadBalancer loadBalancer, Object key) {
        List<Server> allServers = loadBalancer.getAllServers();
        int requestNumber = count.incrementAndGet();
        if (requestNumber >= Integer.MAX_VALUE) {
            count = new AtomicInteger(0);
        }
        if (allServers != null) {
            int size = allServers.size();
            if (size > 0) {
                int index = requestNumber % size;
                Server server = allServers.get(index);
                if (server == null || !server.isAlive()) {
                    return null;
                }
                return server;
            }
        }
        return null;
    }
}

Drawback: each call requires manually specifying the remote target address and many parameters.

private final String SERVER_URL = "http://nacos-provider-demo";
@Resource
private RestTemplate restTemplate;

@RequestMapping("/hello")
public String hello() {
    return restTemplate.getForObject(SERVER_URL + "/hello", String.class);
}

4. OpenFeign (remote call)

OpenFeign builds on Feign, embedding Ribbon for client‑side load balancing. By defining an interface annotated with @FeignClient, developers can invoke remote services without manually handling URLs.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

@FeignClient(value = "${provider.name}")
public interface OrderService {
    @RequestMapping(value = "/create_order", method = RequestMethod.GET)
    String createOrder();
}

The @FeignClient resolves the provider’s artifactId to an IP list via the registry and applies load‑balancing automatically. Timeout can be configured with feign.client.config.default.readTimeout.

Read more about Feign’s dynamic proxy generation: https://mp.weixin.qq.com/s?__biz=... (link omitted for brevity)

5. Dubbo Spring Cloud (remote call)

Dubbo Spring Cloud combines Spring Cloud with Dubbo, using TCP for lightweight remote calls. Features include multiple registries, built‑in load‑balancing strategies, interface‑level granularity, and a micro‑kernel + plugin design.

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>

Key configuration items:

dubbo.scan.base-packages – package scanning for services.

dubbo.protocol.name – protocol name (e.g., dubbo).

dubbo.protocol.port – -1 for auto‑increment starting from 20880.

dubbo.registry.address – address of the registry.

6. Spring Cloud Gateway (gateway)

Gateway acts as a reverse proxy and the first entry point for traffic, handling routing, predicates, and filters (global and local). It is built on WebFlux and Netty, offering 1.6× the performance of the legacy Zuul.

Core components:

Routing – defines forwarding rules.

Predicate – determines whether a route is applicable; custom predicates can be created by extending AbstractRoutePredicateFactory.

Filter – adds custom logic between request and response; global filters implement GlobalFilter and Ordered, while local filters extend AbstractGatewayFilterFactory.

spring:
  cloud:
    gateway:
      routes:
        - id: user_route
          uri: lb://user-server-sample
          order: 1
          predicates:
            - Path=/user/**
          filters:
            - AddRequestHeader=X-Request-token, 12345678

The gateway can obtain service addresses dynamically from Nacos.

7. Sentinel (circuit breaking, rate limiting, degradation)

Sentinel, an Alibaba open‑source flow‑control framework, offers a more comprehensive feature set than Hystrix, supporting gRPC, Dubbo, Spring Cloud, etc.

It provides flow‑control rules (QPS, thread count), degradation rules (RT, exception count, exception ratio), system rules, authorization rules, and hotspot rules. The @SentinelResource annotation allows custom block handlers and fallbacks.

// Resource name: handle1
@RequestMapping("/handle1")
@SentinelResource(value = "handle1", blockHandler = "blockHandlerTestHandler")
public String handle1(String params) {
    return "success";
}

public String blockHandlerTestHandler(String params, BlockException ex) {
    return "fallback response";
}

8. Seata (distributed transaction)

Seata provides AT, TCC, SAGA, and XA transaction modes, with AT as the default, enabling non‑intrusive, high‑performance distributed transactions.

Key components:

Transaction Manager (TM) – defines the global transaction scope.

Transaction Coordinator (TC) – maintains global and branch transaction states.

Resource Manager (RM) – manages branch resources and reports status to TC.

Typical workflow: TM creates a global XID, RM registers branch transactions, TM decides commit/rollback, and TC coordinates the final outcome.

9. Spring Cloud Stream (asynchronous messaging)

Spring Cloud Stream abstracts underlying message middleware (RabbitMQ, Kafka, RocketMQ) and provides annotations such as @Input, @Output, @StreamListener, and @EnableBinding.

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
</dependency>

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

public interface CustomSource {
    @Output("output1")
    MessageChannel output1();
}

@Service
public class SendMessageService {
    @Resource
    private CustomSource customSource;
    public String sendMessage() {
        String message = "test string";
        customSource.output1().send(MessageBuilder.withPayload(message).build());
        return "sent";
    }
}

10. SkyWalking (distributed tracing)

SkyWalking is an APM system for microservices and cloud‑native architectures. It uses agents to collect tracing data and supports multiple storage backends (ES, MySQL, etc.).

Official site: https://skywalking.apache.org/

Quick start: https://skywalking.apache.org/zh/2020-04-19-skywalking-quick-start/

11. XXL‑JOB (distributed task scheduling)

XXL‑JOB is a lightweight distributed scheduling framework that requires only Java and MySQL. It offers a visual console, dynamic task timing, email alerts, sharding, and retry mechanisms.

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.2.0</version>
</dependency>

server:
  port: 8082
xxl:
  job:
    admin:
      addresses: http://127.0.0.1:8002/xxl-job-admin
    accessToken:
    executor:
      appname: xxl-job-executor-sample
      ip:
      port: 9989
      logpath: D:/work/Spring-Cloud-Alibaba/sample/logs
      logretentiondays: 30

@Bean
public XxlJobSpringExecutor xxlJobExecutor() {
    XxlJobSpringExecutor executor = new XxlJobSpringExecutor();
    executor.setAdminAddresses(adminAddresses);
    executor.setAppname(appname);
    executor.setAddress(address);
    executor.setIp(ip);
    executor.setPort(port);
    executor.setAccessToken(accessToken);
    executor.setLogPath(logPath);
    executor.setLogRetentionDays(logRetentionDays);
    return executor;
}

Official site: https://www.xuxueli.com/xxl-job/

All the above components together form a complete Spring Cloud Alibaba microservice ecosystem, enabling rapid development, high availability, and easy management of complex distributed systems.