This article describes how a Python‑based diff utility was created to compare old and new API responses during a promotion change‑record migration, detailing its implementation, handling of JSON structures, improvements over the first version, and plans for integration with an API testing platform.
This article explains how to redesign Spring Security's captcha authentication by creating a custom filter configurer, detailing the inheritance hierarchy, code implementation, and integration into a SecurityFilterChain for clean, reusable authentication handling.
This article provides a comprehensive guide to optimizing SpringBoot services, covering metric exposure with Prometheus, custom business monitoring, Java flame‑graph profiling, SkyWalking distributed tracing, HTTP and Tomcat tuning, layer‑wise code improvements, and practical code examples for real‑world performance gains.
This article revisits the fundamentals of Spring AOP, detailing its core annotations such as @Before, @After, @Around, and their execution sequence, while providing a complete demo project, code examples, and insights into common pitfalls like proxy failures and multi‑aspect ordering.
The article introduces PHP's FFI extension, explains how to call C libraries such as libbloom, manipulate Linux namespaces, and use raylib for graphics, provides complete code examples, and discusses performance considerations, offering a practical guide for backend developers.
This article presents a curated collection of Spring Framework utility classes—including assertion helpers, object/array/collection utilities, file and resource IO tools, as well as reflection and AOP utilities—providing ready‑to‑use methods that replace many custom helper functions in Java backend development.
This article walks through how MyBatis parses the transaction manager factory from XML configuration, builds the Environment, and applies the transaction manager during SqlSession creation, including detailed code examples of XMLConfigBuilder, transaction factories, and the JdbcTransaction implementation.
This tutorial explains how to embed Dataway—a zero‑code API configuration UI built on DataQL—into a Spring Boot application by adding Hasor dependencies, configuring properties, setting up required database tables, wiring the data source into Hasor, enabling Hasor annotations, and finally creating and publishing APIs through the Dataway UI.
This article dissects Netty’s core connection‑acceptance mechanism, explains how the OP_ACCEPT event is processed, reveals a subtle bug that limits read loops to a single connection, and shows the fix introduced in version 4.1.69.final, offering developers a complete understanding of Netty’s reactor architecture.
This article provides a comprehensive overview of Tomcat, covering its role as a Java web server, internal components such as Server, Service, Connector and Container, lifecycle management, deployment methods, connector implementations (BIO, NIO, APR), Comet support, and asynchronous servlet processing, with code examples for thread handling.
This article explains how to guarantee that insert messages are processed before update messages for the same data identifier across different Kafka topics by applying fine‑grained distributed locks and a caching strategy to detect and correct out‑of‑order consumption.
The article outlines the major updates in Spring Boot 3.0.0 M1, including the jump to Java 17, migration from Java EE to Jakarta EE, removed legacy support, upgraded Spring and third‑party dependencies, and the roadmap for upcoming milestone releases.
This article introduces PyWebIO, a Python library that lets developers create web‑based interactive applications with simple input and output functions, eliminating the need for HTML or JavaScript, and demonstrates installation, a BMI calculator example, and core input/output APIs.
This article explains how Spring’s @Transactional annotation leverages AOP dynamic proxies and the TransactionInterceptor to automatically manage transaction boundaries, reducing boilerplate code and allowing developers to focus on business logic.
The article reviews the latest Spring Native 0.11.2 and Spring Authorization Server 0.2.2 releases, detailing new features, compatibility changes, bug fixes, and dependency upgrades that impact cloud‑native Java applications and backend security.
Discover the MyBatis Generator GUI tool that streamlines Java POJO and mapping file creation, outlines its six key features, system requirements, and three easy startup methods—including self‑build, IDE launch, and native packaging—so you can quickly generate MyBatis code.
This article demonstrates how to refactor a coupon‑type service by applying the Strategy pattern and a Map combined with Java 8 lambda expressions, eliminating bulky if‑else or switch statements while improving maintainability and readability.
The article explains how Spring Boot 3 drops Java 8, embraces Java 17 and Spring 6, outlines the major framework changes, removed components, and offers practical advice on when and why developers should consider upgrading.
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 generate contracts, map to databases, publish services, handle testing, documentation, rule processing, and visual service orchestration.
This article explains how an API development platform can manage the full API lifecycle—design, development, testing, deployment, monitoring, and orchestration—by leveraging object‑driven modeling, automatic CRUD generation, rule processing, service composition, and source‑code export for microservice deployment.
This article explains how to design consistent API return codes and messages, using HTTP status code concepts, segmenting error codes, providing human‑readable messages, enabling personalized user messages, and centralizing handling to improve communication, debugging, and monitoring in backend development.
The article reviews VS Code’s 2021 updates, outlines its 2022 roadmap centered on six key areas—including extensive Spring Boot enhancements—and speculates that these improvements aim to keep VS Code competitive against JetBrains’ upcoming Fleet IDE for Java developers.
The article explains why a well‑designed API return‑code system—modeled after HTTP status codes, with clear numeric ranges, descriptive messages, and personalized user messages—reduces communication overhead, simplifies maintenance, and enables effective monitoring and alerting for backend services.
The article chronicles Igor Sysoev’s exit from NGINX and F5, recounts the creation and evolution of NGINX from its 2004 open‑source launch to its 2019 acquisition by F5, and highlights its rise to become the world’s most widely used web server.
This tutorial walks through creating a Spring Boot lottery application that caches activity, prize, and record data in Redis, covering project setup, Maven dependencies, YML configuration, MyBatis‑Plus code generation, Redis key management, lottery API, event‑driven data loading, stock handling, and asynchronous record saving.
This article presents a step‑by‑step guide to building a Spring Boot lottery application that leverages MyBatis‑Plus and Redis for caching activity, prize, and record data, covering project setup, dependencies, configuration, code generation, Redis integration, lottery logic, and stock management.
Spring Boot 3.0.0 M1, released on January 20 2022, upgrades the Java baseline to Java 17, migrates all Java EE APIs to Jakarta EE, drops support for several components, updates numerous Spring and third‑party dependencies, and outlines the upcoming release schedule.
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 guide explains how Sentry uses Django migrations to manage database schema changes, covering commands for upgrading, targeting specific migrations, generating SQL, creating and merging migrations, and detailed best‑practice procedures for handling filters, indexes, column and table modifications, foreign keys, and renaming while avoiding downtime.
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.
