The article defines delivery capability as the ability to provide usable, complete results, explains why thorough delivery matters, and outlines concrete delivery standards for backend, frontend/mobile, and QA roles to achieve high‑quality, end‑to‑end software outcomes.
Full‑chain load testing uncovered a Redis large‑key bottleneck that saturated bandwidth, a memory‑leak caused by repeatedly registering shutdown hooks, and persistently high JVM heap usage, leading to solutions of key sharding with local caching, registering hooks only once, and adjusting heap size, physical memory, and alert thresholds.
go-zero, a CNCF‑listed cloud‑native web and RPC framework, offers a minimalist API definition tool (goctl) that generates client code for multiple platforms, and provides built‑in microservice governance features such as TLS, rate‑limiting, circuit‑breaking, and seamless integration, with the latest release adding TLS support for REST, ZRPC, Redis, etc.
The article explains PHP's session_save_path function, detailing its syntax, how it returns or sets the session storage directory, the required path parameter, and the necessity to call it before session_start(), providing essential guidance for backend developers managing session data.
PHP 8.1 adds support for using the new expression as a default value in constructors, property promotions, static variables and global constants, enabling objects to be instantiated directly in initializer syntax while preserving lazy construction semantics.
mybatis-mate extends MyBatis with enterprise-grade capabilities such as sharding, multi-datasource routing, data audit, sensitive-word filtering, field encryption, dictionary binding, dynamic DDL generation, data-scope permissions, and performance logging, providing a comprehensive solution for agile and secure data handling in Java backend applications.
This tutorial shows how to quickly add GraphQL support to a Spring Boot web project by creating a Maven project, adding custom dependencies, defining schema files, implementing resolvers and a controller, and testing query and mutation endpoints, all without using the official graphql‑java‑tools starter.
This article examines the challenges of implementing a flash‑sale (秒杀) system—such as overselling, massive concurrency, request throttling, and database strain—and proposes a comprehensive backend architecture using separate databases, dynamic URLs, static pages, Redis clustering, Nginx, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.
The article humorously outlines a step‑by‑step workflow for fresh graduates tackling a new coding task, from choosing tools and drafting a technical plan to rapid development, code reviews, testing, and deployment, while emphasizing flexibility and the unpredictable nature of backend work.
This article provides a comprehensive overview of microservices architecture, covering its definition, comparison with monolithic systems, design principles, communication methods, benefits, drawbacks, governance, and practical considerations such as DevOps, containers, and real‑world case studies.
The article explains PHP's session_regenerate_id() function, its optional delete_old_session parameter, return values, and provides a complete code example demonstrating how to replace the current session ID while preserving session data.
This article details the design, deployment steps, technical architecture, and operational workflow of the Jingwei system—a Java code‑coverage solution built on JaCoCo that automates coverage collection, merges execution data, and visualizes results to improve testing quality and efficiency.
This article explains the evolution from local to distributed transactions, detailing the XA protocol, the two‑phase commit process, the LCN framework, the TCC model, and the design of business compensation mechanisms for reliable microservice systems.
The article explains PHP's session_name() function, describing how it returns the current session name, optionally sets a new name when a parameter is provided, details the allowed name format, return behavior, and includes a practical code example.
This article explains PHP 8.1’s native enum feature, covering basic enum definitions, typed properties, methods, backed enums, serialization, case listing, reflection, traits, and practical code examples to help backend developers adopt enums in their projects.
This article walks through developing a simple Go WebSocket server that echoes the current time, shows a minimal client, compares startup speed with Java, and provides full source code and test logs for practical performance testing.
The PHP function session_module_name() retrieves the current session module name or, when given a string argument, sets the session module to the specified value, returning the name of the active module as a string.
This article provides a comprehensive overview of RabbitMQ, covering the AMQP protocol fundamentals, key components such as connections, channels, exchanges, queues, and bindings, as well as message structures, various messaging patterns, consumption models, financial‑grade features, and a detailed feature comparison.
This article explains how MyBatis plugins work, shows how to create a custom interceptor with Java code, configure it in XML, and details the underlying mechanism that uses dynamic proxies to intercept Executor methods.
The article explains PHP's session_id() function, showing how to retrieve or set the current session ID, the optional id parameter requirements, character restrictions for different session handlers, and the function’s return behavior, including using the SID constant for URL integration.
The article explains PHP's session_destroy function, which deletes all data stored in the current session without resetting global variables or the session cookie, describes its return values, and provides a complete example showing how to start a session, clear variables, optionally remove the session cookie, and finally destroy the session.
This guide explains how MyBatis initializes its logging factory, shows how to add SLF4J and Log4j dependencies, configure SimpleLogger properties, resolve multiple SLF4J bindings, and switch the logging implementation via mybatis-config.xml and log4j.properties, with full code examples and sample output.
The session_cache_limiter function returns the current cache limiter name, defines HTTP cache‑control policies such as nocache, public, and private, accepts an optional limiter argument, and can be used in PHP scripts to control client and proxy caching behavior.
This article compiles 128 high‑frequency Kubernetes interview questions covering fundamentals, architecture, networking, storage, security, and operational best practices, helping developers and engineers prepare comprehensively for K8s‑related job interviews.
This article explains the PHP function session_cache_expire(), describing its purpose of returning the current session cache expiration value in minutes, its optional parameter for setting a new expiration time, the default return value, and provides a complete example demonstrating how to configure and display the cache limiter and expiration settings.
This article provides a detailed introduction to MyBatis, covering its relationship with JDBC, core components, execution flow, configuration, design patterns, caching strategies, plugin mechanisms, logging options, dynamic SQL features, and includes complete Java and XML code examples to illustrate practical usage.
This article introduces the testing pyramid, explains unit testing concepts, and provides a step‑by‑step guide for writing Go unit tests using the standard testing package, the AAA pattern, Testify assertions, mocks, and test suites, while highlighting the benefits of fast verification, documentation, and sustainable development.
This article shares practical Java performance‑optimization techniques, covering UI and non‑UI latency metrics, baseline data collection, bottleneck discovery with tools like Arthas, chronic issue handling, and a comprehensive set of governance measures ranging from network‑level caching to code‑level refactoring, asynchronous processing, and service splitting to achieve stable sub‑200 ms response times.
This article presents a full‑stack Java SpringBoot project that manages community users and tracks epidemic data, employing RBAC for role‑based permissions, MySQL for storage, and various Spring modules such as SpringMVC, AOP, interceptors, and global exception handling.
This article explains how to seamlessly integrate JSR‑303 Bean Validation with Spring Boot, covering the underlying concepts, required dependencies, built‑in and Hibernate‑specific constraints, simple, group and nested validation techniques, result handling, the role of spring‑boot‑starter‑validation, and how to create custom validation annotations and validators.
This article introduces Java's ReentrantLock as an easy-to‑use alternative to synchronized, explains its core lock() and unlock() methods, demonstrates practical code examples, and covers advanced APIs such as tryLock, getQueueLength, isLocked, and getHoldCount for robust multithreaded programming.
This guide compares simple Date‑based timing, System.currentTimeMillis(), and Spring's StopWatch utility, showing how to accurately measure and analyze execution durations of individual code blocks in Java applications.
The article explains PHP's session_status() function, which takes no arguments and returns an integer indicating whether sessions are disabled, enabled without an active session, or enabled with an active session, providing developers with a simple way to check session state.
This article explains the benefits of a monorepo for multi‑service web applications and demonstrates how to set up GitLab CI/CD pipelines and Docker containers to build, test, and deploy backend and frontend services efficiently.
session_start() creates a new PHP session or reuses an existing one, detailing how it interacts with session IDs via GET, POST, or cookies, the internal callbacks invoked, optional configuration options, return values, and providing a practical code example demonstrating session variable usage across pages.
This article explains the core storage design of RocketMQ, covering the CommitLog, ConsumeQueue, and Index files, their organization, sequential write strategy, memory‑mapped I/O, and flexible flushing policies that together provide high‑throughput, low‑latency messaging for backend systems.
This article explains the purpose of Java 8's Optional class, illustrates common misunderstandings, lists several bad usage patterns, and provides a set of recommended best‑practice APIs and tips to help developers handle nullable values safely and elegantly in backend Java code.
This article explains why APIs are essential, how to model data and design resource‑oriented endpoints, outlines RESTful conventions, discusses major and minor versioning strategies, and provides practical pagination guidelines to create robust, maintainable backend services.
This article compiles essential Nginx interview questions covering its definition, key features, differences from Apache, request handling mechanisms, master‑worker architecture, proxy types, module usage, and common configuration directives, providing a comprehensive guide for backend engineers preparing for technical interviews.
This article explains four common rate‑limiting algorithms—fixed‑window counter, sliding window, leaky bucket, and token bucket—detailing their mechanisms, advantages, drawbacks such as the critical‑window problem, and how they can be implemented simply using Redis in backend systems.
The PHP function virtual() is an Apache‑specific routine that performs a sub‑request, allowing inclusion of CGI scripts or .shtml files by executing the specified filename and returning TRUE on success or FALSE on failure.
After mastering Go's net/http and fasthttp client libraries, this article presents six distinct server‑side implementations—ranging from basic net/http handlers to Echo, Gin, and fasthttprouter—highlighting their syntax, readability, and configuration differences for rapid backend development.
This article explains why Redis needs high availability, defines common failure scenarios, compares several HA architectures—including single‑instance, master‑slave with one or multiple Sentinel processes, and VIP‑based solutions—and provides step‑by‑step guidance for deploying a robust Redis Sentinel cluster.
The author, a second‑year master's student in Java backend development, summarizes interview questions and experiences from JD, Meituan, Alibaba, Toutiao and Kuaishou, covering Java concurrency, JVM locking, Netty, Redis, MySQL/HBase, distributed systems, and several algorithm problems.
This article provides a detailed tutorial on Spring's RestTemplate class, covering its overview, setup, and extensive examples of GET, POST, file download, header handling, dynamic URL parameters, and integration with HttpClient and OkHttp, along with complete code snippets and best‑practice recommendations for backend Java development.
This article explains Spring's three bean injection approaches—property, setter, and constructor injection—detailing their syntax, advantages, and drawbacks, referencing official Spring documentation to show the evolution from setter to constructor injection and advising developers on best practices.
The article explains PHP's getallheaders function, which returns an associative array of all HTTP request headers for the current request (or FALSE on failure), lists its lack of parameters, describes the return value, and provides a sample code snippet demonstrating its usage.
The article explains the AKF microservice splitting principle, describing how X‑axis horizontal replication, Y‑axis business‑oriented partitioning, and Z‑axis data‑oriented partitioning together address single‑point failures, capacity limits, and performance bottlenecks in clustered backend systems.
This article explains the fundamentals of database transactions, the ACID properties, and how Spring provides both declarative and programmatic transaction support through three core interfaces, detailed configuration examples in XML and Java, and a deep dive into transaction attributes such as isolation, propagation, rollback rules, read‑only mode, and timeout.
When a high‑traffic Dubbo interface began throwing thread‑pool exhaustion errors, the team traced the issue to Redis request spikes, identified mis‑configured connection‑pool parameters and version‑specific bugs, and applied a series of quick fixes, pool‑size adjustments, and client‑side optimizations that dramatically reduced latency and error rates.
This article details the motivation, design, key features, implementation techniques, and evaluation standards of a real‑time Java code‑coverage platform built on Jacoco, covering background industry trends, platform architecture, incremental reporting, visualization, Maven integration, and practical lessons for developers and QA teams.
The article explains why cache breakdown, penetration, and avalanche occur in high‑concurrency Redis environments, and presents practical mitigation techniques such as distributed locking, Bloom‑filter filtering, and careful expiration strategies to keep backend services stable.
This article explains how to implement a lottery feature in a Java backend, covering database schema design for prizes, probability limits and records, constructing a prize pool, the random selection algorithm, handling prize limits, and using a factory pattern to distribute various prize types.
The article explains the PHP function apache_setenv, detailing its purpose, parameters, return values, and provides a clear example of how to set an Apache environment variable for a subprocess.
This article describes the motivation, architecture, technology choices, and operational practices of building a lightweight Node.js middleware layer that acts as an API gateway for a data platform, covering its positioning, NestJS selection, Kubernetes deployment, health probes, and logging strategies.
This article examines the concept of idempotency, illustrates typical business scenarios such as order placement and fund transfer, analyzes which layers of a classic system architecture should enforce idempotency, and provides concrete database‑level strategies and code examples to achieve reliable, repeatable operations.
The apache_request_headers function in PHP returns an associative array of all HTTP request headers for the current request, requires no parameters, and returns FALSE on failure, with an example demonstrating how to iterate and display each header and its value.
This article explains how to design clear and consistent API error and result codes, using HTTP status code concepts, parameter conventions, personalized messages, and unified handling to improve communication, reduce maintenance costs, and enable effective monitoring and alerting for backend services.
This article explains the Apache php function apache_note(), its purpose as a wrapper for table_get/table_set, details its parameters and return values, and provides a practical code example showing how to set and retrieve notes between modules.
This guide explains how to configure and use Spring Bean Validation, demonstrates simple and method‑level validation, and shows how to create custom constraint annotations with full code examples for a Spring Boot 2.4.11 application.
This article introduces a Spring Boot‑based open‑source project that demonstrates how to integrate Alipay's various payment modes—including QR code, PC, WAP, and app payments—by detailing the required tech stack, configuration files, deployment steps, and key code snippets.
This article explains the fundamentals of distributed transactions, compares classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transaction messages, and maximum‑effort notifications, and presents a sub‑transaction barrier technique to handle network anomalies and ensure idempotency, isolation, and rollback safety.
This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to implement a statistical query on a student_score table, compares their code complexity and generation settings, and provides practical code examples and a summary of each framework’s advantages and drawbacks.
This article presents a comprehensive overview of technical middle‑platform architectures, covering core platform diagrams, banking data structures, retail industry models, backend design principles, real‑time data pipelines, enterprise evolution stages, and case studies from Alibaba and NetEase, illustrated with numerous diagrams.
This article explores the fasthttp library as a high‑performance alternative to Go's net/http client, demonstrates basic and advanced API usage with object pools, shows how to set up a mock test server, and provides complete Go unit‑test examples with output verification.
This article introduces SOFABoot, an Ant Financial open‑source framework built on Spring Boot that adds readiness health checks, class and log isolation, unified middleware integration, and modular development capabilities, and provides the project’s source repository for developers.
This article explains how Spring Boot 2.4.11 processes exceptions, routes them to the default /error endpoint, and uses BasicErrorController along with ContentNegotiatingViewResolver and StaticView to generate HTML or JSON error responses based on the Accept header, including code examples and configuration details.
This article explains how the presence or absence of a trailing slash in Nginx location blocks and proxy_pass directives changes request matching and URL rewriting, illustrated with concrete configuration examples and test results to help avoid common deployment errors.
This article explains PHP's mail() function, detailing its parameters, usage cautions, return values, and provides a complete code example for sending an email via SMTP, including formatting of recipient addresses, subject line restrictions, message body limits, and header construction.
This article introduces four powerful Java open‑source projects from the Dromara community—Sa‑Token for lightweight permission authentication, Forest as an elegant HTTP client, LiteFlow for component‑based workflow orchestration, and JPom for lightweight DevOps—detailing their core features, usage examples, and how they boost developer productivity.
This article explains why Spring @Transactional may become ineffective in various situations—such as wrong method visibility, final or static modifiers, internal method calls, missing bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—and provides practical solutions for each case.
The ezmlm_hash() function calculates the hash of an email address for storing EZMLM mailing‑list entries in a MySQL database, describing its parameter, return value, and providing a complete PHP usage example.
The article explains how to properly deal with message‑queue (MQ) outages by first encapsulating MQ operations, then applying degradation tactics such as persisting failed messages to a database, disk, or log, and finally implementing scheduled or manual message‑replay mechanisms while emphasizing monitoring and fallback logic.
This article walks through the Eureka dashboard’s System Status section, explains the meaning of each displayed metric, describes how the self‑preservation mode works and how to enable or disable it, and reviews cluster and instance information shown in a local Eureka cluster.
The author shares a personal journey through Java backend development, big‑data frameworks, database evolution, and team decision‑making, analyzing efficiency, environmental influences, and the impact of community and leadership on technology selection, while emphasizing practical trade‑offs over theoretical performance gains.
This article explains Go's closure mechanism, showing how functions capture surrounding variables, how the compiler's escape analysis moves those variables to the heap, and how closures are internally represented as structs containing a function pointer and captured environment.
This article presents a detailed overview of Alipay's Android wallet system architecture, illustrating its core components such as settlement, customer service, fund processing, and accounting, and further examines the open‑source MetaQ (Metamorphosis) distributed messaging middleware, highlighting its features, advantages over Kafka, and suitable application scenarios.
This guide explains how to add a custom banner.txt file to a SpringBoot project and shows several free online tools for generating ASCII art from text or images, including step‑by‑step instructions and example results that appear when the application starts.
Laravel 8.64 introduces the @aware Blade directive for accessing parent component data, adds new Stringable stripTags, lang_path, throwIf, and hasAny methods, and lists numerous framework enhancements and bug fixes in its release notes.
This article explains essential API design best practices, covering data modeling, resource naming, RESTful conventions, HTTP methods, version control strategies, and pagination techniques, with practical examples to help developers create robust, maintainable, and developer-friendly APIs.
This article explains how to design a modular Java SDK for an open platform, covering HTTP data transmission, flexible JSON/XML serialization adapters, and a simple API client with request/response abstractions, complete with code examples and practical implementation tips.
This article explains the sliding‑window rate‑limiting technique used by Sentinel, presents a classic sliding‑window coding interview problem with a full Java solution, and then dives into Sentinel's internal classes such as WindowWrap, LeapArray, and MetricBucket to show how windows are created, updated, and slid over time.
This guide compiles over 300 interview-style questions covering Python fundamentals, network programming, concurrency, databases, caching, frontend frameworks, DevOps tools, and system design, along with code snippets and brief explanations to help candidates prepare for technical interviews.
The article explains the concept of streaming queries in MyBatis, introduces the Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open during iteration.
This tutorial walks you through setting up iText in a Spring Boot 2.3.10 project, creating a Word‑based PDF template, configuring Adobe Acrobat form fields, and implementing a Java utility class to generate and serve personalized PDFs via a REST endpoint.
This article walks through creating a real‑time video bullet‑chat system using Netty as the backend server and WebSocket for bidirectional communication, covering technology selection, architecture design, data flow, and detailed Java and HTML/JavaScript code to implement the interactive feature.
This article walks through the design and implementation of a Java open‑platform SDK, covering a lightweight HTTP client, flexible serialization adapters for JSON and XML, and a simple API client, while sharing practical code examples and best‑practice tips for building maintainable backend integrations.
This article analyzes common business scenarios requiring timed tasks, compares single‑machine and distributed scheduling solutions such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn, and Xxl‑Job, and provides a detailed feature and capability comparison to help choose the appropriate framework.
This article explains why Spring @Transactional may become ineffective or fail to roll back in various situations—such as wrong method visibility, final modifiers, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—while also offering practical solutions and best‑practice recommendations.
This article explains how Redis implements distributed locks using the SET command with NX and PX options, compares plain setnx, Lua‑based atomic unlock scripts, and Redisson’s high‑level APIs including the RedLock algorithm, and provides practical code examples and pitfalls to avoid.
This article walks through creating a reusable Go HTTP client wrapper, demonstrates its use in a test script, shows console output, and integrates a mock server with Moco to enable quick API testing while applying a learning‑by‑doing approach.
This article introduces SpringBoot's core capabilities such as independent jar execution, embedded servlet containers, starter dependencies, auto‑configuration, production‑grade monitoring, and annotation‑driven development, while also outlining its advantages, disadvantages, CLI tool, Maven setup, and frequently used annotations.
This article reviews a series of common Node.js utilities—type checking, async sleep, file handling, streams, HTTP requests, assertions, code coverage, debugging, deprecation warnings, source‑maps, child processes, and CLI testing—comparing community packages with built‑in APIs, rating their replaceability, and offering practical migration advice for modern Node.js development.
This article explains the evolution from MVC to SPA, highlights the pain points of tightly coupled front‑end and back‑end development, and provides concrete responsibility separation, development processes, and a detailed API specification to enable efficient, loosely‑coupled collaboration in modern web projects.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This article walks through the design and implementation of a complete captcha solution—including image and SMS verification—using .NET Core, covering background context, code details for generating graphics, unsafe handling, noise lines, caching strategies, rate limiting, validation logic, runtime results, and a link to the full source repository.
This article explains how Nginx location directives match request paths and demonstrates the four different behaviors of proxy_pass when the trailing slash is present or omitted, using concrete configuration examples and test results to clarify the impact on URL rewriting and request forwarding.
This article outlines a practical approach to designing open‑platform APIs, covering service‑provider application registration, usability, security, OAuth2‑based authorization, systematic and business request parameters, signature generation, verification, and best‑practice code examples.
This article introduces MySQL 8.0's enhanced JSON capabilities, covering key constraints, storage functions, GeoJSON support, indexing, in‑place updates, essential JSON utilities, path expressions, extraction, modification techniques, and the powerful JSON_TABLE feature with clear code examples.
This article explains why manual jar management can cause class loading conflicts, shows quick IDE-based steps to reorder jars for a temporary fix, and dives into JVM classloader isolation, the parent‑delegation mechanism, and Tomcat's startup loading order to help developers debug and prevent such issues.
