This article demonstrates how to implement HTTP requests in Java using the built-in HttpURLConnection class, covering request creation, adding parameters, setting headers, handling timeouts, cookies, redirects, and reading responses, including error handling, with complete code examples.
This article explores practical approaches for building a distributed WebSocket cluster in a Spring Cloud environment, covering session handling, Netty versus Spring WebSocket implementations, session broadcasting, consistent‑hash routing, gateway configuration, Ribbon limitations, and provides code examples for each solution.
This article explains the fundamental concepts, design requirements, and modeling techniques for payment accounts and transaction flows in e‑commerce systems, covering distinctions between payment and login accounts, internal vs. external accounts, and detailed entity, account, and transaction models.
This article explains why Dubbo’s RPC model and single‑connection design make it unsuitable for transmitting large files, compares it with HTTP streaming, and shows how Feign’s encoder still loads whole payloads into memory, recommending direct client uploads instead.
This collection highlights a free ByteDance backend training camp, alternatives to web frameworks, Node.js architecture, Flutter performance tricks, an underrated Deno overview, Chrome 100 updates, transitional architecture concepts, a Koa2 signaling server tutorial, a detailed Webpack component library guide, and a comprehensive comparison of npm, npx, cnpm, yarn, and pnpm.
This article recounts a series of real‑world challenges—including Excel‑to‑SQL imports, temporary table handling, Canal service failures, jar conflicts, and deployment mistakes—and explains the step‑by‑step solutions that restored system stability and delivered the required data to operations.
This article explains the eight situations that trigger flow control in RocketMQ—four on the broker side and four on the consumer side—detailing their causes, relevant code paths, and practical measures such as broker scaling or consumer optimization to resolve them.
This article details the design and implementation of a highly available membership platform, covering Elasticsearch dual‑center primary‑backup clusters, traffic‑isolation architectures, deep ES optimizations, Redis caching and dual‑center clusters, MySQL partitioned clusters, seamless SqlServer‑to‑MySQL migration, abnormal member governance, and refined flow‑control and degradation strategies.
To orchestrate multi‑channel marketing activities, the article explains how a finite‑state machine models status flows, compares conditional, state‑pattern, and DSL implementations, evaluates Spring Statemachine, Squirrel, and Cola frameworks, and showcases Vivo’s high‑performance DSL‑based FSM as a practical solution.
This article provides a comprehensive tutorial on Spring Boot's auto‑configuration process, covering bean injection styles, XML and JavaConfig configurations, BeanDefinition internals, autowire modes, constructor argument handling, custom BeanFactoryPostProcessor usage, @Import mechanisms, and the inner workings of Spring Boot's EnableAutoConfiguration and its loading of META‑INF/spring.factories.
This article explains how to perform MySQL pagination manually in a Java backend using MyBatis by calculating offset and limit, adding total‑count queries, and exposing a REST endpoint that returns paged data and total records without relying on the PageHelper plugin.
This article explains what CORS is, shows the typical browser error, and provides step‑by‑step SpringBoot configuration and custom filter techniques—including priority settings—to reliably enable cross‑origin requests in Java backend applications.
This article explains how to create a Spring Boot AOP request‑logging aspect that captures request parameters, execution time, results, and errors, while also adding trace‑ID support for easier debugging in high‑concurrency environments.
This article compares three popular open‑source message brokers—RabbitMQ, Kafka, and Redis—examining their scalability, persistence, consumer models, and ideal use cases to help developers select the most suitable asynchronous communication solution for their microservice architecture.
This article explains how to design a gRPC connection pool, covering scaling rules, idle‑connection timeout and keep‑alive, pool‑full handling, core gRPC features, and practical tuning parameters to achieve high performance in high‑concurrency backend services.
This article explains how to create the open‑source pm2-intercom-log4js tool to reliably synchronize log4js output in PM2’s multi‑process mode, covering log4js’s sync mechanism, PM2 process management, IPC communication, and alternative messaging approaches with practical code examples.
This article explains the challenges of generating globally unique identifiers in distributed systems and presents various solutions—including UUID, database auto‑increment, Redis atomic counters, and the Snowflake algorithm—detailing their requirements, implementations in Java and SpringBoot, and their pros and cons.
The article explains how to prevent duplicate requests on the server side by using unique request identifiers stored in Redis, hashing request parameters (excluding volatile fields) with MD5, and provides a reusable Java helper class with example code and test logs.
This tutorial demonstrates how to add Create, Read, Update, and Delete functionality to a SpringBoot application using MyBatis XML mappers, configure the datasource in application.yml, and expose REST endpoints through a service and controller layer.
This article details the design, architecture, key technologies, and deployment of Xiaosi, an AI‑powered intelligent customer service chatbot built on the internal IM platform, highlighting its problem‑diagnosis accuracy, manpower savings, adapter mechanism, high‑availability backend, and practical use cases.
This article explains how to diagnose and fix common CORS problems between a localhost frontend and backend by configuring Nginx as a reverse proxy, covering preflight requests, required response headers, multiple error scenarios, and complete Nginx configuration examples.
This article explains the officially announced Spring Framework remote code execution vulnerability CVE‑2022‑22965, outlines the affected environments, provides upgrade paths for Spring and Spring Boot, and shares safe code‑based mitigation techniques for developers.
This beginner-friendly tutorial walks through creating a Spring Boot project, adding MySQL and MyBatis dependencies, configuring the application.yml file, and implementing UserMapper, User, and UserController classes to demonstrate a complete MySQL query demo.
The article discusses how to achieve interface idempotency using unique business identifiers or token mechanisms, then explores distributed rate limiting by outlining its dimensions, common algorithms such as token bucket and leaky bucket, and provides concrete implementation examples with Guava RateLimiter, Nginx, and Redis‑Lua scripts.
This article presents a comprehensive design of a unified multi‑account login system, covering self‑built phone‑number authentication, password‑less login, third‑party integrations (Weibo, WeChat, QQ), database schema separation for user basics and authorizations, and a one‑click mobile number login flow, while discussing advantages, drawbacks, and implementation details.
This article introduces Netty, explains Java's BIO/NIO/AIO models, compares reactor threading architectures, details Netty's internal thread and handler pipeline design, and provides a complete example of building a high‑performance HTTP server with Netty.
This article compares several approaches to implementing delayed tasks in Java, including Quartz polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues, analyzing their principles, code examples, advantages, and drawbacks for order timeout handling.
The article describes how a three‑day, cross‑team investigation of a mini‑program image‑upload failure led to the design and implementation of an SRE‑driven, metrics‑driven observability platform that quantifies SLIs, automates tracing, and provides dashboards for real‑time and long‑term analysis, ultimately reducing MTTR.
This article presents a curated list of fifteen widely used open‑source Python frameworks, covering full‑stack web development, lightweight micro‑frameworks, event‑driven I/O, OLAP, distributed computing, continuous integration, and web crawling, each with a brief functional overview.
This article explains how to start a new project using Domain‑Driven Design, describes the evolution from SaaS to PaaS to IaaS, introduces bounded contexts, the four‑layer DDD boundaries, and compares clean, hexagonal, and onion architectures for building maintainable backend systems.
This article explores several methods for creating PHP extensions—including native C, Zephir, php-cpp, php-x, and CGO—provides sample code, describes compilation steps, and compares their execution speed using a Fibonacci benchmark with and without PHP JIT.
This article explains server‑side strategies for preventing duplicate user requests—covering unique request IDs, parameter‑based deduplication with MD5 hashes, handling time‑dependent fields, and a complete Java utility class that leverages Redis SETNX with expiration to ensure idempotent operations.
This article details a step‑by‑step engineering experiment that reproduces a high‑throughput "red‑envelope" service, outlining the required hardware, software stack, load‑generation logic, monitoring setup, and performance results for handling up to 6 000 QPS on a 100‑million‑user scale.
This page compiles a curated list of technical articles covering API testing, HTTP client usage, socket programming, Java NIO, and related backend development topics, each linked with its publication date for reference.
This article traces the evolution of Node.js web frameworks—from early lightweight options like Express and Koa, through enterprise‑grade solutions such as Egg and Midway, to modern front‑end‑oriented stacks like Next.js and Nuxt.js—highlighting their features, trade‑offs, and the progressive design principles that enable seamless full‑stack development.
The article presents a comprehensive design of the Cleaner anti‑crawler system, detailing its background, current challenges, related research, system architecture—including data processing, ban center, and ban store modules built on Flink, MQ, and Redis—implementation details, effectiveness evaluation, and concluding insights on achieving real‑time accuracy in protecting platform data.
The article analyzes various cache update strategies—including delete‑then‑write, write‑then‑delete, and asynchronous binlog subscription—examining their impact on system throughput, concurrency safety, failure scenarios, and fault detection to ensure data consistency between cache and database.
Through systematic measurement, bottleneck identification, and targeted optimizations—including lock redesign, Redis caching, and URL parsing improvements—the author transformed a Go‑based Dubbo registry’s registration throughput from 40 QPS to over 1100 QPS, demonstrating practical performance‑tuning techniques for high‑scale backend services.
The article examines the chaotic changes in Jira's newer API version, detailing six incompatible methods of passing issue status parameters, explains the mismatch between name and id fields, and provides Java helper functions to handle these inconsistencies effectively.
This article examines the characteristics of Redis and Memcached, identifies typical design mistakes such as consistency, cache avalanche, hot‑key, penetration and breakdown issues, and presents practical mitigation strategies—including consistent hashing, binlog‑driven cache invalidation, distributed locking, and multi‑node replication—to help backend engineers build reliable high‑concurrency cache layers.
When a Spring @Bean is defined with multiple names, only the first name becomes the bean identifier while the others become aliases that are ignored by type‑based Map injection, causing dynamic data‑source routing to fail unless the aliases are manually added back into the map.
This article dissects Go's net package, showing how its Listen, Accept, Read and Write functions combine goroutines with epoll to deliver synchronous‑style code that avoids costly thread switches, and walks through the underlying source code and runtime mechanisms step by step.
This article explains how to enhance Spring Cache by creating custom cache annotations, replacing the costly KEYS command with SCAN in a rewritten DefaultRedisCacheWriter, and dynamically registering RedisCacheManager beans to support per‑module TTL and transaction‑aware caching, all illustrated with full Java code examples.
This article explains how Redis can be used to build message queues by leveraging List commands with LPUSH/RPOP and BRPOPLPUSH for simple queues, the Stream data type introduced in Redis 5.0 for durable, ordered, consumer‑group‑based queues, and the Pub/Sub model for real‑time broadcasting, while also analyzing the underlying source code structures such as quicklist, radix trees, and stream internals.
This roundup covers recent Java ecosystem developments, including the promotion of the Value Objects (Preview) JEP to candidate status, release notes for JDK 18 and early‑access JDK 19 builds, multiple Spring project updates such as Spring Boot 2.7.0‑M1, Spring Data 3.0‑M2 with ListCrudRepository, Spring Security enhancements, as well as Quarkus 2.7.2.Final and a new early‑access version of JReleaser adding Windows resources to jpackage.
This article outlines the step‑by‑step evolution of Taobao's backend architecture—from a single‑machine setup to distributed clusters, caching, load balancing, database sharding, microservices, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles involved at each stage.
This article explains the fundamental concepts of software architecture, including definitions of systems, subsystems, modules, components, and frameworks, outlines various architectural layers such as business, application, data, code, technical, and deployment, and discusses evolution from monolithic to distributed and microservice architectures along with common pitfalls and evaluation criteria.
This article provides a comprehensive guide to cache usage, covering its performance benefits and costs, various update strategies, granularity control, and detailed optimizations for issues such as penetration, avalanche, hot key reconstruction, and distributed batch operations.
This tutorial explains how to create a Python‑based stock monitoring bot that periodically fetches real‑time prices, compares them with preset thresholds, and sends alerts to a Feishu group via a custom webhook, including step‑by‑step setup and scheduling code.
This article provides a detailed introduction to microservices, covering its definition, core principles such as small independent services, lightweight communication, independent deployment and management, the advantages and disadvantages, suitable organizational contexts, and the essential components like service discovery, API gateways, configuration centers, monitoring, circuit breaking, container orchestration, and service mesh.
This article traces Airbnb's architectural journey from a single‑Ruby‑on‑Rails monolith through a microservices era to its current hybrid micro‑macro service model, highlighting the motivations, challenges, and engineering practices that shaped each transition.
This article explains how a scene‑centered, no‑code platform standardizes UI, data, and APIs to dramatically accelerate backend page development, improve product consistency, and provide a measurable efficiency framework for comparing source code, low‑code, and no‑code development modes.
In this interview‑style tutorial, an Alibaba P7 engineer walks through the limitations of BIO, the non‑blocking NIO API, kernel‑level select/poll mechanisms, and the design of epoll, illustrating how each solves the C10K problem and how they are used in Java.
The article describes how the Zhaunzhuan app backend team replaced a hard‑coded Map‑based routing configuration with a rule‑driven Aviator expression engine, detailing the problem analysis, engine selection, architectural redesign, code changes, a deployment incident, and the resulting improvements in flexibility, maintainability, and performance.
When using the Disruptor library for high‑throughput testing, the default FatalExceptionHandler can repeatedly abort consumer threads on exceptions, causing QPS to drop to zero, but replacing it with an ignore handler or a custom implementation restores stability.
This article presents a backend‑focused study on reducing latency of vector‑based ad recommendation retrieval by leveraging Gonum, SIMD AVX2 intrinsics, and direct Plan9 assembly integration in Go, and it validates the approach with detailed performance benchmarks and CPU usage analysis.
This article reviews eight popular Node.js WebSocket libraries—SockJS, ws, Socket.IO, Faye WebSocket, SocketCluster, Sockette, and Feathers—detailing their features, popularity, installation commands, and typical use cases for building real‑time backend applications.
This guide explains how to install, configure, and use Midway 3.x's info component to expose application details, customize the info route, hide sensitive data, and access diagnostic APIs for deeper backend insight.
This tutorial walks through creating a Slackbot using the new Bolt API with Node.js, covering workspace setup, app creation, OAuth scopes, server configuration, code installation, environment variables, socket mode, slash commands, event subscriptions, a simple JSON knowledge‑base, and deployment steps.
This post shares a comprehensive Java interview handbook containing over 1,000 questions covering MyBatis, Zookeeper, Dubbo, Redis, MySQL, concurrency, Spring, Kafka, micro‑services and more, hosted on GitHub with 30K+ stars, and explains how to obtain the latest PDF via a WeChat QR code.
This article revisits RESTful API design using Go Web, covering twelve practical guidelines such as JSON usage, verb‑free and pluralized paths, hierarchical resources, pagination, unified response formats, proper HTTP status codes, versioning, HTTPS, and documentation to help developers build clear, consistent, and secure APIs.
This article provides an in‑depth overview of Kafka, covering why messaging systems are needed, core concepts, cluster architecture, performance optimizations such as sequential disk writes and zero‑copy, resource planning, deployment steps, configuration details, operational tools, and advanced topics like custom partitioners and time‑wheel scheduling.
This article demonstrates how to retrieve flat menu data from a database into a List, then use Java 8 Stream operations and recursive methods to assemble a hierarchical tree structure, printing the result as JSON for verification.
This article outlines the architectural principles, middle‑platform strategy, service layers, common components, cloud deployment, security measures, and detailed design diagrams for building a scalable, high‑concurrency e‑commerce transaction system using DDD, microservices, and cloud‑native technologies.
This article explains how to architect a highly scalable backend by starting with a simple single‑server setup, then applying vertical and horizontal scaling, database replication, sharding, caching, load balancing, CDN, GeoDNS and stateless design to support over a hundred million concurrent users.
This article details the background, overall architecture, iterative improvements, and future directions of JD Daojia's order timeliness system, covering early limitations, business‑driven challenges, solution iterations, order‑control mechanisms, product‑dimension handling, and the final business architecture to enhance fulfillment rates and user experience.
This article explains how Redis stores Set and Sorted Set objects using dual internal representations—intset and hashtable for sets, skiplist and ziplist for sorted sets—detailing their structures, encoding selection criteria, upgrade processes, command usage, and the reasons behind combining dictionaries with skiplists for optimal performance.
This article outlines seven fundamental Java performance‑optimization directions—ranging from code reuse and parallel execution to JVM tuning—providing a theoretical framework that helps developers understand how to balance resource usage, reduce latency, and improve overall system efficiency.
Learn to protect your server from malicious crawlers by creating a dynamic IP blacklist using Nginx, Lua, and Redis, covering architecture choices, installation steps, configuration snippets, and how to share and update the blacklist across multiple machines.
This article explains the risks of microservice architectures and presents a collection of reliability patterns—including graceful degradation, change management, health checks, self‑healing, failover caching, retries, rate limiting, bulkheads, and circuit breakers—to help engineers design and operate highly available backend services.
This article reviews common distributed ID generation methods—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Zookeeper—detailing their principles, advantages, drawbacks, and suitable scenarios to help developers select the most appropriate solution for their microservice architecture.
The article explains why unified log structures and traceId identifiers are essential for quickly locating bugs in high‑traffic backend services, provides a Java LogObject example, demonstrates chain‑style setters, shows how to combine request and response in one log entry, and compares manual logging with AOP‑based approaches for performance and maintainability.
This article analyzes a Spring transaction rollback issue caused by the use of pattern‑based exception matching, explains why certain custom exceptions trigger unexpected rollbacks, traces the problem through source code and GitHub issues, and describes how the Spring team fixed it with type‑safe rollback rules and documentation updates.
This article compiles a comprehensive list of video tutorials covering interface testing, HTTP request handling, JSON manipulation, performance testing, Java concurrency, and the Arthas diagnostic tool, each with titles, publication dates, and links for developers seeking practical guidance.
Spring Framework 6.x has been officially released, introducing Jakarta EE‑based packages for core annotations, requiring Hibernate‑Core‑Jakarta upgrades, updating servlet containers to Tomcat 10/Jetty 11/Undertow 2.2.14, and altering Web MVC/WebFlux behavior, with detailed migration steps and reference links.
This article explains how to design a dictionary entity, create a custom annotation, and use Spring's ResponseBodyAdvice together with Java reflection to automatically convert enum values to their textual representations in API responses, improving front‑end display without manual mapping.
This article provides a detailed overview of the evolution of software architecture from monolithic to microservices, discusses the advantages and drawbacks of each stage, and outlines essential microservice technologies such as service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD pipelines.
This article explains why matplotlib fails on macOS with a pyenv‑managed Python, details the RuntimeError about missing framework and the subsequent _tkinter module error, and provides step‑by‑step solutions using TkAgg, Qt5Agg, and proper installation of PyQt and tkinter.
This article provides a comprehensive PHP form validation tutorial, covering required and optional fields, validation rules using regular expressions, secure handling of user input with trim, stripslashes, and htmlspecialchars, prevention of XSS via $_SERVER['PHP_SELF'] sanitization, and includes complete example code for both the HTML form and processing script.
This article explains why Spring Cloud Gateway can return duplicate Access‑Control‑Allow‑Origin and Vary headers during CORS handling, analyzes the underlying processing flow, and provides two practical solutions—using DedupeResponseHeader configuration or implementing a custom GlobalFilter—to ensure a single, correct header is sent to the client.
This article presents 22 practical best‑practice guidelines for designing consistent, secure, and user‑friendly RESTful APIs, covering URL naming conventions, HTTP methods, versioning, pagination, JSON naming, monitoring endpoints, CORS, error handling, and other essential considerations for backend developers.
This article explains why traditional delay solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, then demonstrates step‑by‑step how to configure RabbitMQ’s delayed‑queue plugin, create exchanges, queues, and bindings in Spring Boot, and send and consume delayed messages with code examples.
This article reveals how creating a new thread pool for each @Async method in Spring can exhaust system resources, explains Spring Boot’s default executor behavior, shows code examples, and offers practical guidance to prevent thread‑pool related crashes in Java backend applications.
This article explains why using scheduled tasks for closing timed‑out orders is problematic, demonstrates how to use RabbitMQ dead‑letter queues and the x‑delay‑message plugin to achieve accurate order timeout handling, and provides complete Spring Boot configuration and code examples with testing and limitations.
This guide explains the fundamentals of Netty, shows how to combine it with Spring MVC using DispatcherServlet, and provides complete Java code examples for a Netty server, channel pipeline, request handler, server startup, and a sample controller, along with practical configuration tips.
This article provides a comprehensive overview of Spring's core utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose, key methods, and practical code examples for robust backend development.
This article introduces two Spring Boot based workflow solutions—Spring‑boot‑activiti and RuoYi‑vue 4.x + Flowable—detailing their architecture, key features, deployment steps, and available resources to help developers understand and experiment with workflow engines.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable with exe4j, bundling a local JRE, and then creating a user‑friendly installer using Inno Setup, providing step‑by‑step screenshots and configuration details to avoid common pitfalls.
The author describes a high‑QPS Java web service, analyzes its GC behavior using jstat and gceasy, applies JVM parameter adjustments such as enlarging the young generation, tweaking MaxTenuringThreshold and disabling biased locking, and achieves roughly a 15% overall performance gain with improved GC throughput.
This article explains how to replace repetitive try‑catch blocks in Spring applications by using @ControllerAdvice for global exception handling, custom Assert utilities, and enum‑based error codes, resulting in cleaner, more maintainable backend code and consistent API responses.
This article explains why caching is essential for high‑concurrency systems, analyzes the challenges of keeping database and cache data consistent, and compares five practical cache‑invalidation strategies—including write‑after‑DB, delete‑before‑write, delayed double delete, queue‑based deletion, and binlog subscription—highlighting their trade‑offs and suitable scenarios.
This article presents a concise set of best‑practice guidelines for designing consistent, resource‑oriented RESTful APIs, covering naming conventions, URL structures, HTTP methods, parameter handling, versioning, monitoring, security, error handling, and documentation tools.
The article analyzes the memory overhead of naïvely storing per‑user read/unread lists for group chat messages and proposes a bitmap‑based scheme with user‑to‑map ID mapping, quit flags, and compact storage that can reduce per‑message space by over 95 percent.
This article explains why front‑end and back‑end separation is needed, describes the evolution from MVC to SPA, outlines responsibilities, development workflow, and provides a detailed version‑1.0.0 API contract with request/response formats, special field rules, and future front‑end trends.
This article explains the motivations for separating frontend and backend, outlines the evolution from MVC to SPA architectures, details responsibilities, development workflows, and provides a comprehensive API specification including request/response formats, special data handling, and future frontend trends.
This article provides a step‑by‑step methodology for identifying why a Redis instance becomes slow, covering baseline latency testing, slow‑log analysis, big‑key detection, expiration patterns, memory limits, fork overhead, huge‑page effects, AOF configuration, CPU binding, swap usage, memory fragmentation, network saturation, and practical remediation techniques.
PHP 8.1.3 has been released as a security‑focused update that fixes numerous core, FFI, filter, FPM, MBString, MySQLnd, pcntl, sockets, and standard extension bugs, and users of the 8.1 series are encouraged to upgrade promptly.
The article details how DaJia's recommendation system progressed through three architectural versions—V1.0's simple strategy‑factory design, V2.0's vertical business split and configurable pipeline, and V3.0's dynamic configuration service and modular pipeline—addressing scalability, fault isolation, and personalization challenges while outlining future directions for explainable AI recommendations.
This guide walks through the complete setup of SQLE's development environment, covering the Go-based backend API, MySQL configuration, and the Node.js/React frontend, including required tools, code cloning, building, and testing steps on Linux.
This article explains how DolphinScheduler (DS) implements workflow versioning by introducing integer‑based versions, describes the core principles of workflow and task relationships, outlines the key database tables and architecture, and provides detailed Java code for creating, updating, and managing workflow definitions, tasks, and their relations.
