BestHub
Sign in
Tagged articles
4050 articles
Page 28 of 41
FunTester
FunTester
Sep 2, 2021 · Backend Development

How to Build a Robust Redis Connection Pool Wrapper in Java for Performance Testing

This article walks through creating a reusable Redis connection‑pool manager and a functional wrapper class in Java, explaining pooling concepts, resource recycling, and providing ready‑to‑use methods for common Redis commands to support efficient performance testing with the FunTester framework.

Connection PoolPerformance Testingbackend-development
0 likes · 18 min read
How to Build a Robust Redis Connection Pool Wrapper in Java for Performance Testing
Programmer DD
Programmer DD
Sep 2, 2021 · Backend Development

Unlocking Spring: 9 Essential Design Patterns Every Backend Developer Should Know

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, core principles, key Spring interfaces, and code examples for each pattern.

backend-developmentdependency-injectionjava
0 likes · 16 min read
Unlocking Spring: 9 Essential Design Patterns Every Backend Developer Should Know
MaGe Linux Operations
MaGe Linux Operations
Aug 31, 2021 · Backend Development

What’s New in Linux Kernel 5.14? Key Features and Hardware Support

Linux kernel 5.14 has been promoted to stable, bringing extensive hardware support, core scheduler enhancements, new graphics drivers, expanded ARM and RISC‑V capabilities, and numerous updates for laptops, servers and peripherals, offering developers a richer, more secure platform for modern workloads.

Hardware SupportKernel 5.14Operating System
0 likes · 5 min read
What’s New in Linux Kernel 5.14? Key Features and Hardware Support
Programmer DD
Programmer DD
Aug 28, 2021 · Backend Development

Master the Updated Spring Boot Swagger Starter with Pure Configuration

This article explains the history, recent updates, and step‑by‑step usage of the Spring Boot Swagger starter, including dependency setup, detailed configuration options, grouping, JSR‑303 validation support, custom response messages, UI tweaks, ignored parameter types, and authorization settings.

API documentationConfigurationSpring Boot
0 likes · 17 min read
Master the Updated Spring Boot Swagger Starter with Pure Configuration
Top Architect
Top Architect
Aug 27, 2021 · Backend Development

Injecting List, Array, Set, and Map Values in Spring Using @Value and EL Expressions

This article explains how to configure and inject List, Map, Set, and array values in Spring applications using @Value annotations, EL expression split functions, default values, and custom parsing methods, providing practical code examples and discussing the advantages and limitations of each approach.

EL ExpressionsValue Annotationbackend-development
0 likes · 9 min read
Injecting List, Array, Set, and Map Values in Spring Using @Value and EL Expressions
Ops Development Stories
Ops Development Stories
Aug 26, 2021 · Backend Development

Master Real-Time Communication: Build WebSocket Apps in Go

This guide explains how WebSockets enable full‑duplex communication over a single TCP connection, compares popular Go WebSocket libraries, and provides complete client‑server code examples for TCP, UDP, and HTTP‑based WebSocket implementations, helping developers build real‑time applications such as chat, games, and monitoring tools.

GoGorillaNetwork programming
0 likes · 22 min read
Master Real-Time Communication: Build WebSocket Apps in Go
Laravel Tech Community
Laravel Tech Community
Aug 25, 2021 · Backend Development

Implementing Dependency Injection in PHP Using Reflection

This article explains how to build a simple PHP IoC container with reflection to automatically resolve constructor and method dependencies, demonstrates its use with example classes A, B, and C, and shows how to invoke methods with injected parameters.

Design PatternsPHPReflection
0 likes · 5 min read
Implementing Dependency Injection in PHP Using Reflection
Xianyu Technology
Xianyu Technology
Aug 25, 2021 · Backend Development

Designing an Extensible User Identity and Benefits System: Xianyu App Case Study

The article presents a case study of Xianyu’s extensible user identity and benefits system, explaining how tiered identities grant differentiated product permissions and signal user influence, while detailing an authentication service with three extension points for condition judgment, validation, and audit handling, enabling flexible integration and unified state management.

System DesignXianyuauthentication service
0 likes · 7 min read
Designing an Extensible User Identity and Benefits System: Xianyu App Case Study
Java Backend Technology
Java Backend Technology
Aug 24, 2021 · Backend Development

Is Lombok a Blessing or a Curse? Uncovering Hidden Pitfalls in Java Development

This article examines the advantages and hidden risks of using Lombok in Java projects, illustrating how its annotations can dramatically reduce boilerplate code while also introducing version compatibility issues, forced dependencies, reduced readability, increased coupling, and technical debt, and suggests alternative approaches for cleaner code.

LombokSpring BootTechnical Debt
0 likes · 11 min read
Is Lombok a Blessing or a Curse? Uncovering Hidden Pitfalls in Java Development
Top Architect
Top Architect
Aug 21, 2021 · Fundamentals

Comprehensive Guide to Java Collections Framework: Lists, Sets, Queues, Maps and Their Implementations

This article provides an in-depth overview of Java's Collections Framework, detailing the structure, usage, and source code of core interfaces like List, Set, Queue, and Map, and their key implementations such as ArrayList, LinkedList, HashSet, TreeSet, PriorityQueue, ArrayDeque, HashMap, and Hashtable, while highlighting performance characteristics and thread-safety considerations.

CollectionsData Structuresbackend-development
0 likes · 39 min read
Comprehensive Guide to Java Collections Framework: Lists, Sets, Queues, Maps and Their Implementations
Top Architect
Top Architect
Aug 21, 2021 · Backend Development

RabbitMQ vs Kafka: Architectural Comparison and Performance Considerations

This article compares RabbitMQ and Kafka by explaining their architectures, queue consumption and production mechanisms, highlighting RabbitMQ's single‑master limitation and Kafka's partition‑based design for higher throughput, and provides guidance on selecting the appropriate middleware based on performance needs.

KafkaMessage QueueRabbitMQ
0 likes · 7 min read
RabbitMQ vs Kafka: Architectural Comparison and Performance Considerations
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Aug 20, 2021 · Backend Development

Design and Implementation of a Pricing Calculation Engine for E-commerce Promotions

The article details the design and implementation of a dedicated pricing calculation engine that decouples complex e‑commerce promotion logic from transaction services, using componentized rules, configurable pipelines, multi‑level caching, and lane‑based simulations to achieve high extensibility, low latency, and accurate pricing across browsing and checkout scenarios.

Configurationbackend-developmentpricing engine
0 likes · 9 min read
Design and Implementation of a Pricing Calculation Engine for E-commerce Promotions
Code Ape Tech Column
Code Ape Tech Column
Aug 20, 2021 · Backend Development

Build Restful File Upload & Download APIs with Spring Boot 2.2.6

This step‑by‑step tutorial explains how to create Restful file upload and download APIs using Spring Boot 2.2.6, covering environment setup, project structure, interface and implementation details, size‑limit configuration, global exception handling, and testing the endpoints with Postman.

REST APISpring Bootbackend-development
0 likes · 11 min read
Build Restful File Upload & Download APIs with Spring Boot 2.2.6
Top Architect
Top Architect
Aug 19, 2021 · Backend Development

Understanding Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot's auto‑configuration works by loading configuration classes from spring.factories, using @EnableAutoConfiguration and conditional annotations to bind properties from application.properties or application.yml to beans such as ServerProperties, enabling rapid backend development without extensive manual setup.

ConfigurationPropertiesSpring Bootauto-configuration
0 likes · 8 min read
Understanding Spring Boot Auto‑Configuration Mechanism
vivo Internet Technology
vivo Internet Technology
Aug 18, 2021 · Backend Development

Design and Implementation of Vivo Mall Promotion Pricing Engine

The article details Vivo Mall’s new promotion pricing engine, which replaces duplicated site‑level logic with a layered model (product, shop, platform) that supports configurable stacking, processes discounts through three calculation stages, and uses a meta‑driven rule engine to flexibly interpret JSON promotion templates, ensuring extensible, stable pricing functionality.

backend-developmentdiscount modele‑commerce
0 likes · 12 min read
Design and Implementation of Vivo Mall Promotion Pricing Engine
Tencent Cloud Developer
Tencent Cloud Developer
Aug 17, 2021 · Backend Development

Design and Implementation of a Calculation DSL and Engine

The article presents a domain‑specific language that mimics Excel formulas, a stack‑based parser and recursive engine for evaluating calculations, and a multi‑layer architecture—including a dynamic priority scheduler—to efficiently resolve field dependencies, improve maintainability, and enable monitoring across large data systems.

Calculation EngineDSLbackend-development
0 likes · 11 min read
Design and Implementation of a Calculation DSL and Engine
Top Architect
Top Architect
Aug 17, 2021 · Backend Development

Introduction to Message Queues, JMS, RabbitMQ, and Kafka

This article explains the fundamentals of message queues, compares point-to-point and publish‑subscribe models, introduces Java Message Service (JMS) and its programming model, and provides an overview of popular MQ implementations such as RabbitMQ, ActiveMQ, RocketMQ, and Kafka, highlighting their architectures and use cases.

AMQPJMSKafka
0 likes · 17 min read
Introduction to Message Queues, JMS, RabbitMQ, and Kafka
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 16, 2021 · Backend Development

Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations

This article explains Spring's pointcut implementations, covering static and dynamic pointcuts, regular‑expression based pointcuts, the RegexpMethodPointcutAdvisor, control‑flow pointcuts, and how to create custom pointcuts by subclassing Spring’s abstract pointcut classes, with full XML and Java code examples.

Pointcutaopbackend-development
0 likes · 9 min read
Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations
Java Interview Crash Guide
Java Interview Crash Guide
Aug 16, 2021 · Backend Development

When to Update Redis Cache: DB‑First vs Cache‑First Strategies Explained

This article examines the consistency challenges of using Redis as a cache, compares three update strategies—updating the database before the cache, deleting the cache before updating the database, and updating the database then deleting the cache—analyzes their pitfalls, and presents practical solutions such as delayed double‑delete, asynchronous retries, and binlog‑driven cache invalidation.

Cache Consistencybackend-developmentcache-aside
0 likes · 17 min read
When to Update Redis Cache: DB‑First vs Cache‑First Strategies Explained
Top Architect
Top Architect
Aug 15, 2021 · Backend Development

Choosing and Implementing Distributed Cache Systems with Redis

This article reviews various cache system types, compares popular distributed caches such as Memcache, Tair, and Redis, explains Redis cluster high‑availability mechanisms, discusses sharding strategies, and outlines common cache problems and solutions, providing practical configuration examples for Java backend developers.

Cache StrategiesClusterbackend-development
0 likes · 12 min read
Choosing and Implementing Distributed Cache Systems with Redis
Architecture Digest
Architecture Digest
Aug 14, 2021 · Backend Development

Solving Duplicate Order Number Issues in High-Concurrency Java Applications

After encountering duplicate order IDs during a system upgrade, the author analyzes the shortcomings of the original timestamp-and-random-based generator, demonstrates concurrency tests revealing collisions, and presents a revised Java implementation using atomic counters, shortened timestamps, and IP suffixes to reliably produce unique order numbers even under high load.

AtomicIntegerbackend-developmentjava
0 likes · 9 min read
Solving Duplicate Order Number Issues in High-Concurrency Java Applications
Java Tech Enthusiast
Java Tech Enthusiast
Aug 13, 2021 · Backend Development

Handling Request Parameters in Spring MVC

Spring MVC lets developers retrieve request data using the raw HttpServletRequest, or more conveniently with annotations such as @RequestParam, @RequestHeader, @RequestBody, and @CookieValue, supports automatic binding to POJOs including nested objects, injects native Servlet objects like HttpSession, and handles character encoding via CharacterEncodingFilter.

Request ParametersSpring MVCannotations
0 likes · 9 min read
Handling Request Parameters in Spring MVC
Top Architect
Top Architect
Aug 13, 2021 · Backend Development

Implementing Student Score Statistics with Fluent MyBatis, MyBatis, and MyBatis‑Plus

This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to query a student_score table for term‑wise statistics of English, Math, and Chinese scores, providing complete code examples, SQL statements, mapper definitions, and code‑generation configurations for each approach.

Fluent MyBatisMyBatisbackend-development
0 likes · 9 min read
Implementing Student Score Statistics with Fluent MyBatis, MyBatis, and MyBatis‑Plus
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 13, 2021 · Backend Development

How Hystrix Stops Service Avalanches: A Hands‑On Guide with Code

This article explains the avalanche effect caused by synchronous service calls, lists common scenarios, and demonstrates how to use Netflix Hystrix—through thread isolation, circuit breakers, and fallback methods—to protect backend services from cascading failures, complete with practical Java examples.

HystrixMicroservicesService Resilience
0 likes · 11 min read
How Hystrix Stops Service Avalanches: A Hands‑On Guide with Code
Taobao Frontend Technology
Taobao Frontend Technology
Aug 12, 2021 · Backend Development

Midway 2.0 Unveiled: Key Features and Performance Boosts for Node.js Developers

Midway 2.0 introduces a runtime‑based Hook system, removes compiler constraints, enables faster startup under 2 seconds, supports code reuse, new middleware models, flexible configuration via midway.config.ts, enhanced testing utilities, and broader deployment scenarios including web servers, all backed by open‑source Vite and Prisma integrations.

ConfigurationMidwayNode.js
0 likes · 12 min read
Midway 2.0 Unveiled: Key Features and Performance Boosts for Node.js Developers
Open Source Linux
Open Source Linux
Aug 11, 2021 · Backend Development

Boost Web Performance with OpenResty: Caching, Compression, and Dynamic Updates

This article explains how to use OpenResty with Lua to build a high‑performance caching layer that directly accesses Redis, compresses large responses, schedules periodic updates, forwards requests intelligently, and provides configurable URL caching, thereby improving concurrency, reducing latency, and optimizing bandwidth usage.

LuaOpenRestybackend-development
0 likes · 6 min read
Boost Web Performance with OpenResty: Caching, Compression, and Dynamic Updates
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 10, 2021 · Backend Development

How Spring Cloud RefreshScope Works: From Annotation to Runtime Refresh

This article explains the inner workings of Spring Cloud's RefreshScope, covering its annotation definition, registration in the auto‑configuration, the refresh endpoint workflow, event handling, and how beans annotated with @ConfigurationProperties or @RefreshScope are dynamically refreshed at runtime.

@RefreshScopeConfiguration RefreshSpring Boot
0 likes · 10 min read
How Spring Cloud RefreshScope Works: From Annotation to Runtime Refresh
dbaplus Community
dbaplus Community
Aug 9, 2021 · Backend Development

Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons

This article explains the fundamentals of Domain‑Driven Design (DDD), outlines its strategic and tactical design processes, and demonstrates how Haro’s transaction platform applies DDD across taxi, e‑commerce, and core trading scenarios, highlighting benefits, challenges, and practical recommendations.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 29 min read
Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons
Top Architect
Top Architect
Aug 8, 2021 · Backend Development

My First Java Web Project: From Planning to Deployment – A Full‑Stack Journey

This article recounts the author’s experience building a simple Java web application for a university anniversary, covering planning, environment setup, documentation, database design, coding challenges with Spring Boot, Redis, and session handling, deployment on Alibaba Cloud, and the lessons learned about architecture, logging, and monitoring.

DeploymentProject ManagementSpring Boot
0 likes · 10 min read
My First Java Web Project: From Planning to Deployment – A Full‑Stack Journey
Programmer DD
Programmer DD
Aug 7, 2021 · Backend Development

Master Spring Validation: Advanced Techniques, Group & Nested Validation in Spring Boot

This comprehensive guide dives deep into Spring Validation, covering basic usage, dependency setup, requestBody and requestParam validation, group and nested validation, custom constraints, fail‑fast mode, and the underlying implementation in Spring MVC and AOP, all with practical code examples.

Hibernate ValidatorSpring BootSpring Validation
0 likes · 19 min read
Master Spring Validation: Advanced Techniques, Group & Nested Validation in Spring Boot
Top Architect
Top Architect
Aug 7, 2021 · Backend Development

Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow

The article explains why multithreading is essential for modern CPUs, introduces thread pools to reduce overhead, and details Java's ThreadPoolExecutor creation parameters, execution process, and core methods such as addWorker, runWorker, and getTask, using JDK 1.8 source code examples.

ThreadPoolExecutorbackend-developmentconcurrency
0 likes · 7 min read
Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow
Top Architect
Top Architect
Aug 7, 2021 · Backend Development

Redis Practical Use Cases: Caching, Distributed Locks, Global IDs, Counters, Rate Limiting, Bitmaps, Shopping Cart, Timeline, Message Queue, and More

This article presents a comprehensive guide to using Redis for various backend scenarios, including caching hot data, sharing sessions, implementing distributed locks, generating global IDs, counting, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking, all illustrated with concrete code examples.

BitmapsMessage Queuebackend-development
0 likes · 8 min read
Redis Practical Use Cases: Caching, Distributed Locks, Global IDs, Counters, Rate Limiting, Bitmaps, Shopping Cart, Timeline, Message Queue, and More
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 5, 2021 · Backend Development

Master Spring Security: Step‑by‑Step Authentication Flow in Spring Boot

This article walks through the Spring Security authentication flow in a Spring Boot 2.2.11 application, detailing filter execution, token creation, provider selection, custom DaoAuthenticationProvider configuration, and session management, complemented by code snippets and diagrams for each step.

AuthenticationSession ManagementSpring Boot
0 likes · 8 min read
Master Spring Security: Step‑by‑Step Authentication Flow in Spring Boot
Top Architect
Top Architect
Aug 4, 2021 · Backend Development

Comparing API Architectural Styles: RPC, SOAP, REST, and GraphQL

This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—explaining how each works, outlining their advantages and disadvantages, and providing guidance on selecting the most suitable style for different project requirements.

APIGraphQLRPC
0 likes · 19 min read
Comparing API Architectural Styles: RPC, SOAP, REST, and GraphQL
Java High-Performance Architecture
Java High-Performance Architecture
Aug 4, 2021 · Backend Development

Top 10 Common Spring Framework Mistakes and How to Fix Them

This article outlines the ten most frequent errors developers make when using the Spring framework—ranging from over‑focusing on low‑level details to neglecting proper testing—and provides concrete best‑practice solutions with code examples to improve code quality, maintainability, and reliability.

backend-developmentjavaspring
0 likes · 17 min read
Top 10 Common Spring Framework Mistakes and How to Fix Them
macrozheng
macrozheng
Aug 4, 2021 · Backend Development

Master Global Exception Handling in Spring Boot with @ControllerAdvice

This article explains how to use Spring Boot's @ControllerAdvice and @ExceptionHandler annotations to implement clean, global exception handling, covering basic usage, controller‑specific handlers, and ordered advice for multiple handlers, with practical code examples and diagrams.

ControllerAdviceException HandlingSpring Boot
0 likes · 7 min read
Master Global Exception Handling in Spring Boot with @ControllerAdvice
Programmer DD
Programmer DD
Aug 4, 2021 · Backend Development

Boost Java Productivity with Essential Utility Libraries

This article introduces essential Java utility libraries—including built‑in methods, Apache Commons, and Google Guava—showing practical code snippets and Maven dependencies that help developers reduce boilerplate, improve readability, and boost productivity across backend projects.

Apache CommonsGoogle GuavaUtility Libraries
0 likes · 13 min read
Boost Java Productivity with Essential Utility Libraries
Tencent Cloud Developer
Tencent Cloud Developer
Aug 3, 2021 · Backend Development

Overview of Java Garbage Collection Algorithms and Memory Management

The article explains Java’s automatic memory management, detailing JVM memory regions, object liveness via reachability analysis, allocation strategies, and the main garbage‑collection algorithms—Mark‑Sweep, Mark‑Copy, Mark‑Compact—and compares HotSpot collectors such as Serial, Parallel, CMS and G1, guiding developers to choose the best fit for their workloads.

GC AlgorithmsGarbage CollectionJVM
0 likes · 16 min read
Overview of Java Garbage Collection Algorithms and Memory Management
IT Architects Alliance
IT Architects Alliance
Aug 1, 2021 · Backend Development

Design and Architecture of a Cloud Shopping Cart System

This article explains the design and architecture of a cloud-based shopping cart system, covering its functional modules, layered and cluster designs, distributed goals such as stability and elasticity, three-level caching, asynchronous checks, heterogeneous storage, payment solutions, and anti‑scalping measures.

Distributed SystemsPayment IntegrationShopping Cart
0 likes · 5 min read
Design and Architecture of a Cloud Shopping Cart System
21CTO
21CTO
Aug 1, 2021 · Backend Development

What Does It Take to Become a Great Software Architect? Key Skills and Practices

This article outlines the career path toward software architecture, detailing the market expectations, essential competencies such as project management, technical depth, business insight, communication, decision‑making, and optimization techniques for systems, backend services, and databases, while emphasizing continuous learning and community involvement.

Software ArchitectureSystem Designbackend-development
0 likes · 17 min read
What Does It Take to Become a Great Software Architect? Key Skills and Practices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 1, 2021 · Backend Development

Designing a Scalable Cloud Shopping Cart: Architecture, Caching, and Payment Strategies

This article details the design and architecture of a cloud‑based shopping cart system, covering its functional modules, layered and cluster designs, technical goals such as stability and elasticity, three‑level caching, asynchronous checks, storage heterogeneity, and payment‑processing solutions.

Shopping CartSystem Designbackend-development
0 likes · 4 min read
Designing a Scalable Cloud Shopping Cart: Architecture, Caching, and Payment Strategies
Top Architect
Top Architect
Jul 30, 2021 · Backend Development

Integrating Alipay’s New Transfer API with Spring Boot (Java)

This guide explains how to replace the old Alipay transfer interface with the new certificate‑based alipay.fund.trans.uni.transfer API, upgrade the SDK, configure certificates, add Maven dependencies, and implement Spring‑Boot beans and utility classes for secure payment and transfer operations.

APIPayment IntegrationSpring Boot
0 likes · 10 min read
Integrating Alipay’s New Transfer API with Spring Boot (Java)
360 Tech Engineering
360 Tech Engineering
Jul 29, 2021 · Backend Development

Understanding HTTP/2: History, Features, and Protocol Mechanics

HTTP/2, now widely supported by browsers and major sites, replaces HTTP/1.1 by introducing a binary framing layer, header compression, stream prioritization, server push, and flow control, addressing head-of-line blocking and inefficiencies while maintaining HTTP semantics, with detailed discussion of its evolution, structure, and deployment considerations.

HTTP/2Header Compressionbackend-development
0 likes · 22 min read
Understanding HTTP/2: History, Features, and Protocol Mechanics
Su San Talks Tech
Su San Talks Tech
Jul 29, 2021 · Backend Development

How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips

Designing a flash‑sale (秒杀) system for massive concurrent users requires careful handling of instant traffic spikes, page staticization, CDN acceleration, caching strategies, distributed locks, rate limiting, asynchronous processing, and reliable stock management, with nine detailed techniques to ensure stability and prevent overselling.

backend-developmentcachingdistributed-lock
0 likes · 26 min read
How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips
Selected Java Interview Questions
Selected Java Interview Questions
Jul 28, 2021 · Backend Development

Four Ways to Implement a Generic Auth Whitelist in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter

This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—to implement a reusable appkey whitelist validation, provides complete code examples for each, and clarifies their execution order within the request processing pipeline.

ArgumentResolverInterceptorSpring Boot
0 likes · 10 min read
Four Ways to Implement a Generic Auth Whitelist in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter
macrozheng
macrozheng
Jul 28, 2021 · Backend Development

Master Spring Batch: Core Concepts, Architecture, and Best Practices

This article provides a comprehensive overview of Spring Batch, covering its purpose, architecture, core components such as Job, Step, ItemReader/Writer/Processor, execution contexts, chunk processing, skip strategies, and practical tips for configuration and memory management.

Batch ProcessingChunk ProcessingJob Scheduling
0 likes · 20 min read
Master Spring Batch: Core Concepts, Architecture, and Best Practices
IT Architects Alliance
IT Architects Alliance
Jul 27, 2021 · Backend Development

Unlock Scalable Microservices: Master the AKF Design Cube

This article explains the AKF scalability cube for microservice architecture, detailing the Y‑axis functional decomposition, X‑axis horizontal scaling, Z‑axis data partitioning, as well as front‑end/back‑end separation, stateless services, and RESTful communication, providing practical diagrams and guidance for building robust, scalable systems.

Data PartitioningMicroservicesRESTful
0 likes · 9 min read
Unlock Scalable Microservices: Master the AKF Design Cube
Senior Brother's Insights
Senior Brother's Insights
Jul 27, 2021 · Fundamentals

Mastering the Proxy Pattern: A Hands‑On Guide with Nacos Client

This article explains the proxy design pattern, demonstrates its static implementation with Java code, and shows how Nacos Client leverages a custom proxy delegate to switch between HTTP and gRPC protocols, highlighting structural roles, practical usage, and differences from the decorator pattern.

Design PatternsNacosProxy Pattern
0 likes · 12 min read
Mastering the Proxy Pattern: A Hands‑On Guide with Nacos Client
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 27, 2021 · Backend Development

Mastering Spring Cloud Gateway Filters: Add Header, Parameter, Retry, and More

This guide demonstrates how to configure and test various Spring Cloud Gateway filter factories—including AddRequestHeader, AddRequestParameter, AddResponseHeader, PrefixPath, StripPrefix, Retry, RedirectTo, and default filters—using Spring Boot 2.3.7 with Hoxton.SR9, complete with YAML snippets and code examples.

FiltersMicroservicesSpring Cloud Gateway
0 likes · 7 min read
Mastering Spring Cloud Gateway Filters: Add Header, Parameter, Retry, and More
Programmer DD
Programmer DD
Jul 26, 2021 · Backend Development

Is Lombok a Hidden Threat? Uncovering the Risks Behind Java’s Code‑Gen Magic

This article examines Lombok’s ability to shrink Java boilerplate, walks through code transformations from verbose getters and setters to concise annotations, and critically evaluates five major drawbacks—including JDK compatibility, forced adoption, readability loss, tighter coupling, and technical debt—offering guidance on when to avoid it.

Technical Debtbackend-developmentcode-generation
0 likes · 11 min read
Is Lombok a Hidden Threat? Uncovering the Risks Behind Java’s Code‑Gen Magic
Java Architect Essentials
Java Architect Essentials
Jul 23, 2021 · Backend Development

Preventing Message Loss in RabbitMQ and Kafka: Transactions, Confirm Mode, Persistence, and Configuration Best Practices

This article explains the common points where messages can be lost in RabbitMQ and Kafka, compares transaction and confirm mechanisms, describes how to enable persistence and proper acknowledgments, and provides concrete configuration recommendations for producers and consumers to ensure reliable message delivery.

KafkaMessage ReliabilityRabbitMQ
0 likes · 9 min read
Preventing Message Loss in RabbitMQ and Kafka: Transactions, Confirm Mode, Persistence, and Configuration Best Practices
ByteDance Web Infra
ByteDance Web Infra
Jul 23, 2021 · Backend Development

Design and Refactoring of ByteDance's Node.js RPC Framework

This article explains the motivation, design principles, model architecture, and implementation challenges of rebuilding ByteDance's Node.js RPC system, covering DDD‑based decomposition, protocol and connection abstractions, multi‑protocol nesting, client/server creation APIs, and performance‑optimized context extensions.

DDDNode.jsRPC
0 likes · 14 min read
Design and Refactoring of ByteDance's Node.js RPC Framework
Baidu Intelligent Testing
Baidu Intelligent Testing
Jul 22, 2021 · Backend Development

Performance Optimization Techniques for Baidu C++ Backend Services: Memory Access, Allocation, and Concurrency

This article presents a comprehensive collection of Baidu C++ engineers' performance‑optimization practices, covering memory‑access patterns, string handling, protobuf manipulation, allocator choices, job‑level memory arenas, cache‑line considerations, and memory‑order semantics to achieve substantial latency and cost reductions in large‑scale backend services.

backend-developmentconcurrencymemory allocation
0 likes · 32 min read
Performance Optimization Techniques for Baidu C++ Backend Services: Memory Access, Allocation, and Concurrency
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 22, 2021 · Backend Development

From Monolith to Microservices: Lessons Learned and Best Practices

This article walks through the evolution of an online supermarket from a simple monolithic website to a fully split micro‑service system, highlighting the motivations, architectural changes, operational challenges, and the tooling needed for monitoring, tracing, logging, and resilient deployment.

Microservicesbackend-developmenttesting
0 likes · 24 min read
From Monolith to Microservices: Lessons Learned and Best Practices
Programmer DD
Programmer DD
Jul 22, 2021 · Backend Development

Boost Spring Boot Scheduled Tasks with Elastic Job Sharding

This tutorial explains how to use Elastic Job's sharding configuration in Spring Boot to accelerate scheduled task execution, improve resource utilization, and achieve high‑availability by distributing work across multiple job instances.

Elastic-JobScheduled TasksSpring Boot
0 likes · 8 min read
Boost Spring Boot Scheduled Tasks with Elastic Job Sharding
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 21, 2021 · Backend Development

Mastering Spring @Autowired: 9 Powerful Injection Techniques

This guide explains how Spring's @Autowired annotation works across constructors, methods, fields, arrays, collections, maps, optional dependencies, and built‑in Spring components, providing code examples and tips for handling required and optional beans in a Spring 5.2.15 environment.

Autowiredbackend-developmentdependency-injection
0 likes · 7 min read
Mastering Spring @Autowired: 9 Powerful Injection Techniques
MaGe Linux Operations
MaGe Linux Operations
Jul 21, 2021 · Backend Development

Why Go’s Concurrency Beats Threads: Inside Goroutine Scheduling

This article explains how Go’s lightweight goroutine model and user‑space scheduler provide faster, more efficient concurrency than traditional OS threads, detailing the design, execution environment, task queues, work‑stealing, and blocking mechanisms that make Go’s concurrency a standout feature for backend development.

Schedulerbackend-development
0 likes · 12 min read
Why Go’s Concurrency Beats Threads: Inside Goroutine Scheduling
vivo Internet Technology
vivo Internet Technology
Jul 21, 2021 · Backend Development

Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions

The Fast App Center’s duplicate OpenID rows were traced to a non‑atomic check‑then‑insert race condition, prompting the team to evaluate a unique‑index safeguard versus application‑level distributed locking, ultimately implementing a Redis‑based lock to serialize inserts and adding a cleanup job to purge existing duplicates.

Database Concurrencybackend-developmentdistributed-lock
0 likes · 18 min read
Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions
ITPUB
ITPUB
Jul 21, 2021 · Backend Development

How Our Reactive API Gateway Handles Routing, Rate Limiting, and Security in Microservices

This article explains the overall architecture of a reactive API gateway built on RxNetty, detailing its request dispatch, conditional routing for gray releases, API management, rate‑limiting and circuit‑breaking, security policies, and integrated monitoring and tracing within a microservices ecosystem.

Microservicesapi-gatewaybackend-development
0 likes · 13 min read
How Our Reactive API Gateway Handles Routing, Rate Limiting, and Security in Microservices
Top Architect
Top Architect
Jul 21, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.

aopbackend-developmentjava
0 likes · 10 min read
Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 21, 2021 · Backend Development

Designing a Scalable Business Middle Platform: Modeling, Service Principles, and Distributed Operations

This article explains how to abstract business functions into a middle platform through 0‑level and 1‑level modeling, defines domain capabilities and centers, outlines eight service design principles, and describes essential distributed mechanisms such as service registration, elastic scaling, rate limiting, gray release, messaging, and distributed transactions.

Distributed SystemsMicroservicesbackend-development
0 likes · 17 min read
Designing a Scalable Business Middle Platform: Modeling, Service Principles, and Distributed Operations
macrozheng
macrozheng
Jul 19, 2021 · Fundamentals

Mastering the Chain of Responsibility Pattern in Java: A Practical Guide

This article explains the Chain of Responsibility design pattern, outlines its four roles, demonstrates a real‑world Java implementation for encrypted request handling, and shows how to build an extensible processing chain that improves code readability and maintainability.

Chain of Responsibilitybackend-developmentdesign pattern
0 likes · 10 min read
Mastering the Chain of Responsibility Pattern in Java: A Practical Guide
Top Architect
Top Architect
Jul 18, 2021 · Backend Development

Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics

This article explains the @Autowired annotation in Spring, covering its various usage forms such as constructor, setter, method, field, and collection injection, and delves into the underlying implementation details within Spring's AutowiredAnnotationBeanPostProcessor, including metadata handling, reflection-based injection, and common pitfalls.

Autowiredannotationsbackend-development
0 likes · 19 min read
Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics
Java Backend Technology
Java Backend Technology
Jul 17, 2021 · Backend Development

Unlock Powerful API Docs with Knife4j: A Complete Guide for Java Backend Developers

Knife4j is a lightweight, feature‑rich enhancement for Swagger that integrates seamlessly with Java MVC frameworks, offering customizable UI, advanced functionalities like interface sorting and export options, and easy Maven integration for both monolithic Spring Boot and Spring Cloud microservice architectures.

API documentationKnife4jSpring Boot
0 likes · 7 min read
Unlock Powerful API Docs with Knife4j: A Complete Guide for Java Backend Developers
Laravel Tech Community
Laravel Tech Community
Jul 16, 2021 · Backend Development

PHP rewinddir Function – Reset Directory Handle to Start

The PHP rewinddir function resets a directory stream resource opened by opendir() back to the beginning of the directory, returning the filename on success or FALSE on failure, and requires a valid directory handle as its sole parameter.

PHPbackend-developmentdirectory handling
0 likes · 1 min read
PHP rewinddir Function – Reset Directory Handle to Start
Laravel Tech Community
Laravel Tech Community
Jul 15, 2021 · Backend Development

PHP readdir Function: Reading Directory Entries

Provides a detailed explanation of PHP's readdir function, including its signature, parameters, return values, and example code demonstrating correct and incorrect ways to iterate through directory entries using a directory handle opened by opendir().

PHPbackend-developmentreaddir
0 likes · 2 min read
PHP readdir Function: Reading Directory Entries
Programmer DD
Programmer DD
Jul 15, 2021 · Backend Development

Mastering Spring Boot Scheduled Tasks: From Basics to Distributed Locks

This tutorial explains how to create and configure scheduled tasks in Spring Boot, demonstrates code examples for simple 5‑second intervals, details the @Scheduled annotation parameters, and discusses the pitfalls of clustering without distributed locks.

Scheduled TasksSpring Bootbackend-development
0 likes · 7 min read
Mastering Spring Boot Scheduled Tasks: From Basics to Distributed Locks
Liangxu Linux
Liangxu Linux
Jul 14, 2021 · Cloud Native

Master Docker from Scratch: Build, Run, and Deploy Containers for Web Projects

This comprehensive guide walks you through Docker fundamentals, compares containers with virtual machines, explains core concepts, shows step‑by‑step installation, image building, container execution, and best practices, enabling you to containerize and deploy web applications efficiently.

Cloud NativeDevOpsLinux
0 likes · 17 min read
Master Docker from Scratch: Build, Run, and Deploy Containers for Web Projects
Baidu Geek Talk
Baidu Geek Talk
Jul 14, 2021 · Backend Development

Understanding Nginx Architecture, Process Model, and Module Design

The article explains Nginx’s high‑performance, event‑driven architecture, detailing its master‑worker process model, asynchronous non‑blocking I/O, CPU affinity, accept‑mutex load balancing, and the modular design built around ngx_module_t, covering core and HTTP modules, configuration parsing, data structures, and compilation guidelines for developers.

Event-drivenNginxWeb server
0 likes · 18 min read
Understanding Nginx Architecture, Process Model, and Module Design
macrozheng
macrozheng
Jul 14, 2021 · Backend Development

Spring GraphQL Leaves Experimental Stage – What’s Next?

Spring GraphQL has officially left the experimental stage to become a top‑level Spring project, with a milestone release planned, and the article explains its collaboration with GraphQL Java, the goals of the integration, a brief overview of GraphQL versus REST, and upcoming conference talks.

APIGraphQL JavaSpring Framework
0 likes · 4 min read
Spring GraphQL Leaves Experimental Stage – What’s Next?
Tencent Cloud Developer
Tencent Cloud Developer
Jul 13, 2021 · Backend Development

Function Mesh: Serverless Innovation in Message and Streaming Data Scenarios

The talk by Zha Jia showcases StreamNative’s open‑source Function Mesh, which builds on Apache Pulsar’s unified messaging and streaming platform and its lightweight Pulsar Functions, using Kubernetes CRDs to simplify deployment, management, and scaling of serverless data processing while highlighting the project’s rapid community growth.

Apache PulsarCloud NativeFunction Mesh
0 likes · 18 min read
Function Mesh: Serverless Innovation in Message and Streaming Data Scenarios
Programmer DD
Programmer DD
Jul 13, 2021 · Backend Development

Spring Cloud Alibaba 2.2.6 Released: New Features, Nacos & Dubbo Enhancements, and Bug Fixes

Spring Cloud Alibaba 2.2.6, compatible with Spring Cloud Hoxton.SR9, introduces feature enhancements for Nacos, Dubbo, and Sentinel along with numerous bug fixes, providing developers with improved service registration, refactored integrations, and resolved issues across Kubernetes, Consul, and tracing components.

DubboNacosSpring Cloud Alibaba
0 likes · 4 min read
Spring Cloud Alibaba 2.2.6 Released: New Features, Nacos & Dubbo Enhancements, and Bug Fixes
Wukong Talks Architecture
Wukong Talks Architecture
Jul 12, 2021 · Backend Development

Why Use Message Queues? Pain Points, Challenges, and Practical Solutions

This article explains the drawbacks of traditional synchronous architectures, outlines why adopting message queues improves latency, coupling, and peak‑handling, and then details common MQ problems such as duplicate messages, data inconsistency, loss, ordering, backlog, and increased complexity along with concrete mitigation strategies.

AsynchronousDecouplingMessage Queue
0 likes · 13 min read
Why Use Message Queues? Pain Points, Challenges, and Practical Solutions
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 10, 2021 · Backend Development

Mastering Programmatic Transaction Management in Spring Boot 2.3.9

This guide explains Spring Boot's two programmatic transaction approaches—TransactionTemplate/TransactionalOperator and direct TransactionManager—provides detailed code examples for using TransactionTemplate with return values, rollbacks, property configuration, demonstrates PlatformTransactionManager usage, and shows how to listen to transaction events with @TransactionalEventListener.

Programmatic TransactionsSpring Bootbackend-development
0 likes · 8 min read
Mastering Programmatic Transaction Management in Spring Boot 2.3.9
Top Architect
Top Architect
Jul 10, 2021 · Backend Development

Optimizing Complex Search Queries with Redis: A Backend Development Demo

This article explores how backend developers can handle intricate e‑commerce search filters by first attempting a monolithic SQL solution, then improving performance with index analysis and query splitting, and finally achieving fast, scalable results using Redis sets, sorted sets, and transaction commands.

backend-developmentcachingperformance
0 likes · 8 min read
Optimizing Complex Search Queries with Redis: A Backend Development Demo
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 9, 2021 · Backend Development

Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases

This article provides a detailed introduction to Zookeeper, covering its definition as a distributed coordination service, core features such as a hierarchical file system, notification mechanism, and cluster management, various application scenarios, the ZAB protocol, node types, leader election process, distributed lock implementation, and watch mechanism, all illustrated with diagrams.

Distributed CoordinationZAB ProtocolZooKeeper
0 likes · 8 min read
Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases