FastAPI is a high‑performance, easy‑to‑learn Python web framework that lets you build robust APIs quickly, offering features like speed, concise code, automatic validation, and OpenAPI compatibility, with simple installation via pip and interactive documentation out of the box.
This article explains how to correctly load resources in Java using Class and ClassLoader getResource methods, compares their behavior, demonstrates batch resource retrieval, and shows how Spring's ResourceLoader and ResourcePatternResolver simplify resource access, providing practical code examples and best‑practice guidelines.
This article continues the Spring bean lifecycle series by explaining the property‑assignment stage, Aware interface callbacks, bean initialization phases, and the destruction process, illustrating each step with source‑code diagrams and highlighting how BeanPostProcessor extensions drive the lifecycle.
The article demonstrates how to structure a Go backend using Clean Architecture’s four‑layer model, interface‑driven design, and compile‑time dependency injection with Google Wire, providing concrete examples of repository, service, and API implementations and unit‑testing each layer with sqlmock, gomock, and httptest.
This article explains four distinct approaches to register Spring Boot event listeners, shows how to create custom events and listeners, provides complete code examples for each method, and demonstrates their execution order through a test run.
This article explains the concepts, pros and cons of monolithic and microservice architectures, details the design of API gateways, outlines service registration and discovery mechanisms, and introduces open‑source configuration center solutions for modern backend systems.
This article demonstrates how to leverage IntelliJ IDEA's diagram feature to clearly view, customize, and explore the inheritance and interface implementation hierarchy of Java Servlet classes, including removing irrelevant nodes, inspecting members, adding extra classes, and jumping directly to source code.
This article demonstrates how to use Redis key‑expiration notifications together with Spring Boot to automatically close orders that remain unpaid after a configurable timeout, eliminating inefficient polling and providing a clean backend solution for order lifecycle management.
This article explains Java exception classification, distinguishes checked and unchecked exceptions, and demonstrates how to configure Spring's @Transactional annotation to control rollback behavior, including examples of rollbackFor, notRollbackFor, and propagation settings, while highlighting common pitfalls with try‑catch blocks.
This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data structures, detailing their usage, advantages, drawbacks, and how they compare to dedicated queue middleware.
This article explains MyBatis dynamic SQL, covering its purpose, the distinction between static and dynamic SQL, the core SqlNode and SqlSource classes, how MyBatis parses and assembles SQL scripts recursively, and provides concrete code examples to illustrate each step.
The talk explains how Tubi's Multimedia Processing Platform uses an interface‑driven architecture, Elixir protocols, and composable movers and comparators to migrate petabyte‑scale video files across cloud storage while balancing performance, cost, and testability, offering practical insights for Ruby and backend engineers.
The 2021 Node.js Developer Survey reveals a healthy, steadily evolving ecosystem focused on improved usability, growing framework diversity, increased adoption beyond front‑end developers, and heightened attention to performance, memory management, and serverless architectures.
This article provides a step‑by‑step guide for integrating email functionality into a Spring Boot application, covering SMTP/IMAP/POP3 basics, configuring JavaMailSenderImpl, sending simple and MIME messages with attachments, and includes full source code examples and troubleshooting tips.
This article describes how ZTO's testing team created a centralized test‑tool platform that integrates front‑end and back‑end services, standardizes tool access, tracks usage via AOP, supports data generation, order creation, tracking, MQ messaging, and other platform integrations to dramatically improve testing productivity.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean and dependency‑injection annotations, and essential Spring Boot configuration annotations, illustrating their usage with code examples and explaining how they work together to build robust backend applications.
This article explains the fundamentals of web application architecture, detailing components such as user agents, DNS, load balancers, virtual machines, web servers, databases, caching services, CDNs, external and cloud storage, as well as best‑practice guidelines for building efficient, scalable, and secure backend systems.
In distributed e‑commerce systems, achieving Redis cache consistency requires invalidating stale entries via reliable DB change detection (e.g., binlog listeners) and optionally using versioned writes that only update when newer, combined with safeguards like TTLs, double deletes, and business‑specific designs to mitigate race conditions and ensure eventual consistency.
This article details the step‑by‑step design, architecture, plugin configuration, authentication methods, code implementation, and performance testing of a Kong‑based API gateway built to handle millions of QPS during large‑scale events, highlighting challenges, solutions, and future directions.
This article explains the three‑tier architecture pattern—its UI, business logic, and data access layers, the role of an entity layer, a practical restaurant analogy, and the advantages and drawbacks compared to two‑tier designs, highlighting high cohesion and low coupling.
This article explains the concept of Spring Boot starters, how they replace cumbersome Spring MVC setup with automatic dependency import and configuration, details the inner workings of Spring Boot's auto‑configuration mechanism, and guides you through creating custom starters and publishing them as reusable modules.
This article provides a comprehensive overview of message queue concepts, common interview questions, and practical solutions covering use cases, popular frameworks, selection criteria, message models, reliability, ordering, backlog handling, data consistency, transactional messaging, performance optimization, high availability, and specific Kafka considerations.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style for a given project.
This guide walks you through Nginx fundamentals, reverse‑proxy concepts, load‑balancing techniques, static‑dynamic separation, cross‑platform installation steps, essential commands, and core configuration examples, equipping developers with the skills to deploy and manage a robust web server.
JDK 18, released on March 22 2022, introduces nine new JEPs—including default UTF‑8 charset, a simple web server, code snippet support in JavaDoc, vector API, external function and memory API, and switch pattern matching—while being a short‑term feature release following the LTS JDK 17.
This tutorial explains how to use parallel gateways in Activiti 7 with Spring Boot, covering their branching and merging functions, a complete reimbursement‑approval example, BPMN XML definition, and Java code for starting, querying, and approving workflow tasks.
The article demystifies Java’s Arrays.sort by tracing its call to TimSort.sort, explaining how the hybrid Timsort algorithm blends merge and insertion sorts, determines minimum run lengths, partitions and merges runs, addresses implementation bugs such as stack allocation and comparator misuse, and celebrates its elegant, efficient design.
This tutorial demonstrates how to set up a Spring Cloud Gateway using Spring Boot 2.1, configure static and Nacos‑driven dynamic routes, and create a custom authentication GlobalFilter that validates tokens against Redis, providing a complete guide for backend developers to implement secure, flexible routing.
The article outlines the March 22, 2022 release of JDK 18, highlights its nine new features—including UTF‑8 as the default charset, a simple web server, and a foreign function & memory API—while noting its short‑term support compared to the LTS JDK 17.
This article explains how to implement fixed‑time scheduled tasks on a single machine using Timer and ScheduledThreadPoolExecutor, how to build a custom Redis‑based distributed scheduler with distributed locks, and compares several third‑party frameworks such as Quartz, TBSchedule, Elastic‑Job and Sature for distributed task execution.
This article examines the Athena customer‑service system by describing its purpose, behavior‑tree based architecture, configuration‑driven logic, and practical testing approaches, while also proposing future improvements such as engine‑plus‑configuration designs and automated test‑case generation.
Spring Framework 6.0 milestone introduces Jakarta EE migration, updates core containers and persistence, upgrades servlet baselines, removes deprecated APIs, changes controller scanning rules, and replaces the HttpMethod enum with a class, while previewing the upcoming Spring Boot 3.0 release.
Spring Boot 2.6.2, released on December 21, introduces 55 bug fixes, documentation improvements, and a comprehensive set of dependency upgrades, providing developers with more stable configuration binding, corrected database initialization, enhanced security handling, and updated libraries across the ecosystem.
The article guides readers from grasping hardware, OS, and software layers—including Intel Xeon, virtualization, VPC, and containers—to gathering performance data with tools like JProfiler and perf, then applying data‑driven optimization across business logic, architecture, code, caching, databases, runtime and hardware, illustrated by real‑world case studies and emphasizing continual learning.
Spring Framework 6.0 milestone introduces Jakarta EE package migrations, updates core containers, overhauls persistence APIs, modernizes servlet middleware with Tomcat 10, Jetty 11, Undertow 2.2.14, removes legacy components, and changes controller scanning and HttpMethod handling, while offering resources for learning Spring Boot and Cloud.
This article explains how Spring Framework resolves circular dependencies during object creation using a three-level caching mechanism, detailing the process through code examples and architectural diagrams.
This article explains Kafka’s fundamental design concepts—including topics, partitions, replicas, consumer groups, and its network architecture—while highlighting performance features such as sequential writes, zero‑copy, log segmentation, and how the controller coordinates with ZooKeeper, providing a comprehensive overview for backend developers.
This article examines the benefits, costs, and design patterns of caching—including update policies, granularity control, penetration, bottom‑hole, avalanche, and hot‑key issues—while offering concrete optimization techniques and practical recommendations for building robust Redis‑MySQL cache layers.
OOX is a Node.js‑based microservice solution that removes the need for route definitions and configuration files, supports both HTTP and Socket.IO, provides example code for calculator services, and includes recent updates such as AsyncLocalStorage tracing and Socket.IO 4.4.0.
This article explains four approaches for implementing Spring Boot event listeners—including manual registration, component scanning, properties configuration, and @EventListener annotation—while also covering how to create custom events and listener classes with complete code examples.
This guide demonstrates how to create a Go-based WebSocket server and client using the gobwas library, enabling two services to exchange random numbers, handle connections, and gracefully manage disconnections, with complete code examples and testing instructions.
This article explains the evolution of Go's development workflow from the legacy GOPATH mode to the modern Go Modules system, details version‑specific changes, answers common migration questions, and provides a step‑by‑step tutorial with code examples for creating, testing, and managing Go modules in production projects.
This article analyzes a Spring Boot startup failure caused by a conflict between @Autowired and @DubboReference annotations when injecting the same service bean, explaining the underlying mechanism and providing solutions.
This article introduces the concept of signals, explains the features of the Python Blinker library, demonstrates various usage patterns—including named, anonymous, multicast, and topic‑based signals—as well as how to integrate Blinker with Flask for custom and built‑in Flask signals, highlighting advantages and limitations.
The article introduces eladmin, an open‑source, front‑back separated admin platform built with Spring Boot, JPA, Spring Security, Redis and Vue, detailing its features, modular architecture, key functionalities, highlights, and providing a link to its GitHub repository.
This article explains Go Modules' major version suffix rules, how the Go tool resolves package paths to module paths using GOPROXY, and the structure and advanced features of the go.mod file, including deprecated warnings and programmatic manipulation.
The article explains Go module paths defined in go.mod, how they combine with package subdirectories, the semantic versioning scheme (major, minor, patch, pre‑release), and how Go generates and orders pseudo‑versions from tags, branches, or commits when fetching modules.
This article explains how to create custom HttpServletRequestWrapper classes and servlet filters in Java to automatically decrypt or transform request parameters—such as converting email fields to lowercase—before they reach controller methods, covering both form/ajax and JSON payload scenarios with configuration examples for web.xml and Spring Boot.
This article presents a comprehensive, layer‑by‑layer framework for unifying business architecture design, detailing product contracts, business models, services, flows, components, infrastructure, and model adapters, and shows how low‑code and hard‑coded approaches can be combined to accelerate development while maintaining consistency.
FlyCms is an open‑source, Java‑based, Q&A‑style CMS built on Spring Boot, MySQL, Redis, Elasticsearch and Vue, and this guide walks you through its architecture, key features, required environment setup, installation commands, configuration, building, and launching the application.
This article introduces the Java Persistence API (JPA), explains why Spring Data JPA has become an essential skill for large companies, outlines its benefits for development efficiency and career growth, and recommends the comprehensive book “Spring Data JPA: From Basics to Advanced” with its detailed structure and practical examples.
To reduce response time when invoking multiple independent APIs, this article demonstrates how to refactor sequential Java calls into asynchronous executions using thread pools and CompletableFuture, providing complete code examples and performance comparisons.
This article introduces the high‑performance gRPC framework, explains why it uses HTTP/2 and Protocol Buffers, outlines its core components, and provides a step‑by‑step Python tutorial with environment setup, code generation, server and client implementations, and common application scenarios.
The Laravel 8.74.0 release introduces new commands, helper methods, Eloquent aggregation, string reversal, database notification type customization, full‑text indexing, and several bug fixes and performance improvements, while also upgrading Symfony to 5.4 and refining queue connection handling.
This article explains how to integrate Elasticsearch into a Spring Boot project, covering version compatibility, supported access methods, dependency setup, configuration, entity mapping with annotations, repository creation, and unit testing to verify successful indexing and retrieval.
This tutorial explains how to install Docker, pull and run a FastDFS Docker image, verify the deployment, and then integrate FastDFS with Spring Boot by adding Maven dependencies, configuration files, and a Java utility class for file operations.
This article reviews the ten most widely used PHP frameworks—Laravel, ThinkPHP, Yii, CodeIgniter, Symfony, CakePHP, Zend, Phalcon, FuelPHP, and Slim—highlighting their origins, key features, typical use cases, and the latest versions to help developers choose the right tool for their web projects.
This guide explains how to use Spring Boot's programmatic transaction APIs—including TransactionTemplate, TransactionManager, and transactional event listeners—through detailed code examples, configuration tips, rollback handling, and best‑practice recommendations for backend Java development.
This article demonstrates how to achieve Java hot‑update without rebuilding by leveraging Groovy's metaclass and GroovyShell, walking through a verification example, a full script implementation, and practical tips for handling script encoding issues.
The article explains how PHP’s alarmingly low bus factor of two sparked the creation of the PHP Foundation, detailing the key contributors, the backing companies, funding goals, and how the foundation aims to raise the bus factor and sustain core development.
This article explains the differences between Spring’s ObjectFactory and FactoryBean interfaces, demonstrates how they are used internally for bean creation, dependency injection, and servlet API injection, and shows how to customize ObjectFactory behavior to resolve bean conflicts and inject specific implementations.
This article describes the architecture, core features, and implementation details of a high‑performance API gateway built with RxNetty, covering request dispatch, conditional routing, API management, rate‑limiting, security policies, monitoring, and future improvement directions.
This article introduces Mybatis-Mate, an enterprise‑level MyBatis extension that provides sharding, data audit, sensitive‑word filtering, field encryption, dictionary binding, data permission, dynamic DDL generation and other features, and shows how to integrate and use them with practical code examples.
Spring Boot 2.6.0 arrives with a host of new features—including default circular‑reference protection, SameSite cookie support, reactive session enhancements, custom sanitizing rules, endpoint changes, Redis pool options, WebTestClient testing, Log4j2 composite configuration, numerous dependency upgrades, and several deprecations—plus updated Maven coordinates and version timelines for developers to consider before upgrading.
This guide shows how to use IntelliJ IDEA’s diagram feature to visualize, clean up, and explore Java Servlet inheritance and interface relationships, including removing unwanted classes, inspecting members, adding new classes, and jumping directly to source code for deeper understanding.
Built on Java 8, Aviator is a lightweight, high-performance expression evaluator that compiles expressions to JVM bytecode, supporting arithmetic, logical, regex, custom functions, and variable binding, while outlining its limitations, usage examples, and integration steps for developers.
This guide walks you through setting up a comprehensive logistics and warehouse management system using Spring Boot and Jeecg‑boot, covering required environment versions, technology stack, database configuration, backend and frontend setup, and deployment steps with detailed screenshots and code snippets.
This article introduces ten useful IntelliJ IDEA plugins—including aiXcoder, Java Stream Debugger, easy_javadoc, Easy Code, Restfultoolkit, Key promoter X, String Manipulation, Translation, Git Auto Pull, and .gitignore—detailing their features, shortcuts, and how they can streamline Java backend development and improve coding productivity.
The article traces Go’s shift from GOPATH to Go Modules—detailing their history, migration steps, practical commands, and best‑practice tips such as using replace directives, managing go.mod and go.sum, and emphasizing why teams should adopt modules now for reliable dependency handling, security, and developer efficiency.
This article walks through the complete lifecycle of Spring Cloud Feign in a Spring Boot 2.2.13 application, covering how to enable Feign, scan and register @FeignClient beans, inject them into controllers, create dynamic proxy instances, and finally execute remote calls with load‑balancing and Hystrix support.
This article analyzes the extreme‑traffic problem of Chinese train ticket sales, presents a multi‑layer load‑balancing architecture with Nginx weighted round‑robin, demonstrates Go and Redis code for local and global stock deduction, and shows benchmark results proving that a single machine can handle over 4 000 requests per second while preventing oversell and few‑sell.
This article explains how Java 8’s Function functional interface and related interfaces such as Supplier, Consumer, and Runnable can replace traditional if‑else statements for exception handling and branching, providing concise code examples and utility methods for cleaner backend development.
Spring Boot 2.6.0 introduces major updates such as SameSite cookie support, health group configuration for main and management ports, enhanced /info endpoint with Java runtime details, WebTestClient testing, automatic spring‑rabbit‑stream setup, custom env/configprops sanitizing, new metrics, Docker build improvements, and default prohibition of circular bean references.
The article examines the evolution of Tencent Cloud’s F-Stack—a full user‑space networking framework built on DPDK, FreeBSD, and micro‑threading—detailing its architecture, supported versions, POSIX‑compatible API, real‑world deployments such as HttpDNS and DNSPod, performance gains over kernel stacks, and the roadmap for future enhancements.
This tutorial walks through installing Docker, configuring remote access, creating a Spring Boot project with Maven, adding Docker support via plugins, writing Dockerfile and application code, building the image, and running the container, demonstrating a complete end‑to‑end deployment workflow.
This article reviews Java’s default class loading mechanism and parent‑delegation model, explains how the model can be broken, and details Tomcat’s custom classloader architecture—including Common, Catalina, Shared, Webapp, and JSP loaders—showing why Tomcat deviates from the standard delegation hierarchy.
This article demonstrates how to use Fluent Mybatis, native Mybatis, and Mybatis‑Plus to implement a complex student‑score aggregation query, compares their code structures, generation settings, and highlights the advantages and drawbacks of each approach for backend development.
This article explains how to perform elegant parameter validation in Spring Boot by distinguishing controller‑level and service‑level checks, introduces Hibernate Validator annotations, demonstrates their usage with code examples, and shows additional utilities like commons‑lang3 and custom validation annotations for robust backend development.
This article highlights recent web development tools and concepts—including Chrome's Recorder panel, Webpack's SplitChunksPlugin, detailed analyses of React Fiber and startTransition, Node.js architecture and multi‑process techniques, as well as source‑code explorations of Fabric.js, Vue2 utilities, and Svelte implementation—providing practical insights for both frontend and backend engineers.
iQIYI built a Spring Cloud extension that adds zone‑ and region‑aware client‑side load balancing, metadata‑driven instance filtering, and delayed registration plus deregistration hooks, enabling proximity routing, graceful startup, and graceful shutdown for multi‑region, multi‑datacenter deployments and improving service stability and disaster‑recovery.
This article examines three frequent challenges when using Feign in Spring Cloud—where to place the client, whether to wrap Feign interfaces, and how to handle business exceptions—offering a detailed comparison of two call styles, a ResponseBodyAdvice‑based wrapper solution, and a custom error decoder to propagate original exceptions.
This article outlines the full sequence of Spring Boot application events—from ApplicationStartingEvent at launch to ApplicationFailedEvent on errors—explaining when each event fires, its purpose, and providing code snippets that illustrate the event triggers within the SpringApplication lifecycle.
The author shares personal insights and advice on working in Java backend and real‑time big‑data platforms, discussing common doubts, the value of continuous learning, and how early career choices can shape long‑term professional growth.
This tutorial walks through creating your own image‑hosting site by setting up a Vue front‑end with Ant Design Vue, configuring a UCloud US3 bucket, and implementing Spring Boot backend code to handle file uploads, generate signed URLs, and return structured responses.
This article demonstrates how to combine multiple exception types in a single catch block and how to employ Java's try‑with‑resources construct to automatically close resources, providing complete code examples drawn from Nacos's BaseDatabaseOperate class.
This article explains three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.
This article recommends a comprehensive CSDN blog series on reactive Spring, detailing beginner‑friendly explanations of reactive programming, lambda and functional concepts, testing tips, performance insights, and includes vivid CPU‑I/O analogies, plus useful links to the Reactor 3 manual and Apache Shenyu gateway.
This article explains the fundamentals of Remote Procedure Call (RPC), its historical evolution, core concepts such as remote procedures and calls, practical examples, analogies, and the challenges it introduces—like latency, address‑space isolation, partial failures, and concurrency—while highlighting RPC’s pivotal role in enabling scalable distributed architectures.
This article explains how to use APIPOST to send HTTP requests, configure header, query, and body parameters, switch between form-data, x-www-form-urlencoded, and raw modes, view responses, and efficiently import parameter descriptions, providing a practical guide for backend developers.
This article explains how Spring Boot’s auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories file, conditional annotations, and how configuration properties are bound to beans such as ServerProperties to make settings like server.port effective at runtime.
This article demonstrates how APIJSON dramatically reduces boilerplate for typical CRUD operations by using a single generic endpoint for all request types, showing concrete SpringBoot examples, request/response JSON structures, permission configuration, and advanced query capabilities, all with minimal code.
This guide explains how to install JRebel, a hot‑deployment tool for Java web applications, using either Tomcat startup parameters or the IntelliJ IDEA plugin, and details the necessary VM options, deployment settings, and Maven/Gradle integration to achieve instant code updates without restarting the server.
This article examines whether Service and DAO layers in Java Spring applications must always have interfaces, explains why dependency‑injection frameworks make interfaces optional, discusses development workflows, multiple‑implementation scenarios, project structuring options, and outlines the trade‑offs of using or not using interfaces.
This article explains how RocketMQ's six core features—asynchronous decoupling, peak‑shaving, distributed transaction messages, message filtering, scheduled messages, and ordered delivery—enable Alibaba's Double 11 platform to handle billions of transactions and hundreds of thousands of orders per second while maintaining system stability and reliability.
This article provides a concise collection of frequently used Nginx configuration examples—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—to help developers quickly set up a high‑performance web server.
This article explains how to perform parameter validation in Spring applications, covering the distinction between controller‑level and service‑level checks, using Hibernate Validator and commons‑lang3, and creating custom validation annotations for complex scenarios.
This article explains the fundamentals of Domain-Driven Design, covering its core concepts, step‑by‑step design methodology, domain modeling techniques, and how to apply DDD in microservice architectures with considerations for technical elements such as distributed transactions and scalability.
This article explains how to place parameter validation in the appropriate Spring layer, demonstrates using Hibernate Validator and commons‑lang3 for concise validation annotations, provides code examples for entity definitions and controller methods, and mentions creating custom validation annotations when needed.
This article shows how to streamline Java backend unit tests by loading JSON fixtures, deserializing them into objects, and re‑serializing results for concise assertions, while providing naming conventions, Maven setup, FastJSON tricks, and advanced Mockito techniques to replace verbose manual object construction.
From its 2017 v2.0 upgrade to a service‑oriented design, vivo Mall’s product system was split from the monolithic mall, progressively adding independent activity, flash‑sale, consignment, and inventory services while employing rate limiting, multi‑level caching, circuit breaking, and distributed transactions to ensure stability, high performance, and data consistency.
