This article outlines practical strategies such as service isolation, circuit breaking, rate limiting, dependency governance, and chaos engineering to keep microservice systems highly available and resilient, reducing outage impact and operational costs.
This article explains how to streamline OpenFeign usage during local development by configuring custom URL routing, detailing the underlying Feign mechanism, creating a custom ImportBeanDefinitionRegistrar, and providing step‑by‑step code examples, testing procedures, and best‑practice recommendations.
Tencent's PolarisMesh showcases cloud-native microservice governance by detailing the shift from monoliths to containerized services, outlining service splitting principles, Kubernetes deployment, dynamic routing, fault isolation, and real-world case studies that demonstrate cost savings, reliability improvements, and open-source availability.
This article explains how to integrate SkyWalking's distributed tracing with an ELK logging stack, embed Trace IDs into logs via SkyWalking layouts or MDC, and use Kibana to query and visualize trace‑linked log data for comprehensive microservice observability.
This article details the step‑by‑step architectural evolution that merged retail and catering product systems into a shared, extensible platform using domain‑driven design, service standardization, and incremental vertical and horizontal upgrades to reduce technical debt and improve scalability.
The article describes how an operations engineer transforms a complex, multi‑language smart delivery platform into an elastic, container‑native system that automatically scales, registers, and logs services during the high‑load Chinese New Year period using Kubernetes, Docker, init containers, and a configuration center.
This article explains four common microservice deployment approaches—multi‑instance, containerized, serverless, and service‑mesh—detailing their architectures, advantages, disadvantages, and suitable scenarios to help engineers choose the right strategy for scalable, resilient systems.
This article shares practical guidance on rolling out Istio service mesh to over ten business lines, covering selection of pilot projects, benefit analysis using access logs, sidecar injection, performance and resource impact, multi‑region active‑active architecture benefits, and rapid fault‑recovery tactics.
In this interview, AMP Robotics' robot architect Carter Schultz explains how adopting Rust reshaped their facility‑wide control system, the challenges of migrating from C++/Python, the role of ROS microservices, and practical advice for engineers entering robotics.
This article explores the fundamentals of distributed systems, compares stateful and stateless services, examines monolithic, SOA, and microservice models, and provides practical guidance on access layers, fault tolerance, service discovery, scaling, and data storage for building robust cloud‑native architectures.
This article explains how to streamline OpenFeign usage during local development by creating a custom ImportBeanDefinitionRegistrar that registers Feign clients with configurable URLs, avoiding manual URL changes in annotations and ensuring seamless switching between local and production environments.
This article explains how Meituan Dianping’s transaction platform evolved through three architectural stages—simple monolith, micro‑service, and platform—by adopting Domain‑Driven Design concepts such as ubiquitous language, bounded contexts, and iterative modeling to manage growing business complexity and improve system maintainability.
This guide walks you through the entire Mall‑Swarm microservices e‑commerce project—covering setup, core Spring Cloud components, scaffolding, Kubernetes deployment, and extending functionality—so newcomers can confidently tackle a real‑world microservice system.
This article compares Dubbo and Feign, outlining their architectures, features, and suitability for different microservice scenarios, and provides practical guidance on selecting the appropriate RPC framework based on performance, reliability, and development efficiency requirements.
This tutorial shows how to configure Spring Boot 3 to start multiple Tomcat servers, isolate services into separate modules with shared parent configuration, and test the endpoints, providing full code snippets and screenshots for each step.
This article explains how ArchGuard’s Architecture Analyzer extracts domain and business knowledge from microservice codebases, integrates generative AI to produce structured documentation, and provides practical CLI usage, architecture models, and code‑review strategies for modern software engineering teams.
This article records and reviews a production incident where multiple Spring Boot services consumed excessive memory, explains how default JVM settings caused each instance to allocate up to 12 GB of heap, and provides step‑by‑step diagnostics, configuration guidelines, and optimization recommendations for backend developers.
This article examines Ctrip’s evolution of its account system—from a monolithic service to a domain‑driven, middle‑platform architecture with multi‑region deployment—detailing the motivations, domain restructuring, read/write comparison process, configuration‑driven capabilities, and routing strategies that enable scalable, reliable user management.
This article walks frontend developers through the fundamentals of the TRPC framework, explaining why understanding RPC protocols, the layered architecture, plugin system, multi‑process handling, and Protobuf serialization is essential for building high‑performance, scalable services and improving debugging efficiency.
Clean software architecture, built on principles like vertical and horizontal separation and proper module qualification, reduces complexity and technical debt, boosts scalability, flexibility, and reliability, and guides organizations in proactively managing architectural health through continuous assessment, AI-driven observability, and targeted team training.
Sentinel, an open‑source flow‑control component born from Alibaba’s ecosystem, offers out‑of‑the‑box circuit‑breaking, rate‑limiting, and real‑time monitoring for Java microservices, with extensive rule types, dashboard visualization, datasource integrations, and adaptable architecture that supports multiple protocols, making it a versatile solution for cloud‑native traffic governance.
This article provides a comprehensive overview of Sentinel, covering its purpose as a flow‑control component, the rich set of rules it offers, the internal ProcessorSlotChain architecture, datasource integrations, dashboard interactions, source package structure, and practical deployment considerations for Java‑based microservice systems.
This article presents a comprehensive guide to building a Spring Boot backend system by outlining essential design principles, detailing a multi‑module architecture with clear responsibilities, and providing complete Maven POM configurations for each module to enable scalable and maintainable development.
This article demonstrates how to integrate Kafka with Spring Boot, add necessary dependencies and configuration, implement both single‑message and batch consumers, and tune batch settings to dramatically improve processing speed for millions of records in a microservice environment.
This article explains the fundamentals of ACID transactions, the challenges of multi‑data‑source operations, surveys common distributed‑transaction solutions such as 2PC, 3PC, TCC, transaction‑status tables and message‑queue based eventual consistency, and then details the implementation of Seata’s AT mode in a micro‑service e‑commerce scenario.
This article explains three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑AOP header checks—to restrict APIs to internal calls only, and provides detailed Spring Cloud code examples for the preferred AOP solution.
Baidu Canghai Storage’s unified technology stack—comprising a meta‑aware distributed metadata layer, a hybrid single‑node‑distributed namespace, and an online erasure‑coding data layer—delivers AI‑driven, high‑performance, low‑cost, ZB‑scale cloud storage by modularizing metadata, namespace, and data services for object, file, and block workloads.
This article explains the concept of full-link multi-version deployment in microservice architectures, describes the challenges of traditional test environments, and details the technical solutions—including traffic coloring, isolation, label propagation, environment management, and monitoring—implemented through a flexible CI/CD pipeline.
Microservices are evolving toward 2025 with trends such as edge computing, container orchestration via Kubernetes, DevSecOps, serverless functions, AI-driven management, advanced observability, API gateways, service meshes, multi-language services, event-driven designs, improved data handling, low-code integration, and stronger resilience, reshaping agile, scalable software development.
This guide demonstrates how to integrate OpenFeign with Resilience4j in Spring Boot, covering dependency setup, Feign client definition, fallback implementation, circuit breaker configuration, custom timeout settings, and generating circuit names, enabling robust, fault‑tolerant microservice communication.
This article explains Apache Shiro’s fundamental components—Subject, SecurityManager, Realm, Session, authentication, authorization, and cryptography—then walks through a complete configuration example, a custom Realm, JWT integration, and a Spring Boot microservice scenario to illustrate secure, stateless authentication and fine‑grained permission control.
This article explains RocketMQ's transactional message mechanism, covering half‑message concepts, back‑check processes, implementation steps with code examples, and how to achieve reliable event handling and distributed transaction consistency in a microservice architecture.
This article details Baidu’s unified storage architecture—covering its metadata, hierarchical namespace, and data layers—explaining how meta‑aware design, custom partitioning, flexible engines, and micro‑service based erasure coding together meet the scalability, performance, and cost demands of modern AI‑driven cloud storage workloads.
This article explores a hands‑on AI4SE prototype that leverages ArchGuard, Team AI, and Shire AI to digitize and automate architecture knowledge across the full SDLC of a Protobuf‑driven microservices system, detailing challenges, methods, and concrete tool integrations.
This article explains the essential concepts of continuous integration, delivery, and deployment, outlines the differences between monolithic and microservice CI/CD pipelines, and presents five practical best‑practice recommendations—including testing strategies, environment design, CI practices, configuration management, and failure handling—to improve DevOps efficiency in cloud‑native development.
This article analyzes the motivations, models, and design considerations for building stateful distributed architectures—covering microservices, service discovery, access‑layer isolation, fault tolerance, scaling, and deployment strategies—to help architects create reliable, low‑latency cloud‑native systems.
This article explains how to achieve lossless releases for Spring Boot microservices by deregistering old instances, handling shutdown hooks, configuring graceful shutdown in Spring Boot 2.3+, and integrating custom interceptors for various containers and registration centers.
The article traces software architecture from early distributed systems through monoliths, SOA, microservices and serverless, explaining why each paradigm arose, the trade‑offs they entail, and how to decide between monolith and microservices based on team size, expertise, organizational structure, and business needs.
This article explains the need for dynamic, fine‑grained rate limiting in high‑traffic services, describes Sentinel's core mechanisms, and details a three‑step implementation—data collection, rule management, and traffic verification—using sliding‑window counters and priority‑based throttling.
This article examines the shift from PHP to Node.js, outlining Node.js’s asynchronous, JavaScript‑unified, micro‑service‑friendly advantages and its thriving package ecosystem, while also highlighting PHP’s stability, mature CMS support, and hosting ease, and discusses key migration challenges to help developers decide which platform best fits their project needs.
The article outlines twelve harmful coding habits—such as excessive microservice splitting, incomplete refactoring, overly long methods, deep nesting, random variable names, inaccurate or outdated comments, duplicated code, ignoring specifications, missing logging, over‑engineered frameworks, and reinventing wheels—that degrade readability, complicate maintenance, increase bugs, and hurt team productivity.
This article provides a step‑by‑step tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its core concepts, features, architecture, four‑dimensional model, project creation, Maven dependencies, Spring Boot configuration, test controllers, various runtime scenarios, cluster and namespace usage, and deployment on Kubernetes with Docker.
This article details the end‑to‑end architecture of a high‑traffic business middle platform, covering business and technical design, Kong API Gateway, SpringBoot microservices, Dockerfile creation, MyCat‑MySQL sharding, cold/hot data strategies, DevOps pipelines, Kubernetes deployment, and operational monitoring.
This article analyzes the motivations, benefits, and challenges of building stateful distributed systems, compares monolithic, SOA, and microservice models, and provides detailed guidance on access layers, service discovery, fault tolerance, scaling, and data storage for cloud‑native architectures.
The article presents a comprehensive checklist of critical questions covering API design, system architecture, performance tuning, data consistency, reliability, automation, and advanced features that guide backend developers toward building scalable, secure, and high‑performance services.
This article explains the fundamentals of distributed transactions, the CAP theorem, various transaction patterns such as 2PC, 3PC, TCC, Saga, and introduces Seata's AT mode with step‑by‑step setup of the TC coordinator and microservice clients, culminating in a working e‑commerce example and key best‑practice takeaways.
Tencent Docs tackles the trade‑offs of monolithic and microservice architectures by implementing a flexible, automated system that merges selected microservices into a few monoliths for private‑cloud scenarios, reducing runtime costs, deployment overhead, image size, memory usage and CPU consumption while preserving performance and scalability.
This article presents a Sentinel‑based dynamic rate‑limiting solution that uses parameter priority and a sliding‑window counter to automatically adjust thresholds per scenario, addressing the limitations of static QPS limits, simplifying rule management via Zookeeper, and integrating as an independent SDK within Sentinel’s responsibility‑chain architecture.
This article provides a comprehensive overview of mainstream distributed transaction solutions, explains the CAP theorem and consistency models, compares various approaches such as 2PC, 3PC, TCC, Saga, and demonstrates how to configure and use Seata's AT mode in a micro‑service environment.
This article compares API composition and CQRS patterns for handling distributed queries in evolving monolithic systems, illustrating their workflows with e‑commerce and online‑education examples, discussing performance trade‑offs, implementation details using Canal and ElasticSearch, and offering practical guidance on when to adopt each approach.
This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.
This article explains ByteDance’s merge‑compilation technique that combines multiple microservices into a single binary at build time, detailing its performance benefits, architectural trade‑offs, dependency isolation, call conversion, version management, real‑world case studies, and future roadmap for large‑scale service optimization.
This article explains how Nacos’s ConfigService initiates a long‑polling task on the client side, how the client periodically checks for configuration changes, and how the Nacos server processes long‑polling requests, detailing the relevant classes, methods, and code flow.
This article details how a microservice‑based backend team designed and implemented a code‑analysis platform that creates a knowledge base, enables precise test selection and application slimming, and ultimately accelerates demand iteration while reducing dead code and unnecessary test runs.
This article explains the concept of gray (canary) release, details the core components and version configuration, and provides a complete Spring Cloud implementation—including custom request holders, gateway filters, Ribbon load‑balancer extensions, Feign interceptors, and deployment instructions—for smoothly rolling out new service versions.
This article explains the fundamentals of Service Mesh and Istio, covering their architecture, control‑plane and data‑plane components, deployment modes, key capabilities such as traffic control and security, and the interaction workflow that enables modern cloud‑native microservice environments.
This article explores the DevOps mindset, its core principles such as collaboration, automation, continuous improvement, and customer focus, outlines essential practices like CI/CD, IaC, monitoring, microservices, and provides a step‑by‑step adoption roadmap illustrated with a detailed case study and future trends.
This article explores the CQRS (Command Query Responsibility Segregation) pattern, detailing its core concepts, implementation approaches—including logical, storage, and asynchronous separation—its benefits and challenges, and practical best‑practice guidelines for applying CQRS in modern high‑performance, scalable systems.
This article explains the API‑First design methodology, outlining its core principles, implementation steps, best practices, and a real‑world e‑commerce case study to help architects build flexible, maintainable, and scalable systems.
This article demonstrates how to generate, store, and validate login tokens for both PC and mobile clients in a distributed micro‑service architecture using Spring Boot, Redis, custom annotations, AOP verification, and a Vue front‑end that manages token lifecycle and expiration.
This article walks through a zero‑to‑one charging‑station system built with Spring Cloud microservices, Vue front‑end, and a suite of enterprise features such as distributed locks, idempotency, multi‑level caching, and custom starters, providing concrete design documents and module breakdowns to help candidates showcase real project experience in interviews.
Cloud native architecture, a modern design paradigm leveraging containers, microservices, CI/CD, and infrastructure-as-code, enables flexible, scalable, and automated applications; this article explores its definition, evolution, core technologies, maturity models, benefits, challenges, and best practices for enterprises transitioning from traditional systems.
The article recounts a production incident where Spring Event caused bean‑lookup failures during service shutdown, explains the three‑step usage of Spring Event with code examples, and presents three mitigation strategies—abandoning Spring Event, handling exceptions with MQ retries, and implementing graceful shutdown—ultimately opting to drop Spring Event.
This article explains why Spring Cloud uses HTTP instead of RPC for remote calls, compares HTTP and RPC protocols, describes how to implement a simple HTTP server in Java, outlines the principles of RESTful architecture, and discusses the advantages, disadvantages, and future trends of both approaches.
This article provides a comprehensive introduction to Spring Cloud OpenFeign, comparing it with Feign and HttpExchange, and walks through practical setup, client declaration, custom configuration, interceptors, error handling, timeout and logging settings with full code examples for Spring Boot 3.2.5.
To overcome Didi’s costly, months‑long, manual multi‑region rollouts, the team built a Configuration‑as‑Code platform that isolates environment settings in a dedicated repository, enforces a versioned template with validation rules, and integrates automated placeholder substitution into CI/CD, cutting manual effort by roughly 80 % and removing coordination bottlenecks.
The article walks through six concrete rate‑limiting methods—fixed window, sliding window, leaky bucket, token bucket (Guava RateLimiter), Sentinel middleware, and Spring Cloud Gateway—showing Java implementations, test results, advantages, drawbacks, and how they fit into microservice architectures.
This article explains the limitations of traditional RPC, introduces gRPC and Protocol Buffers, details their architecture and performance advantages, provides step‑by‑step C++ server and client code, and discusses practical scenarios such as microservices, real‑time data processing, and a file‑storage service example.
This article explains how a legacy task system was redesigned by standardizing incoming messages, introducing a rule engine (QLExpress) for configurable completion conditions, and building a lightweight admin UI, reducing task‑integration time from a week to a few minutes.
Vivo’s full‑link multi‑version deployment framework lets a complete microservice system be launched once while concurrently running multiple service versions in isolated baseline and on‑demand feature environments, using custom traffic‑coloring headers, tag propagation across HTTP/Dubbo/MQ, dynamic routing, and distributed tracing to reduce resource waste, accelerate hot‑fix testing, and pave the way for future data‑level isolation and production‑grade A/B experiments.
This guide reviews two actively maintained open-source Chinese payment platforms—Jeepay, an internet-focused system supporting WeChat Pay, Alipay, UnionPay and more with Spring Boot backend and Ant Design Vue front-end, and DaxPay, a Java-SDK-enabled solution for Alipay, WeChat and UnionPay built on Spring Boot and Vue 3, both offering documentation, demos, and high-concurrency deployment options.
This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
This guide walks through creating a Spring Boot 3.3.3 microservice permission framework with OAuth2, covering technology stack, core features, project structure, step‑by‑step service startup, token acquisition, API calls, and provides the complete source repository for hands‑on experimentation.
The article explains service rate limiting and demonstrates six Java implementations—Fixed Window, Sliding Window, Leaky Bucket, Token Bucket, Sentinel middleware, and Spring Cloud Gateway—detailing their algorithms, code examples, and configuration to protect microservices from overload.
This article explains why Spring Cloud prefers HTTP over RPC for remote calls, covering the embedded Tomcat architecture, JSON data exchange, the fundamentals of RPC over TCP, and compares their advantages, disadvantages, and suitability for microservice development.
This article explains the fundamental differences between distributed systems and microservices, covering their definitions, application scenarios, deployment models, and efficiency trade‑offs, helping readers understand when to choose each architectural approach.
Layered architecture offers abstract stability, functional reuse, cohesion, hidden complexity, and scalability, but can introduce extra complexity, performance overhead, and dependency risk, so designers should retain essential layers, enforce one‑way cross‑layer calls, depend only on lower layers, keep lower layers stable, and ensure each layer has a clear purpose.
The article outlines Ctrip Hotel's transition from a monolithic BFF model to a multi‑endpoint "one‑code‑many‑ends" architecture using NestJS, introduces a cloud‑function platform for improved performance and operational efficiency, and describes a dynamic gateway layer that further enhances front‑end flexibility across multiple client types.
This guide explains how to automatically inject userId and orderId into log statements in a Spring Boot microservice by configuring Log4j2 patterns, using MDC to store context variables, and creating a custom @UserLog annotation with an AOP aspect that populates the MDC before method execution.
This article introduces Tonic, a Rust gRPC framework, explains its core features, components, and provides detailed, code‑rich instructions for building both server and client applications, while highlighting performance, security, and ideal use‑cases for microservices.
This article walks through the challenges of setting up a Java backend environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides reusable code snippets for exception handling, logging, CORS, Swagger, and response wrapping, along with recommended tools.
This article presents Xide International's cross‑border e‑commerce data platform, detailing its multi‑layer business architecture, the scalability and data‑access problems encountered, and how a Protonbase‑driven data‑warehouse and micro‑service redesign dramatically improved query speed, operational efficiency, and cost.
This article provides a comprehensive overview of five popular service registries—Zookeeper, Eureka, Nacos, Consul, and Etcd—covering their core concepts, CAP trade‑offs, underlying protocols, implementation details, and practical guidance for selecting the most suitable registry for microservice architectures.
This article provides a detailed walkthrough of Nacos' configuration center long‑polling mechanism, covering both client‑side initialization, reflection‑based service creation, scheduled tasks, cache handling, and server‑side request processing, with code examples and architectural diagrams to illustrate each step.
This article walks through upgrading the Mall‑Swarm microservice e‑commerce project to Spring Boot 3, Spring Cloud 2023, JDK 17, and related dependencies, covering architecture, version changes, permission solution migration, documentation updates, Elasticsearch usage, and deployment on Windows and Linux.
This article shares a backend‑centric methodology and practical experiences for constructing systems that simultaneously achieve high performance, high concurrency, and high availability, covering performance optimization, read/write strategies, scaling techniques, fault‑tolerance mechanisms, and deployment considerations.
This article analyses the ambiguous concepts of BFF in microservice architectures, distinguishing between “fat” BFFs that handle extensive orchestration and “skinny” BFFs that act mainly as transparent gateways, and discusses their responsibilities, advantages, drawbacks, and suitable scenarios.
This course provides an in‑depth exploration of the technical challenges faced by Java architects, covering Spring bean lifecycle, AOP, transaction mechanisms, SpringBoot auto‑configuration, JVM memory models, MySQL indexing, Redis caching, microservice patterns, distributed locks, and performance optimization techniques across 99 video modules.
This article explains the challenges of microservice communication and fault tolerance, introduces service mesh and its drawbacks, and presents a Java bytecode‑enhancement solution that combines SDK performance with sidecar‑less governance, detailing the Joylive Agent architecture, plugin system, request abstraction, governance strategies, and Kubernetes deployment practices.
This article details Huolala's comprehensive server‑side quality assurance strategy—covering code‑branch checks, change testing, regression, canary releases, and monitoring—to improve stability, reduce financial loss, and achieve a 40% defect‑rate reduction across its microservice architecture.
This article walks through SkyWalking, an open‑source APM solution, covering its architecture, server and client installation, configuration for MySQL persistence, log collection, performance profiling, and alerting, while comparing it with Spring Cloud Sleuth + Zipkin and showing practical code examples.
This article compares monolithic and microservice architectures across latency, complexity, reliability, resource usage, scalability, throughput, deployment speed, and communication cost, revealing where each approach excels and offering guidance on choosing the right style for different team sizes and workloads.
This article examines the debate over sharing versus isolating databases in microservice architectures, presents arguments from both sides, shares a detailed incident from an online education platform, and outlines best‑practice recommendations for balancing availability, cost, and development efficiency.
The article recounts how a large group‑level development organization tackled siloed, duplicate systems by creating a public‑service team, evolving into a platform strategy, adopting a unified Dew micro‑service framework, establishing middle‑platform standards such as the 6S model, and finally building a BIOS integration layer to achieve coherent, scalable engineering and management practices.
This guide walks you through why Java remains vital, explains what Spring Boot is, outlines its core features, and provides a detailed learning roadmap covering Java fundamentals, Spring core concepts, web development, AOP, microservices, databases, security, DevOps tools, and deployment strategies for building robust enterprise applications.
This article explains the challenges of microservice architectures, introduces service mesh concepts, and provides an English overview of Istio’s core components and functionalities such as traffic management, security, observability, and policy enforcement for modern cloud-native applications.
From zero‑to‑hero in 2021, a Shanghai tech firm designed, selected, and implemented a full‑stack Cloud‑Native DevOps solution on Alibaba Cloud, covering project management, GitFlow, CI/CD pipelines, multi‑environment image promotion, infrastructure‑as‑code, and monitoring to support hundreds of micro‑services.
Facing exploding trace volumes, Pupu APM replaced Elasticsearch with ClickHouse, added tail sampling, and then engineered a head‑sampling solution that discards irrelevant spans at source, cutting daily span reports by half and halving infrastructure costs while preserving critical observability.
The article explains why adopting a message‑queue improves microservice decoupling and responsibility boundaries, then details the design of a pluggable Base‑MQ component—including @MQEventListener, MQEvent base class, configuration, and MQClient interface—followed by concrete implementations for RocketMQ, Kafka, Redis and RabbitMQ, an example event flow, and guidance for extending the framework.
This article explains how to implement gray (canary) release in a Spring Cloud micro‑service system using Nacos for service discovery, Spring Cloud Gateway filters, ThreadLocal gray flags, custom Ribbon load‑balancing rules, and configuration files to switch between production and gray versions.
