BestHub
Sign in
Tagged articles

Backend

5000 articles · Page 38 of 50
IT Architects Alliance
IT Architects Alliance
Mar 6, 2022 · Backend Development

How to Implement Delayed Message Delivery with RabbitMQ’s Plugin in Spring Boot

This article explains why traditional delay solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, then demonstrates step‑by‑step how to configure RabbitMQ’s delayed‑queue plugin, create exchanges, queues, and bindings in Spring Boot, and send and consume delayed messages with code examples.

BackendJavaRabbitMQ
0 likes · 9 min read
How to Implement Delayed Message Delivery with RabbitMQ’s Plugin in Spring Boot
macrozheng
macrozheng
Mar 4, 2022 · Backend Development

Why Misusing Spring @Async Can Crash Your System – and How to Avoid It

This article reveals how creating a new thread pool for each @Async method in Spring can exhaust system resources, explains Spring Boot’s default executor behavior, shows code examples, and offers practical guidance to prevent thread‑pool related crashes in Java backend applications.

BackendThreadPoolasync
0 likes · 7 min read
Why Misusing Spring @Async Can Crash Your System – and How to Avoid It
IT Services Circle
IT Services Circle
Mar 3, 2022 · Backend Development

Implementing Precise Order Timeout with RabbitMQ Delayed Message Plugin in Spring Boot

This article explains why using scheduled tasks for closing timed‑out orders is problematic, demonstrates how to use RabbitMQ dead‑letter queues and the x‑delay‑message plugin to achieve accurate order timeout handling, and provides complete Spring Boot configuration and code examples with testing and limitations.

BackendMessage SchedulingRabbitMQ
0 likes · 13 min read
Implementing Precise Order Timeout with RabbitMQ Delayed Message Plugin in Spring Boot
Selected Java Interview Questions
Selected Java Interview Questions
Mar 1, 2022 · Backend Development

Cache Consistency Strategies: From Simple Write‑Through to Binlog Subscription

This article explains why caching is essential for high‑concurrency systems, analyzes the challenges of keeping database and cache data consistent, and compares five practical cache‑invalidation strategies—including write‑after‑DB, delete‑before‑write, delayed double delete, queue‑based deletion, and binlog subscription—highlighting their trade‑offs and suitable scenarios.

BackendBinlogCache invalidation
0 likes · 10 min read
Cache Consistency Strategies: From Simple Write‑Through to Binlog Subscription
Code Ape Tech Column
Code Ape Tech Column
Feb 28, 2022 · Backend Development

Best Practices for Consistent Backend API Design

This article presents a concise set of best‑practice guidelines for designing consistent, resource‑oriented RESTful APIs, covering naming conventions, URL structures, HTTP methods, parameter handling, versioning, monitoring, security, error handling, and documentation tools.

API DesignBackendHTTP methods
0 likes · 11 min read
Best Practices for Consistent Backend API Design
IT Architects Alliance
IT Architects Alliance
Feb 27, 2022 · Frontend Development

Guidelines for Front‑End/Back‑End Separation and API Specification

This article explains why front‑end and back‑end separation is needed, describes the evolution from MVC to SPA, outlines responsibilities, development workflow, and provides a detailed version‑1.0.0 API contract with request/response formats, special field rules, and future front‑end trends.

APIArchitectureBackend
0 likes · 13 min read
Guidelines for Front‑End/Back‑End Separation and API Specification
Top Architect
Top Architect
Feb 27, 2022 · Frontend Development

Guidelines for Frontend‑Backend Separation and API Specification

This article explains the motivations for separating frontend and backend, outlines the evolution from MVC to SPA architectures, details responsibilities, development workflows, and provides a comprehensive API specification including request/response formats, special data handling, and future frontend trends.

BackendSPAfrontend
0 likes · 11 min read
Guidelines for Frontend‑Backend Separation and API Specification
Refining Core Development Skills
Refining Core Development Skills
Feb 25, 2022 · Databases

Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues

This article provides a step‑by‑step methodology for identifying why a Redis instance becomes slow, covering baseline latency testing, slow‑log analysis, big‑key detection, expiration patterns, memory limits, fork overhead, huge‑page effects, AOF configuration, CPU binding, swap usage, memory fragmentation, network saturation, and practical remediation techniques.

BackendOptimizationPerformance
0 likes · 40 min read
Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues
Laravel Tech Community
Laravel Tech Community
Feb 24, 2022 · Backend Development

PHP 8.1.3 Security Release: Bug Fixes and Updates

PHP 8.1.3 has been released as a security‑focused update that fixes numerous core, FFI, filter, FPM, MBString, MySQLnd, pcntl, sockets, and standard extension bugs, and users of the 8.1 series are encouraged to upgrade promptly.

BackendPHPbug fixes
0 likes · 2 min read
PHP 8.1.3 Security Release: Bug Fixes and Updates
Top Architect
Top Architect
Feb 24, 2022 · Artificial Intelligence

Evolution of the DaJia Recommendation System Architecture: From V1.0 to V3.0

The article details how DaJia's recommendation system progressed through three architectural versions—V1.0's simple strategy‑factory design, V2.0's vertical business split and configurable pipeline, and V3.0's dynamic configuration service and modular pipeline—addressing scalability, fault isolation, and personalization challenges while outlining future directions for explainable AI recommendations.

AIBackendconfiguration service
0 likes · 14 min read
Evolution of the DaJia Recommendation System Architecture: From V1.0 to V3.0
政采云技术
政采云技术
Feb 24, 2022 · Backend Development

Implementation of Workflow Versioning in DolphinScheduler

This article explains how DolphinScheduler (DS) implements workflow versioning by introducing integer‑based versions, describes the core principles of workflow and task relationships, outlines the key database tables and architecture, and provides detailed Java code for creating, updating, and managing workflow definitions, tasks, and their relations.

BackendDolphinSchedulerversioning
0 likes · 13 min read
Implementation of Workflow Versioning in DolphinScheduler
FunTester
FunTester
Feb 24, 2022 · Backend Development

How to Add Load Balancing to a Custom Go DNS Resolver

This guide shows how to modify a Go custom DNS resolver to perform simple load balancing by predefining IP addresses and randomly selecting one for each new connection, including full code examples and test output.

BackendCustom ResolverDNS
0 likes · 5 min read
How to Add Load Balancing to a Custom Go DNS Resolver
vivo Internet Technology
vivo Internet Technology
Feb 23, 2022 · Backend Development

Design and Implementation of Vivo Multi‑Language Document System

The article describes Vivo’s overseas sales team’s multi‑language document system, detailing its low‑maintenance i18n design that leverages the existing configuration center, a MCMS UI, and a runtime JAR to streamline project creation, translation, testing, publishing, and real‑time front‑end text updates across web and decoupled architectures.

BackendConfigurationJava
0 likes · 10 min read
Design and Implementation of Vivo Multi‑Language Document System
JavaScript
JavaScript
Feb 23, 2022 · Backend Development

Unlock Node.js’s Built‑in fetch(): How It Works and Why Use It

Node.js now offers a native fetch() API—an experimental, Promise‑based HTTP client introduced in v17.5.0 that mirrors the browser Fetch API, simplifying requests, improving performance, and paving the way for future LTS support.

BackendHTTP ClientJavaScript
0 likes · 4 min read
Unlock Node.js’s Built‑in fetch(): How It Works and Why Use It
Senior Brother's Insights
Senior Brother's Insights
Feb 22, 2022 · Backend Development

Mastering Snowflake: Build High‑Performance Distributed IDs in Java

This article explains the Snowflake distributed ID algorithm, compares it with other ID generation methods, details its 64‑bit structure, provides a complete Java implementation with thread‑safe code, and discusses practical limits such as the 69‑year timestamp and front‑end numeric handling.

BackendJavaSnowflake
0 likes · 11 min read
Mastering Snowflake: Build High‑Performance Distributed IDs in Java
Top Architect
Top Architect
Feb 22, 2022 · Backend Development

Designing a Multi‑Account Unified Login System and Optimized Authentication Flow

This article explains how to design a scalable multi‑account login architecture—including self‑built phone‑number registration, optimized password‑optional flows, third‑party integrations such as Weibo, and a unified user‑basic and user‑auth table schema—while also covering one‑click carrier‑based login and its advantages and drawbacks.

Account ManagementBackendThird-party Integration
0 likes · 16 min read
Designing a Multi‑Account Unified Login System and Optimized Authentication Flow
Programmer DD
Programmer DD
Feb 22, 2022 · Information Security

How Does Spring Security Manage Built‑In Filter Order? A Deep Dive

This article explains how Spring Security’s HttpSecurity class maintains the order of its built‑in filters using FilterOrderRegistration, demonstrates the registration and retrieval logic with code examples, and clarifies how duplicate orders are resolved during filter sorting.

BackendFilter OrderHttpSecurity
0 likes · 8 min read
How Does Spring Security Manage Built‑In Filter Order? A Deep Dive
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Feb 21, 2022 · Backend Development

How Nohost Turns Whistle into a Multi‑User Remote Proxy Service

This article explains how Nohost extends the Whistle packet‑capture tool into a multi‑process, multi‑user remote proxy platform, detailing its architecture, interaction flow, master‑process logic, environment injection, user‑state recording, and Whistle process management for developers and operations teams.

BackendNode.jsNohost
0 likes · 8 min read
How Nohost Turns Whistle into a Multi‑User Remote Proxy Service
ITPUB
ITPUB
Feb 21, 2022 · Backend Development

Unlocking Multi‑Process Server Speed: How Linux REUSEPORT Works

This article explains why Linux kernels 3.9+ allow multiple processes to bind the same port, how the REUSEPORT option implements kernel‑level load balancing, and provides step‑by‑step examples showing configuration, code snippets, and performance verification.

BackendLinuxSO_REUSEPORT
0 likes · 14 min read
Unlocking Multi‑Process Server Speed: How Linux REUSEPORT Works
IT Architects Alliance
IT Architects Alliance
Feb 20, 2022 · Backend Development

Cache Consistency Strategies for Database and Redis: Tiered Storage and Synchronization Techniques

The article examines tiered data storage and evaluates four cache‑synchronization strategies—updating the database before the cache, deleting the cache before updating the database, updating the cache before the database, and deleting the cache after a database update—highlighting their trade‑offs and practical solutions such as delayed double deletion, message‑queue retries, and binlog‑driven cache updates.

BackendMySQLRedis
0 likes · 8 min read
Cache Consistency Strategies for Database and Redis: Tiered Storage and Synchronization Techniques
Selected Java Interview Questions
Selected Java Interview Questions
Feb 19, 2022 · Backend Development

Implementing a Lightweight Redis‑Based Message Queue: Environment Setup, List, Pub/Sub, and Stream Solutions

This article details the research background, environment preparation, and three Redis‑based message‑queue implementations—using List structures, Pub/Sub, and Stream APIs—along with code examples, design considerations, testing strategies, and deployment tips for building a lightweight messaging component in Java Spring Boot.

BackendJavaRedis
0 likes · 17 min read
Implementing a Lightweight Redis‑Based Message Queue: Environment Setup, List, Pub/Sub, and Stream Solutions
Top Architect
Top Architect
Feb 18, 2022 · Backend Development

Ensuring Data Consistency Between Cache and Database: Strategies and Trade‑offs

The article analyzes the problem of data inconsistency when using caches such as Redis or local memory alongside a database, classifies data by real‑time requirements, compares four write‑through/write‑behind strategies, and proposes practical solutions like delayed double‑delete, message‑queue compensation, and binlog‑driven cache updates.

Backendcacheconsistency
0 likes · 8 min read
Ensuring Data Consistency Between Cache and Database: Strategies and Trade‑offs
Laravel Tech Community
Laravel Tech Community
Feb 17, 2022 · Backend Development

Key New Features and Changes in Elasticsearch 8.0 Release

Elasticsearch 8.0 introduces major updates including 7.x REST API compatibility headers, default‑enabled security with registration tokens, protected system indices, a preview KNN search API, storage‑efficient keyword/match_only_text/text fields, faster indexing for geo_point and geo_shape, PyTorch model support, and numerous deprecations and enhancements across aggregations, allocation, analysis, authentication, cluster coordination, and engine components.

BackendElasticsearchKNN
0 likes · 8 min read
Key New Features and Changes in Elasticsearch 8.0 Release
21CTO
21CTO
Feb 17, 2022 · Backend Development

10 Essential API Design Rules for Consistent Backend Services

This guide presents a concise set of best‑practice rules for designing consistent, RESTful backend APIs—including naming conventions, URL structures, HTTP methods, versioning, pagination, security, and documentation tools—to help developers create clear, maintainable, and user‑friendly services.

API DesignBackendHTTP methods
0 likes · 9 min read
10 Essential API Design Rules for Consistent Backend Services
ITPUB
ITPUB
Feb 17, 2022 · Backend Development

How to Efficiently Read Redis Source Code: 7 Proven Steps

This guide outlines a practical seven‑step methodology for mastering Redis source code, from mapping the project structure and preparing prerequisite knowledge to focusing on core execution paths, handling complex functions, exploring side modules, and iteratively filling knowledge gaps.

BackendRedisreading guide
0 likes · 14 min read
How to Efficiently Read Redis Source Code: 7 Proven Steps
Top Architect
Top Architect
Feb 17, 2022 · Backend Development

Understanding API Idempotency and How to Ensure It

This article explains the concept of API idempotency, why duplicate requests occur in distributed systems, and presents a comprehensive set of server‑side and client‑side techniques—including token mechanisms, PRG pattern, unique indexes, optimistic locking, distributed locks, and idempotent state machines—to guarantee that repeated calls produce only a single effect.

APIBackendOptimistic Lock
0 likes · 10 min read
Understanding API Idempotency and How to Ensure It
Zhuanzhuan Tech
Zhuanzhuan Tech
Feb 16, 2022 · Backend Development

Leveraging ngx_lua for Traffic Grouping in Nginx

This article explains how to use the ngx_lua module in Nginx to assign traffic tags, implement header‑based or domain‑based routing, and integrate with dynamic upstreams for parallel testing, load testing, and gray‑release scenarios, providing code examples and configuration details.

BackendLua scriptingload balancing
0 likes · 9 min read
Leveraging ngx_lua for Traffic Grouping in Nginx
Node Underground
Node Underground
Feb 16, 2022 · Backend Development

What’s New in Midway 3.0? Deep Dive into the Latest Backend Framework Features

Midway 3.0 was officially released on January 20, 2022, introducing multi‑version documentation, a clarified tech stack for standard, serverless, and integration projects, a redesigned API syntax with zero‑API calls, enhanced operators, Prisma ORM support, a new full‑stack suite, and a lightweight request SDK for both Node.js and browser environments.

APIBackendMidway
0 likes · 11 min read
What’s New in Midway 3.0? Deep Dive into the Latest Backend Framework Features
Programmer DD
Programmer DD
Feb 16, 2022 · Backend Development

Master Tencent Interview: Deep Dive into HashMap, Redis, MySQL & System Design

This article compiles a comprehensive set of Tencent interview questions and detailed answers covering HashMap internals, thread safety, red‑black trees, Redis performance, MySQL indexing, TCP reliability, IO multiplexing, RPC, and system bottleneck analysis to help candidates prepare effectively.

BackendHashMapMySQL
0 likes · 11 min read
Master Tencent Interview: Deep Dive into HashMap, Redis, MySQL & System Design
Java High-Performance Architecture
Java High-Performance Architecture
Feb 15, 2022 · Backend Development

What’s New in Elasticsearch 8.0? Key Features, Security Enhancements, and Performance Boosts

Elasticsearch 8.0 introduces 7.x REST API compatibility headers, default‑on security features with automatic enrollment tokens, tighter protection of system indices, a preview KNN search API, storage‑saving field encodings, faster geo‑point and geo‑shape indexing, PyTorch model support, and a long list of deprecations and internal improvements.

BackendElasticsearchsearch engine
0 likes · 10 min read
What’s New in Elasticsearch 8.0? Key Features, Security Enhancements, and Performance Boosts
Top Architect
Top Architect
Feb 13, 2022 · Backend Development

Understanding Forward and Reverse Proxies and Their Role in Load Balancing

The article explains the concepts of forward and reverse proxies, compares their functions and deployment scenarios, and then introduces load balancing principles, layer classifications, and common software such as DNS‑based, reverse‑proxy, NAT, and application‑layer solutions, highlighting their use in backend architectures.

Backendforward proxynetwork
0 likes · 9 min read
Understanding Forward and Reverse Proxies and Their Role in Load Balancing
Top Architect
Top Architect
Feb 13, 2022 · Operations

Performance Optimization Lessons from a Legacy Web Application: Monitoring, Load Testing, and Maintaining Old Systems

The article shares a real‑world case study of a legacy multi‑service web platform where traffic spikes exposed DB connection leaks, leading to a 90% response‑time bottleneck, and outlines four key takeaways about tail‑latency metrics, investing in tools and people, actively maintaining legacy systems, and treating every line of code as critical for performance.

BackendLoad TestingSRE
0 likes · 9 min read
Performance Optimization Lessons from a Legacy Web Application: Monitoring, Load Testing, and Maintaining Old Systems
Java Interview Crash Guide
Java Interview Crash Guide
Feb 10, 2022 · Backend Development

Why Kafka Consumer Rebalance Stops Your Apps and How to Fix It

This article explains Kafka consumer group rebalance, covering core concepts, trigger conditions, detailed protocol steps, common pitfalls like long pause times, and modern improvements such as static membership and incremental cooperative rebalance, plus practical configuration tips to minimize disruptions.

BackendConsumer GroupIncremental Rebalance
0 likes · 13 min read
Why Kafka Consumer Rebalance Stops Your Apps and How to Fix It
FunTester
FunTester
Feb 10, 2022 · Backend Development

How to Implement Load‑Balancing with a Custom Java DNS Resolver

This article explains why the default InMemoryDnsResolver cannot provide load balancing, shows how to create a custom SystemDefaultDnsResolver that randomly selects IPs, and demonstrates single‑thread, multi‑thread, and single‑connection pool tests to verify the behavior.

BackendDNSHttpClient
0 likes · 9 min read
How to Implement Load‑Balancing with a Custom Java DNS Resolver
IT Xianyu
IT Xianyu
Feb 9, 2022 · Backend Development

Introducing kkFileView: An Open‑Source Spring Boot Document Preview Solution

kkFileView is a free, Apache‑licensed Spring Boot project that enables online preview of numerous file types—including office documents, PDFs, CAD files, images, archives, and multimedia—offering RESTful APIs, easy deployment, and extensible interfaces for developers seeking a versatile document viewer.

BackendDocument ViewerSpring Boot
0 likes · 5 min read
Introducing kkFileView: An Open‑Source Spring Boot Document Preview Solution
IT Architects Alliance
IT Architects Alliance
Feb 9, 2022 · Backend Development

How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned

This article walks through the design and practical implementation of a high‑throughput red‑envelope service capable of handling 10 billion requests, covering target load calculations, hardware and software choices, client‑server coordination, performance testing, monitoring, and key takeaways for building scalable backend systems.

BackendLoad Testingdistributed systems
0 likes · 20 min read
How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned
IT Xianyu
IT Xianyu
Feb 8, 2022 · Backend Development

Deploying a Spring Boot Application with Docker Using IntelliJ IDEA

This tutorial explains how to install Docker, configure remote access, create a Spring Boot project in IntelliJ IDEA, add Dockerfile and Maven settings, build a Docker image, run the container, and verify the application through a browser and log inspection.

BackendDockerIntelliJ IDEA
0 likes · 7 min read
Deploying a Spring Boot Application with Docker Using IntelliJ IDEA
Programmer DD
Programmer DD
Feb 7, 2022 · Backend Development

Master Spring’s Core Utility Classes: Assertions, Collections, IO, and Reflection

This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, common methods, and usage examples to replace redundant custom code.

BackendJavaReflection
0 likes · 16 min read
Master Spring’s Core Utility Classes: Assertions, Collections, IO, and Reflection
Java Architect Essentials
Java Architect Essentials
Feb 6, 2022 · Backend Development

SpringBoot DevTools, Lombok, and Configuration Processor: A Quick Guide for Hot Deployment and Code Simplification

This article introduces how to enable SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and use the Spring Configuration Processor for property binding hints, providing Maven dependencies, IDE settings, and example code snippets for Java backend development.

BackendConfigurationProcessorDevTools
0 likes · 6 min read
SpringBoot DevTools, Lombok, and Configuration Processor: A Quick Guide for Hot Deployment and Code Simplification
FunTester
FunTester
Feb 6, 2022 · Backend Development

Collection of API and Interface Testing Articles and Resources

This curated list compiles numerous Chinese-language articles and tutorials covering API and interface testing techniques, including Java HttpClient usage, Spring Boot integration, socket and WebSocket testing, performance measurement, automation frameworks, and related tools, offering developers practical guidance for backend service validation.

API-testingBackendHttpClient
0 likes · 12 min read
Collection of API and Interface Testing Articles and Resources
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 6, 2022 · Backend Development

Understanding MyBatis Architecture: Layers, Core Components, and Execution Flow

This article provides a comprehensive overview of MyBatis, detailing its three‑layer architecture, core modules such as caching, reflection, and transaction management, as well as the complete execution process from configuration files to SQL execution, helping developers master the framework for enterprise‑level Java applications.

ArchitectureBackendJava
0 likes · 11 min read
Understanding MyBatis Architecture: Layers, Core Components, and Execution Flow
Top Architect
Top Architect
Feb 5, 2022 · Backend Development

Designing Domain‑Driven Microservices: Bounded Contexts, Aggregates, and Event‑Storming

This article explains how to break monolithic applications into domain‑driven microservices by defining clear bounded contexts, using aggregates, applying context‑mapping and event‑storming techniques, and choosing appropriate communication patterns such as asynchronous events, CAP trade‑offs, and BFF for frontend integration.

BackendEvent Stormingservice architecture
0 likes · 19 min read
Designing Domain‑Driven Microservices: Bounded Contexts, Aggregates, and Event‑Storming
Top Architect
Top Architect
Feb 3, 2022 · Backend Development

System Performance Issue Analysis, Diagnosis, and Optimization for Business Applications

This article explains how to analyze, diagnose, and optimize performance problems in production business systems, covering the typical causes such as high concurrency, data growth, hardware limits, and environment changes, and detailing practical steps for hardware, OS, database, middleware, JVM tuning, code review, and APM monitoring.

BackendJVMOptimization
0 likes · 15 min read
System Performance Issue Analysis, Diagnosis, and Optimization for Business Applications
IT Services Circle
IT Services Circle
Feb 2, 2022 · Backend Development

Backend Engineer Interview Experience and Technical Q&A at Huanju (YY)

This article shares a detailed account of a backend engineer's multi‑stage interview process at Huanju (formerly YY), covering personal background, common Java and system design questions, database and caching strategies, distributed lock handling, and reflections on preparation and outcomes.

BackendMySQLPerformance
0 likes · 16 min read
Backend Engineer Interview Experience and Technical Q&A at Huanju (YY)
Code Ape Tech Column
Code Ape Tech Column
Jan 29, 2022 · Backend Development

Using IntelliJ IDEA Stream Trace to Debug Java Streams

IntelliJ IDEA's Stream Trace feature allows developers to visualize each step of Java Stream operations during debugging, showing element counts, intermediate results, and object details, with split and flat modes, demonstrated through a sample code that filters strings by length.

BackendIntelliJ IDEAJava
0 likes · 3 min read
Using IntelliJ IDEA Stream Trace to Debug Java Streams
Top Architect
Top Architect
Jan 24, 2022 · Backend Development

Ensuring Data Consistency Between Cache and Database in Double‑Write Scenarios

The article analyzes the challenges of maintaining data consistency when using both cache (local memory or Redis) and a database, classifies data by real‑time requirements, evaluates four double‑write strategies, and proposes practical solutions such as delayed double deletion, message‑queue compensation, and binlog‑driven cache updates.

Backendcachedata synchronization
0 likes · 8 min read
Ensuring Data Consistency Between Cache and Database in Double‑Write Scenarios
Alibaba Cloud Native
Alibaba Cloud Native
Jan 23, 2022 · Cloud Native

Why Choose RocketMQ? Synchronous Writes, Multi‑Topic Speed, and SPI Extensibility

This article explains the reasons for selecting Apache RocketMQ—its synchronous double‑write safety, strong performance under massive multi‑topic loads, rich features like transactional and delayed messages, active community support, and demonstrates how to leverage Java’s SPI mechanism to build a configurable, dynamically adjustable client architecture.

BackendCloud NativeJava
0 likes · 13 min read
Why Choose RocketMQ? Synchronous Writes, Multi‑Topic Speed, and SPI Extensibility
21CTO
21CTO
Jan 20, 2022 · Backend Development

Building a Backend to Handle 100 Billion Red‑Packet Requests: 1M‑User Simulation

This article details a practical backend design and stress‑test that simulates 1 million concurrent users handling 100 billion WeChat red‑packet requests, covering load calculations, Go‑based implementation, QPS targets, monitoring, and performance analysis.

BackendLoad Simulationdistributed systems
0 likes · 19 min read
Building a Backend to Handle 100 Billion Red‑Packet Requests: 1M‑User Simulation
High Availability Architecture
High Availability Architecture
Jan 20, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation

This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.

BackendCQRSEvent Sourcing
0 likes · 17 min read
Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation
21CTO
21CTO
Jan 19, 2022 · Blockchain

Your Complete 2022 Roadmap to Mastering Web3 & Blockchain Development

This comprehensive guide walks developers from essential computer‑science fundamentals through front‑end basics, Solidity programming, and DApp construction, offering curated resources and step‑by‑step instructions to become proficient in Web3 and blockchain development within a year.

BackendWeb3dapp development
0 likes · 9 min read
Your Complete 2022 Roadmap to Mastering Web3 & Blockchain Development
Architect's Tech Stack
Architect's Tech Stack
Jan 19, 2022 · Backend Development

Implementing Chunked and Resumable File Upload with Fast Upload (秒传) in Java

This article explains how to implement fast (MD5‑based) upload, chunked upload, and resumable (break‑point) upload for large files in Java, detailing the Redis‑based status tracking, server‑side file handling with RandomAccessFile or MappedByteBuffer, and the required front‑end and back‑end coordination.

BackendJavaMappedByteBuffer
0 likes · 13 min read
Implementing Chunked and Resumable File Upload with Fast Upload (秒传) in Java
Efficient Ops
Efficient Ops
Jan 18, 2022 · Backend Development

Boost Nginx Performance: Custom 404 Pages, Status Monitoring, and Concurrency Tuning

Learn how to enhance your Nginx server by creating custom 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring client-side caching for static assets, with step‑by‑step commands and examples.

BackendNginxPerformance
0 likes · 9 min read
Boost Nginx Performance: Custom 404 Pages, Status Monitoring, and Concurrency Tuning
Java Captain
Java Captain
Jan 18, 2022 · Backend Development

Best Practices for Java Backend Development: Configuration, Lombok, Modular Code, Exception Handling, and More

This article shares a collection of practical Java backend development habits, covering configuration with @ConfigurationProperties, Lombok's @RequiredArgsConstructor, code modularization, exception throwing, reducing DB queries, avoiding null returns, simplifying if‑else, keeping controllers thin, IDE tips, source code reading, design patterns, and fundamental coding techniques.

BackendConfigurationDesign Patterns
0 likes · 6 min read
Best Practices for Java Backend Development: Configuration, Lombok, Modular Code, Exception Handling, and More
FunTester
FunTester
Jan 18, 2022 · Backend Development

Mastering Spock Unit Tests: From Dependencies to Mocking Static Methods

This article walks through setting up Spock for Java/Groovy projects, lists required Maven dependencies, shows how to handle static‑method mocking with PowerMock and Mockito, and provides concrete code examples for mocking @Autowired components, shared objects, and defining mock behavior.

BackendGroovyJava
0 likes · 11 min read
Mastering Spock Unit Tests: From Dependencies to Mocking Static Methods
Architecture and Beyond
Architecture and Beyond
Jan 17, 2022 · Information Security

Understanding Web Session Management: Concepts, Storage Strategies, and Token‑Based Authentication

This article explains the fundamentals of web session management, compares server‑side, cookie‑based, and token‑based storage methods, discusses authentication versus authorization, and outlines security considerations and best‑practice recommendations for managing user sessions in modern web applications.

AuthorizationBackendCookie
0 likes · 11 min read
Understanding Web Session Management: Concepts, Storage Strategies, and Token‑Based Authentication
Java Backend Technology
Java Backend Technology
Jan 16, 2022 · Backend Development

Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips

This article presents a comprehensive guide to building maintainable, extensible backend systems by covering coding conventions, branch naming, commit messages, comment standards, result‑wrapping patterns, database normalization, algorithmic improvements, concurrency handling, service layering, and practical code examples.

BackendPerformancecode quality
0 likes · 20 min read
Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips
Top Architect
Top Architect
Jan 15, 2022 · Backend Development

Distributed Lock Implementation Strategies: Database, Redis, and Zookeeper

This article explains why distributed locks are needed beyond Java's JVM‑level locks, compares three common implementation approaches—database unique indexes, Redis SETNX, and Zookeeper ephemeral sequential nodes—and provides concrete SQL and Java code examples with analysis of re‑entrancy, release timing, and single‑point risks.

BackendJavaRedis
0 likes · 15 min read
Distributed Lock Implementation Strategies: Database, Redis, and Zookeeper
IT Architects Alliance
IT Architects Alliance
Jan 15, 2022 · Backend Development

How to Build a Million‑Message‑Per‑Second RabbitMQ Cluster: Lessons from Google and Real‑World Experiments

This article explains the fundamentals of RabbitMQ, compares normal and mirrored cluster modes, details Google’s large‑scale test setup, and walks through advanced plugins such as sharding, consistent‑hash exchange, federation, and high‑availability strategies for achieving million‑level message throughput.

BackendClusteringPerformance
0 likes · 24 min read
How to Build a Million‑Message‑Per‑Second RabbitMQ Cluster: Lessons from Google and Real‑World Experiments
Selected Java Interview Questions
Selected Java Interview Questions
Jan 14, 2022 · Backend Development

Understanding CompletableFuture in Java 8: Overview, Features, and Source‑Code Walkthrough

This article explains Java 8's CompletableFuture, covering its purpose, core features such as thenCompose, thenCombine, thenAccept, thenRun, and thenApply, demonstrates practical code examples, and provides a detailed analysis of the underlying source‑code implementation for asynchronous callbacks.

BackendCompletableFutureFuture
0 likes · 11 min read
Understanding CompletableFuture in Java 8: Overview, Features, and Source‑Code Walkthrough
IT Architects Alliance
IT Architects Alliance
Jan 14, 2022 · Backend Development

Designing a Scalable Architecture for Million‑Level DAU User Systems

The article outlines a comprehensive backend architecture for handling million‑level daily active users, covering DNS routing, L4/L7 load balancing, monolithic versus microservice deployment, caching, database sharding, hybrid‑cloud deployment, elastic scaling, and multi‑level degradation strategies to ensure high availability under sudden traffic spikes.

BackendMicroservicescaching
0 likes · 12 min read
Designing a Scalable Architecture for Million‑Level DAU User Systems
DeWu Technology
DeWu Technology
Jan 12, 2022 · Backend Development

Real-time Traffic Comparison Platform for Enhancing Code Quality

The proposed real‑time traffic comparison platform samples production traffic, replays mock requests, and checks database records, MQ messages, API parameters, and responses against a reference version, enabling near‑instant detection of regressions during refactoring, reducing test effort and release cycles while requiring instrumentation and configuration but no dedicated comparison database.

BackendESMQ
0 likes · 7 min read
Real-time Traffic Comparison Platform for Enhancing Code Quality
Programmer DD
Programmer DD
Jan 12, 2022 · Backend Development

Mastering Spring’s HttpMessageConverter: Elegant Request/Response Handling

This article explains how Spring's HttpMessageConverter abstracts HTTP message conversion, shows how to read request bodies via HttpInputMessage and ServletServerHttpRequest, demonstrates a practical filter using FormHttpMessageConverter, and illustrates writing JSON responses with MappingJackson2HttpMessageConverter, all with concise code examples.

BackendHttpMessageConverterJava
0 likes · 6 min read
Mastering Spring’s HttpMessageConverter: Elegant Request/Response Handling
FunTester
FunTester
Jan 11, 2022 · Backend Development

Mastering GORM: A Beginner’s Guide to Go ORM CRUD Operations

This article walks through setting up GORM in a Go project, covering dependency management, database initialization, model definition, and practical examples of select, insert, update, delete, raw SQL execution, and transaction handling with detailed code snippets.

BackendCRUDGORM
0 likes · 9 min read
Mastering GORM: A Beginner’s Guide to Go ORM CRUD Operations
Java Architect Essentials
Java Architect Essentials
Jan 10, 2022 · Backend Development

Introducing magic-api: A Java Rapid API Development Framework

magic-api is a Java‑based rapid API development framework that lets developers create HTTP interfaces through a UI without writing Controllers, Services, DAOs, or XML, offering extensive database support, dynamic scripting, Swagger generation, and easy Spring Boot integration.

APIBackendJava
0 likes · 5 min read
Introducing magic-api: A Java Rapid API Development Framework