This article explains the semaphore model, its three core operations (init, down, up), how they manage counters and waiting queues, and demonstrates proper usage in Java to achieve mutual exclusion and resource limiting, complete with code examples and visual diagrams.
This article shares Baidu C++ engineers' practical performance‑optimisation techniques, covering memory‑access patterns, custom allocation strategies, string handling, protobuf handling, cache‑line considerations and memory‑order semantics to achieve significant latency and cost reductions in large‑scale backend services.
This article explains how Netty, an asynchronous event‑driven network framework built on Java NIO, simplifies the creation of high‑performance, scalable web servers and client components by handling I/O streams, connection management, threading, zero‑copy transfers, and offering flexible reactor thread models for various application scenarios.
This article walks through the evolution from traditional Servlets to Spring MVC's DispatcherServlet, explaining how each component—Servlet, BaseServlet, DispatcherServlet, HandlerMapping, HandlerInterceptor, HandlerExecutionChain, ModelAndView, ViewResolver, and View—contributes to a cleaner, more modular server‑side architecture.
This article explains how Spring MVC evolved from basic Servlets to a two‑level controller architecture, detailing the roles of DispatcherServlet, HandlerMapping, HandlerInterceptor, ModelAndView, ViewResolver and View, and shows configuration examples that simplify server‑side development in Java web applications.
This article explains the origins and limitations of REST APIs, introduces GraphQL as a flexible alternative, describes its core concepts such as schema, types, and modifiers, and outlines various server‑side and client‑side implementations, tools, and deployment architectures for modern backend development.
The article explains common mistakes of using API gateways together with service registries as internal proxies, shows how this adds latency and complexity, and offers guidance on when to use gateways versus direct service‑to‑service calls in microservice architectures.
This guide walks beginners through setting up a basic live‑streaming pipeline using the open‑source LiveGo server, OBS for RTMP publishing, and flv.js for browser playback, while explaining push‑pull architecture, protocol choices, Docker deployment, and a Redis‑based chat system for live rooms.
This article investigates the duplicate unregister bug in Dubbo 2.7.3, explains how the shutdown hook interaction causes the error, and shows how the issue was fixed in later versions and can be mitigated without upgrading the whole framework.
This article explains how the @SpringBootApplication annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan, walks through the SpringApplication.run execution flow, and reveals the inner workings of Spring Boot’s auto‑configuration mechanism using SpringFactoriesLoader and META‑INF/spring.factories.
This article examines Ctrip’s Hermes messaging system, tracing its evolution from a simple Mongo‑based queue to a broker‑centric, MySQL/Kafka hybrid architecture, and explains the design choices, performance optimizations, cluster management via lease‑based meta‑server, and lessons learned for building high‑throughput, low‑latency MQ solutions.
This article introduces Zookeeper as a high‑performance coordination service for distributed systems, covering its role in concurrent environments, installation steps on Linux, core characteristics, data model, session and watch mechanisms, and practical usage examples to help readers understand and apply it in backend development.
Understanding the actual memory footprint of Java objects—including headers, class pointers, fields, and alignment—reveals hidden waste, and the article provides calculations for Integer objects, arrays, and collections, plus practical guidelines to reduce memory usage by preferring primitive types, smaller fields, and arrays over collections.
Through a whimsical first‑person narrative, the article explains three Java thread‑creation techniques—extending Thread, implementing Runnable (including anonymous and lambda forms), and using Callable with FutureTask—to illustrate their syntax, usage, and the ability to retrieve thread results.
The article explains that Java lambda expressions capture variables by value, requiring them to be effectively final, which prevents modification of the original variable and aligns with functional programming principles that avoid stateful functions.
This article introduces seven RabbitMQ messaging patterns—Simple, Work Queue, Publish/Subscribe, Routing, Topics, RPC, and Publisher Confirms—explains their typical use cases such as email delivery, order processing, cache synchronization, and provides complete Java code examples for each pattern.
The 2020 State of Spring report reveals that the majority of Java developers favor Spring/Spring Boot, spending more time on unit testing, achieving higher code quality, and appreciating benefits such as easier web/API setup and robust testing support, with user adoption rising from 60% to 86%.
This article explores Baidu C++ engineers' deep‑dive into performance optimization, covering memory‑access patterns, string‑buffer handling, protobuf merging, malloc strategies, job‑arena allocation, cache‑line effects, and modern memory‑order semantics to achieve multi‑fold speedups in large‑scale backend services.
This article explains how Sentinel's metric statistics work, focusing on the sliding window algorithm used for rate limiting and the underlying architecture involving classes like StatisticNode and ArrayMetric.
This guide explains RabbitMQ dead-letter queues, detailing the conditions that cause messages to become dead letters, how to configure exchanges and queues with x-dead-letter parameters, and demonstrates three testing methods—reject/nack, TTL expiration, and max-length overflow—using Spring Boot code examples.
Learn how to send emails using Python by exploring three approaches—smtplib, zmail, and yagmail—including setup, authentication, constructing MIME messages, attaching files, and sending, with complete code examples and step‑by‑step instructions for each method.
The PHP function zip_close() terminates a ZIP archive opened with zip_open(), taking the ZIP resource as its sole argument, performs no return value, and is essential for properly releasing file handles in backend development.
This article explains how to achieve graceful shutdown for Dubbo services by leveraging operating‑system signals, Docker commands, JVM shutdown hooks, Spring event mechanisms, and Dubbo's own extensions, illustrating each layer with code examples and best‑practice recommendations.
This article explains Java thread pool fundamentals—including core parameters, task submission behavior, rejection policies, queue selection, thread factory usage, keep-alive settings—and provides practical guidance on determining optimal thread counts for I/O‑bound and CPU‑bound workloads.
Aviator is a lightweight, high‑performance Java expression evaluation engine that compiles expressions to JVM bytecode, offering rich operator support, custom functions, variable handling, and compilation for reuse, while detailing its features, limitations, dependency setup, and multiple code examples for practical backend integration.
This article explains the core roles of HttpSecurity and WebSecurity in Spring Security, how they build and manage SecurityFilterChain objects, the purpose of FilterChainProxy, and why WebSecurity serves as the framework’s external entry point while HttpSecurity defines internal security policies.
This article examines common pain points in building and maintaining business applications, proposes a design specification that standardizes technical details, encourages component reuse, promotes continuous refactoring, and introduces a service orchestration engine to streamline complex workflow integration.
This article provides a comprehensive guide to the most essential Spring Boot annotations, explaining their purpose, usage, and code examples, helping developers configure beans, enable auto‑configuration, and control application behavior effectively.
This article outlines what middleware development is, the essential technical and personal qualities required, and provides a step‑by‑step learning roadmap for aspiring Java developers aiming to join or build middleware teams in modern backend environments.
This article summarizes the latest Spring Boot 2.4.5 and 2.3.10 releases, detailing dozens of bug fixes, documentation improvements, and a comprehensive list of upgraded dependencies, providing developers with a clear view of the enhancements and migration considerations for each version.
This article provides an in‑depth tutorial on Nginx, covering its core concepts, installation, configuration directives, reverse proxy, load balancing, caching, HTTPS setup, CORS handling, gzip compression, and the internal multi‑process architecture for high‑performance web serving.
This article explains Sentinel’s internal flow‑control workflow by dissecting the entryWithPriority method, the construction of the ProcessorSlot chain, the role of each slot such as NodeSelectorSlot, ClusterBuilderSlot, StatisticSlot, and how the SPI‑based SlotChainBuilder enables extensible, high‑performance request limiting in Java middleware.
This article breaks down Java Stream usage by dissecting each line of a sample program, comparing it with equivalent non‑stream code, and illustrating how iterate, limit, map, filter, and reduce work together to produce the final result.
This whimsical diary narrates the evolution of the HTTP protocol—from its humble GET request origins to the sophisticated features of HTTP/2—using a client‑server love story to illustrate methods, headers, pipelining, chunked transfer, and server push in an engaging, educational way.
This article explains how Spring Boot, a Pivotal‑backed extension of the Spring framework, simplifies Java backend development by providing auto‑configuration, starter dependencies, embedded servers, and seamless integration with micro‑service architectures, while also covering core annotations, configuration files, security, and deployment options.
This article explains the concept, practical usage, internal implementation, and key methods of Java's CyclicBarrier, compares it with CountDownLatch, and provides a complete code example demonstrating how multiple threads can repeatedly synchronize at a reusable barrier.
This comprehensive guide explains what Spring Boot is, why it was created for micro‑service development, how it simplifies configuration with starters and auto‑configuration, and provides detailed coverage of core annotations, configuration files, security, CORS, transaction management, and deployment options for Java backend developers.
This article provides a comprehensive overview of Java thread pools, covering their advantages, internal workflow, creation parameters, various execution states, shutdown procedures, performance tuning strategies, and key monitoring metrics, supplemented with practical code examples.
An in‑depth guide to the Spring framework covering its lightweight architecture, core principles such as IoC, DI, and AOP, key design patterns, module structure, bean lifecycle, circular dependency handling, and essential annotations for building robust Java backend applications.
Instead of Docker, we leveraged Go 1.16’s //embed feature to create a single binary for our web service, detailing the rapid build, test, and deployment steps, and arguing that Docker’s overhead isn’t necessary for small teams focused on fast delivery.
This guide presents a concise, step‑by‑step roadmap for mastering Go, covering beginner fundamentals, essential packages, and advanced cloud‑native projects like Etcd, Docker, Kubernetes, and Istio, while offering practical study tips and career insights.
This article introduces EasyCaptcha, a Java graphic captcha library supporting GIF, Chinese characters, and arithmetic types, explains how to integrate it via Maven, demonstrates usage in SpringBoot with controller and HTML snippets, and provides demo links and a concise summary for developers.
This article presents nine practical MyBatis techniques—including pagination, preset column selection, one‑to‑many and one‑to‑one associations, foreach‑in queries, dynamic where clauses, choose/otherwise logic, hidden _parameter usage, and dynamic set updates—illustrated with SpringBoot and MySQL code examples.
The article explains how Java 8's ConcurrentHashMap implements a lock‑free get() operation by replacing the Segment design with Node objects, using volatile fields and CAS, and how the volatile‑marked table array ensures visibility during resizing, making reads both safe and efficient.
This guide walks through configuring Spring Boot 2.3.9 with Spring Cloud Hoxton to register services in Zookeeper, set up provider and consumer applications, and achieve client‑side load balancing using Spring Cloud LoadBalancer.
This article explains how to integrate Swagger using Springfox 3.0.0 into a Spring Boot project, covering required dependencies, configuration files, annotations, new features, compatibility requirements, and provides a complete example with code snippets for generating interactive OpenAPI documentation.
This article explains the thread‑safety differences between StringBuilder and StringBuffer, demonstrates the problems of using mutable shared objects in multithreaded Java code, presents three solutions, and discusses why Servlets are not thread‑safe by default, highlighting visibility and ordering concepts.
This guide walks through integrating RocketMQ 4.8.0 with Spring Boot 2.3.9, covering dependencies, configuration, code examples for normal, ordered, cluster/broadcast, and transactional messages, and demonstrates testing results with detailed explanations of each messaging mode.
This article explains the fundamental differences between RPC and HTTP services, outlines the OSI model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for backend development.
This article explores how MyBatis implements nine fundamental design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with concrete classes, code snippets, and diagrams to deepen developers' understanding of design patterns in practice.
Effective traffic governance and protection rely on properly configuring thresholds—either a fixed global limit that stays constant regardless of node count, or a per‑machine allocation that scales the total capacity as nodes are added or removed—to prevent sudden surges from overwhelming services and ensure high availability.
This article analyses how MyBatis applies nine classic design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete Java examples to deepen understanding of software design in backend development.
This article explains the concept of max‑effort notification, contrasts it with reliable messaging, and provides a complete Spring Boot 2.4.9 and RabbitMQ 3.7.4 implementation—including project structure, configuration, entity models, repositories, services, controllers, and message listeners—plus testing steps and results.
This article shares a two‑year journey of using Kafka in a high‑traffic restaurant ordering system, covering why message order matters, how network glitches and partition routing cause failures, and the practical retry, partition‑balancing, and database strategies that finally eliminated backlog and duplication issues.
When migrating Spring Boot services to Spring Cloud on servers with constrained memory, understanding the JVM's default heap configuration and applying explicit -Xms and -Xmx parameters, along with using built‑in Java tools to inspect and tune runtime memory, can prevent out‑of‑memory failures.
This article walks through the design, core components, task states, API endpoints, and full Java implementation of a Redis-powered delay queue using Spring Boot, complete with code samples, container structures, timer processing, and testing procedures.
The article demonstrates how to create a custom @ValidShop annotation and an AOP aspect that intercepts Spring MVC controller methods, extracts the annotated parameter via reflection, validates the shop code through a helper service, and proceeds only when the check succeeds.
Baidu’s Baijiahao team built a web‑based video editor that uses a PHP backend to translate timeline JSON into FFmpeg command pipelines, a React front‑end for drag‑and‑drop editing and preview, and a Redis‑driven scheduler to process and store videos in Baidu’s cloud.
This article explains how Spring Cloud Feign works, details its key annotations, shows how to enable GZIP compression, configure logging and timeouts, and demonstrates techniques for handling multiple parameters in GET and POST requests with code examples.
This article explores what a web architect does, the core value they bring to software projects, and the extensive technical and soft‑skill competencies required, offering a practical roadmap for developers aspiring to transition from coding to strategic system design.
This article explains how to configure, render, and extend Django templates, covering template directories, context data, built‑in tags and filters, reusable blocks, includes, and creating custom tags to efficiently build dynamic web interfaces.
This article explains how to upgrade Java code to use lambda expressions and the Stream API, highlights the inconvenience of repeatedly writing collect(Collectors.toList()) calls, and shows how IntelliJ IDEA's Live Templates can automate common collector patterns to boost productivity.
Learn how Spring Boot’s @Enable* annotations work, explore the role of @Import, and follow a step‑by‑step example that defines a custom @EnablePack annotation, implements ImportAware, and demonstrates its usage in a Spring Boot application.
The article explains that MyBatis returns the constant -2147482646 when the executor type is set to BATCH, shows how to trace the source code to uncover this behavior, and provides a simple configuration change to restore correct update counts.
This article explains the inner workings of Java's ThreadLocal, covering its storage mechanism, ThreadLocalMap structure, get/set/remove operations, thread isolation, potential memory leak pitfalls, and provides a practical demo program to illustrate proper usage.
The article challenges typical objections to using Lombok—such as JDK version issues, forced plugin installation, reduced readability, increased coupling, and perceived technical debt—by providing detailed rebuttals that argue Lombok remains practical and beneficial for Java backend development.
This article explains Node.js’s asynchronous execution model, defines key concepts such as execution frames and continuation points, demonstrates event flow with code examples, and shows how the async_hooks API and AsyncLocalStorage can be used for tracing, debugging, and performance analysis of backend JavaScript applications.
Learn how to set up Go in Linux, macOS, and Windows, understand its core syntax, manage packages, work with variables, arrays, slices, maps, control structures, goroutines, channels, interfaces, write unit tests, use Go Convey, connect databases with GORM, and build simple web servers with the standard library or Gin.
On March 16, OpenJDK announced the General Availability of JDK 16, a six‑month‑supported release that introduces 17 enhancements including a Vector API incubator, C++14 language support, Unix‑domain socket channels, pattern‑matching for instanceof, sealed classes, and broader platform ports.
Spring Framework 5.3.5 introduces JDK 16 support, a host of new features, extensive bug fixes, documentation updates, and a Reactor 2020.0.5 upgrade, providing developers with a comprehensive overview of the latest enhancements and how to access the full release notes.
This article provides a detailed overview of the latest Spring Boot 2.4.4 and Spring Cloud 2020.0.2 releases, highlighting key module upgrades, bug fixes, documentation improvements, and dependency updates, helping developers understand the enhancements and how to integrate them into their Java applications.
This article compares REST and GraphQL, highlighting REST's issues like excessive round‑trips, over‑/under‑fetching, and rigidity, and shows how GraphQL solves them with single‑request queries and flexible data selection, while offering guidance on when to choose each approach.
This article examines the chronic decay of a complex warehouse inbound/outbound system, analyzes its tangled business logic and chaotic architecture, and presents a domain‑driven design solution with onion architecture, CQRS, and practical implementation steps to achieve clearer boundaries, higher cohesion, and sustainable evolution.
This tutorial explains PHP's foreach loop syntax, illustrating how to iterate over arrays with value-only and key‑value formats, and how to traverse object properties, accompanied by complete code examples for each case.
This article introduces SOFABoot, an open‑source framework built on Spring Boot that adds readiness checks, classloader isolation, log space isolation, seamless SOFA middleware integration, modular development support, and provides a starter‑based programming model for large‑scale microservice architectures.
This article outlines practical software design principles—layered architecture, single responsibility, data redundancy, security, concurrency, and API design—derived from real‑world financial platform projects, showing how concrete rules help avoid coupling, data loss, and performance pitfalls.
This article presents a curated list of fifteen Alibaba‑originated developer tools—including Arthas, Cloud Toolkit, ChaosBlade, Docsite, and more—detailing their purpose, typical use cases, tutorial links, and acquisition methods to help backend engineers boost productivity and reliability.
The article shares a senior developer’s firsthand observations on how architects differ in attitude, technical depth, system‑level responsibilities, and collaboration, offering practical steps and mindset changes needed to transition from senior engineering to a full‑stack architecture role.
The article examines typical criticisms of the Lombok library—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived drawbacks—while providing detailed rebuttals that argue Lombok remains useful for Java backend development despite these concerns.
This article explains how to implement delayed message delivery in RabbitMQ using the delayed‑message‑exchange plugin and Spring Boot, covering the shortcomings of traditional approaches, configuration of exchanges and queues, sending messages with delay headers, and a test demonstrating a 6‑second delayed receipt.
The article outlines how a call platform’s architecture progressed through successive stages—starting with a monolithic design, then business service splitting, service governance and isolated deployment, horizontal scaling, distributed database sharding, and finally micro‑service adoption—highlighting the problems each evolution solved and the new challenges introduced.
This article explains the evolution, relationships, and dependencies of Java logging libraries such as Log4j, JUL, JCL, SLF4J, and Logback, and provides practical guidance on configuring adapters, solving common conflicts, and unifying logging output across frameworks like Spring.
Midway Serverless 2.0 (codenamed “Hercules”) revamps the original framework with unified decorators, a modern CLI, faster Vite‑based builds, enhanced testing, and seamless integration of traditional web frameworks, delivering a smoother, more efficient serverless development experience.
This article provides an in‑depth exploration of Linux’s epoll mechanism, covering its blocking behavior, kernel‑level processing, NAPI optimization, comparisons with select/poll, and practical insights into I/O multiplexing, helping backend engineers understand performance characteristics and design efficient network services.
This article explains how to integrate FluentValidation into ASP.NET Core for robust model validation, covering installation, defining validators, registering services, handling validation errors, conditional rules, cascade modes, asynchronous validation, and advanced features, with complete code examples.
This tutorial explains how to replace the default Swagger UI with Swagger‑Bootstrap‑UI (now called Knife4j) in a Spring Boot application, covering Maven dependencies, configuration classes, common annotations, a sample controller, launch steps, and troubleshooting tips.
This tutorial walks you through upgrading Spring Boot, introduces MongoDB basics, and provides a hands‑by‑step guide to adding the spring‑boot‑starter‑data‑mongodb dependency, defining entity and repository classes, writing unit tests, and configuring connection properties for robust backend data management.
This guide walks you through installing Node.js on various Linux distributions by using NVM for version management, native package managers for stable releases, and the NodeSource repository for the latest versions, complete with commands, verification steps, and troubleshooting tips.
This article details ByteDance's evolution from offline ClickHouse ingestion to a robust real‑time analytics pipeline, covering external transaction handling, risks of direct INSERTs, recommendation and ad‑delivery use cases, Kafka Engine design, multi‑threaded consumption, fault‑tolerance improvements, platform tooling, and future roadmap.
This article explains how to secure app open‑API endpoints by using HTTPS, token‑based authentication, timestamp validation, and a URL‑signature algorithm implemented in Java, including detailed steps, interception rules, and sample code for generating and verifying signatures.
A curated list of free Bilibili video courses covering Java, computer networks, operating systems, Redis, RocketMQ, Kafka, and MySQL, each with brief descriptions and direct links for beginners and intermediate learners.
HHVM 4.98 has been officially released, ending support for version 4.92 while continuing maintenance for 4.93‑4.97 and LTS releases, introducing minor typechecker improvements, new error detection for conflicting constants, and outlining future deprecations such as the inst_meth function and stricter string concatenation rules.
An in‑depth analysis reveals that Dubbo 2.7.x fails to propagate provider‑side implicit parameters back to the consumer because the new AsyncRpcResult/AppResponse architecture discards attachments, a change introduced for better async support, effectively making this behavior a bug in the 2.7 series.
This article walks through creating a WebSSH solution from scratch using Spring Boot, WebSocket, JSch and the xterm.js front‑end library, covering dependency setup, backend WebSocket configuration, message handling, SSH session management, and a minimal HTML/JS client to display a browser‑based terminal.
Netflix’s Domain Graph Service (DGS) framework, now open‑sourced, provides a Spring Boot‑based, annotation‑driven solution for building both standalone and federated GraphQL services, offering schema‑first and code‑first development, code generation, testing tools, and seamless integration with Netflix’s tracing and security infrastructure.
The article explains the core concept of Inversion of Control (IoC), how a third‑party container manages resources to reduce coupling, illustrates the idea with everyday examples, and clarifies the related terms dependency injection and control inversion, especially in the context of Spring.
iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.
This article explains how to secure mobile app open APIs by enforcing HTTPS, designing request signatures with timestamps and tokens, validating them on the server, and managing token‑UID relationships using Redis, complete with Java code examples for parameter extraction and signature generation.
This article explains the origins of Nginx, compares it with Apache, describes why Nginx gained popularity, details forward and reverse proxy concepts, and outlines the various load‑balancing algorithms it supports, providing a comprehensive overview for backend developers and operations engineers.
This article explains the fundamentals of unit testing in Spring Boot, covering the purpose of unit tests, how to add the spring-boot-starter-test dependency, the role of MockMvc for controller testing, step‑by‑step creation of Service and Controller test classes, key annotations, assertion techniques, and a brief comparison with Postman.
