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.
This comprehensive tutorial walks you through OpenFeign—its relationship to Feign, environment setup, service provider and consumer creation, various parameter passing methods, timeout handling, logging, HTTP client replacement, GZIP compression, and Sentinel-based circuit breaking—providing practical code examples and configuration snippets for Spring Cloud microservices.
This article introduces the RSocket binary protocol, explains its four interaction models, highlights key features such as back‑pressure and lease, and provides step‑by‑step Spring Boot 2.7 examples for Request‑Response, Request‑Stream, Channel, and Fire‑and‑Forget communication.
This article introduces Sentinel, the core flow‑control component of Spring Cloud Alibaba, explains its key features, architecture, and functional modules such as traffic shaping, rate limiting, circuit breaking and load protection, and provides a step‑by‑step Spring Boot integration example with code.
This article explains how to achieve high availability in microservice architectures by applying flow governance techniques such as circuit breaking, isolation, retry policies, degradation, timeout management, and rate limiting, while detailing key metrics like MTBF and MTTR and providing practical implementation guidance.
This article presents a comprehensive case study of refactoring a consumer installment system, detailing the background, technical debt, redesign goals, domain‑driven design, module splitting, code design with Java patterns, migration process, monitoring setup, and the overall benefits achieved.
This article explains the underlying principles of Nacos as a service registry, covering registration flow, health‑checking, dynamic service awareness, the architecture diagram, key source‑code components, and how service discovery works in Spring Cloud micro‑service environments.
The article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication—including event notification and event sourcing—discusses their trade‑offs, and offers practical guidance on choosing and combining these approaches for scalable backend systems.
2023 saw a wave of high‑profile tech leaders—Google’s engineers, Amazon Prime Video, and DHH—questioning the microservices paradigm, presenting data‑driven case studies that show dramatic latency and cost reductions when moving to monolithic or runtime‑managed architectures, and urging architects to reassess scalability versus complexity trade‑offs.
Microservices, also known as microservice architecture, is a cloud‑native approach that breaks a single application into loosely coupled, independently deployable services, each with its own tech stack, communicating via REST APIs, event streams, or message brokers, and organized around business capabilities and bounded contexts.
This article analyzes common problems in a large‑scale supply‑chain backend—such as unclear service boundaries, tangled dependencies, and client‑specific adaptations—and proposes a layered solution using a dedicated API layer, BFF pattern, Spring Cloud components, and clear team division to improve modularity, reduce code duplication, and streamline development.
This article explains how to design a plug‑in architecture for a data‑governance service that can start, stop, add, or upgrade individual tasks at runtime without restarting the whole service, using a custom URLClassLoader, Spring bean registration, XXL‑Job integration, dynamic configuration updates, and a clean unload process.
This article outlines the functional and non‑functional requirements of a booking platform, proposes a micro‑service‑based backend architecture, presents UML component and sequence diagrams, details database schemas, defines RESTful APIs, and provides Go code examples for user registration and booking creation, offering a comprehensive design blueprint.
API gateways act as reverse proxies that streamline request routing, API composition, and authentication, enabling the creation of collaborative ecosystems, thriving API marketplaces, and seamless cross‑platform compatibility, ultimately simplifying access and boosting productivity for developers and users alike.
This article analyzes common distributed‑transaction scenarios, explains the CAP theorem’s relevance, compares ACID/BASE, TCC, XA, 2PC/3PC, Saga and AT patterns, and provides a decision‑making framework to help architects select the most suitable approach for their microservice systems.
Spring Cloud can use either HTTP‑based REST calls, which offer flexible, language‑agnostic JSON communication and simpler implementation, or RPC over TCP, which provides faster, binary‑serialized calls that appear local but require tighter API contracts, so modern microservices usually prefer HTTP for its adaptability and scalability.
When converting Date parameters in OpenFeign calls, the client serializes them to strings using the local CST timezone, causing a 14‑hour discrepancy that can be resolved by using timestamps, @DateTimeFormat, or custom formatters on both client and server sides.
The article examines a complex supply‑chain system built on Spring Cloud, identifies issues with interface placement and tangled service dependencies, proposes an intermediate API layer and later a BFF pattern, and evaluates the trade‑offs, implementation details, and remaining challenges of these architectural changes.
This article explains cloud native fundamentals, covering its definition, core characteristics such as microservices, containerization, automation, storage, and networking, and introduces key technologies like Docker, Kubernetes, service mesh, CI/CD, and monitoring, while showing how they enable modern applications in AI, IoT, and big data.
This article provides a comprehensive overview of microservice architecture, detailing its definition, key characteristics, advantages and disadvantages, and presenting ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—along with their pros, cons, and appropriate scenarios.
The article explains the drawbacks of token pass‑through in microservice authentication, advocates explicit parameter passing, outlines unified gateway authentication with Feign or Dubbo, explores Kubernetes‑integrated deployment options, and concludes with a promotional invitation to a technical community.
This article explains the weak dependency principle, contrasts it with the less‑dependency principle, and presents concrete microservice architecture strategies—including module splitting, independent deployment, asynchronous messaging, interface abstraction, fault‑tolerance, and governance—to improve system flexibility, scalability, and high availability.
This article explains the challenges of using WebSocket in a microservice environment, introduces a load‑balancing library that forwards messages between service instances, shows how to enable it with Spring annotations, and details the underlying connection, subscription, and selector mechanisms for reliable message routing.
The article walks through nine practical techniques—system splitting, decoupling, asynchronous processing, retry, compensation, backup, multi‑active deployment, rate limiting, circuit breaking, and degradation—explaining why each is needed, how they are implemented in real‑world microservice architectures, and what trade‑offs to consider.
Instead of forwarding JWTs through every microservice, the gateway should validate the token, extract the userId and send it as a header, keeping internal services stateless, while developers can choose among Feign, Dubbo, or combined Spring‑Boot/Dubbo patterns, optionally using a shared auth module and Kubernetes ingress for discovery, as the optimal architecture depends on project needs.
The article analyzes high coupling problems caused by multiple controller calls and third‑party integrations in a Java settlement backend, and proposes a dedicated TPS microservice with unified Feign interfaces, enum‑based routing, and factory patterns to decouple frontend and backend logic while providing implementation examples and diagrams.
This article explains how to achieve zero‑downtime releases for Java applications by using JVM shutdown hooks, Spring context events, and service‑registry tricks for both monolithic and microservice architectures, with concrete code samples, configuration details, and Kubernetes probes to ensure seamless online upgrades.
This article walks through creating a lightweight API gateway in Go using the standard net/http/httputil ReverseProxy, explains its core concepts, compares it with other gateway solutions, and provides a complete, runnable example that routes authentication and user services.
This article explains the concept of graceful shutdown, walks through a Kubernetes pod termination flow, demonstrates a Spring Boot + Nacos example with PreStop hooks, identifies common pitfalls, and provides practical optimizations—including MQ handling, scheduled tasks, traffic control, and actuator shutdown—to achieve reliable, zero‑downtime service termination.
The article compares several microservice internal‑call strategies—including token‑pass-through, Feign, Dubbo, Spring Boot Web with Dubbo, and K8s‑integrated approaches—explaining their advantages, drawbacks, and how to implement unified authentication while keeping APIs stateless and reusable.
Learn how to use Alibaba Cloud's MSE Cloud Native Gateway WASM plugins to implement sophisticated full‑link canary releases, including custom header‑based routing, parameter‑driven traffic percentages, and multi‑condition rules, with step‑by‑step Go code, configuration examples, and compilation instructions.
This article analyzes the problems of a scattered, poorly‑designed order‑processing codebase, proposes a three‑layer interface combined with a strategy‑template pattern, walks through concrete Java implementations, testing and gray‑release safeguards, and shows how the redesign improves readability, maintainability, and extensibility.
Tencent Docs transformed its high‑traffic Collection Form by refactoring a monolithic C++‑style service into 19 loosely‑coupled vertical services with light‑heavy separation, database isolation, async Kafka pipelines, and full observability via Tianji, achieving dramatically improved stability, millisecond‑level sync, reliable export, and faster incident resolution.
This article provides an in‑depth tutorial on Alibaba Sentinel, covering its core concepts, installation of the dashboard, integration with Spring Cloud microservices, detailed configuration of flow control, degrade rules, hot‑parameter limiting, system adaptive protection, custom block handlers, persistence with Nacos, and cluster flow control for high‑availability services.
This document details the motivation, technology selection, overall architecture, data‑plane and control‑plane design, key implementation challenges such as HTTPS interception, precise URL monitoring, and plugin extensibility, and outlines future directions for scaling service mesh within the organization.
This article explains the fundamentals of Remote Procedure Call (RPC), why it is crucial for developing production‑grade instant‑messaging clusters, how it differs from plain HTTP, the typical RPC call flow, common frameworks such as gRPC, Thrift and Dubbo, and practical considerations for high‑throughput distributed systems.
This article explains the fundamentals of distributed tracing, why it’s essential for complex microservice architectures, the core concepts and mechanisms behind it, and compares popular tracing frameworks such as Zipkin, Spring Cloud Sleuth, Jaeger, and Pinpoint.
The article explains how microservice systems handle service calls, compares RPC and event‑driven (message) communication, details various coupling types, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling through API gateways, versioning, and gRPC.
This article provides a detailed outline of an enterprise‑grade Kubernetes operations curriculum, covering cluster installation, component deployment, high‑availability, networking, storage integration with Ceph, Helm package management, microservice migration with Spring Cloud, CI/CD pipelines using Jenkins, and service mesh fundamentals with Istio.
This article explains what a service gateway is in a microservice architecture, outlines its key responsibilities such as routing, load balancing, traffic control, security, and monitoring, and compares popular gateway solutions to help you choose the right one for your system.
This article explains the fundamentals of Remote Procedure Call (RPC), its historical origins, the step‑by‑step execution process, and provides a practical guide to installing and using gRPC with Protocol Buffers in Go, including full code examples and advantages.
LXD, developed by Canonical as an advanced layer on LXC, combines VM-level isolation, easy command-line and REST API management, and high performance to offer a lightweight, secure container solution ideal for cloud-computing and micro-service architectures, positioning it as a promising milestone in container technology.
This article compiles a comprehensive Java backend interview guide covering network protocols, HTTP characteristics, core data structures and algorithms, MySQL logging mechanisms, Elasticsearch full‑text search, Kafka reliability and deduplication, common micro‑service components, load‑balancing algorithms, and essential Spring concepts such as IoC, AOP, transactions, and MVC workflow.
The article analyzes why Spring Cloud often prefers HTTP instead of RPC for remote calls, detailing the technical differences, advantages, disadvantages, and selection criteria of each approach, and explains how microservice trends shape this choice.
This article explores why rate limiting is essential for high‑concurrency services, introduces four core algorithms with Go implementations, compares their strengths and weaknesses, and presents practical distributed limiting strategies using Redis, load balancers, and coordination services.
This article details how to transition a Dubbo 3.0 microservice architecture to an Istio service mesh on Kubernetes, covering code modifications, deployment configurations, sidecar injection, traffic management policies, and verification steps with practical YAML examples and log analysis.
The article analyzes front‑end and back‑end coupling problems caused by multiple controller calls and third‑party push integrations, and proposes a dedicated TPS microservice that centralizes third‑party interactions via a Feign interface to reduce duplication and simplify future changes.
This article introduces Spring Cloud Gateway as a powerful tool for building scalable microservice gateways, explains its reactive architecture and advantages, and provides a step‑by‑step tutorial—including Maven dependency, route configuration, custom filter code, and deployment instructions—plus suggestions for advanced features.
This article provides a step‑by‑step tutorial on integrating the Apollo configuration center into SpringBoot applications, covering basic concepts, client design, environment, cluster and namespace management, Maven setup, Docker image creation, and deployment on Kubernetes for dynamic configuration updates.
This article analyzes the challenges of tightly coupled message‑business code, duplicated service implementations, and intermittent message loss, then details the design of the X‑Pigeon centralized messaging platform—including its three‑element model, lifecycle states, rate‑limiting strategies, and template system—to achieve scalable, reliable communication across microservices.
This comprehensive guide analyzes the core concepts, CAP trade‑offs, consensus algorithms, and practical deployment details of Zookeeper, Eureka, Nacos, Consul, and Etcd, providing concrete examples and selection criteria to help engineers and architects decide the most suitable service registry for their micro‑service environments.
This guide explains why rate limiting is essential for micro‑service stability, outlines six design principles, details four classic algorithms—fixed window, sliding window, leaky bucket, and token bucket—and compares centralized Redis, load‑balancer cache, and coordination‑service distributed solutions.
This article thoroughly explains OpenFeign’s core architecture, including its dynamic proxy mechanism, seven essential components, the process of building and executing HTTP calls, and how Spring Cloud integrates and configures OpenFeign through annotations, factories, and property settings.
This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.
This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.
This article shares hard‑won production lessons on using Spring Event, explaining why graceful service shutdown, proper startup timing, consistency requirements, and retry mechanisms are essential for reliable event publishing in Java backend systems.
This article presents a comprehensive overview of how to design and implement a recommendation system using cloud‑native technologies, covering the cloud‑native stack, system architecture, key design considerations such as virtualization, micro‑service migration, service governance, resilience, and stability through chaos engineering.
This article provides a comprehensive overview of Dubbo, a Java RPC framework, covering its necessity, core components, implementation principles, architecture layers, supported protocols, registry options, load‑balancing strategies, and typical application scenarios for building scalable micro‑services.
This article explains what distributed systems are, why they are essential for scaling and high availability, and walks through core technologies such as service frameworks, caching, file systems, locks, ID generation, transactions, messaging, and other essential components.
The article explains why passing tokens between microservices is a poor design, proposes exposing explicit userId parameters, describes unified authentication via an API gateway with Feign, Dubbo or Spring Boot Web implementations, compares their pros and cons, and shows how to integrate these patterns with Kubernetes and internal API path rules.
This article shares practical lessons from real‑world production incidents, explaining why graceful shutdown, proper listener registration timing, consistency requirements, retry mechanisms, idempotency, and traffic control are essential when using Spring Event in Java backend systems.
McDonald's engineering team built a fast, reliable, and flexible continuous integration system by leveraging reusable GitHub Actions workflows, centralizing CI code, defining a golden‑path pipeline, balancing developer autonomy, and adding observability across multilingual microservices, improving productivity and maintainability.
This article details how Bilibili’s membership‑purchase platform tackled massive traffic spikes by redesigning the order call chain, introducing concurrent and asynchronous processing, and applying a sharding strategy that split databases and tables, ultimately boosting latency performance and supporting over 4,000 TPS during peak sales.
Spring Boot, an evolution of the Spring framework, simplifies project setup, offers built-in web servers, provides production-ready features, and enhances development efficiency, distinguishing it from traditional Spring which requires extensive XML configuration and external servlet containers, making Boot the preferred choice for modern Java backend development.
The article outlines emerging forces such as cloud, mobile, social, and big data that drive modern application architecture, advocates moving beyond traditional three‑tier designs, and recommends adopting service‑oriented, microservice, event‑driven, and open‑standard approaches while considering paradigms, models, and organizational structures.
This guide explains how to design a high‑concurrency, high‑throughput internet architecture that ensures database high availability with double‑master sync and virtual IPs, and how to horizontally shard and smoothly expand the cluster in seconds using configuration changes, reloads, and cleanup steps.
This tutorial explains how to use Spring Cloud Gateway for unified API routing, metrics collection, metadata handling, timeout settings, fluent Java route definitions, service‑discovery routing, and troubleshooting techniques in microservice architectures.
This article explains how integrating Apollo with a microservice architecture enables developers to create highly scalable, resilient applications by detailing microservice fundamentals, challenges, best‑practice solutions, and practical steps for building extensible data graphs and robust monitoring.
The article critiques token pass‑through for microservice authentication, explains why internal APIs should stay stateless, and presents unified authorization patterns using Spring Cloud Gateway with Feign, Dubbo, or a gateway‑less design, plus Kubernetes integration and trade‑offs.
This article presents a comprehensive case study of applying domain‑driven design, layered architecture, and microservice decomposition to a restaurant scenario, detailing domain analysis, modeling, upstream‑downstream relationships, architectural mapping, and functional design to guide backend developers in building maintainable systems.
The article humorously lists twelve detrimental coding habits—such as over‑splitting microservices, writing excessively long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and reinventing wheels—that reduce code readability and increase maintenance difficulty.
The article examines how API automation testing can be measured and implemented effectively, arguing that coverage and pass‑rate targets vary by team context, emphasizing cost‑benefit analysis, prioritizing core interfaces, and focusing on reducing feedback cycles rather than chasing statistical metrics.
This article explains how Spring Cloud Commons abstracts service discovery, load balancing, and circuit breaker patterns, covering annotations like @EnableDiscoveryClient, SimpleDiscoveryClient configuration, service registration, RestTemplate and WebClient load balancing, network interface filtering, HTTP client factories, and creating custom features for Spring Cloud applications.
Facing low development efficiency, poor CPU utilization, and fragile fault tolerance, the QQ Browser content ingestion team rebuilt a 93‑service microservice system into a single‑process, plugin‑driven architecture, achieving up to 13‑fold throughput gains, 10‑fold batch‑processing speedups, and dramatically reduced lead times and code complexity.
This article traces the evolution of software architecture—from early monolithic Java war packages through Service‑Oriented Architecture to modern microservices and cloud‑native designs—highlighting their structural differences, benefits, challenges, and the key principles that guide successful migration to distributed, scalable systems.
This article provides a comprehensive English overview of Spring Cloud, detailing its purpose as a full‑stack microservice solution and explaining its five core components—Eureka, Hystrix, Zuul, Ribbon, and Config—along with their roles, architecture, and how they integrate to enable scalable, fault‑tolerant cloud‑native applications.
This article walks through the practical application of Domain‑Driven Design to a large‑scale pricing system, detailing business understanding, strategic and tactical design, context integration, layered architecture, and concrete Java implementations that illustrate how DDD improves modularity, testability, and maintainability.
Spring Boot, emerging as the preferred Java framework for microservices, differs from traditional Spring by offering automatic configuration, simplified Maven setup, embedded containers, production-ready features, and streamlined Spring MVC, which together accelerate development, ease deployment, and improve cloud integration compared to the more complex, slower-starting classic Spring.
This article explains how to start a new project using Domain-Driven Design, covering IAAS/PAAS/SAAS terminology, architecture evolution, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their impact on microservice design.
This article explains how Spring Cloud leverages embedded Tomcat to handle HTTP requests for flexible, cross‑platform microservice communication, contrasts it with TCP‑based RPC's handshake and serialization requirements, and outlines the advantages, disadvantages, and future trends of each approach.
This article explains why and how to replace OpenFeign with native Spring HttpInterface alternatives such as Apache HttpClient, OkHttp, and RestTemplate, covering security motivations, configuration details, code examples, and practical recommendations for microservice remote calls.
This tutorial provides a step‑by‑step guide to configuring a PHP gRPC client using proto files, Composer, Docker, and Docker‑Compose, covering project structure, code generation, autoload setup, Dockerfile creation, and client execution in a containerized environment.
The article lists twelve common anti‑patterns—such as splitting microservices per table, writing overly long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and over‑engineering solutions—that dramatically reduce code readability and make maintenance a nightmare.
This article details the end‑to‑end design, node‑level splitting, metric definition, and Spring‑based implementation of SLA monitoring for a high‑volume message‑push system, showing how precise latency and vendor‑stability metrics uncovered bottlenecks, enabled rapid issue detection, and ultimately doubled overall throughput.
This article details the end‑to‑end design, implementation, and operational results of a smart customer‑service platform that automates FAQ capture, leverages both Elasticsearch and LLM‑based models, and provides a low‑code, multi‑team backend for rapid issue resolution.
This article explains essential software architecture concepts such as entropy and broken‑window effects, the sources and symptoms of complexity, the importance of orthogonality and consistency, and classic design principles like SOLID, DRY, and layered abstraction to guide architects in building maintainable, flexible systems.
This tutorial walks through creating a complete Spring Boot 2.7 project that integrates Apache Dubbo for RPC, covering environment setup, Maven dependency management, interface definition, provider and consumer implementations, configuration with Nacos, and testing the end‑to‑end service.
This article walks through the complete design and implementation of full‑stack distributed tracing for Go‑based microservices, explaining correlation IDs, OpenTracing concepts, component roles, client and server code, database and service call tracing, compatibility issues, and best‑practice design guidelines.
This guide walks through setting up a fully automated CI/CD pipeline that pulls code from Git, builds it with Maven, packages the resulting JAR into a Docker image, pushes the image to a registry, and finally deploys or updates the service on Kubernetes using Jenkins pipelines and supporting scripts.
The article details how a high‑traffic Helios scoring service, originally taking several seconds to return a day’s worth of data, was profiled with Arthas and iteratively optimized through four code revisions, ultimately reducing latency to around 60 ms while exposing key performance pitfalls such as object creation, date formatting, and trivial list operations.
This article explains the fundamental concepts of software architecture, distinguishes between systems, subsystems, modules, components, frameworks and architectures, outlines the evolution from monolithic to distributed and micro‑service designs, presents fifteen universal design principles, and highlights typical mistakes architects should avoid.
This article explains the limitations of traditional MVC, introduces the four‑layer DDD architecture (Interface, Application, Domain, Infrastructure), discusses the Dependency Inversion Principle, compares package‑level and Maven‑module implementations, and details the roles and conversions of Entity, DO, and DTO models for Java projects.
This article explains how Spring Cloud leverages HTTP via an embedded Tomcat container for flexible, cross‑platform microservice communication, contrasts it with TCP‑based RPC's serialization requirements, and outlines the advantages, disadvantages, and selection criteria for each approach.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session storage in Redis, service discovery via Nacos, and permission checks in a Spring Cloud Gateway micro‑service architecture, complete with code examples and deployment settings.
This article analyzes the CPU‑heavy routing and load‑balancing modules of Dubbo in a large‑scale microservice cluster, identifies O(n) traversal as the root cause, and presents a step‑by‑step redesign—including disabling unused routers, caching route results with epoch validation, BitMap‑based intersection, and grouped routing—that reduces CPU usage by up to 27% and doubles TPS when provider instances exceed 2,000.
This article explains how to combine Domain‑Driven Design's four‑layer architecture with a microservice‑oriented application SDK, introduces the D3boot lightweight framework and its modular base components, and shows how the approach simplifies building SaaS and PaaS systems while keeping code reusable and maintainable.
This tutorial explains how to automate the full lifecycle of a Spring Cloud microservice—from developers pushing code to Git, Jenkins pulling and building it with Maven, packaging the JAR into a Docker image, pushing the image to a private registry, and finally deploying or updating the service on a Kubernetes cluster using YAML manifests.
Bilibili created an AI‑powered customer‑service platform that integrates a WeChat Work chat UI, a conversation state machine, Elasticsearch and LLM‑based FAQ retrieval, and a low‑code admin console, replacing a thousand‑person manual support team, handling thousands of queries, boosting resolution rates and enabling cross‑team reuse.
This article explains the concept of distributed tracing, outlines its underlying principles in Java, details step‑by‑step implementation using popular SDKs, and describes common application scenarios such as performance monitoring, fault diagnosis, complex event handling, traffic analysis, and system optimization.
