The article analyzes why many game server architectures avoid microservices, highlighting real‑time latency requirements, stateful processing, network overhead, and the mismatch between typical microservice patterns and the high‑performance demands of multiplayer online battle arena games.
This article explains the seven fundamental software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, drawbacks, and suitable application scenarios.
This article explains the fundamentals of distributed architecture, describing its definition, key characteristics such as cohesion and transparency, common applications like distributed file systems, caches, and databases, and outlines the evolutionary stages from single‑server setups to clusters, load balancing, caching, CDN, NoSQL, and service‑oriented designs.
This article introduces Kotlin’s growing role in backend development, explains its interoperability with Java, and walks through creating a Spring Boot microservice using Kotlin, including project setup with Spring Initializr, Maven configuration, and sample code for a simple web endpoint, illustrating the benefits of concise Kotlin syntax.
The article chronicles Vivo’s official mall transformation from a 2015 monolithic Java MVC system to a service‑oriented architecture with independent activity, product, coupon, and order services, later expanding to consignment, CPS, and promotion subsystems, and finally adding multi‑language, multi‑timezone, and multi‑region capabilities for global markets.
Managing hundreds or thousands of tightly coupled services inevitably creates diverse operational challenges, so effective service governance—covering definition, lifecycle, versioning, registration, monitoring, ownership, testing, and security—is essential, and can be realized through a unified DevOps‑driven platform.
This article introduces Kotlin for backend development, explains why Kotlin works well with Spring Boot, and provides a step‑by‑step tutorial—including Maven setup, essential dependencies, and sample Kotlin code—to create a simple Spring Boot web application.
This article introduces Kotlin for backend development, explains its advantages over Java, and provides a hands‑on tutorial with Maven configuration, source code, and deployment steps to create a simple Spring Boot web service using Kotlin.
This article explains how Spring Boot 2.3.4 implements graceful shutdown for Jetty, Reactor Netty, Tomcat and Undertow, shows the simple YAML configuration, demonstrates code examples using DisposableBean and @PreDestroy, and describes the actuator shutdown endpoint and its relevance to Kubernetes liveness and readiness probes.
This article explains common software architecture patterns—including traditional three‑tier, cluster (horizontal scaling), distributed (vertical splitting), and microservice (vertical division) architectures—detailing their components, advantages, drawbacks, and configuration examples such as Tomcat clustering with Nginx load balancing.
This article outlines a comprehensive knowledge framework for software architects, covering nineteen essential areas such as responsibilities, foundational concepts, internet system challenges, distributed caching, messaging, load balancing, performance testing, operating systems, algorithms, networking, database design, JVM internals, flash-sale systems, microservices, domain‑driven design, security, high‑availability, big data, and blockchain.
This article walks through the evolution of an online supermarket from a simple monolithic website to a fully split microservice architecture, highlighting the pitfalls of ad‑hoc growth, the need for service abstraction, monitoring, tracing, fault tolerance, testing, and the trade‑offs of frameworks versus service mesh.
In a detailed interview, Guosen Securities’ IT head Yang Yang explains how the Gold Sun mobile app’s DevOps assessment reached the national Level‑2 standard, describing the project’s micro‑service architecture, automated pipelines, monitoring, capacity management, and the broader impact on the firm’s operational maturity and future DevOps roadmap.
This article explains the purpose of API gateways in microservice architectures, outlines their key capabilities such as unified routing, security, logging and rate limiting, describes when they are needed, and reviews popular open‑source and cloud offerings like Kong, Alibaba Cloud, and Goku.
This article compares microservices and monolithic architectures across eight operational dimensions—network latency, complexity, reliability, resource usage, scaling precision, throughput, deployment time, and communication—showing where each approach excels and concluding which wins overall.
This tutorial walks through setting up the PassJava project, covering microservice architecture, service discovery with Nacos, remote calls via OpenFeign, API gateway configuration, OSS file storage integration, and centralized exception handling, providing detailed code examples and configuration steps for each component.
This article explains the importance of service tracing in micro‑service architectures, describes core concepts such as traceId and spanId, outlines a three‑layer tracing system (collection, processing, visualization), and shows how real‑time and offline processing enable rapid fault isolation and system‑wide performance optimization.
This article reviews the evolution from traditional local and distributed transactions to BASE theory and presents four microservice data‑consistency patterns—reliable event notification, maximum‑effort notification, business compensation, and TCC—detailing their principles, advantages, drawbacks, and implementation examples.
The article presents a comprehensive case study of Haodf.com's transition to a micro‑service architecture, detailing the challenges of service stability and observability, the design of a unified governance platform with log‑holographic analysis, real‑time alerts, application profiling, SLO/SLA definition, and future roadmap for capacity and reliability improvements.
This comprehensive guide walks you through Spring Cloud's core components—including Eureka for service discovery, Ribbon for client‑side load balancing, OpenFeign for declarative REST calls, Hystrix for circuit breaking, Zuul as an API gateway, and Config plus Bus for centralized configuration—showing how they work together to build resilient microservices architectures.
This article explains why data consistency is critical in microservice architectures, introduces the Saga pattern as a solution for achieving eventual consistency, compares it with two‑phase commit and TCC, and details the design of a centralized Saga framework including logging, recovery, and execution components.
Traditional testing suffers from low efficiency, unclear scope, and unquantifiable quality standards, especially in fast‑paced agile and microservice architectures; the article introduces a Precise Testing system that leverages bidirectional traceability, intelligent test case selection, incremental coverage analysis, and recommendation algorithms to make testing more accurate, automated, and data‑driven.
This article explains the advantages and disadvantages of using message middleware in microservice architectures and details practical solutions for handling concurrency, ordered processing, duplicate messages, and transactional messaging using patterns like partitioning, outbox tables, CDC, and RocketMQ's two‑phase commit.
This article explains the purpose and benefits of layered software architecture, compares traditional three‑tier designs with hexagonal architecture, discusses system splitting and micro‑service considerations, and provides C# code examples illustrating domain, application, and adapter layers.
This tutorial walks through setting up Spring Cloud microservices using Spring Boot, configuring Eureka for service registration, implementing Ribbon and Feign for client-side load balancing, and configuring high‑availability Eureka clusters, complete with Maven pom.xml, application.yml, and Java code examples.
This article provides a concise overview of Kubernetes, covering its master‑node architecture, core components such as API server, scheduler, controller, kubelet and kube-proxy, the lifecycle of Deployments and Pods, and explains service types, networking, and service discovery within a cloud‑native environment.
This article provides a comprehensive guide to Spring Cloud Gateway, covering its purpose, advantages, configuration steps, CORS handling, custom filters, token‑bucket rate limiting, and deployment instructions for building a robust microservice gateway in Java.
This article explores cloud‑native software architecture, covering the 12‑factor app foundation, loose‑coupled design, API‑first and SOLID principles, event‑driven and service‑mesh patterns, observability, serverless runtimes, and emerging technologies such as Dapr, GraalVM and WebAssembly.
This article presents a systematic performance comparison between Java and Go microservices—covering raw speed, memory usage, logging impact, GraalVM native images, and Kubernetes deployments—to reveal when each language excels and the practical trade‑offs involved.
iQIYI’s Consul‑based service registry, tightly integrated with its QAE container platform and API gateway, suffered a multi‑DC outage caused by network jitter and a metrics‑library lock‑contention bug, which was resolved by upgrading Go, go‑metrics, and Raft, adding extensive monitoring, redundant DC registration, and dedicated per‑gateway Consul clusters to ensure continued stability and scalability.
The article examines the challenges of exposing numerous backend microservices to clients and proposes using an API gateway to centralize traffic, handle authentication, rate limiting, protocol conversion, service discovery, performance optimization, and operational concerns, while also discussing the shift toward decentralized service‑mesh solutions.
This article explains the concept and implementation approaches of SAGA as a distributed transaction solution, covering the problem definition, the two strategies—Choreography and Orchestration—including their workflows, event handling, state machine coordination, advantages, drawbacks, and references to Alibaba's Seata framework.
This guide walks you through packaging the Ruoyi microservice project with Maven, copying the resulting JAR files to a Windows server, running each service with the correct Java encoding, and configuring the front‑end proxy via vue.config.js or Nginx for full deployment.
Spring Cloud Hoxton.SR9, a bug‑fix release compatible with Spring Boot 2.3.x and 2.2.x, introduces enhancements across Spring Cloud Gateway, Commons, Netflix, OpenFeign, Contract, Sleuth, Config, and Consul, including new SecureHeadersGatewayFilter, actuator route definitions, BooleanOpSpec.not(), performance‑tuned load balancers, and expanded configuration options.
This article provides a comprehensive overview of Spring Cloud’s core components—including Eureka for service registration, Ribbon for client‑side load balancing, Feign for declarative REST calls, Hystrix for circuit breaking, and Zuul as an API gateway—explaining their mechanisms, configurations, and interactions within a microservice architecture.
This article presents a comprehensive SOA service‑architecture planning methodology—from end‑to‑end business process analysis and data‑architecture design to technical platform assessment, integration mapping, service‑catalog creation, and practical case study—showing how to identify, refine, and organize reusable services in a micro‑services and mid‑platform environment.
This guide walks you through updating the mall‑swarm project to use Nacos for service registration and configuration, preparing Docker images, configuring Jenkins jobs for each microservice, handling Docker network settings, and verifying the deployment, enabling one‑click builds and releases for the entire e‑commerce platform.
This article explains the principles, architecture, and practical adoption of distributed tracing—covering OpenTracing standards, SkyWalking's design, sampling strategies, plugin development, and real‑world company practices—to help engineers pinpoint bottlenecks and improve observability in microservice systems.
This article explains a practical approach to applying layered architecture and Domain‑Driven Design (DDD) to a Java microservice‑based fresh‑food e‑commerce platform, outlining five architectural layers, domain service partitioning, common pitfalls, and guidance for building maintainable, high‑cohesion services.
This article explains the fundamentals of single- and multi-data-source transactions, reviews common distributed-transaction solutions such as 2PC, 3PC, TCC, transaction-status tables and message-queue based eventual consistency, and then details Seata’s AT mode implementation, including its workflow, undo-log mechanism, and isolation handling.
This article explains the limitations of single‑database transactions in multi‑data‑source micro‑service scenarios, reviews common distributed‑transaction models such as 2PC, 3PC, TCC, status‑table and message‑queue based final consistency, and details the implementation of Seata's AT mode for achieving global ACID properties.
This article examines the trade‑offs between monolithic and microservice architectures, outlines the benefits, costs, and technical prerequisites of microservices, and provides concrete criteria—such as business complexity, team size, and talent readiness—to help engineers decide the right moment to adopt a microservice approach.
This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.
This article explains the concepts of circuit breaking, degradation, rate limiting and isolation, introduces the two widely‑used flow‑control components Sentinel and Hystrix, compares their designs, features and trade‑offs, and provides guidance on selecting the right solution for high‑concurrency microservices.
This article presents a structured approach to mastering microservices, covering the learning pyramid concept, a detailed learning path with resource collection, and an overview of the six essential components—service description, registry, framework, monitoring, tracing, and governance—along with practical tips and visual diagrams.
This article provides a detailed, hands‑on tutorial for installing the required tools, configuring Nacos and MySQL, cloning the RuoYi-Cloud source, initializing databases, and launching both backend and frontend services so you can run the full microservice system on a local machine.
This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.
This guide walks you through cloning the dubbo-go repository, configuring environment variables, launching a Go server and client, examining the key source files, and understanding the full export and invocation chain—including registry registration, proxy invokers, and filter wrappers—while highlighting common pitfalls.
This article introduces Nacos, an open‑source Alibaba project that serves as both a service registry and a distributed configuration center, explaining its core concepts, architecture, and how it simplifies service discovery and configuration management in cloud‑native microservice environments.
This article uses Taobao's backend as a case study to illustrate how a system evolves from a single‑machine deployment to a multi‑layer, highly available, cloud‑native architecture capable of handling millions of concurrent users, covering concepts such as distribution, load balancing, caching, database sharding, micro‑services, containerization, and cloud platforms.
Cloud native, coined by Matt Stine in 2013, blends DevOps, continuous delivery, microservices, and agile infrastructure into a philosophy that redesigns applications for any public, private, or hybrid cloud, emphasizing container packaging, automated pipelines, and cultural shifts to boost scalability and delivery speed.
This article introduces seven open‑source projects that demonstrate frontend‑backend separation using technologies such as Vue, Angular, React, SpringBoot, and SpringCloud, providing practical examples and resources for developers to deepen their full‑stack development skills.
The author recounts a three‑year journey of scaling a Python‑based HR SaaS backend from a simple Django MVC prototype to a microservice architecture with domain‑driven design, detailing each architectural stage, the challenges faced, and the concrete optimizations applied.
The author recounts a four‑stage evolution of a Python‑based SaaS backend—from a simple Django MVC prototype through service splitting, microservice adoption with Kong and custom RPC, to an exploratory domain‑driven design—highlighting practical problems, optimizations, and architectural trade‑offs.
The article identifies seven common DevOps configuration pitfalls—including over‑emphasis on microservices, hard‑coded container settings, mismanaged Kubernetes, missing continuous delivery, fragile test automation, self‑managed databases, and unnecessary multi‑cloud—and offers practical guidance to avoid them and boost developer productivity.
This article explains the distinctions between SOA and microservice architectures, describes ESB and API gateway roles, outlines the characteristics of both architectures, and provides practical Dubbo service design guidelines such as packaging, granularity, versioning, and pre‑release environment configuration.
This article explains the motivation behind circuit breakers, illustrates how cascading failures occur in distributed microservices, describes the three circuit breaker states (closed, open, half‑open), and provides Python and Envoy configuration examples to implement fault‑tolerant service communication.
This article provides a detailed introduction to Spring Cloud’s core modules—including Eureka service discovery, Ribbon load balancing, Feign declarative HTTP client, Zuul API gateway, Hystrix fault‑tolerance, and Config centralized configuration—explaining their principles, advantages, and typical usage scenarios in microservice architectures.
This article outlines the evolution of project architecture from single‑server MVC to RPC, SOA, and micro‑services, and provides clear explanations of core distributed‑system terms such as clusters, load balancing, caching, and flow control for developers.
This article examines the challenges of microservice communication and explains how to transform an Nginx+Lua layer into an OpenResty‑based API gateway, covering core concepts, usage scenarios, security, performance, high‑availability, extensibility, and a comparative review of popular open‑source gateway solutions such as Nginx, Spring Cloud Zuul, Kong, Tyk and others.
This article explains what Druid Monitor and Druid Admin are, why cluster‑level monitoring is needed in microservice architectures, and provides a complete Spring Cloud starter implementation with configuration examples, code snippets, and usage limitations.
This article explains the financial background, product and technical design, logical architecture, amount calculations, invoice splitting rules, and asynchronous interface flows needed to implement a robust online VAT invoicing system that complies with Chinese tax regulations.
SOFABoot, an open‑source framework from Ant Financial built on Spring Boot, enhances microservice development by adding readiness checks, class isolation via SOFAArk, log space isolation, unified middleware integration, and modular development support, helping prevent class conflicts and simplify large‑scale service deployments.
This report recaps a technical closed‑door session where experts from Weibo and Ziroom shared real‑world API gateway implementations, discussed centralized versus decentralized designs, explored the evolution of Ziroom's gateway, introduced the Gamma‑RPC framework, and debated future trends like service mesh.
This article details Youzan’s testing team’s evolving API automation strategy, covering architectural context, dual‑approach request simulation, regression efficiency enhancements, blind‑spot elimination through online validation and traffic recording‑replay, and practical lessons for large‑scale product delivery.
Microservice architectures increase system complexity and failure rates, so this article explains key reliability patterns—such as graceful degradation, change management, health checks, self‑healing, fallback caches, retry logic, rate limiting, circuit breakers, and testing—to help engineers design resilient, high‑availability services.
The article reviews microservice data consistency challenges, explains why traditional distributed transactions like 2PC/3PC are unsuitable, introduces the BASE theory, and details four implementation patterns—reliable event notification, maximum effort notification, business compensation, and TCC—to achieve eventual consistency.
This article explains the principles, types, and layer responsibilities of DDD layered architecture, compares it with traditional four‑layer and three‑layer designs, and shows how microservices can evolve by reorganizing aggregates and applying dependency inversion across UI, application, domain, and infrastructure layers.
This article examines the motivations for service discovery in microservice architectures, compares client‑side and server‑side discovery patterns, discusses consistency versus availability trade‑offs (CAP, CP vs AP), and reviews various health‑check mechanisms, graceful up/down strategies, metadata considerations, and high‑availability designs.
This article examines the inherent risks of microservice architectures and presents practical patterns—such as graceful degradation, change management, health checks, self‑healing, fallback caching, retries, rate limiting, bulkheads, and circuit breakers—to build highly available, fault‑tolerant services.
This comprehensive guide explains the essence of software architecture, clarifies related concepts such as systems, modules, and frameworks, and details various architectural layers, classifications, evolution paths, and best‑practice considerations for building robust, scalable systems.
This article walks through the step‑by‑step evolution of a high‑concurrency backend—from a single‑machine setup to a cloud‑native, micro‑service architecture—highlighting the technical challenges, key technologies, and design principles at each stage.
This article explains the motivations for adopting Spring Cloud, defines its components and design goals, compares it with Spring Boot and other frameworks, outlines its main sub‑projects, versioning scheme, and provides practical guidance on configuration, service discovery, load balancing, fault tolerance, and gateway development for cloud‑native microservices.
This article reviews the evolution of service discovery in cloud‑native microservices, comparing Eureka, Consul, Nacos, SLB, Kubernetes Service and Istio, and discusses their architectures, strengths, limitations, and practical considerations for selecting the most suitable solution.
This article explains the origins, core principles, and practical components of Cloud Native—including microservices, containerization, DevOps, continuous delivery, and cloud infrastructure—showing how they reshape development culture, organization, and technology adoption for modern software teams.
This comprehensive guide explains what software architecture is, distinguishes systems, subsystems, modules, components, and frameworks, outlines architecture layers and classifications, describes strategic versus tactical design, tracks the evolution from monoliths to micro‑services, and highlights how to evaluate and avoid common architectural pitfalls.
This article presents a curated list of 29 Alibaba open‑source projects—including Spring Cloud Alibaba, Ant Design, Druid, Fastjson, Dubbo, JStorm, Nacos, Sentinel, and many more—detailing their core purpose, key features, and GitHub repositories for developers seeking robust solutions across cloud, micro‑services, frontend, and data processing domains.
This article outlines the step‑by‑step evolution of a high‑traffic e‑commerce backend—from a single‑machine setup through caching, load balancing, database sharding, microservices, containerization, and finally cloud deployment—while summarizing the key technologies and design principles at each stage.
The article introduces Tars, a high‑performance RPC framework and integrated service governance platform that leverages micro‑service architecture, detailing its design philosophy, layered architecture, key features such as the Tars protocol, load balancing, fault tolerance, overload protection, configuration management, and open‑source availability.
This article explains how service discovery has progressed from simple centralized proxies to client‑embedded libraries and finally to host‑level independent processes like Service Mesh, detailing each generation, their pros and cons, and how Kubernetes implements discovery and load balancing.
Microservice architecture blends SOA, componentization, and domain modeling, and today a variety of open‑source frameworks—such as Spring Cloud, Eclipse MicroProfile, Dubbo, Tars, Helidon, SOFAStack, gRPC, Thrift, and brpc—along with leading Service Mesh solutions like Linkerd, Envoy, Istio, and Conduit, empower developers to build scalable, cloud‑native applications.
This article explains the fundamental concepts of software architecture, distinguishes systems, subsystems, modules and components, describes various architectural layers such as business, application, data, code, technical and deployment, outlines evolution from monoliths to micro‑services, and highlights common misconceptions and measurement criteria for a sound architecture.
This article explains how to construct a PaaS cloud platform using microservice architecture, Docker containers, and Spring Cloud components such as Zuul, Eureka, and Hystrix, covering service gateway, registration, fault tolerance, and dynamic configuration to enable rapid development and deployment.
This article explains why microservice calls need fault‑tolerance mechanisms, introduces Hystrix’s core features such as timeouts, circuit‑breaker, fallback, monitoring and resource isolation, and provides step‑by‑step code examples for integrating Hystrix and Feign in a Spring Cloud project.
Microservices aren’t a universal solution; this article outlines five common situations—insufficient complexity, small teams, indivisible applications, legacy system integration, and tight real‑time integration—where adopting a microservice architecture can add unnecessary overhead and risk, advising developers to choose the right architecture for their needs.
Before defaulting to a microservices architecture, developers should evaluate whether their application is large enough, truly needs component scaling, can handle cross-service transactions, and can tolerate increased latency and complexity, as these factors determine if microservices will add value or unnecessary overhead.
This article compares three seasoned experts' approaches to microservice splitting—vertical vs. horizontal, business‑driven, stability‑driven, and performance‑driven—highlighting trade‑offs, team size considerations, and practical guidelines for achieving scalable, maintainable architectures.
This article presents a structured approach to mastering microservices, covering a learning pyramid, a step‑by‑step roadmap, weekly ARTS habits, and detailed explanations of the six essential components that together form a robust microservice architecture.
This article explores the fundamentals of monolithic and microservice architectures, assesses the benefits, costs, and risks of adopting microservices, and provides practical criteria—including business complexity, team size, and technical readiness—to help decide the optimal moment for migration.
In large‑scale microservice environments, centralized log collection, filtering, and visualization using Filebeat, Elastic APM, Kafka Streams, Grafana and Prometheus can turn scattered logs into actionable operational data while controlling resource costs.
This article explains the fundamentals of distributed systems, covering the CAP and BASE theorems, caching strategies, message queues, database choices, JVM optimization, and practical architectural improvements applied to New Oriental's mobile app to enhance availability and performance.
This article explains the concept, states, and practical benefits of circuit breaker mechanisms in microservice architectures, illustrating how they prevent cascading failures, improve system stability, and provide configurable recovery strategies for robust cloud‑native applications.
This article details Saike Mobility's successful Level‑3 DevOps continuous‑delivery assessment, shares insights from an interview with their operations director, and explains the national DevOps capability maturity model that is shaping engineering efficiency across Chinese tech enterprises.
This article explains what GraphQL is, how its type system and Relay standard work, the N+1 problem, and presents three architectural approaches—prefixing, schema stitching, and RPC composition—for integrating GraphQL into microservices, along with authentication, authorization, and routing considerations.
Xianyu’s zero‑downtime upgrade strategy for its multi‑microservice search stack combines rigorous forward/backward compatibility checks, batch‑wise stateless updates, careful stateful migrations via hot‑updates or dual‑write sync, robust service‑discovery traffic control, and Alibaba‑style monitoring, gray‑release testing, and rapid rollback to ensure uninterrupted service.
This article explains how to construct a reliable, high‑throughput microservice platform using open‑source components such as Consul, an access layer, and token‑based multi‑tenant service discovery, covering architecture, registration, heartbeat handling, performance optimizations, high‑availability strategies, graceful shutdown, and deployment best practices.
This guide explains how to download, build, and run Nacos from source, customize its UI, ensure server‑client version consistency, and modify configuration files, providing step‑by‑step commands and code snippets for Linux, macOS, and Windows environments.
This article explains how to design a non‑intrusive distributed tracing system for microservices by assigning global TraceIDs, generating hierarchical SpanIDs, using lightweight agents to propagate identifiers via transport headers, and aggregating data in a collector to visualize complete call graphs and diagnose performance issues.
This article explores how Nginx’s high‑performance, event‑driven architecture underpins modern DevOps practices, detailing its roles in web hosting, proxying, caching, API gateways, dynamic routing with Lua/Redis, emergency failover designs, data‑driven operations, and micro‑service integration.
This article explains how Sentinel Go provides flow control, warm‑up throttling, concurrency limiting, circuit breaking, hotspot protection, and system‑adaptive safeguards to keep distributed microservices stable under traffic spikes, third‑party failures, and resource contention.
