This article explains a configurable multi‑strategy data‑masking solution for Spring Boot APIs, covering the design of a custom annotation, serializer, AnnotationIntrospector, ObjectMapper integration, and example usage on response objects.
This article introduces the Guava‑Retrying library for Java, explains how to add its Maven dependency, demonstrates building a Retryer with customizable retry conditions, stop strategies, wait strategies, and listeners, and provides detailed code examples illustrating each component.
This article explains how to configure RabbitMQ queue priority, defines reusable PHP base, service, and client classes, and demonstrates running the code to send and consume prioritized messages using the PhpAmqpLib library.
This tutorial explains the producer‑consumer principle using RabbitMQ, provides a reusable PHP base class for queue connections, and demonstrates how to create service and client classes to send and receive messages, followed by step‑by‑step instructions to run the code and view the queue.
This article explains the role of RocketMQ's NameServer, detailing its registration process, data structures, periodic heartbeat checks, failure cleanup, and how producers and consumers retrieve routing information to send and receive messages efficiently.
IntelliJ’s source code has moved to Java 17, meaning most platform and plugin modules now target Java 17, the 2022.3 IDE release requires it, and developers can use new language features by setting plugin.xml to 223, while still supporting older versions with Java 11.
This article explains how Elasticsearch leverages inverted indexes, term dictionaries, and compression techniques such as Frame‑of‑Reference and Roaring Bitmaps to enable rapid full‑text search, detailing the underlying data structures, query processing, and practical indexing tips for efficient backend search implementations.
This article introduces Go (Golang), explains its key advantages for building high‑availability, scalable backend services, and provides step‑by‑step installation instructions for macOS, Windows, and Linux platforms.
This article explains common pitfalls of Spring's transaction management—including AOP proxy limitations, unchecked exception handling, self‑invocation, asynchronous execution, multiple data sources, and large transaction issues—and provides practical solutions such as using class‑based proxies, configuring rollback rules, and splitting transactions into smaller units.
This article introduces Spring WebFlux, explains the concept of reactive programming, compares it with Spring WebMVC, describes its concurrency model, and provides complete code examples for building a reactive Spring Boot application using Mono, Flux, functional routing, and WebClient.
This tutorial walks through downloading compatible Erlang versions, installing RabbitMQ on Windows, starting the service, verifying its status, and accessing the management UI with default credentials, providing a complete setup for backend development with RabbitMQ.
This session explains why SaaS applications need tenant data routing, compares multi‑tenant sharing models, details dynamic data source architecture, routing plugin design, tenant identifier propagation, and future sidecar solutions, helping developers choose appropriate isolation strategies, configure flexible data sources, and avoid cross‑tenant data contamination.
This tutorial demonstrates how to use the MyBatis-Plus-Join (MPJ) library to perform left and right join queries in Spring Boot without writing XML SQL, covering dependency setup, entity and mapper modifications, query construction with MPJLambdaWrapper and MPJQueryWrapper, pagination support, and practical tips.
This article explains how Elasticsearch uses inverted indexes, term dictionaries, and advanced compression techniques such as Frame‑of‑Reference and Roaring Bitmaps to achieve rapid search performance while minimizing memory and disk usage, and it also covers practical indexing tips for production use.
This article theoretically outlines seven major Java performance optimization strategies—including reuse, computation, result set, resource conflict, algorithm, high‑efficiency implementation, and JVM tuning—explaining their principles, typical techniques, and how they collectively improve resource utilization and application speed.
This article provides a comprehensive analysis of Spring AOP, covering its core concepts, configuration parsing, BeanFactoryPostProcessor and BeanPostProcessor mechanisms, namespace handling, the creation of advisors and advice from @Aspect annotations, and the proxy generation process that enables method interception.
This article explains how Spring implements various design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and practical code examples within the Spring container.
This comprehensive guide explains why a service gateway is needed in microservice architectures, details Spring Cloud Gateway's core concepts, deployment steps, route and predicate configurations, local and global filters, integration with Nacos for service discovery, dynamic routing via Apollo, and custom global exception handling, providing code examples throughout.
This article introduces Spring WebFlux, explains reactive programming concepts, compares it with Spring MVC, and provides practical code examples demonstrating how to build a reactive web application using Spring Boot, Reactor's Mono and Flux, and functional routing.
This article explains the fundamentals of RPC and gRPC, compares popular RPC frameworks, details gRPC's features and Protocol Buffers advantages, and provides a complete Java hands‑on example with code, project structure, and performance benchmarks.
The article explains how a Business Monitoring Platform isolates user‑defined Groovy scripts by assigning each script its own custom Java ClassLoader that loads uploaded JARs, breaking parent‑delegation, preventing class conflicts, reducing Metaspace growth, and dynamically creating Feign and Dubbo beans for safe, independent execution.
This article explains the concept of dependency injection, why it is essential for Go backend services, compares manual object wiring with DI containers, reviews popular Go DI libraries, and demonstrates how to use Uber’s Fx framework (and a custom Viego framework) to simplify application initialization and lifecycle management.
This article walks through practical Go implementations of Redis list commands—including LPush, RPush, LLen, LRange, and others—provides unit test examples, demonstrates a simple performance benchmark, and shares a reusable wrapper library for streamlined backend development.
This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.
This article explains how systematic data construction, using a low‑code front‑end and Java back‑end platform, streamlines complex test scenarios, reduces manual effort, and enhances both testing efficiency and code quality across multiple business systems.
This article explains the fundamentals of Remote Procedure Call (RPC), compares popular RPC frameworks such as gRPC, Thrift, Dubbo and Spring Cloud, details gRPC’s architecture, Protocol Buffers serialization, HTTP/2 advantages, and provides a step‑by‑step Java demo with full source code and performance benchmarks.
This article explains how to start PHP's built‑in HTTP server for local testing, keep it running after the terminal closes by using nohup, and notes the default log file and production‑environment limitations.
This article explains the concept of multi‑tenant architecture, compares three data isolation strategies, and provides a complete MyBatis‑Plus configuration with code examples to automatically add tenant IDs, including how to filter specific SQL statements, helping developers build cost‑effective SaaS back‑ends.
This article explains the concept of idempotency, why it is needed for HTTP interfaces, the impact on system design, and presents several practical backend solutions—including database unique keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples using Redis for token management.
Time management in programming spans human concepts of time, language-specific handling of zones and timestamps, 32‑bit overflow risks, sync versus async processing, log timestamping, business‑level period calculations, and common pitfalls, emphasizing that mastering these nuances prevents bugs, improves performance, and enables reliable analytics.
Domain‑Driven Design (DDD) transforms traditional three‑tier development by introducing a unified domain model, clear bounded contexts, and tactical patterns like aggregates and value objects, enabling teams to separate business complexity from technical concerns, improve collaboration, and build more maintainable, adaptable software architectures.
This article walks through installing VSCode, adding Java‑related extensions, configuring Maven, importing a SpringBoot project, and using essential shortcuts and debugging features, demonstrating that VSCode can serve as a lightweight, open‑source alternative for Java development.
The article explains how Domain‑Driven Design combined with Onion Architecture creates a flexible, maintainable, and testable backend system by organizing code into concentric layers that isolate business logic from external concerns, supporting microservices, modular packaging, and appropriate testing strategies.
This article outlines the major new features of PHP 8 and PHP 7, explains why PHP 7 outperforms PHP 5, describes the execution flow, web‑request lifecycle, underlying architecture, data structures, garbage‑collection mechanism, and the PHP‑FPM master‑worker model with optimization tips.
This article explains three major pitfalls when using java.util.Arrays.asList: passing primitive arrays, attempting to modify the returned list, and misunderstanding that the list shares the original array, providing code examples and proper alternatives for each case.
This article walks through the evolution of software design from a traditional monolithic API server to a CQRS-based architecture, highlighting the drawbacks of the anemic CRUD model, the benefits of read/write separation, domain messaging, eventual consistency, and practical implementation considerations.
The article examines the difficulties encountered when implementing a Backend‑For‑Frontend (BFF) layer in the JD Finance app, introduces a visual service‑orchestration platform that replaces hard‑coded solutions with drag‑and‑drop workflows, details its core functions, architecture, and performance benefits, and demonstrates how it dramatically improves delivery speed, service governance, and debugging efficiency.
This article provides a detailed overview of Nginx, covering its role as a high‑performance web server and reverse proxy, explains installation steps, walks through core configuration files—including global, events, and http blocks—and demonstrates practical setups for reverse proxy, load balancing, static‑dynamic separation, performance tuning, and high‑availability clustering.
The article outlines common problems in API integration and presents a comprehensive set of design principles—such as sufficiency, single responsibility, simplicity, abstraction, compatibility, low coupling, orthogonality, testability, and uniformity—to help engineers create clear, maintainable, and developer‑friendly backend APIs.
This free public roadmap guides beginners through essential front‑end fundamentals, rapid PHP onboarding, and optional advanced topics, providing curated course titles and direct links to help learners quickly master web development with PHP.
This article explains the Chain of Responsibility design pattern in Java, illustrating its use for multi‑level approval workflows during high‑traffic events, provides step‑by‑step code implementations, refactors naive IF logic into modular link classes, and demonstrates testing, highlighting benefits for clean, extensible backend architecture.
This article explains how Domain‑Driven Design combined with the Onion Architecture creates a flexible, maintainable backend by separating concerns into concentric layers, detailing principles, services, testing strategies, microservice applicability, and modular packaging to help developers build scalable, technology‑agnostic systems.
This article introduces Java's Stream API, explaining how filter, map, flatMap, and other intermediate operations work, provides practical code examples for each, and demonstrates stream creation, conversion, and parallel processing to efficiently handle collections and large data sets.
This article explains the concept and execution methods of rule engines, describes the forward‑link inference approach used by ZhiZhuan’s risk‑control engine, and details the evolution from hard‑coded rules to feature‑engineered expressions using the Aviator expression engine, highlighting configuration, data sources, and practical examples.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, and disadvantages for building scalable, high-performance systems.
This guide details nine practical techniques for accessing files in a Java project's resources folder, covering classloader paths, URL decoding, getFile vs getPath, InputStream retrieval, ClassPathResource usage, absolute paths, and environment variable methods, with complete code examples for each approach.
This article explains how to start a new project using Domain‑Driven Design, introduces key terminology such as IAAS/PAAS/SAAS, describes the evolution of architecture through bounded contexts, and details the four DDD boundaries together with clean layered, hexagonal and onion architectures for building scalable backend systems.
This article explains how a Java compiler‑time AST injection component replaces manual monitoring instrumentation with a simple @UMP annotation, detailing the technology selection, implementation using JSR‑269 annotation processors, and the trade‑offs of compile‑time versus runtime weaving.
Meta has officially added Rust, Hack, Python, and C++ as its preferred backend languages, outlining strict criteria such as core library support, security, operational risk, expertise, and developer experience, while also noting community‑supported languages and its long‑term commitment to Rust amid broader VR ambitions.
This article explains how interview candidates can demonstrate mastery of MQ reliability by describing the three message lifecycle stages, detection mechanisms for loss, idempotent consumption techniques, and strategies to resolve backlog, providing concrete examples and design principles for robust backend systems.
This article explains the concept, scenarios, advantages, and implementation details of Apache RocketMQ's timed/delay messages, including the TimerWheel algorithm, service workflow, a financial payment‑timeout use case, and practical steps for creating and consuming timed messages.
This article presents a detailed survey of over thirty Python web frameworks, describing their official sites, main features, advantages, and drawbacks, and offers guidance on selecting popular options such as Django, Flask, FastAPI, and many others for various development needs.
This article provides a detailed overview of the major features introduced in PHP versions 5 through 8, including autoloading, PDO, MySQLi, namespaces, traits, built‑in server, scalar type declarations, nullable types, JIT compilation, named arguments, union types, match expressions, and many useful code examples.
This article provides a comprehensive analysis of MyBatis, covering its core architecture, the process of obtaining SqlSessionFactory and SqlSession, the dynamic proxy mechanism for mappers, the execution flow of SQL statements, the plugin system, first‑ and second‑level caching strategies, and how Spring manages MyBatis mappers through factory beans and import registrars.
This article explains the principles behind Spring Boot Starters, how auto‑configuration works via META‑INF/spring.factories, provides practical code examples, and lists the most common starters to help Java developers streamline dependency management and reduce configuration complexity.
This tutorial explains how to create a Dockerfile for a PHP‑Apache project, build the image, run the container, verify its status, and use volume mounting and exec commands to manage the application inside the container.
The talk traces the evolution of API Gateway architectures and the engineering practices—design patterns, deployment strategies, and operational considerations—required for scalable, reliable services, then demonstrates how ClickHouse can be leveraged for massive data workloads, highlighting practical scenarios, performance optimizations, and key lessons learned.
This article explains the principle of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then delves into distributed rate‑limiting dimensions, common algorithms like token‑bucket and leaky‑bucket, and concrete implementations using Guava, Nginx, Redis and Lua with full code examples.
This article introduces XEChat‑Idea, a Netty‑based instant messaging and game‑battle plugin for IntelliJ IDEA, detailing its project structure, required development environment, and step‑by‑step instructions for building, running, and deploying both the server and the IDEA plugin.
The July VS Code Java update introduces built‑in Lombok support, notification‑driven activation, language‑bar version management, toggleable settings, drag‑and‑drop file operations, inlay hint exclusions, function‑breakpoint debugging, expanded quick‑fix actions, and a Spring bean dependency view, all aimed at improving the Java developer experience.
This article explains how to create a lightweight, plug‑in‑style microservice flow orchestration system using Docker‑installed Nacos for configuration, three SpringBoot services with Kafka integration, and dynamic topic management to enable hot‑swapable data pipelines without heavy frameworks.
This article provides a comprehensive overview of Spring Cloud’s microservice architecture, detailing core components such as Eureka, Zuul, Ribbon, Hystrix, Feign, and Config, comparing registration centers like Nacos, ZooKeeper, Consul, and Etcd, and discussing best practices for service discovery and API gateway design.
The article presents a comprehensive overview of JD Daojia's Open Platform, detailing its service lifecycle—from platform introduction, service design, publishing, and authorization to state management and traffic‑control mechanisms—while explaining the underlying RPC‑based architecture and fixed‑window rate‑limiting algorithm.
This article provides a comprehensive guide to Spring Batch, covering its purpose, architecture, core components such as Job, Step, ItemReader/Writer/Processor, chunk processing, skip strategies, common pitfalls, and practical configuration examples for robust batch applications.
This article introduces Spring Batch as a lightweight, comprehensive batch‑processing framework for enterprise applications, explains its overall architecture, and details core concepts such as Job, JobInstance, JobParameters, JobExecution, Step, StepExecution, ExecutionContext, JobRepository, JobLauncher, ItemReader, ItemWriter, ItemProcessor, chunk processing, skip/failure handling, best‑practice guidelines, and common troubleshooting tips.
This article introduces EasyFunction, JD's serverless FaaS platform built on iPaaS, detailing its background, applicable scenarios such as BFF, data processing, SSR and admin panels, the business benefits, core product features, and several real‑world deployment cases.
Monet is a custom API gateway built on Spring Cloud Gateway that consolidates multiple platform endpoints into a single domain, providing unified routing, API management via Zookeeper, authentication and authorization, dynamic rate‑limiting with Sentinel, and extensible monitoring, addressing scalability and operational challenges of the Linglong platform.
This guide walks through obtaining a free SSL certificate, exporting it from the provider, and configuring a Spring Boot application to use the certificate, including detailed steps, screenshots, and the necessary server.yml configuration.
The article explains how marketing automation platforms adopt industrial‑grade workflow engines to streamline complex user‑journey processes, outlines sequential, state‑machine and rule‑driven engine types, describes a self‑developed engine’s core modules and service interfaces, and highlights performance, versioning, plugin and monitoring considerations.
This article demonstrates how to implement a flexible data‑masking solution for sensitive fields in Spring Boot APIs by defining a custom annotation, creating a serializer, integrating it with Jackson via an AnnotationIntrospector, configuring the ObjectMapper, and applying the annotation to domain objects.
PHP 8.2 expands the language’s strong‑typing capabilities by introducing two new standalone types, null and false, which can now be used independently in type declarations, a feature previously unavailable and now available after the RFC’s acceptance and merge into the master branch.
The article explains that overriding ThreadPoolExecutor's beforeExecute and afterExecute hooks requires handling any exceptions internally, because uncaught exceptions cause the worker thread to terminate, reducing pool size and preventing proper reuse, and such errors are not logged by default.
This tutorial explains how to install and use the GsonFormat IntelliJ plugin to automatically generate JavaBean classes from JSON strings, dramatically reducing repetitive getter/setter code and improving backend development efficiency.
This article explains essential Java exception‑handling techniques, including cleaning resources in finally blocks or using try‑with‑resources, declaring specific exceptions, documenting throws clauses, providing descriptive messages, catching the most specific exceptions first, avoiding catching Throwable, not ignoring exceptions, and correctly wrapping exceptions without losing original causes.
In this interview, Apache Dubbo Committer and GSoC mentor Niu Xuewei shares his open‑source journey, contributions to Dubbo‑go and Kata Containers, experiences as a community contributor and mentor, and offers practical advice on code quality, time management, and the benefits of open‑source participation for students.
This article explains how Baidu Intelligent Cloud’s low‑code platform “AiSuDa” enables developers to create API orchestration flows, integrate Function‑as‑a‑Service nodes, and connect directly to external or built‑in databases, providing a no‑code alternative to traditional backend development for data‑driven applications.
This article explains why a Spring Boot application can end up with two UserManager beans—one from @Configuration + @Bean and another from @Component—by analyzing bean definition overriding, the role of ConfigurationClassPostProcessor, and the impact of the allowBeanDefinitionOverriding setting across Spring versions.
This article introduces CodeSmith, a template‑driven code generation tool, explains why code generators improve efficiency and consistency, demonstrates how to write and reuse templates—including Java bean generation and data‑type conversion—and shares practical tips for automating model, SQL, and UI code creation.
This article explains Netty’s multithreaded Reactor architecture, introduces the underlying concepts such as Channel, ChannelPipeline, and EventLoop, shows how threads are allocated to ChannelHandlers, and demonstrates how to customize thread pools for customer‑service and agent‑side logic in an IM system.
This article explains Nginx's network design, showing how the master process only creates and binds listening sockets while worker processes each create an epoll instance, register events, and handle accept, read, and write operations, illustrating the complete flow from code snippets to multi‑process coordination.
This article explains the Java constant pool concept, details how the String constant pool works in different JDK versions, demonstrates the effects of String.intern() with code examples, and discusses practical applications and pitfalls of using intern for memory optimization and synchronization.
This post shares a concise diagram that clearly illustrates the compatibility relationship between various Spring Framework releases and the corresponding Java versions, helping developers quickly determine which Java version to use with each Spring version.
xxl-job uses Netty HTTP for communication, employing dynamic proxy patterns, full asynchronous processing, and thread‑blocking mechanisms to efficiently dispatch tasks from the scheduler to executors, with detailed code examples illustrating request IDs, future responses, and synchronized result retrieval.
Deno recently secured $21 million in funding, and its creator Ryan Dahl argues that the future of scripting lies in browser‑compatible JavaScript, proposing a new container abstraction that simplifies server development by aligning web services with JavaScript rather than traditional Linux containers.
This article compares AspectJ and Spring AOP, explains the four types of Spring AOP support, details classic Spring AOP proxy creation, demonstrates various advice implementations, shows XML and annotation configurations, and introduces auto‑proxy creators for simplifying AOP setup in Java backend development.
This article explains Twitter's open‑source Snowflake distributed ID generation algorithm, detailing its bit‑field structure, common pitfalls such as clock rollback and JavaScript precision limits, and practical mitigation strategies for high‑concurrency, sharding, and sequence handling.
This article introduces a custom BeanConvertUtils class that extends BeanUtils to provide concise, lambda‑friendly conversion of single objects and lists between PO, VO, and DTO types, while highlighting BeanUtils limitations, performance impact, and important usage cautions.
This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, alongside tactical guidelines for high concurrency, high availability, and business design, and illustrates the concepts with logical and physical architecture diagrams.
Git 2.37, released last week, introduces short‑hand aliases for version and help commands, generates external diff temporary files in a dedicated subdirectory, rewrites the interactive add feature in C, begins transport and pack refactoring, and delivers multiple performance improvements and bug fixes.
Since 2016, the author shares a collection of Spring Boot best practices—including using custom BOMs, leveraging auto‑configuration and starters, employing Spring Initializr, structuring code, designing services, managing databases, handling concurrency, externalizing configuration, global exception handling, logging, and thorough testing—to help developers build robust, maintainable microservices.
This article explains the Eureka heartbeat mechanism in microservice architectures, covering who sends the heartbeat, its scheduling interval, the request construction, server-side handling, and how the lease information is updated to determine service liveness.
This article provides a thorough, step‑by‑step exploration of Go 1.18 generics, explaining what generics are, their advantages and drawbacks, how Go implements them compared with other languages, and offering detailed examples of generic variables, functions, methods, interfaces, type constraints, and best‑practice patterns for developers.
This article presents a detailed collection of Spring Boot best practices—from custom BOM dependency management and automatic configuration to project initialization, code structure, logging, testing, and configuration externalization—providing actionable guidance for building robust, maintainable micro‑services in Java.
This article explains how to use MyBatis dynamic SQL tags—including if, where, set, choose, foreach, sql fragments, and bind—to build flexible queries and updates, with detailed code examples and tips for handling null parameters and avoiding syntax errors.
This article explains how to override Spring Security OAuth2's default /oauth/token endpoint to return a unified response structure by redefining the TokenEndpoint and optionally the CheckTokenEndpoint, providing complete Java code examples and implementation details.
This guide demonstrates how to construct flexible MyBatis dynamic SQL statements using tags such as if, where, set, choose, foreach, sql fragments, and bind, showing practical examples for conditional queries, updates, and reusable SQL components to streamline backend data access.
This article explains the principles and implementations of Java's built‑in SPI, Dubbo's enhanced SPI, and Spring's SPI mechanisms, compares their designs, walks through concrete code examples, and shows how they can be applied for dynamic extension in real projects.
This article explains the fundamental distinctions between RPC and HTTP services, covering OSI network layers, the core components of RPC architecture, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and a comparison with RESTful HTTP services.
This tutorial walks through creating a live dashboard by generating simulated user‑score events, storing them in Redpanda, materializing the data with Materialize, streaming updates via a Deno WebSocket backend, and visualizing the results in real time with Chart.js on the frontend.
Go 1.19, slated for an August 2022 release, brings minor language tweaks, a revised memory model aligned with major languages, new LoongArch support, Unix build constraints, runtime soft memory limits, compiler and assembler enhancements, and an updated ELF linker format.
