This article explains RabbitMQ's core messaging patterns—including simple, work queues, publish/subscribe, routing, topics, RPC, and publisher confirms—along with the four main exchange types, providing practical use‑case examples for each to help developers choose the appropriate pattern for their backend systems.
This article explains why Python’s Django framework is a top choice for backend development, outlining its popularity, benefits, essential system‑planning and web‑script skills, rapid prototyping, scientific computing, and the specific Python and Django expertise needed to become a proficient developer.
This tutorial explains how to set up two virtual machines, install JDK, Nginx and Tomcat on each, configure Nginx as a reverse‑proxy load balancer for the Tomcat instances, and verify the high‑availability setup with sample HTML pages.
This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.
This article compiles essential Spring Boot interview questions, covering its definition, benefits, core configuration files, starter modules, auto‑configuration, embedded containers, actuator monitoring, security concerns, exception handling, differences from Spring MVC, and integration with tools like ELK and Docker.
This article explains three Redis-based techniques—Hash, Bitset, and HyperLogLog—for efficiently counting daily page visits, detailing command usage, memory trade‑offs, and accuracy considerations, helping backend engineers implement scalable visitor statistics in high‑traffic environments like large e‑commerce platforms.
This article examines the challenges of repetitive if‑else parameter checks, introduces Hibernate Validator as a JSR‑303 implementation, demonstrates how to build a reusable validation module, and shares best‑practice patterns for integrating elegant, decoupled validation into Java backend systems.
This article explains the fundamental differences between database connection pools and ThreadLocal, how each is used in Java to improve performance and enable cross‑method transaction control, and provides practical code examples and best‑practice guidelines for managing connections in multi‑threaded applications.
This article explains how a lightweight test‑automation platform built with SpringBoot, MyBatis and Layui dramatically reduces data‑generation and validation effort, streamlines integration testing, and boosts overall testing productivity for developers and QA engineers.
The article examines why many Java server‑side developers resist switching to Kotlin, exploring misconceptions about learning time, language maturity, pride, tooling, hiring costs, complexity, codebase mixing, and perceived lack of benefits, while offering practical insights to encourage adoption.
This article explains how to create and use IntelliJ IDEA live templates to replace repetitive Java Stream collector calls such as toList(), toSet(), and groupingBy() with concise shortcuts, improving code readability and productivity when migrating legacy code to Java 8 streams.
This article provides a comprehensive guide to JVM performance tuning, covering the JVM architecture, runtime data areas, various garbage collectors, configuration flags for heap and GC settings, and practical recommendations for selecting the optimal GC strategy based on workload characteristics.
This article walks through a real‑world scenario of extending trial‑user eligibility rules, explains the logical flow using AND/OR short‑circuiting, and presents a modular Java rule engine design with abstract templates, concrete rules, a service builder, and a test case, highlighting its advantages and drawbacks.
This article explains how Spring MVC evolved from basic Servlets to a sophisticated two‑level controller architecture, detailing the roles of DispatcherServlet, HandlerMapping, HandlerInterceptor, Handler, ModelAndView, ViewResolver, and View, while showing configuration examples and code snippets.
This tutorial demonstrates how to integrate Spring Boot with WebSocket to achieve server‑initiated real‑time message pushing, covering dependency setup, configuration, server implementation, controller and client page code, and troubleshooting initialization order issues.
This article explains the ESModule standard, compares it with CommonJS and AMD, describes how Node.js and modern browsers implement ESModules, discusses compatibility challenges with third‑party dependencies, and reviews next‑generation tools such as Snowpack and Vite that leverage native module loading.
This article documents a Python web service performance optimization case, detailing the initial bottlenecks, architectural redesign with caching and message queues, load‑testing methodology, Linux TCP time‑wait tuning, and the final results achieving 50k QPS with sub‑70 ms latency.
This guide introduces Erupt, a low‑code full‑stack Java framework that lets you create enterprise‑level backend management systems without writing any front‑end code, covering installation, SpringBoot integration, CRUD generation, extended modules like scheduling, code generation, monitoring, NoSQL support, and online API development.
This article details the implementation of Spring StateMachine for refactoring a content platform question bank system, addressing complex state management and coupling issues through state machine patterns.
This article explores comprehensive API lifecycle management, detailing how a lightweight API gateway works with a robust development platform that uses object‑driven modeling to automatically generate CRUD interfaces, map objects to databases, support testing, documentation, rule processing, service composition, code export, and microservice packaging.
This article explains how to replace repetitive try‑catch blocks in Spring Boot applications with a unified global exception handling solution by defining a standard AjaxResult response, a custom BusinessException, an error enumeration, and a @RestControllerAdvice handler, enabling clean, extensible error management.
This article provides a step‑by‑step tutorial on building a Spring Boot project, covering project generation, core starters, automatic Redis configuration, common annotations like @SpringBootApplication and @ControllerAdvice, web container and HTTPS settings, profile management, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, mail sending, and Swagger API documentation.
The article describes a backend‑for‑frontend architecture that pushes GraphQL into the BFF layer, separates fetch and display units, drives execution with metadata, unifies query models, applies caching and parallel processing optimizations, and demonstrates over 50 % logic reuse and doubled development efficiency in production.
This article explains how Kafka's producer uses a memory pool to reuse RecordBatch objects, detailing the allocation and deallocation mechanisms, lock handling, and conditions that prevent full garbage collection pauses, thereby improving throughput and resource efficiency.
This article explores Nginx's origins, why it outperformed Apache, its core features such as event‑driven architecture and modularity, explains forward and reverse proxy concepts, and details the load‑balancing algorithms Nginx supports, providing practical insights for backend engineers.
This guide explains why Python is essential, presents a step‑by‑step learning roadmap covering beginner basics, backend web development, web crawling, data analysis, and machine learning, and provides curated resources and project links to help learners progress efficiently.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.
This guide shows how to install PHP‑Casbin, configure an RBAC model, initialize an enforcer with a MySQL adapter, add roles and permissions, and verify access decisions for different users using concrete code examples.
This tutorial walks through configuring Spring Boot 2.3.10 with Elasticsearch 7.8, defining Maven dependencies, setting up application properties, creating a searchable Product model, implementing a repository with derived query methods and custom @Query annotations, and testing CRUD and advanced search operations using both repository and RestTemplate approaches.
This article explains internal service communication patterns, covering request/response and asynchronous messaging, their implementations, message formats, RPC and REST principles, service discovery methods, channel types, and key considerations for choosing a message‑queue component.
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.
