The article details multiple ways to skip unit tests when packaging a Maven Java project, including command‑line flags, pom.xml configuration, IDE settings, and Maven runner VM options, enabling developers to build JAR files without test execution when production configurations are needed.
This article explains Redis's compressed list structures—ZIPLIST and its successor LISTPACK—detailing their layouts, encoding schemes, query and update complexities, and how LISTPACK resolves ZIPLIST's chain‑update performance issues to provide a more memory‑efficient list implementation.
This article presents a detailed analysis of modern payment system architecture, covering the transaction and payment cores, service governance, data consistency, asynchronous processing, and practical production practices such as performance testing and stability management, illustrated with numerous diagrams.
This article explains three Redis‑based rate‑limiting techniques—using setnx for simple counters, leveraging ZSet for a sliding‑window algorithm, and applying a token‑bucket pattern with List—provides Java code examples for each method, discusses their advantages and drawbacks, and shows how to integrate them into backend services.
The article explains the classic cache consistency problem between MySQL and Redis, analyzes how inconsistencies arise, and details four cache‑update design patterns—delete‑then‑update, cache‑aside, read/write‑through, and write‑behind—highlighting their workflows, advantages, and drawbacks.
Spring Boot 3.0.4 arrives early, addressing a PathMatchingResourcePatternResolver issue that broke bean and controller scanning, and brings 19 bug fixes, documentation enhancements for Gradle 8 and other topics, plus numerous dependency upgrades across Couchbase, Jetty, Reactor, Spring Framework, and more.
This guide walks through building and configuring NGINX 1.22 with OpenTracing and Jaeger, covering required dependencies, compiling gcc, cmake, jaeger-client‑cpp, and the nginx‑opentracing module, and shows how to set up tracing configuration and verify spans in Jaeger.
This article explains the Alibaba Java development specification for layered domain models, detailing the purpose and naming conventions of DO, DTO, BO, AO, VO, Query objects, and further clarifies the roles of PO, VO, DAO, BO, DTO, and POJO in Java backend architecture.
Spring Boot 3.0.4 arrives ahead of schedule, fixing 19 issues—including a path‑matching bug that broke bean scanning—while adding documentation updates and upgrading key dependencies such as Couchbase, Jetty, and Spring Framework, providing developers with a more stable backend platform.
This article introduces FastMyBatis—a lightweight, zero‑configuration MyBatis extension for Spring Boot—covering its core principles, Maven setup, sample CRUD controller, service and mapper implementations, a comprehensive list of mapper methods, Query object usage examples, and links to the open‑source repository.
FFmpeg 6.0 "Von Neumann" introduces a host of new codecs, decoders, filters, CLI enhancements, ABI versioning, and a more frequent release cadence, offering developers expanded multimedia processing capabilities and improved performance across platforms.
This article walks through a complete TCP connection example in Node.js, detailing server and client code, the three-layer Node.js architecture (JS, C++, C), the initialization process, Libuv’s event‑loop phases, task scheduling, I/O models, and how Node.js maintains non‑blocking, concurrent connections.
This article examines how MyBatis leverages around ten core design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex scenarios, improve modularity, and streamline ORM operations within its extensive codebase.
Cloudflare engineers have rewritten a core Nginx module in Rust, creating the Pingora proxy to replace Nginx, improve performance and safety, and pave the way for a future backend infrastructure without Nginx, highlighting Rust’s security benefits for complex, high‑scale services.
This article explains how Spring enables transaction management through @EnableTransactionManagement, details the underlying proxy mechanism, outlines the basic and detailed execution flow, describes transaction propagation types and their classifications, and shows how to force rollback and use TransactionSynchronization for custom callbacks.
This release note details SpringBoot 3.0.3 bug fixes, documentation updates, and dependency upgrades, and introduces Spring Cloud 2021.0.6 with its new features, module improvements, and a concise Maven dependencyManagement snippet, providing developers with a comprehensive overview of the latest stable versions.
This article explains the role of network communication in RPC, compares blocking I/O, non‑blocking I/O, I/O multiplexing and asynchronous I/O, discusses why blocking I/O and multiplexing dominate, introduces zero‑copy techniques at the OS and Netty levels, and shows how Netty optimizes data handling for high‑performance RPC.
This article explains how Spring MVC processes exceptions using the DispatcherServlet and a configurable HandlerExceptionResolver chain, outlines the built‑in resolver implementations, shows how to customize error pages, and provides code examples for handling errors in both HTML and JSON responses.
This article explains the fundamentals of REST and gRPC APIs, compares their design constraints, features, and typical use cases, and helps developers choose the most suitable framework for building scalable, high‑performance microservice architectures.
Javalin is a lightweight Java web framework that supports WebSocket, HTTP/2, and asynchronous requests, offering simple configuration, route definitions, parameter validation, handlers, access management, and easy deployment via an embedded Jetty server, with examples and troubleshooting tips for common issues like port conflicts.
This article walks through a hands‑on Go RPC demo, explains the underlying server and client mechanisms, explores registration, HTTP handling, request processing, object pooling, and the gob codec, and clarifies why Go includes RPC alongside HTTP.
This tutorial walks through the evolution from manual Redis calls to Spring Cache abstraction, explains AOP‑based proxying, details core annotations, demonstrates Caffeine and Redisson integration, explores list caching, and shows how to build a custom two‑level cache for high‑performance Java back‑ends.
This tutorial explains how to implement a like/unlike feature using Spring Boot, Redis caching, and periodic persistence to a database with Quartz, covering data modeling, key design, service layers, controller APIs, and scheduled synchronization.
This article explains how to create a unified response class, define custom exception and error‑enum types, and implement a global exception handler in Spring Boot, enabling clean error handling, reduced boilerplate, and flexible business‑specific extensions.
This article explains the concept of scaffolding for software development, outlines why it is essential for microservice architectures, compares custom persistence solutions with Spring Data, and reviews popular backend scaffolding tools such as Spring Boot, Maven, Netty, Java EE, and Dropwizard.
This tutorial explains what MybatisX is, outlines its advantages, and provides a detailed, code‑rich walkthrough for integrating the plugin into a Spring Boot project, configuring the database, generating MyBatis‑Plus entities, and writing a simple controller to query data.
The article describes how an e‑commerce product ranking system was migrated to the new “Liao Yue” platform, decoupling it from the search module, introducing fresh metrics and Elasticsearch‑based sorting, then optimizing storage by separating B‑end and C‑end data—cutting costs 60%—with a gray‑scale rollout, dual‑read validation, rollback safeguards, and completing the two‑week, zero‑failure migration that delivered a closed‑loop, faster iteration system.
This roundup covers the latest Java ecosystem news, including new JEP drafts for pattern matching and constructors, the Rampdown Phase Two of JDK 20 with its final six features, early‑access builds of JDK 21, and recent releases of GraalVM, Spring, Quarkus, Micronaut, JobRunr, Hibernate, Apache projects, and more.
The announcement details CodeIgniter version 4.3.0, highlighting over 50 enhancements, important breaking changes, required updates to the spark executable and configuration files, and provides links to the changelog and upgrade guide for developers to safely migrate their applications.
The article explains how REST, despite its 20‑year popularity and simplicity, suffers from redundancy, coarse granularity and maintenance overhead, and shows how GraphQL’s declarative, schema‑driven approach, single endpoint and flexible data fetching address these problems while offering a versatile integration architecture and rich ecosystem.
This article presents a collection of basic Java programming methods and best‑practice recommendations—ranging from using @ConfigurationProperties and @RequiredArgsConstructor to modularizing code, handling exceptions, reducing unnecessary database queries, avoiding null returns, and applying design patterns—to help developers write cleaner, more maintainable backend code.
This article explains how Domain‑Driven Design can guide the splitting of monolithic applications into well‑structured microservices by introducing DDD fundamentals, strategic domain modeling, tactical design patterns, and a concrete Go code example that demonstrates a four‑layer architecture.
This article explains Scrapy's comprehensive crawling framework and Twisted's event‑driven networking engine, detailing their core concepts, workflow, code execution process, and how to debug Scrapy spiders using breakpoint tracing, providing a deep technical overview for backend developers.
This article details the design and implementation of a SpringBoot‑based API automation platform with a layui front‑end, covering architecture choices, permission management, hierarchical data design, test case handling, test set execution, result reporting, and future enhancements such as scheduling, email notifications, and multithreading.
This article explains how Go’s fast compilation, lightweight runtime, built‑in concurrency, strong type safety, and cross‑platform compatibility make it a compelling choice for building scalable, high‑performance backend services, and provides practical code examples to get started quickly.
The article examines backlog, abnormal and over‑consumption problems in a small court’s task distribution, proposes an active‑claim model with user‑task lock queues to decouple qualification checks, and shows that these changes raise completion to 100%, cut processing time from 20 hours to under 2 hours while recommending a factory‑plus‑strategy architecture for future extensibility.
This article demonstrates how to convert multiple asynchronous queries into a synchronous response using Java's CompletableFuture, providing step‑by‑step code examples in both Java and Groovy, explaining execution flow, timeout handling, and practical considerations for WebSocket‑like scenarios.
This article explains how to use Sina's short URL API to convert long links into short t.cn links, detailing request formats, required parameters, example PHP code for generating and expanding URLs, and shows sample JSON and XML responses.
This article explores Spring's eleven most commonly used extension points—including custom interceptors, bean factory access, global exception handling, type converters, configuration imports, startup runners, bean definition tweaks, bean post‑processing, initialization methods, shutdown hooks, and custom scopes—providing code examples and practical guidance for Java backend developers.
This article explains the fundamental components of RPC architecture, details the client‑server roles, communication protocols, serialization methods, transport protocols, and synchronous versus asynchronous invocation patterns, providing a comprehensive guide for building a custom RPC framework.
This article provides a detailed introduction to Spring Boot, covering its purpose, advantages, core @SpringBootApplication annotation, supported logging frameworks, starter mechanism, new features in version 2.x, configuration methods, security, CORS handling, actuator monitoring, hot deployment, multi‑datasource setup, session sharing, and packaging differences, all aimed at helping developers quickly adopt and master the framework.
This article explains why Medium transitioned from a monolithic Node.js application to a microservice architecture, outlines the core design principles, shares practical strategies for building, deploying, and observing services, and warns about common pitfalls such as the microservice syndrome.
This article outlines the typical evolution stages of large internet system architectures—from single‑node deployments to cluster, distributed, and future cloud‑native designs—highlighting the business‑driven reasons, technical challenges, and practical tips for each phase.
This article comprehensively reviews the various techniques for injecting beans into the Spring container—including XML and properties configuration files, annotation-based declarations, manual BeanDefinition registration, direct singleton registration, and FactoryBean usage—providing code examples, underlying principles, and practical guidance for each method.
This article examines four common approaches for synchronizing product data from MySQL to Elasticsearch—synchronous dual write, asynchronous dual write with message queues, scheduled batch jobs, and binlog‑based data subscription—detailing their advantages, drawbacks, and implementation considerations.
This article explains Bilibili’s unified API management platform, covering service launch processes, manual versus automated metadata collection, code‑first API definitions in Go and Java, version control, collaboration features, mock testing, and micro‑service standardization to improve development efficiency and reduce operational costs.
Spring Cloud 2022, built on Spring Framework 6.x and Spring Boot 3.x, requires Java 17 and introduces crucial bug fixes across modules like Gateway, Commons, and Kubernetes, along with new features such as a secure flag for service instances and optimized load‑balancing.
This guide explains how to use Spring MVC's @RequestMapping and its shortcut annotations, choose between PathPattern and AntPathMatcher for URI matching, configure suffix and media type handling, and customize request mapping with parameters, headers, and programmatic registration.
This article explains why Redis is essential for flash‑sale systems, detailing load characteristics, the three sale phases, Redis features such as high concurrency and atomic operations, and practical implementations using Lua scripts and distributed locks to ensure safe stock checking and deduction.
This article explains the fundamentals of web application architecture, covering its core components, layered models, modern design patterns, popular technologies, and best practices for building secure, scalable, and maintainable web systems across cloud and on‑premise environments.
The article reflects on Elon Musk’s criticism of microservices, argues that the architecture is often over‑hyped and misapplied, compares it with monolithic and other service granularity models, and warns that blind adoption driven by trends can lead to costly technical debt.
This article reviews the rapid evolution of PHP over the past decade, highlights the role of the PHP Foundation, showcases new PHP 8.2 features with code examples, and analyses ecosystem statistics such as Packagist growth and framework adoption to illustrate why 2023 is a pivotal year for PHP developers.
This article explains how Node.js uses the NODE_CHANNEL_FD environment variable to establish a socketpair for IPC between a parent process and its child, detailing the spawn implementation, underlying libuv handling, and how a Go subprocess can read and write through the shared file descriptor.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution from monolith to microservices, bounded context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical design guidelines for backend systems.
This article demonstrates how to implement the Chain of Responsibility design pattern in PHP using the Hyperf framework, detailing the file structure, core classes such as IndexController, HandlerInterface, AbstractHandler, and concrete handlers, and includes a unit test example to verify the workflow.
This article explains how to use @ExceptionHandler with @Controller, @ControllerAdvice, and @RestControllerAdvice for local and global exception handling in Spring MVC, details supported method parameters and return types, and shows how to customize REST API error responses by extending ResponseEntityExceptionHandler.
This article walks through the complete design and implementation of a friend‑follow microservice, covering requirement analysis, MySQL table schema, Redis set operations, Spring Boot dependencies, configuration, service and controller code, gateway routing, and end‑to‑end testing with concrete examples and performance insights.
The article analyzes the growing demands on network I/O, explains Linux’s kernel bottlenecks, and shows how user‑space frameworks like DPDK and UIO can achieve multi‑hundred‑million packets per second through techniques such as huge pages, SIMD, zero‑copy, and careful CPU cache management.
This article introduces RabbitMQ's core concepts, key features, and typical use cases, then provides step‑by‑step installation instructions for macOS, Windows, and CentOS, and demonstrates how to configure and use the delayed‑message plugin with Java Spring Boot code examples.
This guide demonstrates how to modify Spring Boot 2.4.12 logger levels at runtime using LoggingSystem, enabling per‑package or whole‑application log level changes without editing configuration files or restarting the service.
This article explains the core distinctions between Remote Procedure Call (RPC) and Message Queue (MQ) technologies, covering their architectures, communication patterns, functional features, and performance considerations, and outlines typical use cases such as synchronous calls, decoupling, traffic shaping, and asynchronous processing in distributed systems.
This guide demonstrates how to use Java 11’s HttpClient to build a WebSocket client, implement a listener for various message events, and send both text and binary data, including a complete runnable example that showcases connection setup, message handling, and periodic sending.
Learn how Java 11’s built‑in HttpClient simplifies both synchronous and asynchronous HTTP calls, covering client and request creation, setting URIs, methods, headers, timeouts, and various body types, with complete code examples and a comparison to alternative libraries.
This article explains how to create a reusable dynamic Feign client in Java, replacing multiple static Feign interfaces with a generic service that can invoke any microservice endpoint via configurable URLs, and provides full code examples and usage instructions.
The guide defines backend coding standards and best practices, specifying clear naming conventions for classes, methods, variables and constants, enforcing consistent code style via .editorconfig, recommending unchecked exceptions for simpler error handling, promoting structured asynchronous logging with trace IDs, and outlining performance optimizations such as loop refinement, CompletableFuture concurrency, and proper resource management to prevent memory leaks.
This article explains how to create a Spring Boot package that keeps dependencies external by configuring the spring-boot-maven-plugin and maven-assembly-plugin, using a ZIP layout and PropertiesLauncher, so the application can be started with a custom loader.path that points to a libs directory.
This article explores Java 9's module system, its core principles, and practical implementation through a multi-module project example, highlighting benefits like modular encapsulation, dependency management, and reduced resource usage.
This article explains how to protect user privacy by applying data desensitization in a Java backend, using a custom annotation and Jackson serializer to mask sensitive fields such as phone numbers, emails, IDs, and names during JSON serialization.
This tutorial walks through setting up an Elasticsearch server, creating a Java REST client, implementing a custom GET‑with‑body request, building a reusable ESClient wrapper with common CRUD and search methods, and providing Groovy performance test cases for indexing and querying.
This article explains how Spring Boot 3 introduces a native declarative HTTP client via HttpServiceProxyFactory, showing required dependencies, supported annotations, interface definition, and complete code examples for building, configuring, and invoking remote HTTP services without third‑party libraries.
This article demonstrates how to create a dynamically configurable thread pool in a Spring Boot backend by leveraging Nacos as a configuration center, covering dependency setup, YAML configuration, Java implementation with @RefreshScope, runtime parameter updates, and a simple controller for testing.
This article explains how NetEase Cloud Music tackled the tight coupling between frontend UI and backend services by introducing a Backend‑For‑Frontend layer built on GraphQL, detailing the architectural choices, low‑code editor, custom directives, deployment pipeline, and the resulting improvements in scalability and developer productivity.
This article explains how to redesign an automated testing framework by applying the Strategy pattern to replace complex conditional branches, thereby improving script reusability, maintainability, and extensibility across diverse business scenarios in Python.
This guide explains how to create a custom Oracle datasource plugin for Nacos 2.2 by adding Maven dependencies, importing the Oracle SQL script, configuring connection properties, and setting the datasource platform, enabling Nacos to use Oracle instead of the default MySQL or Derby.
This article explains the Decorator (Wrapper) pattern, shows how to apply it in a Spring Boot project with concrete surfing‑service examples, demonstrates single‑ and multi‑layer decorators, and provides complete Java code and controller snippets to illustrate dynamic behavior extension without modifying existing classes.
This article provides a comprehensive guide to Java's BigDecimal class, covering its purpose for high‑precision arithmetic, common constructors, usage pitfalls with double values, essential methods, comparison techniques, formatting options, exception handling, and a utility class for everyday operations.
This article explains how to batch multiple cluster endpoint requests in Go by using a token‑based queue and concurrent workers, dramatically reducing load on the registration center while requiring minimal changes to existing code.
This article describes the background, design, configuration, encryption, mock data handling, and practical deployment steps of an external gateway that unifies and secures communication between internal vehicle payment services and external channels such as Apple Pay, Alipay, WeChat Pay, and UnionPay.
This article provides a comprehensive guide to PHP multi‑process development on Linux, covering basic shell commands, ELF file types, terminal concepts, process states, orphan and zombie processes, process groups and sessions, signal handling, and practical pcntl/posix code examples for forking, daemonizing, and managing child processes.
The article explains Go’s caller‑callee model, stack‑frame layout, and how parameter and return‑value passing shifted in Go 1.17.1—using registers for up to nine arguments or results and the stack for any beyond—highlighting the impact on performance and optimization.
Node.js is a server‑side JavaScript runtime built on V8 that replaces the browser environment with native libraries, uses libuv’s event loop and thread pool to provide non‑blocking asynchronous I/O, and organizes its architecture into application code, V8, bindings, and libuv layers for efficient backend development.
This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right communication approach for enterprise applications.
This article demonstrates how to use the Decorator (Wrapper) pattern in a Spring Boot application to extend existing services with additional responsibilities, showing both single‑layer and multi‑layer decorations through concrete code examples and controller endpoints.
This article introduces GraphQL, explains its adoption by GitHub, discusses its challenges, and demonstrates how Apache APISIX can perform fine‑grained GraphQL routing with practical code examples and future enhancement ideas.
This article introduces a two-level cache framework designed to address issues with Spring-Cache, providing enhanced caching strategies and improved performance in Java-based backend systems.
The article presents a branch‑path graph scheduling framework that extends traditional finite‑directed‑graph scheduling with branch nodes and AND/OR activation semantics, converting it into a deterministic directed acyclic graph, thereby eliminating exponential state growth and improving scalability, readability, and maintainability of Vivo’s real‑time advertising estimation service.
Janus is Baidu’s high‑throughput, multi‑purpose gateway that complements BFE, supporting traffic, business, and hybrid routing for dozens of internal services; the article explains its motivations, architecture, three‑tier routing rules, variable and conditional expressions, plugin system, performance benchmarks, and future extensions.
AGEIPort is Alibaba's event‑driven, high‑throughput data import‑export framework that handles hundreds of billions of rows monthly, offering transparent concurrency, decentralized clustering, GitOps‑based delivery, and standardized domain‑model APIs to simplify complex B2B scenarios.
This article introduces PhpSpreadsheet—the modern PHP library that replaces PHPExcel—showing how to install it, import necessary namespaces, create a spreadsheet with data, build bar and donut charts, configure gridlines and positions, and finally output the workbook as an XLSX file.
This article provides a comprehensive guide to MyBatis, covering its basic concepts, Maven dependency configuration, XML setup, entity and mapper definitions, execution flow using dynamic proxies, and a custom lightweight framework implementation with full Java code examples.
This article explains the terminology, background, goals, technical choices, workflow, and API design of a token‑based authentication solution that leverages OAuth2 password grant and JWT to provide secure, stateless, cross‑platform access for enterprise applications.
Spring MVC provides built‑in CORS support, allowing you to configure preflight, simple, and actual requests via global HandlerMapping settings, @CrossOrigin annotations, Java‑based CorsRegistry, or CorsFilter, with detailed options for origins, headers, methods, credentials, and max‑age to secure cross‑origin interactions.
This article explains why PIG chose Tencent Polaris for service governance, outlines the necessary adjustments when moving to Spring Boot 3.0—including Java 17, Jakarta EE, SPI changes, security and documentation updates—and lists the upgraded Spring Boot starters that support the new platform.
This article outlines the essential requirements for empowering autonomous teams, details the challenges of transitioning and splitting monolithic systems into microservices—including organizational, technical, and cultural hurdles—and presents comprehensive best‑practice recommendations for platform design, service development, deployment, operations, and team management.
The article explains how a WeChat e‑commerce team adopted Domain‑Driven Design, reorganizing a fast‑paced, multi‑team project into a four‑layer onion architecture with strategic sub‑domains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories and services, to achieve maintainability, extensibility, cohesion and loose coupling.
This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the client with enums, implementing a connection pool using r2d2, creating a global singleton with once_cell, and providing example code for querying and storing data.
The article demonstrates how to apply the Chain of Responsibility pattern to Java servlet filters by defining abstract and concrete validation filters, organizing them in an ordered FilterChain that uses ThreadLocal state (including composite filters) to replace tangled if‑else logic, improve extensibility, and warn of potential ThreadLocal memory‑leak risks.
This article explains the various Apache Commons Lang StringUtils methods such as isEmpty, isNotEmpty, isAnyEmpty, isNoneEmpty, isBlank, isNotBlank, isAnyBlank, and isNoneBlank, providing usage examples, code snippets, and detailed behavior for handling null, empty, and whitespace strings in Java.
This article examines Java file change monitoring, explains the limitations of a simple timestamp‑polling approach, details a JDK bug that loses millisecond precision, explores the built‑in WatchService and its fallback to polling, and demonstrates how Linux inotify provides a more reliable solution.
CakePHP 4.4.8, the maintenance release of the 4.4 branch, introduces several bug fixes and enhancements such as aligned scheme handling, improved paginator compatibility, infinite‑loop prevention when creating table classes, better mail assertion, pagination defaults fixes, and refined type hints and API documentation.
