BestHub
Sign in
Tagged articles

Backend

5000 articles · Page 33 of 50
MaGe Linux Operations
MaGe Linux Operations
Nov 20, 2022 · Backend Development

Master Elasticsearch Pagination: From/Size, Scroll & Search After

This article examines Elasticsearch's three pagination strategies—basic from/size, scroll-based deep paging, and the newer search after method—detailing their execution phases, performance implications, code examples, and practical recommendations for choosing the appropriate approach based on data volume and real‑time requirements.

Backendfrom+sizepagination
0 likes · 17 min read
Master Elasticsearch Pagination: From/Size, Scroll & Search After
Architect
Architect
Nov 18, 2022 · Backend Development

Handling Cross‑Origin Issues with @CrossOrigin, Spring Cloud Gateway, and HttpClient

This article explains why browsers enforce same‑origin policies, presents common CORS solutions such as the @CrossOrigin annotation, gateway integration with Spring Cloud Gateway, and using HttpClient, and provides detailed configuration and code examples for implementing these approaches in a Java backend project.

BackendCORSHttpClient
0 likes · 11 min read
Handling Cross‑Origin Issues with @CrossOrigin, Spring Cloud Gateway, and HttpClient
Nightwalker Tech
Nightwalker Tech
Nov 18, 2022 · Backend Development

Design and Implementation of an E‑commerce Search Engine Using Go and Elasticsearch

This article presents a comprehensive engineering guide for building a high‑performance e‑commerce search engine with Go (Kratos), Elasticsearch/OpenSearch, Redis, MySQL, and Kafka, covering architecture, index construction, query processing, ranking, user‑guidance features, and future extensions such as recommendation and visual search.

Backende-commercegolang
0 likes · 19 min read
Design and Implementation of an E‑commerce Search Engine Using Go and Elasticsearch
Tencent Cloud Developer
Tencent Cloud Developer
Nov 18, 2022 · Backend Development

Cache Consistency Strategies and Best Practices

The article explains how using a Redis cache can boost read performance but introduces consistency challenges, compares four cache‑aside write strategies, and recommends the reliable “update database then delete cache” approach combined with short expiration times and asynchronous message‑queue invalidation to keep data fresh.

BackendMySQLRedis
0 likes · 20 min read
Cache Consistency Strategies and Best Practices
JD Tech
JD Tech
Nov 18, 2022 · Backend Development

Paginated Loading of Shopping Cart Auxiliary Information in JD E‑commerce Platform

This article examines the challenges of scaling JD's shopping cart, proposes a paginated loading strategy for auxiliary product information to reduce backend load and improve user experience, and details the technical design, pagination options, pre‑loading mechanisms, and measured performance benefits.

Asynchronous LoadingBackendPerformance
0 likes · 14 min read
Paginated Loading of Shopping Cart Auxiliary Information in JD E‑commerce Platform
High Availability Architecture
High Availability Architecture
Nov 18, 2022 · Backend Development

Microservice Architecture: Benefits, Pitfalls, and Lessons Learned from a Data‑Service Company

An in‑depth case study of a data‑service company's transition to microservices details the initial benefits such as visibility and reduced deployment cost, the subsequent problems of queue head blocking, shared‑library versioning, scaling complexity, and the eventual trade‑offs that led to a partial monolith rollback.

ArchitectureBackendMicroservices
0 likes · 10 min read
Microservice Architecture: Benefits, Pitfalls, and Lessons Learned from a Data‑Service Company
Code Ape Tech Column
Code Ape Tech Column
Nov 18, 2022 · Backend Development

Using SLF4J MDC to Correlate Logs Across Threads and Asynchronous Tasks in Java

This article explains how to use SLF4J's MDC to attach a request identifier to log entries, demonstrates the limitation of MDC in asynchronous threads, and provides a decorator‑pattern solution (MDCRunnable) that propagates the context, enabling reliable log correlation across threads in Java backend applications.

BackendDecoratorPatternJava
0 likes · 10 min read
Using SLF4J MDC to Correlate Logs Across Threads and Asynchronous Tasks in Java
Laravel Tech Community
Laravel Tech Community
Nov 17, 2022 · Backend Development

Node.js v19.1.0 Release Highlights and New Features

Node.js v19.1.0 introduces function mocking in the test runner, recursive file‑system watching support, updated ICU, documentation collaborator additions, removal of experimental fetch warnings, MIME utilities, and performance improvements for text decoding, providing a comprehensive set of backend enhancements.

BackendNode.jsfilesystem
0 likes · 2 min read
Node.js v19.1.0 Release Highlights and New Features
IT Architects Alliance
IT Architects Alliance
Nov 16, 2022 · Backend Development

How to Transform a Simple Blog into a Scalable High‑Traffic System

This article walks through turning a basic personal‑blog architecture—single server, MySQL, and Node.js—into a high‑concurrency system by adding Redis caching, Nginx load balancing, horizontal scaling, read‑write splitting, sharding, NewSQL databases, and message‑queue techniques.

BackendNewSQLRead-Write Splitting
0 likes · 15 min read
How to Transform a Simple Blog into a Scalable High‑Traffic System
Top Architect
Top Architect
Nov 13, 2022 · Backend Development

Cache Update Strategies and Concurrency Control in Backend Systems

The article analyzes the challenges of keeping cache and database consistent after write operations, evaluates four update‑order strategies, discusses their concurrency pitfalls, and presents practical solutions such as CAS, distributed locks, asynchronous updates, and delayed double‑delete techniques.

BackendCAScache
0 likes · 8 min read
Cache Update Strategies and Concurrency Control in Backend Systems
Top Architect
Top Architect
Nov 12, 2022 · Backend Development

Overview and Core Components of a Payment System Architecture

This article provides a comprehensive overview of payment system architecture, describing the transaction and payment cores, their interactions, service governance, asynchronous processing, data consistency, performance testing, and production practices, while illustrating each component with diagrams and practical insights.

BackendSystem Designpayment
0 likes · 8 min read
Overview and Core Components of a Payment System Architecture
Top Architect
Top Architect
Nov 11, 2022 · Backend Development

Distributed ID Generation Service: Features, Scenarios, and Implementation

This article explains the need for globally unique identifiers in modern applications, outlines the essential characteristics of a distributed ID generation service, examines common implementation techniques, and discusses concrete business scenarios such as order numbers, coupons, short URLs, and tracing with practical code examples.

BackendPHPcoupon code
0 likes · 18 min read
Distributed ID Generation Service: Features, Scenarios, and Implementation
Qunar Tech Salon
Qunar Tech Salon
Nov 11, 2022 · Cloud Computing

Design and Implementation of the Seras Serverless BFF/FAAS Platform for Front‑End Efficiency

This article describes the background, design decisions, architecture, core concepts (Serverless, BFF, FAAS), implementation details, performance results, and future plans of the internally built Seras platform that enables front‑end teams to write cloud functions without managing servers, improving code reuse, traceability, and deployment speed.

ArchitectureBFFBackend
0 likes · 13 min read
Design and Implementation of the Seras Serverless BFF/FAAS Platform for Front‑End Efficiency
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 10, 2022 · Backend Development

Designing a Modular Backend Service with DDD, Caching, Dynamic Proxies and Extensible Configuration

This article explains how to build a modular backend service in Java using domain‑driven design, configurable modules, dynamic proxies, cache adapters, lambda‑based query conditions, and Spring‑based conditional bean loading to enable flexible extensions without altering existing code.

BackendDomain-Driven DesignSpring
0 likes · 25 min read
Designing a Modular Backend Service with DDD, Caching, Dynamic Proxies and Extensible Configuration
ITPUB
ITPUB
Nov 9, 2022 · Backend Development

How to Scale a High‑Traffic Blog: From Nginx to MyRocks and Hadoop

This article explains how to overcome performance bottlenecks of a rapidly growing blog by progressively enhancing the traditional Nginx‑MySQL stack with load‑balanced app servers, Redis caching, read/write splitting, MySQL partitioning, MyRocks, and finally a hybrid NoSQL‑big‑data architecture using Hadoop and HBase.

BackendHadoopscalability
0 likes · 9 min read
How to Scale a High‑Traffic Blog: From Nginx to MyRocks and Hadoop
Top Architect
Top Architect
Nov 6, 2022 · Backend Development

Comprehensive Guide to Backend Development: System Design, Architecture, Network Communication, Fault Handling, Monitoring, Service Governance and Deployment

This article provides a thorough overview of backend development, covering system development principles, architectural design patterns, network communication techniques, common faults and exceptions, monitoring and alerting strategies, service governance practices, and deployment workflows, all illustrated with clear explanations and practical examples.

BackendSystem Designdeployment
0 likes · 33 min read
Comprehensive Guide to Backend Development: System Design, Architecture, Network Communication, Fault Handling, Monitoring, Service Governance and Deployment
JD Tech
JD Tech
Nov 3, 2022 · Backend Development

Asynchronous Refactoring of JD Retail Shopping Cart Service for Performance Improvement

This article details how JD's retail shopping‑cart team tackled growing business complexity by fully converting the cart service to an asynchronous architecture, addressing challenges such as increasing RPC dependencies, pagination, and resource costs, and achieving a 30% reduction in core interface latency.

BackendPerformanceRPC
0 likes · 7 min read
Asynchronous Refactoring of JD Retail Shopping Cart Service for Performance Improvement
Java Architect Essentials
Java Architect Essentials
Nov 1, 2022 · Databases

Designing Routing Keys for Sharding in an Order Platform

The article explains how to select and implement routing keys for database sharding in an order platform, covering time‑based and business‑related keys, user and merchant scenarios, hash‑modulo strategies for single and multi‑database environments, and the overall data flow.

BackendRouting Keydatabase partitioning
0 likes · 5 min read
Designing Routing Keys for Sharding in an Order Platform
php Courses
php Courses
Nov 1, 2022 · Backend Development

Resolving Duplicate Set-Cookie Header Caused by Repeated session_start() Calls in PHP

The article explains why calling PHP's session_start() multiple times generates duplicate Set-Cookie headers, provides a code-based fix using session_abort() and header_remove(), and discusses session file locking, cookie lifetime, and garbage collection settings to manage session behavior effectively.

BackendHTTP headersSession
0 likes · 3 min read
Resolving Duplicate Set-Cookie Header Caused by Repeated session_start() Calls in PHP
Selected Java Interview Questions
Selected Java Interview Questions
Oct 31, 2022 · Backend Development

Understanding Process Engines: Architecture, Design, and Applications

This article provides a comprehensive overview of process engines, explaining their definition, relationship to workflows and BPM, design of process designers, various application scenarios such as workflow and BPM, detailed architectural components, implementation practices, and potential business opportunities, illustrated with diagrams and XML examples.

ArchitectureBPMBackend
0 likes · 18 min read
Understanding Process Engines: Architecture, Design, and Applications
ITPUB
ITPUB
Oct 30, 2022 · Backend Development

Avoid Stale Data: Master Cache Aside, Read‑Through, Write‑Through & Write‑Behind Strategies

This article explains common cache update patterns—Cache Aside, Read‑Through, Write‑Through, and Write‑Behind—illustrates their read/write flows, highlights typical pitfalls such as dirty data caused by wrong update order, and offers practical safeguards for maintaining data consistency in large‑scale systems.

Backendcache-asidecaching
0 likes · 8 min read
Avoid Stale Data: Master Cache Aside, Read‑Through, Write‑Through & Write‑Behind Strategies
Java High-Performance Architecture
Java High-Performance Architecture
Oct 30, 2022 · Backend Development

Boost Your Java Backend: Master MyBatisCodeHelper Pro for Rapid Code Generation

This guide walks you through installing the MyBatisCodeHelper‑Pro IntelliJ plugin, configuring it to generate Java entity, DAO, mapper and service code, customizing type mappings, creating SQL scripts, and using shortcuts to produce find, update, delete, and pagination methods efficiently for backend development.

BackendCode GenerationDAO
0 likes · 7 min read
Boost Your Java Backend: Master MyBatisCodeHelper Pro for Rapid Code Generation
Selected Java Interview Questions
Selected Java Interview Questions
Oct 29, 2022 · Information Security

Comprehensive Guide to Spring Security: Setup, Authentication, Authorization, and Advanced Configurations

This article provides a detailed tutorial on Spring Security, covering its core concepts, project setup, authentication flow, custom user details service, password encoding, login handling, role-based access control, CSRF protection, and integration with Thymeleaf, complete with code examples.

AuthenticationAuthorizationBackend
0 likes · 14 min read
Comprehensive Guide to Spring Security: Setup, Authentication, Authorization, and Advanced Configurations
Top Architect
Top Architect
Oct 28, 2022 · Backend Development

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

The article explains why front‑end and back‑end should be separated, outlines the challenges of integration, describes the responsibilities and development process for a clean API contract, and provides detailed request/response specifications with code examples for building a maintainable SPA architecture.

API DesignArchitectureBackend
0 likes · 11 min read
Guidelines for Front‑End/Back‑End Separation and API Specification
Top Architect
Top Architect
Oct 28, 2022 · Backend Development

Configuring Redis Memory Size and Eviction Policies (LRU & LFU)

This article explains how to size Redis memory, configure maxmemory and maxmemory‑policy settings, and choose among various eviction strategies—including no‑eviction, allkeys‑lru, allkeys‑lfu, and volatile options—while detailing the underlying LRU and LFU algorithms used by Redis.

BackendLFURedis
0 likes · 7 min read
Configuring Redis Memory Size and Eviction Policies (LRU & LFU)
Programmer DD
Programmer DD
Oct 27, 2022 · Backend Development

Do Frameworks Really Damage Software Maintainability?

This article examines how adopting software frameworks—especially web frameworks—can undermine long‑term maintainability through control inversion, mismatched goals, design trade‑offs, and hidden costs, while also showing how a decoupled approach can retain benefits without the drawbacks.

BackendFrameworkscode quality
0 likes · 19 min read
Do Frameworks Really Damage Software Maintainability?
Selected Java Interview Questions
Selected Java Interview Questions
Oct 26, 2022 · Backend Development

Choosing the Right Delayed‑Task Solution: Why Redis Expiration and RabbitMQ Dead‑Letter Queues Are Problematic

The article evaluates common approaches for implementing delayed tasks such as order‑closing, critiques unreliable methods like Redis expiration listeners and RabbitMQ dead‑letter queues, and recommends robust solutions like RocketMQ, Pulsar, or Redisson delay queues with proper compensation mechanisms.

BackendRabbitMQRedis
0 likes · 8 min read
Choosing the Right Delayed‑Task Solution: Why Redis Expiration and RabbitMQ Dead‑Letter Queues Are Problematic
Java High-Performance Architecture
Java High-Performance Architecture
Oct 26, 2022 · Information Security

How to Build a Secure High‑Performance User Login System with Token Management

This article walks through the complete design and implementation of a high‑performance user login system, covering client‑side verification, server‑side token generation, token expiration strategies, gateway authentication, logout handling, anonymous request allowances, rate‑limited auth tokens, and blacklist management, illustrated with diagrams and Java Spring code examples.

BackendSpring
0 likes · 9 min read
How to Build a Secure High‑Performance User Login System with Token Management
Top Architect
Top Architect
Oct 25, 2022 · Backend Development

Understanding Netty's Asynchronous Model, Linux I/O Multiplexing (select, poll, epoll) and JNI Integration

This article explains Netty's high‑performance asynchronous architecture, compares classic multithread, Reactor, select, poll and epoll I/O multiplexing models, describes level‑triggered versus edge‑triggered event handling, and provides a step‑by‑step JNI example and a hand‑written epoll server implementation in C.

BackendEpollIO Multiplexing
0 likes · 34 min read
Understanding Netty's Asynchronous Model, Linux I/O Multiplexing (select, poll, epoll) and JNI Integration
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Oct 24, 2022 · Backend Development

Mastering Long-Connection Load Balancing: Strategies and Pitfalls

This article explains the differences between short and long connections, why long‑connection services need load balancing, and presents practical strategies for connection‑level balancing, handling server restarts, heterogeneous hardware, and scaling challenges.

BackendLong ConnectionServer Architecture
0 likes · 8 min read
Mastering Long-Connection Load Balancing: Strategies and Pitfalls
Top Architect
Top Architect
Oct 23, 2022 · Backend Development

In‑Memory Cache Design with Guava LoadingCache, Eviction Strategies, and LRU Implementation

This article explains the fundamentals of in‑memory caching, introduces Guava's LoadingCache API, discusses cache sizing, eviction policies, common algorithms like FIFO, LRU, LFU, shows a simple LRU implementation using LinkedHashMap, and provides practical guidance on when and how to apply caching for performance optimization.

BackendGuavaJava
0 likes · 14 min read
In‑Memory Cache Design with Guava LoadingCache, Eviction Strategies, and LRU Implementation
Top Architect
Top Architect
Oct 21, 2022 · Backend Development

Comprehensive Guide to Microservice Architecture: Concepts, Evolution, Design Patterns, and Practical Implementation

This article provides an in‑depth overview of microservice architecture, covering its definition, history, differences from monolithic and SOA approaches, core characteristics, design patterns, advantages and drawbacks, practical deployment considerations, and recommended reading resources.

ArchitectureBackendDevOps
0 likes · 20 min read
Comprehensive Guide to Microservice Architecture: Concepts, Evolution, Design Patterns, and Practical Implementation
Architect's Guide
Architect's Guide
Oct 21, 2022 · Backend Development

Understanding Netty's Asynchronous Model and Linux epoll: From the Stone Sword Analogy to High‑Performance IO

This article explains how Netty implements a powerful asynchronous, event‑driven architecture using the Reactor pattern, compares classic multithread, select, poll and epoll I/O multiplexing models, demonstrates JNI integration with Java, and provides a complete, annotated epoll server example with level‑triggered and edge‑triggered handling for high‑concurrency backend development.

BackendEpollIO Multiplexing
0 likes · 32 min read
Understanding Netty's Asynchronous Model and Linux epoll: From the Stone Sword Analogy to High‑Performance IO
Inke Technology
Inke Technology
Oct 20, 2022 · Backend Development

How We Cut 60% of Backend Load with Go’s singleflight and Smart Caching

This article examines how the mic‑queue list in a live‑streaming app caused heavy server load due to three‑second polling, and details a systematic performance‑optimization process—including analysis, reducing I/O, employing Go’s singleflight caching, and switching JSON libraries—to cut resource usage by up to 60% while preserving user experience.

Backendcachinggolang
0 likes · 7 min read
How We Cut 60% of Backend Load with Go’s singleflight and Smart Caching
Liangxu Linux
Liangxu Linux
Oct 19, 2022 · Backend Development

Mastering Application Layering: From Alibaba Specs to Practical Backend Architecture

This article examines common misconceptions about application layering, outlines Alibaba's multi‑layer architecture—including Open Interface, Terminal Display, Web, Service, Manager, and DAO layers—offers optimized layering practices, explains domain model transformations, and provides actionable guidelines for building maintainable, reusable backend systems.

AlibabaBackendController
0 likes · 9 min read
Mastering Application Layering: From Alibaba Specs to Practical Backend Architecture
Laravel Tech Community
Laravel Tech Community
Oct 19, 2022 · Backend Development

Node.js 19 Release Highlights: V8 10.7 Upgrade, Experimental --watch, Default HTTP/1.1 KeepAlive, Stable WebCrypto, and Deprecations

Node.js 19, released today, updates the V8 engine to version 10.7, enables experimental node --watch mode, defaults HTTP/1.1 Keep‑Alive, stabilizes the WebCrypto API, removes experimental specifier‑resolution flag, and deprecates DTrace/SystemTap/ETW support while bundling llhttp 8.1.0 and npm 8.19.2.

BackendNode.jsV8
0 likes · 4 min read
Node.js 19 Release Highlights: V8 10.7 Upgrade, Experimental --watch, Default HTTP/1.1 KeepAlive, Stable WebCrypto, and Deprecations
FunTester
FunTester
Oct 19, 2022 · Backend Development

Controlling Java Async QPS with Semaphore and ThreadPool

This article explains how to use Java's java.util.concurrent.Semaphore together with a fixed-size thread pool to enforce a precise QPS limit for asynchronous tasks, providing API details, implementation steps, and a complete test example.

BackendJavaQPS
0 likes · 6 min read
Controlling Java Async QPS with Semaphore and ThreadPool
Architect
Architect
Oct 18, 2022 · Backend Development

Implementing CORS Cross‑Origin Requests in a Java Spring Backend

This article explains the browser same‑origin policy, defines cross‑origin requests, outlines the restrictions they impose, and presents five practical ways—global filter, WebMvcConfigurer, @CrossOrigin annotation, manual response headers, and a custom filter—to enable CORS in a Java Spring MVC backend with complete code examples.

BackendCORSJava
0 likes · 7 min read
Implementing CORS Cross‑Origin Requests in a Java Spring Backend
Top Architect
Top Architect
Oct 18, 2022 · Backend Development

Nginx Configuration Guide: HTTP Server, Static Files, Reverse Proxy, Load Balancing and Advanced Directives

This comprehensive guide explains how to configure Nginx as an HTTP server, static file server, reverse proxy, and load balancer, covering directory setup, location matching rules, priority order, upstream strategies, and useful directives such as return, rewrite, error_page, logging and access control.

BackendConfigurationNginx
0 likes · 17 min read
Nginx Configuration Guide: HTTP Server, Static Files, Reverse Proxy, Load Balancing and Advanced Directives
Top Architect
Top Architect
Oct 16, 2022 · Backend Development

Common Load Balancing Algorithms and Their Java Implementations

This article provides a comprehensive overview of various load balancing strategies—including round‑robin, random, weighted, smooth weighted round‑robin, consistent hashing, least‑active, and optimal‑response algorithms—explaining their principles, advantages, disadvantages, use‑cases, and offering complete Java code examples for each.

Backendalgorithmdistributed systems
0 likes · 33 min read
Common Load Balancing Algorithms and Their Java Implementations
Selected Java Interview Questions
Selected Java Interview Questions
Oct 15, 2022 · Backend Development

My 2023 Autumn Recruitment Journey and Interview Preparation Insights

The author recounts his 2023 autumn recruitment experience, detailing his background, internships, extensive job applications, interview outcomes, study strategies covering fundamentals, design patterns, and distributed systems, and offers practical advice for fellow graduates navigating the competitive tech job market.

BackendInterview PrepJava
0 likes · 9 min read
My 2023 Autumn Recruitment Journey and Interview Preparation Insights
Top Architect
Top Architect
Oct 15, 2022 · Backend Development

Designing Fault‑Tolerant Microservices: Patterns and Practices

The article explains how microservice architectures can achieve high availability by isolating failures, employing graceful degradation, change‑management strategies, health checks, fallback caching, retry logic, rate limiting, circuit breakers, and chaos testing, while acknowledging the added complexity and cost of such reliability engineering.

BackendOperationscloud-native
0 likes · 13 min read
Designing Fault‑Tolerant Microservices: Patterns and Practices
Java Architect Essentials
Java Architect Essentials
Oct 13, 2022 · Backend Development

Five Java/Kotlin Microservice Frameworks Compared: Helidon, Ktor, Micronaut, Quarkus & Spring Boot

The article builds five microservices with Helidon SE, Ktor, Micronaut, Quarkus and Spring Boot, integrates Consul for service discovery, provides full source code and configuration, shows how to start each service, benchmarks size, startup time and memory usage, and finally lists the pros and cons of each framework.

BackendConsulJava
0 likes · 22 min read
Five Java/Kotlin Microservice Frameworks Compared: Helidon, Ktor, Micronaut, Quarkus & Spring Boot
Efficient Ops
Efficient Ops
Oct 12, 2022 · Backend Development

From Monolith to Microservices: A Real‑World Journey and Lessons Learned

This article walks through the evolution of a simple online supermarket from a monolithic website to a fully split microservice architecture, highlighting the challenges encountered—such as code duplication, database bottlenecks, and operational complexity—and presenting practical solutions like service decomposition, monitoring, tracing, gateway control, service discovery, circuit breaking, rate limiting, testing strategies, and the use of service meshes.

ArchitectureBackendMicroservices
0 likes · 23 min read
From Monolith to Microservices: A Real‑World Journey and Lessons Learned
Python Programming Learning Circle
Python Programming Learning Circle
Oct 12, 2022 · Backend Development

Comprehensive Guide to Downloading Files in Python Using Requests, wget, urllib, urllib3, Boto3, and asyncio

This tutorial walks through multiple Python approaches for downloading files—including simple requests.get calls, the wget module, handling redirects, chunked large‑file downloads, parallel batch downloads, proxy usage with urllib, S3 retrieval via Boto3, and asynchronous fetching with asyncio—providing code examples and best‑practice tips.

BackendBoto3File Download
0 likes · 8 min read
Comprehensive Guide to Downloading Files in Python Using Requests, wget, urllib, urllib3, Boto3, and asyncio
Java Architecture Diary
Java Architecture Diary
Oct 11, 2022 · Backend Development

What’s New in Spring 6? Key Changes for Jakarta EE Migration and Web Development

Spring 6 introduces major updates such as moving JSR‑330 and JSR‑250 annotations to Jakarta packages, deprecating ListenableFuture, requiring Hibernate 5.6.x with jakarta.persistence, updating servlet containers, altering controller detection, converting HttpMethod to a class, and adjusting Kotlin and RestTemplate APIs.

BackendJakarta EEJava
0 likes · 4 min read
What’s New in Spring 6? Key Changes for Jakarta EE Migration and Web Development
Code Ape Tech Column
Code Ape Tech Column
Oct 11, 2022 · Databases

13 Redis Performance Optimization Rules

This article presents thirteen practical guidelines for optimizing Redis performance, covering command selection, key management, data structures, persistence settings, hardware choices, clustering, and memory fragmentation mitigation to achieve significant speed improvements.

BackendOptimizationPerformance
0 likes · 11 min read
13 Redis Performance Optimization Rules
Top Architect
Top Architect
Oct 10, 2022 · Databases

Designing Routing Keys for Sharding in an Order Platform

This article explains how to select and implement routing keys for database sharding in a food‑delivery order system, covering supported scenarios, single‑ and multi‑database strategies, hash‑based distribution for both user and merchant data, and practical flow diagrams to ensure balanced and efficient data access.

BackendHash PartitioningRouting Key
0 likes · 5 min read
Designing Routing Keys for Sharding in an Order Platform
JD Cloud Developers
JD Cloud Developers
Oct 10, 2022 · Backend Development

How MyBatis Executes Queries and Fixes a Pre‑3.4.5 Bug

This article walks through MyBatis's complete query lifecycle—from configuration parsing, SqlSessionFactory creation, and mapper loading to the actual SELECT execution—while reproducing a pre‑3.4.5 bug caused by foreach variable leakage and presenting the official fix and upgrade recommendations.

BackendJavaMyBatis
0 likes · 20 min read
How MyBatis Executes Queries and Fixes a Pre‑3.4.5 Bug
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 9, 2022 · Backend Development

Choosing a Microservice Gateway: Spring Cloud Gateway vs APISIX

After moving to a new team lacking a dedicated gateway, the author evaluates two popular microservice gateway solutions—Spring Cloud Gateway and Apache APISIX—comparing their features, cloud‑native capabilities, performance, and ease of use, ultimately selecting Spring Cloud Gateway for its Java ecosystem and extensibility.

APISIXBackendCloud Native
0 likes · 11 min read
Choosing a Microservice Gateway: Spring Cloud Gateway vs APISIX
dbaplus Community
dbaplus Community
Oct 7, 2022 · Backend Development

Why Onion Architecture Boosts Maintainability and Testability in Complex Systems

Onion Architecture, a DDD‑aligned design pattern, structures applications into concentric layers centered on the domain model, promoting loose coupling, testability, and technology‑agnostic core logic, while detailing principles, layer responsibilities, testing strategies, microservice applicability, modular packaging, and practical implementation considerations.

BackendDomain-Driven DesignOnion Architecture
0 likes · 12 min read
Why Onion Architecture Boosts Maintainability and Testability in Complex Systems
Code Ape Tech Column
Code Ape Tech Column
Oct 5, 2022 · Backend Development

Spring Boot 2.7 Upgrade Pitfalls and Solutions

This article provides a comprehensive guide to upgrading Spring Boot to version 2.7, detailing common issues such as missing dependencies, logging conflicts, circular bean references, Swagger configuration changes, Flyway compatibility, JUnit version mismatches, and JSON Long precision loss, along with concrete code‑based solutions.

BackendFlywayJava
0 likes · 14 min read
Spring Boot 2.7 Upgrade Pitfalls and Solutions
Su San Talks Tech
Su San Talks Tech
Oct 4, 2022 · Backend Development

11 Must‑Know Spring Extension Points to Supercharge Your Java Backend

Explore the 11 most commonly used Spring extension points—from custom interceptors and bean factories to global exception handling, type converters, import mechanisms, startup runners, bean lifecycle processors, and custom scopes—complete with clear code examples and practical guidance for enhancing Java backend applications.

@BeanBackendConfiguration
0 likes · 11 min read
11 Must‑Know Spring Extension Points to Supercharge Your Java Backend
21CTO
21CTO
Oct 2, 2022 · Backend Development

Pyston 2.3.5 Boosts Python Performance with Major CPython Compatibility

Pyston 2.3.5, a fork of CPython 3.8 maintained by Anaconda, delivers double‑digit performance gains for network‑service workloads, offers two‑fold speedups on micro‑benchmarks like chaos.py and nbody.py, and remains highly compatible with the full CPython feature set and C API.

BackendJITPyston
0 likes · 4 min read
Pyston 2.3.5 Boosts Python Performance with Major CPython Compatibility
Top Architect
Top Architect
Oct 2, 2022 · Backend Development

Implementing Load Balancing with Nginx and Spring Boot

This article explains how Nginx can be used to achieve various load‑balancing strategies—including round‑robin, least connections, IP hash, generic hash, random and least‑time—provides concrete upstream and server configuration examples, shows how to integrate Nginx with a Spring Boot application, and details testing procedures to verify balanced request distribution.

BackendConfigurationNginx
0 likes · 8 min read
Implementing Load Balancing with Nginx and Spring Boot
Top Architect
Top Architect
Oct 1, 2022 · Backend Development

Best Practices for Backend Application Layering and Domain Model Conversion

This article discusses the importance of proper backend application layering, outlines Alibaba's multi‑layer architecture (controller, service, manager, DAO, etc.), explains domain model transformations (DO, DTO, BO, VO, etc.), and offers practical recommendations for achieving clear responsibilities and maintainable code.

BackendDAODomain Model
0 likes · 9 min read
Best Practices for Backend Application Layering and Domain Model Conversion
Selected Java Interview Questions
Selected Java Interview Questions
Sep 30, 2022 · Backend Development

Best Practices for Application Layering and Domain Model Design in Backend Development

The article explains why clear application layering—covering controller, service, manager, and DAO levels—is essential for maintainable backend code, describes Alibaba's recommended layer structure, proposes an optimized layering model, and outlines domain object conventions such as DO, DTO, BO, AO, VO, and Query.

ArchitectureBackendDAO
0 likes · 10 min read
Best Practices for Application Layering and Domain Model Design in Backend Development
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 30, 2022 · Backend Development

Designing Modular Backend Services and API Management with Spring Cloud

This article explains how to build a highly extensible, modular backend service using Spring Cloud, demonstrates practical module composition and separation, discusses RESTful API design principles, presents concrete Java code examples for commands, controllers and pagination, and reviews popular API documentation tools such as Swagger, SpringDoc and Knife4j.

BackendRESTfulapi-design
0 likes · 17 min read
Designing Modular Backend Services and API Management with Spring Cloud
Architecture Digest
Architecture Digest
Sep 30, 2022 · Backend Development

Best Practices for Designing a Good API

This article explains why well‑designed APIs are essential, covering data modeling, resource hierarchy, naming conventions, RESTful principles, CRUD operations, versioning strategies, and pagination techniques, and provides concrete examples and guidelines to help developers create robust, maintainable, and developer‑friendly APIs.

API DesignBackendREST
0 likes · 7 min read
Best Practices for Designing a Good API
Top Architect
Top Architect
Sep 29, 2022 · Backend Development

Handling Duplicate Consumption in RabbitMQ: Scenarios, Tests, and Solutions

This article explains the causes of duplicate message consumption in RabbitMQ, demonstrates how to reproduce the issue with a 10,000‑message test, and provides three practical solutions using unique IDs stored in Redis to ensure idempotent processing in Java Spring applications.

Backendduplicate-consumptionmessage-queue
0 likes · 9 min read
Handling Duplicate Consumption in RabbitMQ: Scenarios, Tests, and Solutions
FunTester
FunTester
Sep 28, 2022 · Backend Development

Seamlessly Convert Java Functional Interfaces to Groovy Closures

This article explains the compatibility challenges between Java functional interfaces and Groovy closures, introduces a utility class that converts Supplier, Function, Predicate, and Consumer into Groovy closures, and provides a complete code example with demonstration and output.

BackendFunctional InterfaceGroovy
0 likes · 5 min read
Seamlessly Convert Java Functional Interfaces to Groovy Closures
转转QA
转转QA
Sep 28, 2022 · Backend Development

Remote Debugging Guide for Sandbox and Test Environments

This article explains how to set up remote debugging for services in sandbox or test environments, covering remote creation, locating debug ports, constructing JVM arguments, checking service status, stopping services, and useful alias commands to streamline the debugging process.

BackendRemote DebuggingService Management
0 likes · 5 min read
Remote Debugging Guide for Sandbox and Test Environments
DaTaobao Tech
DaTaobao Tech
Sep 26, 2022 · Backend Development

Deep Dive into Node.js CJS Module Loading Process

The article dissects Node.js v17’s source to reveal how the CommonJS `require` system is bootstrapped, how native modules are loaded, how `Module._load` resolves, caches, and executes user files, and how the overall CJS loading pipeline operates step‑by‑step.

BackendCJSNode.js
0 likes · 15 min read
Deep Dive into Node.js CJS Module Loading Process
Selected Java Interview Questions
Selected Java Interview Questions
Sep 25, 2022 · Backend Development

Understanding Component Implementation Principles for Technical Interviews

The article explains why interviewers probe the implementation details of backend components such as Redis, HashMap, and Memcached, illustrates common interview questions, and shows how mastering the underlying data structures, algorithms, and memory‑allocation mechanisms can improve both interview performance and real‑world problem solving.

AlgorithmsBackendData Structures
0 likes · 8 min read
Understanding Component Implementation Principles for Technical Interviews
Top Architect
Top Architect
Sep 25, 2022 · Backend Development

Using Spring Application Events for Synchronous and Asynchronous Processing

This article explains how to leverage Spring Application Events to decouple business logic, demonstrates creating custom events, listeners, and publishers, shows both synchronous and asynchronous handling with @EventListener and @Async, and provides complete code samples and test results.

Backendapplication-eventasynchronous
0 likes · 9 min read
Using Spring Application Events for Synchronous and Asynchronous Processing
Cognitive Technology Team
Cognitive Technology Team
Sep 25, 2022 · Backend Development

Implementation and Pitfalls of Distributed Locks with Redis and Redisson Watchdog

This article explains the requirements for a Redis‑based distributed lock, analyzes Redisson's watchdog lock implementation—including tryLock and unlock flows, Lua atomic scripts, single‑instance versus cluster limitations—and provides practical tips to avoid common pitfalls in production environments.

BackendRedissondistributed lock
0 likes · 6 min read
Implementation and Pitfalls of Distributed Locks with Redis and Redisson Watchdog
Su San Talks Tech
Su San Talks Tech
Sep 25, 2022 · Backend Development

Mastering Java Thread Pools: Architecture, Execution Flow, and Custom Tuning

This article explains the fundamentals of Java thread pools, covering their purpose, construction parameters, execution process, worker reuse, task retrieval with timeout, lifecycle states, shutdown methods, monitoring techniques, and practical guidelines for customizing thread pools in real-world projects.

BackendExecutorServiceJava
0 likes · 17 min read
Mastering Java Thread Pools: Architecture, Execution Flow, and Custom Tuning
Top Architect
Top Architect
Sep 24, 2022 · Frontend Development

Guidelines for Frontend‑Backend Separation and API Specification

This article explains why and how to separate frontend and backend responsibilities, outlines the evolution from MVC to SPA architectures, and provides detailed API request and response conventions—including JSON formats, pagination, and special field handling—to improve collaboration and reduce integration effort.

API DesignArchitectureBackend
0 likes · 10 min read
Guidelines for Frontend‑Backend Separation and API Specification
Programmer DD
Programmer DD
Sep 23, 2022 · Backend Development

Scaling a Nationwide ID Lookup Service with Minimal Resources

The article outlines a practical backend design for handling 20 million daily ID lookups across a billion records, showing how modest hardware—20 virtual machines with 16 GB RAM each—can meet the load using simple sharding, in‑memory storage, and basic networking techniques.

BackendSystem Designdatabase
0 likes · 7 min read
Scaling a Nationwide ID Lookup Service with Minimal Resources
FunTester
FunTester
Sep 21, 2022 · Backend Development

Mastering Go Redis Set Operations: API Guide and Performance Benchmark

This article provides a comprehensive guide to implementing and testing Go Redis Set APIs—including SAdd, SCard, SIsMember, SMembers, SRem, SPop, and SPopN—complete with code examples, a unified test suite, and a performance benchmark that reports QPS and execution time.

APIBackendGo
0 likes · 8 min read
Mastering Go Redis Set Operations: API Guide and Performance Benchmark
21CTO
21CTO
Sep 20, 2022 · Backend Development

Mastering RESTful URI Design: Naming Conventions for Clear APIs

This guide explains how to name REST API resources using nouns, plural forms, hyphens, and versioning while avoiding verbs, underscores, trailing slashes, and file extensions, and shows how to apply query parameters and standard CRUD operations for clean, intuitive URIs.

BackendRESTURI naming
0 likes · 7 min read
Mastering RESTful URI Design: Naming Conventions for Clear APIs
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 20, 2022 · Backend Development

Understanding MyBatis First-Level and Second-Level Caches: Principles, Implementation, and Differences

This article explains the principles, implementation steps, and configuration of MyBatis first‑level (SqlSession) and second‑level (mapper) caches, compares their scopes and behaviors, and provides practical guidance on when and how to enable each cache to improve database query performance.

BackendJavaMyBatis
0 likes · 7 min read
Understanding MyBatis First-Level and Second-Level Caches: Principles, Implementation, and Differences