This article explains how to invoke external APIs in a SpringBoot application using three approaches—raw HttpClient, RestTemplate, and Feign—detailing configuration, code examples for GET and POST requests, token handling, and header interception.
This article explains PHP exception handling, describing what exceptions are, how the try‑throw‑catch mechanism works, and provides code examples that illustrate throwing, catching, and converting system errors into exceptions for robust backend development.
This article explains three PHP techniques—get_headers, cURL, and apache_request_headers—to fetch HTTP header information of remote images, providing step‑by‑step code examples and sample outputs for developers needing header data in web applications.
This article explains how Domain‑Driven Design (DDD) can be applied to a complex pricing system, covering business understanding, strategic and tactical design, context integration, layered architecture, code organization, and concrete Java examples that illustrate evaluation and pricing algorithms.
This article explains cache avalanche, breakdown, and penetration, describes why they occur, and provides practical strategies such as pre‑warming, staggered expiration, mutex/queue protection, double‑layer caching, Bloom filters, and consistent update patterns to keep backend systems stable and data consistent.
This article explains MySQL's binlog, its role in master‑slave replication, and how businesses can harness it for data heterogeneity, cache synchronization, and task dispatch, illustrating practical middleware designs that transform raw changes into valuable services.
This article provides a detailed overview of Java backend utilities, covering Spring's Assert class for logical checks, common ObjectUtils and StringUtils methods, collection helpers, file and stream utilities, as well as reflection and AOP tools with practical code examples.
This article describes the background, design goals, core technical solution, versioned implementation process, and performance improvements of a real‑time final‑price calculation module that integrates product price, coupons, and promotions to deliver up‑to‑date pricing for e‑commerce users.
This article explains the inner workings of Redis Hashes, covering the dict and listpack storage mechanisms, memory‑optimizing conditions, rehashing strategies, and the underlying C structures that enable fast O(1) field lookups and efficient memory usage.
This article demonstrates how to use PHP's execution functions—exec, system, passthru, popen, proc_open, and shell_exec—to run shell commands, capture output, and handle process streams, providing example code snippets for each function in PHP scripts.
This article explains what logging is, why it matters, when to log, the principles and level conventions, common log formats, and a comprehensive set of mandatory and recommended best‑practice rules for writing robust, secure, and maintainable backend logs.
This article introduces the URule rule engine, explains its background and features, walks through installation and usage in a Spring Boot project, details core concepts such as variable, constant, parameter, and action libraries, and provides complete code examples for rule sets and decision tables.
This article explains Tomcat's component architecture, describes the three critical parameters (maxThreads, maxConnections, acceptCount) that affect request handling, and provides practical tuning recommendations to improve backend performance without additional hardware costs.
This article explains how to design clear, consistent API error codes and messages by referencing HTTP status code segmentation, defining code‑message pairs, customizing user‑friendly messages, and centralizing handling to improve communication, debugging, and monitoring for backend services.
This article analyzes the challenges of distributed transactions in a micro‑service order system, compares XA, TCC, and SAGA patterns, and details how the open‑source DTM framework is applied to achieve reliable order creation while handling crashes, rollbacks, idempotency, and network anomalies.
This article explains the background, key scenarios, functional components, third‑party payment capabilities, implementation logic, rule‑engine usage, and large‑scale data handling strategies of a checkout system, providing a comprehensive view of its backend architecture and operational considerations.
Facing a 50‑million‑row financial transaction table, the team implemented horizontal sharding with sharding‑jdbc, designed migration and pagination strategies, tackled multi‑datasource transaction issues, and outlined a phased rollout, providing practical insights for large‑scale MySQL table splitting and backend system stability.
The article showcases several advanced IntelliJ IDEA debugger features—non‑suspend, exception, and dependent breakpoints, breakpoint restoration, custom object and list renderers, object marking, and reference/async stack trace tools—that enable backend developers to diagnose and resolve issues far more quickly and precisely than with basic debugging operations alone.
This article explains how to restrict the number of concurrent browser logins for a user account by storing login details in a database or Redis, comparing browser agent strings, and returning appropriate error messages, with full PHP code examples.
This article explains the causes of Redis cache penetration, avalanche, and thundering herd, and provides practical mitigation strategies such as caching null values, using white‑lists, Bloom filters, pre‑warming hot keys, staggered expirations, multi‑level caching, and lock mechanisms.
This article introduces seven relatively obscure but highly useful PHP built‑in functions—highlight_string, str_word_count, levenshtein, get_defined_vars, escapeshellcmd, checkdate, and php_strip_whitespace—explaining their purpose and providing clear code examples for each.
This article explains how to enable fuzzy search on encrypted sensitive fields such as phone numbers and ID numbers in a MySQL database by using Spring Boot, AOP, tokenized ciphertext mapping tables, and encrypted keyword queries to balance security and query performance.
This article explains how to create a reusable Spring Boot starter for enterprise‑level object storage services by leveraging the Amazon S3 protocol, covering OSS fundamentals, dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing with code examples.
Bilibili redesigned its fragmented account system into a unified, multi-tenant architecture using DDD and a four-layer design, consolidating all business lines into one codebase with configurable data isolation, logic, and dependencies, split into four micro-services, and migrated safely via gray-release and bidirectional sync.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering database strategies, tenant isolation, dynamic routing, and deployment scenarios for SaaS applications.
The article explains why synchronous protocols should be avoided in microservice communication, describes how to use RabbitMQ as an asynchronous message broker with various exchange types and routing patterns, provides step‑by‑step C# examples for sender and receiver services, and shows how NServiceBus can further decouple and manage long‑running requests.
This article explains three progressively finer-grained approaches to caching paginated lists in Java—directly caching whole pages, caching individual objects after retrieving their IDs, and caching both ID lists and object entries using Redis structures—along with code examples and performance considerations.
A senior Tencent Cloud backend engineer outlines practical best‑practice guidelines—applying DRY and SOLID principles, leveraging common design patterns, designing high‑availability architectures, automating workflows, prioritizing value‑driven development, fostering clear communication, ensuring reliability, and encouraging continuous learning—to write clean, maintainable, and resilient backend systems.
This article explains how JD.com’s retail shopping‑cart team tackled growing business complexity by redesigning the cart with a full asynchronous architecture, detailing the overall solution, implementation challenges such as fine‑grained retries and monitoring, and the resulting performance gains.
The article explains the concept of idempotency for APIs, distinguishes request and business idempotency, highlights the risk of idempotent breakdown under high concurrency, and presents a practical solution using a three‑step process—lock, check, and update—often implemented with Redis distributed locks and database uniqueness constraints.
This article presents a comprehensive technical overview of the Transaction Fulfillment Product Center, detailing its background, system architecture based on DDD and micro‑services, key features such as unified product management, template‑driven form generation, metadata handling, complex search capabilities, and a custom ID generator, while also providing code examples of extension points.
This article introduces Sa-Token, a lightweight Java permission authentication framework, explains why it was chosen over Spring Security and Shiro, details its core login and permission APIs, demonstrates integration with Spring Boot and WebFlux, and lists its extensive feature set for modern backend development.
RocketMQ 5.1.0 introduces a tiered storage module that offloads messages from local disks to cheaper storage, enabling longer retention without impacting hot data performance, and the article explains its design, implementation details, configuration steps, and current challenges.
The article explains Tubi's migration from PHP and Node.js to Elixir, detailing how the functional language improved the performance of their policy engine and other backend services, while sharing engineers' experiences and addressing concerns about using a niche technology.
This article explains the three major Redis cache issues—penetration, avalanche, and breakdown—detailing their causes, real‑world examples, and practical mitigation strategies such as caching null values, using Bloom filters, staggering TTLs, multi‑level caching, and lock mechanisms to protect database stability.
This article introduces the MyBatis‑Plus‑Join library that adds join capabilities to MyBatis‑Plus, explains how to install it via Maven or Gradle, shows how to extend mapper and service interfaces, and provides detailed code examples for simple three‑table queries, pagination, and advanced custom SQL usage.
Spring Boot 3.1 introduces an enhanced Docker Compose module that automatically starts and stops containers, maps service properties without manual duplication, and configures application settings like Redis and MySQL, allowing developers to quickly integrate Docker Compose files into their Spring applications with minimal setup.
This article introduces the URule rule engine, detailing its background, features, installation steps, core concepts such as library files and rule sets, provides code examples for Spring Boot integration, and discusses practical usage scenarios and decision table configuration.
The recent GraalVM community survey reveals that 65% of respondents already use or plan to use GraalVM in production, with native image creation, polyglot APIs, and Java being the most popular use cases, while challenges include library support and better error diagnostics.
This course covers an introduction to message queues and their use cases, detailed RabbitMQ concepts and installation, various PHP RabbitMQ patterns including simple, worker, fanout, direct, and topic modes, as well as dead‑letter and delayed queues, culminating in a TP6 practical implementation.
This article explains how to set up a PHP development environment, install RabbitMQ and its dependencies, and provides complete producer and consumer code examples to create a simple "Hello World" message queue using RabbitMQ's AMQP protocol.
This article explains the origins, usage, and internal dynamic‑proxy workflow of Spring Cloud OpenFeign, illustrating how FeignClient interfaces are scanned, annotated, and transformed into remote service calls through generated proxy classes, with code examples and diagrams.
This article explains how to improve code readability, reusability, and extensibility by adopting a componentized workflow architecture, detailing three‑layer structures, node abstraction, parameter mapping, and practical Java/Spring XML examples for scalable backend systems.
This article recounts how a finance team tackled a 50‑million‑row MySQL table by analyzing system bottlenecks, defining splitting goals, selecting sharding‑jdbc, addressing multi‑datasource transactions and pagination, designing data migration strategies, and executing a staged rollout to ensure stability and performance.
This article introduces the fundamentals of finite‑state machines, explains the four core concepts of state, event, action and transition, and provides a step‑by‑step Spring Statemachine implementation with database schema, enum definitions, configuration, persistence options, testing, common pitfalls and an AOP‑based solution for reliable transaction handling.
This article provides an in-depth overview of Kafka, covering its core value as a message queue, fundamental concepts, cluster architecture, producer and consumer configurations, scaling strategies, monitoring tools, and practical operational commands for building and maintaining high‑throughput, highly available streaming systems.
The New Relic 2023 Java Ecosystem Report analyzes production usage data to reveal rapid adoption of Java 17, declining popularity of older LTS releases, the rise of containerized applications, and Amazon Corretto becoming the leading JDK vendor, while highlighting preferred garbage collectors and non‑LTS usage patterns.
The article details how a finance team tackled a 50‑million‑row MySQL transaction table by analyzing the pre‑split problems, defining split goals, choosing sharding‑jdbc, addressing multi‑datasource transaction and pagination issues, designing a phased migration and rollout plan, and summarizing lessons learned.
This tutorial provides a complete step‑by‑step guide to set up a Jenkins server inside Docker on CentOS, configure Maven and plugins, create a pipeline that builds a Spring Boot project, builds a Docker image with a Dockerfile, and runs the container automatically, covering all common pitfalls.
This article explains why architecture design, especially Domain‑Driven Design, is essential for controlling the complexity, cost, and scalability of microservice systems, detailing common misconceptions, sources of complexity, and concrete steps to define clear domain and service boundaries.
The article introduces PHP 8.2’s major enhancements—including read‑only classes, disjunctive normal form (DNF) types, the ability to use null, false and true as independent types, and constant definitions inside traits—providing code examples that illustrate each new capability.
This article demonstrates how to create a simple custom annotation that mimics Spring's @Autowired functionality by defining a new annotation, a BeanPostProcessor, configuring beans in XML, and wiring everything together in a test class to show the injection working at runtime.
This article explains the Go singleflight package, its original implementation, and a custom WriteGroup enhancement that merges concurrent read and write events to dramatically improve registration center performance under high load.
This article explains several essential PHP string functions—including substr, mb_substr, stripos with substr, and direct character indexing—providing clear code examples and output demonstrations for handling both ASCII and multibyte characters.
This article explains a three‑step architecture for describing, storing, and calculating fan‑based discounts, introduces a crowd‑based abstraction to accelerate high‑traffic queries, and details a hybrid offline‑plus‑real‑time data‑sync strategy that ensures consistency and millisecond‑level response times.
This article outlines typical problems such as domain inaccessibility, signature errors, token expiration, timeouts, HTTP 500/404 responses, inconsistent documentation, and provides practical debugging and mitigation strategies for developers working with third‑party API integrations.
Learn how to configure NGINX to force browsers to download files instead of displaying them, using Content‑Disposition headers, regex location blocks, and proper MIME handling to reduce server load and handle IE quirks.
An in‑depth tutorial demonstrates building a Netty‑based TCP client with Spring Boot, covering project architecture, module layout, message‑queue simulation, detailed Java code for client creation, connection handling, and testing endpoints, providing a complete, production‑ready demo for IoT socket communication.
Learn how to configure NGINX to force browsers to download files instead of displaying them by adding appropriate Content‑Disposition headers, handling various file types, using regex locations, and reloading the server for the changes to take effect.
This article reviews various distributed ID generation methods—including UUID, database auto‑increment, segment mode, Redis INCR, Snowflake, Meituan Leaf, Baidu UidGenerator, and Didi TinyID—explaining their principles, advantages, drawbacks, and providing Java code examples for each.
This article outlines the essential design principles, client‑side optimizations, CDN usage, clustering, caching, database tuning, and service governance techniques required to build robust, high‑traffic, high‑concurrency backend systems.
This article presents a concise, single‑file PHP solution for integrating Alipay and WeChat payment services, detailing required environment settings, configuration steps, essential code snippets, and browser‑specific handling to help developers quickly add payment functionality to their web applications.
This article provides a comprehensive overview of Kafka, covering its core value as a message queue, fundamental concepts, cluster architecture, log storage mechanisms, zero‑copy data transfer, high‑throughput and high‑availability design, consumer group behavior, rebalance strategies, and practical operational commands for managing topics, partitions, and offsets.
This article explains the step‑by‑step evolution of Redis‑based distributed lock implementations—from a simple SETNX approach to a robust solution using UUIDs, expiration, atomic Lua scripts, and finally Redisson’s high‑level lock API—illustrating common pitfalls and their fixes.
Easy Excel is a PHP library built on openspout that enables fast, low‑memory reading and writing of xlsx, csv, and ods files, providing installation steps, environment requirements, and code examples for exporting, importing, and handling Excel data in backend applications.
The article explains how to achieve idempotent order creation and update operations by using unique request identifiers, database primary‑key constraints, Redis flags, and version columns to prevent duplicate submissions and resolve ABA anomalies in distributed backend systems.
This article explains Spring's transaction propagation options, rollback mechanisms, the limitations of self‑invocation within @Transactional methods, and how to correctly use AOP proxies such as AopContext.currentProxy() and @EnableAspectJAutoProxy to ensure transactional behavior in Java backend applications.
This article explores essential API design principles—idempotency, robustness, and security—by discussing practical techniques such as request locks, database unique constraints, Redis distributed locks, token‑based authentication, JWT, and defensive coding practices to ensure reliable, safe, and maintainable backend services.
This article describes the design, technology choices, architecture, and implementation details of an automated payment channel management system that uses Redis‑based time‑series storage, custom circuit‑breaker logic, and monitoring to achieve fast fault detection, accurate alerting, and future automated failover.
This article shares a comprehensive, step‑by‑step guide to optimizing API performance, covering batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelism, indexing, transaction management, deep pagination, SQL tuning, lock granularity, and code structure refactoring, all illustrated with Java examples.
This article explains how to solve the problem of message loss in WebSocket communication within a micro‑service architecture by introducing a library that uses a single configuration annotation to automatically establish inter‑instance connections, manage message routing, and support custom selectors for targeted delivery.
This article explores how Spring implements classic design patterns—Proxy, Strategy, Decorator, Singleton, Simple Factory, Factory Method, Observer, Template, and Adapter—detailing their purpose, core code snippets, and the way Spring leverages them to provide flexible, extensible, and maintainable backend functionality.
This article explains the complete lifecycle of a Spring bean—including creation, merged BeanDefinition processing, factory exposure, property population, initialization, and destruction—while illustrating the underlying source‑code mechanisms and how Spring resolves constructors, handles circular dependencies, and integrates AOP and post‑processors.
This article walks through building a Spring @EventListener demo, explains how to decouple registration logic, shows step‑by‑step debugging of the event‑listener infrastructure, and explores the internal mechanisms that register and invoke listeners during application startup and runtime.
The article presents magic-api, a Java-based rapid API development framework that lets developers create HTTP interfaces through a visual UI without writing traditional controller, service, DAO, or XML code, and provides features, quick‑start instructions, and resource links.
This article explains the principles and workflow of Single Sign‑On (SSO) and OAuth 2.0, compares their concepts, details implementation steps and grant types, and concludes with a promotional invitation to join a community offering related resources and discounts.
This article provides a step‑by‑step tutorial on analyzing a Spring Boot microservice project, configuring parent and child Maven pom files, packaging modules with Maven plugins, and deploying both backend JARs and frontend assets to Windows or Linux servers.
This article analyzes the challenges of stitching multi‑modal transport routes in Ctrip's backend, identifies performance bottlenecks through monitoring, profiling and benchmarking, and presents a series of optimizations—including code refactoring, indexing, multi‑way merge, multi‑level caching, preprocessing, multithreading, lazy computation, and JVM tuning—that collectively reduce latency and resource consumption.
The article details how a midnight interface timeout in Vivo’s e‑commerce activity system was traced to a logging bottleneck: a synchronous Log4j call blocked all threads while a cron‑driven log‑rotation script copied a 2.6 GB file, and the issue was resolved by switching to asynchronous logging with a non‑blocking appender.
This article explains how Tencent’s internal high‑availability service curriculum emphasizes architecture boundaries, unified protocol definitions using JCE, a unified PushAPI, monitoring and feedback mechanisms, and the organizational impact of aligning system and team boundaries to achieve scalable, reliable backend services.
This article compares session‑based and JWT‑based authentication, discusses their advantages, disadvantages, security and performance considerations, and provides a complete Java Spring Boot implementation—including dependency configuration, utility classes, login/logout/password update logic, and interceptor handling—using Redis for token management.
This article explains how Spring Retry's @Retryable and @Recover annotations provide a clean, annotation‑driven way to handle common retry scenarios such as message failures, remote service errors, and lock acquisition issues, while outlining configuration steps, parameter meanings, and important usage cautions.
A seemingly harmless log addition caused a NullPointerException during FastJson serialization, prompting a step‑by‑step investigation of the generated ASM serializer, JavaBeanSerializer workflow, getter detection rules, and practical code‑style guidelines to avoid similar pitfalls.
This article explains how to build a clean, maintainable backend API response format by defining a standard JSON wrapper, categorizing status codes, using a Result class with static helpers, and automatically applying the wrapper through a custom @ResponseResult annotation, interceptor, and ResponseBodyAdvice in a Spring‑based service.
This article demonstrates how to generate all possible SKU combinations in PHP by using Cartesian product on color, size, and version arrays, includes a full code example and the resulting array output.
This article reviews several Python approaches for creating scheduled or periodic jobs—including a simple while‑True loop with sleep, the Timeloop library, the built‑in sched module, the schedule package, APScheduler, Celery, and Apache Airflow—explaining their usage, advantages, limitations, and providing ready‑to‑run code samples.
A recent OpenAI investigation revealed that a bug in the redis-py client caused ChatGPT to leak conversation histories and personal details of about 1.2% of Plus users, prompting a temporary service shutdown and a rapid patch deployment.
This article explains how to solve the WebSocket message‑delivery problem in a micro‑service environment by introducing a lightweight library that uses a custom annotation to automatically forward messages between service instances, with detailed design, configuration, and code examples.
This article explains the three main Java I/O models—BIO (blocking), NIO (non‑blocking), and AIO (asynchronous)—detailing their characteristics, differences in blocking behavior, core components like Buffer, Channel, and Selector, and shows how they are applied in popular frameworks such as Netty, Mina, and Dubbo.
The article explains how Redis cache expiration can cause a cache avalanche, describes typical scenarios, and presents mitigation techniques such as semaphore-based rate limiting and fault tolerance, accompanied by a Java service example demonstrating lock, semaphore, and cache handling.
This article outlines a flash‑sale system architecture from seven perspectives—covering Nginx static‑dynamic separation, CDN caching, gateway rate‑limiting, Redis locking, MQ buffering, business processing, and database sharding—while detailing peak‑shaving, page optimization, security controls, and transaction trade‑offs for massive concurrent traffic.
This article explains the design and implementation of JD's JSF RPC framework, detailing the architecture, XML configuration of providers and consumers, Spring namespace handling, service registration, server startup, client initialization, load balancing, and the overall workflow from provider exposure to consumer invocation.
Effective application layering, as outlined by Alibaba’s coding standards, separates concerns across controller, service, manager, DAO, and other layers, ensuring maintainable, reusable code; the article explains each layer’s role, domain model conversions, and practical tips for implementing a clean, team‑wide architecture.
This article details Bilibili's thumb‑up system design, covering business capabilities, multi‑layer storage, traffic handling, disaster‑recovery strategies, and future plans to ensure a high‑traffic, reliable like service for videos, posts, comments, and more.
This article, based on a SACC 2022 talk by Huolala architect Cao Wei, explains the principles of bytecode‑enhancement, its practical implementation for large‑scale microservice monitoring, compares enhancement frameworks, shares best‑practice patterns, and explores broader applications such as service‑mesh sidecars.
This article explains how to build a Java backend service that converts Word, Excel, PowerPoint, and text files to PDF streams with OpenOffice and JODConverter, integrates the conversion utility into a Spring service and controller, and demonstrates browser‑based online preview of the documents.
This guide walks you through preparing a GitHub and Packagist account, creating a repository, initializing a Composer package (both automatically and manually), configuring PSR‑4 autoload, writing source code, and finally publishing the package by pushing to GitHub and submitting it to Packagist.
This article explains the principles and differences of the SPI mechanisms in Java, Spring, and Dubbo, covering ServiceLoader, SpringFactoriesLoader, and Dubbo's ExtensionLoader, with detailed demos, core implementation details, advantages, drawbacks, and typical usage scenarios for each framework.
This article provides PHP functions that wrap cURL to perform GET, POST, PUT, DELETE, and PATCH HTTP requests, automatically handling JSON encoding of data and decoding responses into associative arrays, with code examples for each request type.
Learn how to implement a functional HTTP/HTTPS proxy in Go, covering proxy concepts, forward and reverse types, protocol specifics, header transformations, and a complete, runnable code example that listens on TCP, parses requests, connects to target servers, and forwards traffic.
