Understanding Microservices: Architecture, Communication, and Key Differences

1. Definition of a microservice

A microservice is a lightweight, independently deployable component that implements a single business capability (e.g., user authentication). Each microservice runs in its own process, is packaged as a separate Maven module (commonly using Spring Boot), and communicates with other services via lightweight protocols.

Microservice = independent, single‑responsibility service application.

2. Independent communication between microservices

Synchronous communication – Remote Procedure Call (RPC) frameworks such as Dubbo or HTTP/JSON‑based REST APIs provided by Spring Cloud.

Asynchronous communication – Message‑oriented middleware like RabbitMQ, ActiveMQ, or Apache Kafka, which decouple producers and consumers and enable event‑driven interaction.

3. Comparison of Spring Cloud and Dubbo

Both are distributed service frameworks, but they use different transport protocols. Dubbo uses a binary protocol, resulting in lower bandwidth consumption and higher raw performance.

Spring Cloud relies on HTTP/JSON (REST), which is more bandwidth‑intensive but offers greater flexibility and language‑agnostic interoperability.

Dubbo has a steeper learning curve and can introduce complex transitive dependencies in large projects.

Spring Cloud provides easier integration, automatic configuration, and code generation, making it suitable for rapidly evolving microservice ecosystems.

REST‑based communication avoids the tight coupling of native RPC, reducing the risk of cascading failures when services evolve independently.

Official Dubbo site: https://dubbo.apache.org/

4. Relationship between Spring Boot and Spring Cloud

Spring Boot focuses on rapid development of individual microservices (micro‑level). Spring Cloud builds on top of Spring Boot to provide global coordination, service discovery, configuration management, and resilience (macro‑level). A Spring Boot application can run standalone, but Spring Cloud’s features require a Spring Boot foundation.

5. Circuit breaking and service degradation

Circuit breaking acts like an electrical fuse: when a downstream service becomes unavailable or exceeds latency thresholds, the circuit opens and further calls are short‑circuited, preventing cascade failures.

Service degradation (fallback) returns predefined responses for non‑critical functions when the system is under heavy load or a dependent service is degraded, preserving overall stability while sacrificing optional features.

6. Advantages, disadvantages and common pitfalls

Advantages : loose coupling, single‑business focus, language‑agnostic, smaller team ownership, isolated failure domains, independent scaling, technology diversity.

Disadvantages : increased operational complexity, higher infrastructure cost, network latency and serialization overhead, more extensive monitoring and logging, data consistency challenges, need for robust distributed tracing.

Typical pitfalls : version incompatibility between services, improper timeout and retry settings leading to hidden latency, insufficient circuit‑breaker configuration, over‑splitting business logic causing excessive inter‑service calls, and neglecting end‑to‑end testing.

7. Eureka vs Zookeeper for service registration

Zookeeper

follows CP (Consistency‑Partition tolerance) principles, providing strong consistency at the cost of availability during leader election. Eureka follows AP (Availability‑Partition tolerance) principles, offering higher availability; each node is equal and the failure of a single node does not affect the registry.

During a Zookeeper master failure, a new leader is elected, which may cause temporary service unavailability.

Eureka’s peer‑to‑peer model continues to serve registration requests even when individual nodes go down.

8. Typical microservice technology stack

A common stack includes:

Runtime: Spring Boot (Java), Node.js, Go, etc.

Service discovery & registration: Eureka, Zookeeper, Consul.

API gateway: Spring Cloud Gateway, Kong, Zuul.

Remote call: Dubbo, Feign, gRPC.

Resilience: Hystrix, Resilience4j, Sentinel.

Asynchronous messaging: RabbitMQ, Kafka, ActiveMQ.

Configuration management: Spring Cloud Config, Apollo.

Containerization & orchestration: Docker, Kubernetes.

Observability: Prometheus, Grafana, ELK stack, distributed tracing (e.g., Zipkin, Jaeger).

9. Microservice architecture

Microservice architecture is the set of patterns and infrastructure that manage a collection of independent microservices. It provides service discovery, centralized configuration, load balancing, security, and monitoring, enabling each microservice to evolve, scale, and be deployed independently while the architecture ensures coherent end‑to‑end functionality.