This article explains microservice service governance, covering registration and discovery, load balancing, rate limiting, circuit breaking, dynamic configuration management, and monitoring using tools like Nacos, Dubbo, Sentinel, Prometheus, and SkyWalking.
This article explains microservice architecture fundamentals, including independent deployment, lightweight communication, single‑responsibility services, and key design patterns such as aggregation, proxy, asynchronous messaging, and data‑sharing, illustrating each with diagrams and practical insights.
The article explains how Helm simplifies deploying complex Kubernetes applications with a single YAML chart but cannot manage runtime operations, while Kubernetes Operators—built on custom resource definitions and webhook logic—automate tasks such as scaling, upgrades, and side‑car injection, offering higher‑level lifecycle management.
This article explains the key changes in Spring Boot 3, outlines the new OAuth2 components, and provides a detailed design for secure microservice authentication and authorization using Spring Authorization Server, JWT, API Gateway, and client applications, complete with architecture diagrams and implementation steps.
The Cloud Development gateway’s evolution from a dual‑layer design—separating encryption/decryption from Envoy—to a single‑layer architecture that embeds encryption directly into Envoy filters streamlines traffic handling, strengthens protection against MITM attacks, reduces CPU and operational overhead, and unifies monitoring for a more efficient cloud‑native solution.
This article explains a subtle thread‑pool deadlock caused by parent‑child task interactions, demonstrates the issue with a reproducible demo, analyzes why the latch logic fails, and provides a practical solution of isolating thread pools to avoid false‑deadlock behavior in microservices.
This article introduces Domain-Driven Design (DDD), explains its core concepts, benefits, and the four-layered DDD architecture—including UI, Application, Domain, and Infrastructure layers—while also offering resources for deeper study and interview preparation.
This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to define clear service boundaries, handle communication, and balance consistency with availability.
This guide explains why traditional Java timers fail in microservice clusters, introduces Spring Cloud Alibaba's SchedulerX module with high‑availability and lock features, and provides step‑by‑step Maven setup, configuration, and code examples for both Alibaba SchedulerX and the open‑source ShedLock approach.
This article breaks down complex B2B e‑commerce permission scenarios—including multi‑client authentication, role‑based and identity‑based authorization, and a conceptual model—providing clear design points and practical implementation guidance for secure, scalable systems.
This article provides a step‑by‑step guide to implementing gray (canary) release in a Spring Cloud microservice architecture, covering core components such as Nacos registration, Spring Cloud Gateway filters, custom Ribbon load‑balancing, OpenFeign interceptors, and configuration details with full code examples.
This article presents a comprehensive case study of NetEase Cloud Music's automatic upgrade platform, detailing the background challenges, technical architecture, sidecar versus component upgrades, workflow orchestration, operational safeguards, performance metrics, and future roadmap for large‑scale microservice migrations.
An October 2023 outage of the bfe‑customer‑application‑query‑svc revealed how traffic spikes, downstream latency, and a mis‑configured custom thread pool saturated Tomcat's worker threads, causing health‑check failures, pod restarts, and a complete zone failure.
The article explains how to build reliable microservices by isolating failures, applying graceful degradation, change‑management, health checks, self‑healing, fallback caching, retry strategies, rate limiting, fast‑fail principles, circuit breakers, and failure‑testing to ensure high availability in distributed cloud‑native systems.
This article breaks down Netflix’s comprehensive technology stack—from mobile and web front‑ends to microservices, data storage, streaming pipelines, and CI/CD tools—showcasing how the platform delivers seamless, high‑performance video experiences to billions of users worldwide.
This article details a complete system refactoring project, describing the original monolithic bottlenecks, the design of a distributed architecture, database model reconstruction, phased migration, testing, and rollout strategies to achieve scalable, reliable backend services.
This comprehensive guide explains Nacos's architecture, registration center, configuration center, deployment modes, data models, service discovery, health monitoring, dynamic configuration, multi‑environment support, and real‑time refresh mechanisms, providing practical code examples and operational best practices.
This article explores essential service design considerations beyond standard guidelines, covering API path structuring, request handling, parameter design, security measures, monitoring, degradation strategies, and code examples to help build flexible, secure, and maintainable backend services.
This article provides an in‑depth overview of Seata, an open‑source distributed transaction solution, covering its core components, workflow, and the four transaction modes (AT, TCC, SAGA, XA) along with their characteristics and usage in microservice architectures.
The article investigates a recurring SocketTimeoutException caused by a circular dependency between two Spring Cloud services, explains the deadlock mechanism, demonstrates how removing the circular call resolves the issue, and provides verification steps with code, JMeter load testing, and thread‑dump analysis.
This article presents a comprehensive case study of refactoring a consumer installment platform, covering business restructuring, technical debt resolution, design of domain and module layers, code redesign with design patterns, phased deployment, monitoring setup, and the overall benefits achieved.
This article explains the fundamentals of distributed architecture, covering its key characteristics, microservice principles, Spring Cloud implementations, Service Mesh concepts, and essential components like distributed storage, caching, and transaction management for building scalable, resilient backend systems.
Suzhou Bank’s Mobile Banking 5.0 platform, showcased at the 23rd GOPS Global Operations Conference, demonstrates how a unified micro‑service architecture, advanced security technologies, and a comprehensive DevOps platform can elevate development efficiency, meet international standards, and drive innovative financial services.
Learn how to build high‑performance, secure gRPC services in Rust using the Tonic framework, covering its core components, advantages, installation steps, project setup, protobuf definition, code generation, server implementation, and client creation with detailed code examples.
This article explains why MSE's graceful startup misinterprets Kubernetes liveness probes as service warm‑up, shows how to configure ignored paths, discusses alternative TCP‑based probes, and outlines the three core no‑loss deployment features—delayed registration, small‑traffic warm‑up, and readiness checks—plus gateway warm‑up steps.
This article explains the fundamentals of distributed RPC, outlines its end‑to‑end communication workflow, and compares major frameworks such as gRPC, Apache Thrift, Dubbo, Spring Cloud Netflix, ZeroMQ, Apache Avro, and gRPC‑Web, helping developers choose the right solution for their microservice architecture.
This article explores three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑AOP header checks—to restrict certain APIs to internal network calls, and provides step‑by‑step SpringBoot code examples for implementing the preferred gateway‑AOP solution.
The article explains how microservice architectures handle inter‑service calls using RPC or event‑driven approaches, analyzes different coupling types, compares event notification with event sourcing, and offers practical guidance on API gateways, service composition, and when to choose each communication style.
This article explains what a service gateway is, why it is essential for microservice architectures, outlines its core functions and design considerations, and presents a practical Java‑based technology stack including Spring Boot, Netflix Zuul, Consul, JWT, Prometheus, and ELK.
This article explores system theory, architectural design, and complexity, presenting a structured view of systems, their characteristics, modeling approaches like 4+1 and C4, microservice concepts, and the Cynefin framework, offering developers practical insights to manage and evolve software systems effectively.
This article compares Spring Boot and Quarkus across architecture, startup speed, memory usage, and native image support, presents detailed JMeter performance tests, and offers practical guidance for migrating Spring applications to the cloud‑native Quarkus framework.
This article traces the historical evolution of backend system architecture—from early single‑machine monolithic deployments through database isolation, static‑dynamic separation, front‑back separation, clustering, caching, message queues, sharding, SOA, microservices, containerization, CI/CD, and finally cloud‑native designs—highlighting the motivations, challenges, and key technologies at each stage.
An in‑depth exploration shows how viewing software as a system, mastering architectural models like 4+1, C4 and TOGAF, and applying the Cynefin framework for complexity can guide developers from basic system concepts to effective microservice design and complexity management.
This article explores how a systematic, high‑dimensional view of software systems—covering system theory, architectural models like 4+1, C4 and TOGAF, micro‑service design, and the Cynefin complexity framework—helps developers move from code‑writing to strategic architecture while managing complexity.
This article analyzes why distributed transactions are difficult in large‑scale microservice architectures, explains the importance of unique transaction IDs, idempotency, and timeout handling, and presents pragmatic approaches such as local logging, undo‑log tables, NoSQL ID arrays, and selective locking to achieve reliable consistency.
The article explains that distributed transactions in micro‑service architectures are difficult because they must guarantee atomicity across heterogeneous services, handle time‑outs, and reconcile results using unique transaction IDs, undo‑logs, or NoSQL strategies, while balancing locking, availability, and consistency trade‑offs.
This article explains how traffic governance—including circuit breaking, isolation, retry mechanisms, degradation, timeout control, and rate limiting—helps microservice systems achieve the three‑high goals of high performance, high availability, and easy scalability, using concrete formulas, algorithms, and practical examples.
This document outlines a detailed training curriculum covering backend development, cloud-native technologies, microservice frameworks, databases, messaging systems, containerization, orchestration, performance tuning, and related tools, presented as a series of numbered sessions with practical labs and theory.
This article explains the two new features introduced in Spring Cloud OpenFeign 4.1.2—request parameter constraints and custom status codes—by providing step‑by‑step examples, code snippets, and configuration details to demonstrate how to enable and use these capabilities in a SpringBoot 3.3.1 microservice environment.
This article walks through a complete gray‑release solution built on Spring Cloud, Nacos as the service registry, and a custom load‑balancer, detailing the architecture, code implementation, configuration, and step‑by‑step deployment to demonstrate traffic splitting and version routing.
This article explains how traffic governance—through circuit breaking, isolation, retry strategies, degradation, timeout handling, and rate limiting—keeps distributed systems highly available, performant, and scalable, using concrete examples, formulas, and best‑practice patterns for modern microservice architectures.
This comprehensive guide explains why a gateway is essential in microservice architectures, outlines Spring Cloud Gateway's core features, walks through building a gateway from scratch, and demonstrates advanced topics such as custom predicates, filters, Nacos service discovery, dynamic routing, and global error handling.
This article presents a comprehensive case study of a high‑traffic business middle‑platform built with SpringBoot microservices, Kong API Gateway, MyCat‑sharded MySQL, Docker containerization, Kubernetes orchestration, CI/CD pipelines, and monitoring tools, detailing design decisions, implementation tricks, and operational lessons learned.
Facing growing complexity in video streaming, the team overhauled a legacy codebase by redefining architecture, improving code quality, and boosting engineering efficiency through componentized micro‑services, static analysis, automated testing, and gradual rollout, ultimately achieving decoupled, fast‑iteration capabilities across the platform.
To tackle mounting complexity in a fast‑growing video streaming platform, the team executed a large‑scale refactor that introduced a vertical‑layered, horizontally modular architecture, enforced coding standards and ArchUnit guards, applied incremental safe refactoring and gray‑release monitoring, ultimately reducing core classes to seven, improving code quality and engineering efficiency.
Traditional LAMP stacks, relying on php‑fpm and nginx, suffer from synchronous blocking and high CPU usage, limiting throughput for IO‑intensive microservice workloads, while benchmarks show that upgrading to PHP 7 and using a modern, asynchronous PHP framework like Webman can dramatically improve QPS and reduce latency.
This document introduces the Exam‑Ning system, detailing its front‑end Vue‑Element‑Admin UI, back‑end Spring Boot/Spring Cloud architecture with Nacos, OAuth2, OpenFeign, Sentinel, and API Gateway, outlines its modules and functions, provides deployment steps, and includes a questionnaire request for obtaining the source code.
The article details a real‑world case study of building and operating a high‑traffic business middle‑platform for a leading consumer‑goods company, covering business and technical architecture, API gateway selection, SpringBoot microservices, custom MyBatis, logging, SSL, Docker, MyCat sharding, K8s deployment, CI/CD pipeline, and monitoring solutions.
This article walks through a complete Domain‑Driven Design case study using a restaurant example, covering domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, microservice boundaries, and functional implementation to illustrate how business concepts map to software structures.
This article provides a deep technical analysis of Spring Boot's startup process, explains every relevant extension point, demonstrates how to log and verify execution order with sample code, answers eleven common questions about bean initialization, and offers practical guidance on when to safely open RPC, MQ, and HTTP traffic.
This comprehensive guide explains what microservices are, why they evolved from monolithic applications, the challenges they introduce, popular open‑source solutions such as Dubbo, Spring Cloud Netflix and Spring Cloud Alibaba, and essential components like service registries, configuration centers, remote‑call mechanisms, load‑balancing, circuit‑breakers, tracing, and monitoring for building resilient cloud‑native systems.
This article explains how to design a plug‑in architecture for a data‑governance service by using a custom URLClassLoader, Spring bean registration, and XXL‑Job integration to dynamically load, start, stop, upgrade, and unload individual governance tasks without restarting the whole service, and also shows how to persist the configuration in local YAML or Nacos.
This guide explains Zipkin's architecture, data collection methods, and step‑by‑step installation and configuration for PHP applications, including creating tracers, recording spans, and integrating a middleware for full‑stack monitoring in Webman microservice environments.
The article benchmarks Spring Boot and Quarkus for cloud‑native Java apps, showing Quarkus native images start up twice as fast, use less memory, and produce smaller artifacts than Spring Boot, while Spring Boot JVM offers slightly lower latency, and a migration guide demonstrates API compatibility and code reuse.
This article presents a comprehensive, step‑by‑step guide to building large‑scale backend systems—including microservice decomposition, CDN and cache layers, message queues, database sharding, read/write splitting, Elasticsearch search, distributed transaction handling, multithreaded data migration, and massive counting services—illustrated with real‑world examples and practical metrics.
This article explains how to use Log4j's Mapped Diagnostic Context (MDC) to generate, propagate, and record a traceId across micro‑service calls, providing a low‑cost, non‑intrusive solution for full‑stack log tracing and debugging.
This article outlines six fundamental microservice splitting principles—including single responsibility, appropriate granularity, interface segregation, product impact avoidance, scalability, and fault tolerance—to help architects design maintainable, decoupled, and resilient services.
Bilibili’s video submission platform uses a layered micro‑service architecture with a DAG‑based scheduler, extensive observability, and HA tactics such as sharding, 64‑bit ID migration, full‑link stress tests, chaos engineering, and multi‑active data‑center deployment, while tooling like trace correlation and automated alerts ensures stability and guides future hybrid‑cloud migration.
This article provides a step‑by‑step tutorial on Apollo's configuration center, covering its core concepts, four‑dimensional model, client design, Spring Boot integration, testing of dynamic updates, and deployment via Docker and Kubernetes for cloud‑native applications.
This article provides a comprehensive overview of a typical microservice architecture, detailing the roles of Nginx as the traffic entry, gateways, business services, service registries, caching, databases, messaging, logging, scheduling, and distributed storage, and offering practical guidance for high‑availability deployment.
The COLA (Clean Object‑Oriented and Layered Architecture) framework replaces traditional monolithic MVC Service layers with a clear, multi‑layered structure—Adapter, Application, Domain, Infrastructure, and Client—enhancing code cohesion, reducing coupling, and improving maintainability, as illustrated through a detailed order‑creation example with refactored Java code.
This article explains what cloud‑native databases are, outlines their key characteristics such as containerization, microservice architecture, elastic scaling, and automation, lists major cloud‑native database offerings, and describes common application scenarios for modern cloud environments.
This article explains how a complex supply‑chain platform with dozens of services and two client apps can be reorganized by introducing a gateway, an API aggregation layer, and a Backend‑for‑Frontend (BFF) pattern to reduce service coupling, simplify interface placement, and improve client‑specific adaptations.
This article outlines a comprehensive backend architecture for community platforms and billion‑level e‑commerce systems, covering microservice decomposition, DDD modeling, caching strategies, Redis clustering, message‑queue decoupling, database sharding, read‑write separation, distributed transaction approaches, multithreaded data migration, and massive counting techniques.
This article explains the concept, architecture, essential components, strategy types, and practical implementation details of a gray (canary) release system in microservice environments, covering simple designs, Nginx integration, gateway handling, and complex multi‑service and data‑layer scenarios.
This article examines the background, refactoring strategy, stability safeguards, and results of redesigning JD Express's refund, amount‑calculation, and reverse‑billing backend modules, highlighting the use of design patterns, incremental testing, and code‑quality improvements to reduce complexity and enhance system reliability.
The article humorously chronicles a series of real‑world over‑design incidents—excessive microservice splitting, needless multi‑database sharding, ubiquitous message‑queue usage, over‑engineered caching, design‑pattern abuse, and bloated database schemas—highlighting why simplicity (KISS) remains the best practice for backend systems.
This article explains how to design and implement a recommendation system by leveraging a four‑layer cloud‑native stack, covering virtualization, micro‑service migration, service governance, elasticity, cloud‑native business capabilities, and chaos‑engineering‑based stability practices to achieve cost‑effective, high‑performance, and reliable recommendation services.
The article recounts how a fast‑growing event‑processing platform initially embraced microservices, then faced queue bottlenecks, test‑suite overload, and operational complexity, leading the team to consolidate over 140 services into a single, shared‑queue architecture, and shares the practical insights and trade‑offs learned from this transition.
Joining Tencent in 2011, the author recounts building the Weibo mobile backend, pioneering location-based services with grid indexing, evolving microservice frameworks like TAF, handling massive traffic and early avalanche failures, and reflecting on the rapid rise of smartphones and competitive dynamics with WeChat.
This article explains the concept of graceful shutdown, outlines essential steps, examines Kubernetes pod termination and Spring Boot integration with Nacos, and provides practical optimizations—including PreStop hooks, terminationGracePeriod settings, and actuator shutdown—to ensure reliable service termination without data loss.
In 2023, leading cloud giants like Google and Amazon publicly questioned the value of microservices, presenting new “Microservices 2.0” principles and monolithic alternatives that promise dramatically lower latency, cost, and operational complexity while reshaping backend architecture debates.
The article details a SaaS company's two‑month development of an AI‑powered skin‑analysis solution, illustrating how DDD’s four‑color modeling split health services into aggregates, integrated Face++ APIs, and delivered a 30‑second, 30‑dimension skin report that attracted over 80 000 users and 9 000 orders.
This article examines the Matrix middle‑platform framework used at JD.com, detailing its hot‑deployment mechanism, the push‑and‑pull integration chains, class‑loader isolation based on the parent‑delegation model, and the design of business‑identity recognition, while offering best‑practice recommendations and code examples.
Tencent’s product middle platform employs a self‑built, stateless workflow orchestration engine—configurable via drag‑and‑drop or DSL—to coordinate massive product processing and audit tasks, using load‑balancing, retry, rate‑limiting, circuit‑breaker and service isolation strategies that ensure high availability, performance, and horizontal scalability on TKE.
Learn how to set up Spring Cloud Gateway, configure routes, predicates, and filters—including custom global filters and time-based predicates—while testing load balancing, weight distribution, and request handling in a microservices environment effectively.
The article explains why granting software teams independent decision‑making power speeds up delivery, reduces coordination overhead, and outlines three architectural approaches—loosely coupled subdomains, modular monoliths, and microservices—to achieve effective team autonomy.
The article introduces retrofit-spring-boot-starter, a lightweight HTTP client library for Spring Boot that simplifies HTTP calls, offers extensive features such as custom OkHttpClient injection, annotation‑based interceptors, retry, logging, circuit‑breaker, and provides detailed usage examples, configuration options, and advanced customization techniques.
The article outlines essential DevOps and agile practices—including Scrum, Kanban, continuous integration, continuous delivery, monitoring, micro‑services, automation, and security—to improve collaboration, increase release frequency, and deliver higher‑quality software faster.
This article explains the importance of rate limiting in microservice architectures, introduces four basic algorithms—fixed window, sliding window, leaky bucket, and token bucket—compares their advantages and disadvantages, and presents both single-machine and distributed implementations with Go code examples.
Manbang Group scaled its digital freight platform by replacing self‑built Eureka and ZooKeeper clusters with Alibaba Cloud MSE Nacos and ZooKeeper, achieving seamless traffic migration, dramatic performance gains, and high‑availability features such as push‑empty protection and incremental pull for Eureka clients.
This article explains the concept of high availability, introduces the dispersal principle, demonstrates its application in microservice architectures and distributed storage, and outlines the benefits such as improved reliability, scalability, fault tolerance, and reduced single‑point failures.
This article offers a detailed overview of Nacos, an open‑source service discovery and configuration platform, covering its core functions, architectural components, and modules while also providing promotional links to extensive Alibaba architecture and Java interview resources.
This article provides a comprehensive overview of Seata, the Alibaba‑developed distributed transaction solution for Spring Cloud Alibaba, explaining its purpose, core components (TC, TM, RM), architecture, and step‑by‑step workflow that ensures consistency across microservices.
This article explains what microservices are, outlines their advantages and disadvantages, compares them with monolithic architectures, and provides practical guidance on when and how to adopt a microservice approach for scalable, maintainable backend systems.
The article recounts Meituan Dianping’s transaction system evolution—from a simple MVC design to microservices and a plug‑in platform—illustrating how domain‑driven design’s ubiquitous language, bounded contexts, and strategic modeling guided the separation of core, supporting, and generic domains and enabled scalable, maintainable architecture.
The article explains how to handle distributed consistency when a financial reimbursement process involves MySQL writes and remote calls to BPM and SAP systems, analyzes failure scenarios, and proposes a split‑transaction approach using a task table, scheduled jobs, and Spring's afterCommit hook.
The article shares ten real‑world problems encountered in a Spring Cloud Alibaba microservice project—ranging from poor service decomposition and shared databases to chaotic configuration, unnecessary components, and deployment mistakes—offering insights to help teams prevent similar pitfalls.
The 2024 DevOps landscape is reshaped by emerging trends such as microservices, Kubernetes, Infrastructure as Code, DevSecOps, and AI/ML, which together accelerate delivery, improve quality, enhance collaboration, reduce costs, and boost enterprise resilience and adaptability.
This article explains how to set up and use Seata's AT mode with Spring Boot, Spring Cloud, and Alibaba components, providing detailed configuration, code examples, database scripts, and testing procedures to achieve reliable distributed transaction management in microservice architectures.
This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.
This article explains how to achieve graceful service startup and shutdown in Java projects, covering monolithic and microservice architectures, Spring and SpringBoot mechanisms, service registration with Eureka and Nacos, Kubernetes probes, thread‑pool and MQ graceful termination, and provides practical code examples for each scenario.
This article explains the fundamentals of Remote Procedure Call (RPC), its core components and workflow, compares it with other communication methods, lists popular RPC frameworks, and distinguishes RPC from SOA, SOAP, and REST, providing a comprehensive overview for backend developers.
This article narrates how McDonald’s food‑delivery platform uses a hexagonal, event‑driven, micro‑service architecture with serverless functions, message brokers, and schema registries to achieve massive scalability, low latency, and reliable order processing for millions of daily users.
This article explains cloud‑native architecture, covering its definition, core concepts such as microservices, containerization, automation, storage, networking, and the guiding principles of service orientation, elastic scaling, and observability that together enable highly available, scalable, and agile applications.
This article provides a comprehensive overview of Istio, explaining its role as an open‑source service mesh for cloud‑native microservices, detailing the data plane and control plane components, sidecar proxy functions, traffic management, security, and monitoring while also promoting related learning resources.
This article explains the fundamentals of TCP, why raw TCP communication faces issues like message boundary ambiguity, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their use cases, performance, and evolution to help developers choose the right protocol for their systems.
This article provides a detailed, English-language overview of Service Mesh, explaining its role in cloud‑native microservice architectures, the need for it, its core principles—including data and control planes—and key Istio components, while also offering promotional links to related resources.
This guide walks you through preparing a Dubbo test environment, creating mock providers, writing JUnit 5 test cases, configuring consumers, sending requests, validating responses, handling errors, and optionally adding performance testing, monitoring, and CI automation to ensure robust backend services.
Building a scalable backend requires a distributed architecture complemented by caching, optimized database queries, robust monitoring, message queues, load balancing, horizontal scaling with containers, CDN integration, auto‑scaling, and a microservices design to ensure performance, reliability, and seamless growth under increasing demand.
