BestHub
Sign in
Tagged articles
4052 articles
Page 29 of 41
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.

Backend DevelopmentDistributed CoordinationZAB Protocol
0 likes · 8 min read
Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases
Tencent Cloud Middleware
Tencent Cloud Middleware
Jul 8, 2021 · Backend Development

Mastering Pulsar Schema: When and How to Use Schemas for Reliable Messaging

This article explains why Apache Pulsar schemas are essential for serializing POJO data, compares producer usage with and without schemas, details primitive and complex schema types, key/value handling, auto‑schema options, versioning, evolution, compatibility strategies, and provides concrete Java code examples for each scenario.

Apache PulsarBackend DevelopmentJava
0 likes · 14 min read
Mastering Pulsar Schema: When and How to Use Schemas for Reliable Messaging
Top Architect
Top Architect
Jul 8, 2021 · Backend Development

Implementing Dynamic Add/Delete/Start/Stop Scheduled Tasks in Spring Boot

This article explains how to overcome Spring Boot's static @Scheduled limitation by customizing the task scheduler, creating wrapper classes and a registrar to dynamically add, remove, start, and stop cron‑based jobs, with full code examples and a database‑driven design.

Backend DevelopmentDynamic SchedulingJava
0 likes · 11 min read
Implementing Dynamic Add/Delete/Start/Stop Scheduled Tasks in Spring Boot
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 8, 2021 · Backend Development

Roadmap to Becoming a Java Backend Architect: Skills from Junior to Senior

From a fresh Java junior engineer to a seasoned architect, this guide outlines the essential skills, technologies, and responsibilities at each career stage—1‑3 years, 3‑5 years, and 5‑8 years—highlighting data structures, algorithms, frameworks, distributed systems, and database expertise needed for backend development.

Backend DevelopmentDistributed SystemsJava
0 likes · 5 min read
Roadmap to Becoming a Java Backend Architect: Skills from Junior to Senior
IT Architects Alliance
IT Architects Alliance
Jul 7, 2021 · Backend Development

Mastering Single Sign-On: From Session Basics to Java Implementation

This article explains the stateless nature of HTTP, introduces session and cookie mechanisms for single‑system login, discusses the challenges of multi‑system applications, and provides a step‑by‑step guide with Java code to implement Single Sign‑On (SSO) including login, token verification, global and local sessions, and coordinated logout.

Backend DevelopmentJavaSSO
0 likes · 16 min read
Mastering Single Sign-On: From Session Basics to Java Implementation
Laravel Tech Community
Laravel Tech Community
Jul 7, 2021 · Backend Development

gout – Go HTTP Client Library Overview

The gout library is a Go‑based HTTP client that offers extensive request configuration, body encoding, response parsing, benchmarking, retry logic, raw packet sending, curl export, and custom client injection, with recent updates adding a WithTimeout option and improved handling of empty values.

Backend DevelopmentGoHTTP client
0 likes · 3 min read
gout – Go HTTP Client Library Overview
Top Architect
Top Architect
Jul 7, 2021 · Backend Development

Design and Implementation of a High‑Concurrency API Gateway

This article details the architecture and implementation of a high‑concurrency API gateway built on RxNetty, covering request routing, conditional routing, API management, rate limiting, circuit breaking, security policies, monitoring, tracing, and future enhancements within a microservices environment.

Backend DevelopmentMicroservicesObservability
0 likes · 11 min read
Design and Implementation of a High‑Concurrency API Gateway
Architect's Tech Stack
Architect's Tech Stack
Jul 7, 2021 · Backend Development

Visualizing Java Servlet Inheritance and Interface Relationships with IntelliJ IDEA Diagrams

This guide demonstrates how to use IntelliJ IDEA's diagram feature to view, customize, and explore the inheritance and interface implementation hierarchy of Java Servlet classes, including filtering irrelevant nodes, inspecting members, adjusting visibility, zooming, adding related classes, and jumping to source code.

Backend DevelopmentIDE TipsInheritance Diagram
0 likes · 6 min read
Visualizing Java Servlet Inheritance and Interface Relationships with IntelliJ IDEA Diagrams
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 6, 2021 · Backend Development

Mastering Layered Architecture: Design Principles and Java Implementation

This article outlines the concepts, advantages, drawbacks, and design guidelines of layered architecture, explores logical, presentation, service, and physical layers, and demonstrates a Java implementation with detailed diagrams to help developers build scalable, maintainable systems.

Backend DevelopmentLayered ArchitectureSystem Design
0 likes · 5 min read
Mastering Layered Architecture: Design Principles and Java Implementation
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 3, 2021 · Backend Development

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

The article explains how to abstract remote data location logic using an RPC framework built on Spring and Dubbo, demonstrates proxy injection and service registration, and shows how similar principles are applied to Redis Cluster to reduce request redirection and improve scalability.

Backend DevelopmentDistributed SystemsJava
0 likes · 12 min read
Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster
21CTO
21CTO
Jul 2, 2021 · Fundamentals

Mastering RBAC: From Basic Models to Advanced Permission Design

This article explains the fundamentals of permission management, detailing RBAC models, user‑role‑permission relationships, organization and position structures, authorization workflows, database schema design, and popular security frameworks for building robust backend access control systems.

Backend DevelopmentPermission ModelRBAC
0 likes · 12 min read
Mastering RBAC: From Basic Models to Advanced Permission Design
Top Architect
Top Architect
Jun 29, 2021 · Backend Development

Performance Comparison of Java Stream API vs Iterator and Recommendations

This article explains Java 8 Stream fundamentals, compares its intermediate and terminal operations with traditional iterator loops through a series of benchmark tests (mapping, filtering, sorting, reduction, string joining, and mixed operations), analyzes results for different data sizes and CPU configurations, and provides practical guidance on when to use Stream, parallel Stream, or iterator in backend development.

Backend DevelopmentIteratorJava
0 likes · 12 min read
Performance Comparison of Java Stream API vs Iterator and Recommendations
Architecture Digest
Architecture Digest
Jun 28, 2021 · Backend Development

Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges

The article explains the rise of Domain-Driven Design by tracing architectural evolution from monolithic to microservices, highlighting DDD’s role in defining business boundaries, its strategic and tactical components, and practical steps for modeling domains to guide microservice design.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 11 min read
Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges
Programmer DD
Programmer DD
Jun 28, 2021 · Backend Development

Unlocking Spring Boot Actuator: Secure Configuration and Hidden Risks

This article explains what Spring Boot Actuator is, how to quickly add and configure it, details the available endpoints, illustrates common security pitfalls such as exposing sensitive configuration, and provides practical recommendations to safely use Actuator in production environments.

ActuatorBackend DevelopmentJava
0 likes · 8 min read
Unlocking Spring Boot Actuator: Secure Configuration and Hidden Risks
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 26, 2021 · Backend Development

Master Spring Boot Startup Tasks: Runners, Config, and Command-Line Tricks

After launching a Spring Boot 2.3.9 application, you can execute custom tasks using ApplicationRunner or CommandLineRunner, access startup arguments, generate random configuration values, disable command-line properties, understand configuration file loading order, and correctly use @EnableConfigurationProperties for bean binding.

ApplicationRunnerBackend DevelopmentConfigurationProperties
0 likes · 6 min read
Master Spring Boot Startup Tasks: Runners, Config, and Command-Line Tricks
Selected Java Interview Questions
Selected Java Interview Questions
Jun 25, 2021 · Backend Development

Message Queues for Interviews: Why Use MQ, Benefits, Drawbacks, and Comparison of Kafka, ActiveMQ, RabbitMQ, and RocketMQ

This article explains why message queues are used in modern systems, outlines common interview questions about MQ, discusses the advantages of decoupling, asynchronous processing, and traffic shaping, examines the pros and cons of MQ, and compares the four major MQ products—Kafka, ActiveMQ, RabbitMQ, and RocketMQ—to help candidates prepare for technical interviews.

ActiveMQBackend DevelopmentKafka
0 likes · 11 min read
Message Queues for Interviews: Why Use MQ, Benefits, Drawbacks, and Comparison of Kafka, ActiveMQ, RabbitMQ, and RocketMQ
Code Ape Tech Column
Code Ape Tech Column
Jun 25, 2021 · Backend Development

Mastering API Full Lifecycle: From Object Modeling to Service Orchestration

This article explores comprehensive API lifecycle management, detailing how lightweight API gateways integrate with object‑driven development platforms, the division into four subsystems, automatic contract generation, rule handling, service composition, microservice packaging, and source‑code export, providing a practical roadmap for building scalable API solutions.

API ManagementBackend DevelopmentMicroservices
0 likes · 16 min read
Mastering API Full Lifecycle: From Object Modeling to Service Orchestration
Top Architect
Top Architect
Jun 23, 2021 · Backend Development

Understanding Load Balancing in Spring Cloud: Registering Multiple Services and Code Analysis

This article explains the concept of load balancing, illustrates it with a bank queue analogy, and demonstrates how to register multiple Spring Cloud service instances, use Feign and DiscoveryClient, configure Ribbon's load‑balancing interceptor, and customize the balancing rule for effective microservice traffic distribution.

Backend DevelopmentDiscoveryClientMicroservices
0 likes · 13 min read
Understanding Load Balancing in Spring Cloud: Registering Multiple Services and Code Analysis
Java Backend Technology
Java Backend Technology
Jun 22, 2021 · Backend Development

Boost Java Productivity: Essential Utility Libraries and Code Tricks

This article introduces a collection of powerful Java utility libraries—including built‑in methods, Apache Commons, and Google Guava—showing practical code snippets for string handling, collection operations, object mapping, file I/O, and advanced data structures to dramatically reduce boilerplate and improve development efficiency.

Apache CommonsBackend DevelopmentCode Examples
0 likes · 13 min read
Boost Java Productivity: Essential Utility Libraries and Code Tricks
Programmer DD
Programmer DD
Jun 22, 2021 · Backend Development

Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue

This article presents a full‑stack Java mall project with distribution features, detailing its object‑oriented advantages, comprehensive backend and frontend technology stack, project structure, implemented modules such as member management, product editing, promotion, order and system management, deployment environment, and provides source code and documentation for developers.

Backend DevelopmentJavaMyBatis
0 likes · 6 min read
Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue
21CTO
21CTO
Jun 20, 2021 · Backend Development

Which Programming Language Is Best for Building Microservices? A Comparative Guide

This article explains what microservices are, who can benefit from them, and compares five popular programming languages—Go, Java, Python, C++, and Ruby—highlighting their strengths and drawbacks for developing scalable, maintainable microservice architectures.

Backend DevelopmentGolangJava
0 likes · 7 min read
Which Programming Language Is Best for Building Microservices? A Comparative Guide
Top Architect
Top Architect
Jun 18, 2021 · Backend Development

Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism

This article explains how Spring Boot's @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are discovered from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat web server, with illustrative code snippets.

Backend DevelopmentJavaSpring Boot
0 likes · 12 min read
Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism
Wukong Talks Architecture
Wukong Talks Architecture
Jun 17, 2021 · Databases

Ensuring Data Consistency Without Native Transactions in MongoDB

The article explains how lack of native transactions in MongoDB 3.0 can cause data inconsistency during order processing, compares it with SQL transaction mechanisms, and proposes optimization and compensation strategies such as retry queues, asynchronous tasks, and refund handling to ensure eventual consistency.

Backend DevelopmentCompensationData Consistency
0 likes · 10 min read
Ensuring Data Consistency Without Native Transactions in MongoDB
IT Xianyu
IT Xianyu
Jun 16, 2021 · Databases

Understanding Database Connection Pools vs. ThreadLocal in Java

This article explains the fundamental differences between database connection pools and ThreadLocal‑cached connections in Java, illustrating how connection pools improve performance while ThreadLocal enables sharing a single connection across methods within the same thread for consistent transaction control, and discusses practical usage patterns.

Backend DevelopmentConnection PoolDatabase
0 likes · 7 min read
Understanding Database Connection Pools vs. ThreadLocal in Java
Alibaba Cloud Native
Alibaba Cloud Native
Jun 14, 2021 · Backend Development

Why RocketMQ Beats Other Open‑Source Queues: A Practical Selection Guide

This article evaluates open‑source message‑queue options by examining company, middleware‑team, and end‑user criteria, then explains why RocketMQ’s low technical and labor costs, stability, rich features, high performance, built‑in management tools, monitoring support, and active community make it a cost‑effective choice over alternatives like Kafka and Pulsar.

Backend DevelopmentMessage queueRocketMQ
0 likes · 12 min read
Why RocketMQ Beats Other Open‑Source Queues: A Practical Selection Guide
Programmer DD
Programmer DD
Jun 12, 2021 · Backend Development

Spring Boot 2.0: Multi‑Image Upload with Real‑Time Preview

This guide demonstrates how to build a Spring Boot 2.0 backend that accepts multiple image files, returns upload success, and displays real‑time previews on the frontend using HTML, JavaScript, and Spring MVC multipart handling, along with configuration and error handling tips.

Backend DevelopmentJavaScript PreviewMultipartFile
0 likes · 7 min read
Spring Boot 2.0: Multi‑Image Upload with Real‑Time Preview
macrozheng
macrozheng
Jun 11, 2021 · Backend Development

How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story

An in‑depth look at how mattsta’s CRCSpeed implementation replaced Redis’s original CRC algorithm, delivering up to four‑fold speed gains, the history of its development from 2014 to its 2020 integration, and the performance impact on RDB generation and cluster slot hashing.

Backend DevelopmentCRCPerformance Optimization
0 likes · 14 min read
How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story
Python Crawling & Data Mining
Python Crawling & Data Mining
Jun 11, 2021 · Backend Development

Build a Java Stock Trading Monitoring System: From Design to Deployment

This article walks through designing and implementing a Java-based stock trading monitoring system, covering strategy overview, architecture with SpringBoot, data collection, notification services, code structure, deployment steps, and sample outputs, enabling readers to build low‑frequency grid and intraday T‑strategies themselves.

Backend DevelopmentJavaQuantitative Trading
0 likes · 8 min read
Build a Java Stock Trading Monitoring System: From Design to Deployment
JavaEdge
JavaEdge
Jun 10, 2021 · Backend Development

Understanding Java Dynamic Proxy: How JDK Generates and Executes Proxy Classes

This article explains the differences between static and dynamic proxies in Java, details the role of Proxy, InvocationHandler, and the invoke method, and walks through the JDK dynamic proxy creation process with code examples and step‑by‑step analysis.

Backend DevelopmentDynamic ProxyInvocationHandler
0 likes · 7 min read
Understanding Java Dynamic Proxy: How JDK Generates and Executes Proxy Classes
Tencent Cloud Developer
Tencent Cloud Developer
Jun 10, 2021 · Backend Development

Understanding Nginx Architecture: Master/Worker Processes, Hot Reload, Epoll, and Load Balancing

The article explains Nginx’s master‑worker architecture, showing how the master process handles signals, restarts workers, and performs hot configuration or binary reloads, while workers use an event‑driven epoll loop with an accept‑mutex to efficiently process connections and balance load across cores without multithreading.

Backend DevelopmentMaster Processepoll
0 likes · 10 min read
Understanding Nginx Architecture: Master/Worker Processes, Hot Reload, Epoll, and Load Balancing
Java Architect Essentials
Java Architect Essentials
Jun 9, 2021 · Backend Development

Using MyBatis Generator for Code Generation and Practical CRUD Examples

This article explains how to set up the MyBatis Generator plugin in a Maven project, configure generatorConfig.xml and jdbc.properties, and demonstrates practical CRUD operations such as deleting users, updating team information, and performing fuzzy and range queries with generated Example classes.

Backend DevelopmentJavaMyBatis
0 likes · 9 min read
Using MyBatis Generator for Code Generation and Practical CRUD Examples
Top Architect
Top Architect
Jun 5, 2021 · Backend Development

Comprehensive Guide to Spring Boot, Spring MVC, and JPA Annotations

This article provides a detailed overview of the most commonly used Spring Boot, Spring MVC, and JPA annotations, explains their purposes, shows how they interact, and includes practical code examples for building robust Java backend applications.

Backend DevelopmentJavaSpring Boot
0 likes · 11 min read
Comprehensive Guide to Spring Boot, Spring MVC, and JPA Annotations
Programmer DD
Programmer DD
Jun 5, 2021 · Backend Development

When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions

This article explains Alibaba’s Java guidelines for using @Transactional, categorizes checked and unchecked exceptions, shows how Spring’s default rollback behavior works, and provides practical examples of configuring rollback rules, avoiding common pitfalls, and best practices for applying @Transactional in backend Java applications.

Backend DevelopmentException HandlingJava
0 likes · 5 min read
When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions
Java Interview Crash Guide
Java Interview Crash Guide
Jun 4, 2021 · Backend Development

Why Logback Beats Log4j: A Deep Dive into Configuration and Features

Logback, the open‑source logging framework created by the log4j founder, offers faster performance, extensive testing, native SLF4J support, flexible configuration, automatic reload, advanced appenders and rolling policies, making it a superior replacement for log4j in modern Java backend applications.

Backend DevelopmentJavaLogging
0 likes · 22 min read
Why Logback Beats Log4j: A Deep Dive into Configuration and Features
Java Tech Enthusiast
Java Tech Enthusiast
Jun 3, 2021 · Backend Development

Master Spring IoC: From Bean Creation to Dependency Injection

This tutorial explains the concept of Inversion of Control in Spring, demonstrates how to configure beans with XML, compares BeanFactory and ApplicationContext, explores bean scopes and lifecycle, and provides detailed examples of constructor, static‑factory, instance‑factory, and collection injection techniques.

Backend DevelopmentIoCJava
0 likes · 19 min read
Master Spring IoC: From Bean Creation to Dependency Injection
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 3, 2021 · Backend Development

Comprehensive Autumn Recruitment Summary and Interview Experiences for Java Backend Positions

This article provides a detailed, step‑by‑step account of the author's two‑year autumn recruitment journey, covering study plans, self‑learning of core computer‑science topics, internship experiences, systematic interview preparation, and a curated collection of interview summaries from major Chinese tech companies, all aimed at helping aspiring Java backend engineers succeed in campus hiring.

Backend DevelopmentJavaStudy Plan
0 likes · 28 min read
Comprehensive Autumn Recruitment Summary and Interview Experiences for Java Backend Positions
Top Architect
Top Architect
Jun 3, 2021 · Backend Development

Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow

This article explains why multithreading and thread pools are essential for modern server-side Java development, details the full set of ThreadPoolExecutor constructor parameters, and walks through the executor, addWorker, Worker, runWorker, and getTask implementations using JDK 1.8 source code examples.

Backend DevelopmentConcurrencyExecutorService
0 likes · 7 min read
Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 3, 2021 · Backend Development

Mastering Spring AOP Pointcut Expressions: A Complete Guide

This article explains the syntax and components of Spring AOP pointcut expressions, demonstrates how to use various pointcut designators such as execution, within, this, target, args, @within, @target, @args, and @annotation, and provides practical code examples with advice types.

Aspect Oriented ProgrammingBackend DevelopmentPointcut Expressions
0 likes · 12 min read
Mastering Spring AOP Pointcut Expressions: A Complete Guide
macrozheng
macrozheng
Jun 3, 2021 · Backend Development

How Redis Starts: Inside the Server’s Event Loop and Reactor Model

This article walks through Redis's startup sequence, explaining how the server creates a listening socket, registers events with the aeFileEvent system, runs a single‑threaded select‑based event loop, and processes client commands using the Reactor pattern, complete with code examples and diagrams.

Backend DevelopmentReactor PatternRedis
0 likes · 8 min read
How Redis Starts: Inside the Server’s Event Loop and Reactor Model
FunTester
FunTester
Jun 3, 2021 · Backend Development

FunTester moco: Architecture and Feature Overview of the moco API Testing Framework

This article introduces the FunTester moco framework, summarizing its architecture, the three core components (RequestMatcher, ResponseHandler, HttpServer), detailed matching and response capabilities, and additional utilities such as runners and monitoring, providing a comprehensive guide for developers using the moco API.

API mockingBackend DevelopmentMoCo
0 likes · 7 min read
FunTester moco: Architecture and Feature Overview of the moco API Testing Framework
MaGe Linux Operations
MaGe Linux Operations
Jun 2, 2021 · Backend Development

Build a Simple Redis‑Like Service with RocksDB and RestExpress

This article walks through creating a lightweight Redis‑style key/value service called kedis by integrating Facebook's RocksDB storage engine and the RestExpress HTTP container, showing how to set up the server, define API routes, and perform basic put/get operations via HTTP requests.

Backend DevelopmentJavaRestExpress
0 likes · 7 min read
Build a Simple Redis‑Like Service with RocksDB and RestExpress
Top Architect
Top Architect
Jun 2, 2021 · Backend Development

Dynamic Array Injection and Configuration Refresh in Spring Cloud

This article explains how to enable Spring Cloud to refresh configuration properties that are arrays, discusses the underlying Spring Environment and BeanFactory mechanisms, and presents a practical trick using a custom PropertySource to achieve dynamic array injection during refresh.

Array InjectionBackend DevelopmentConfiguration Refresh
0 likes · 11 min read
Dynamic Array Injection and Configuration Refresh in Spring Cloud
Java Interview Crash Guide
Java Interview Crash Guide
Jun 1, 2021 · Backend Development

How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management

This article explains the purpose and inner workings of Spring’s @Transactional annotation, detailing how AOP creates proxies, defines pointcuts, and orchestrates transaction management through BeanPostProcessors, advisors, interceptors, and the TransactionInterceptor, illustrated with source code snippets and diagrams.

AOPBackend DevelopmentJava
0 likes · 10 min read
How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management
Youzan Coder
Youzan Coder
May 31, 2021 · Backend Development

16 TCP Network Programming Best Practices for Building Robust Applications

The article presents sixteen practical TCP network‑programming best practices—from setting SO_REUSEADDR and defining port standards to using application‑layer heartbeats, exponential backoff, connection limits, client‑side load balancing, periodic DNS refresh, optimal buffer sizing, configurable timeouts, proper connection‑pool sizing, and comprehensive metrics—to help developers build stable, reliable applications.

Backend DevelopmentConnection PoolLinux TCP
0 likes · 28 min read
16 TCP Network Programming Best Practices for Building Robust Applications
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 29, 2021 · Backend Development

Peer-to-Peer Decentralized Architecture and High‑Availability Configuration for Eureka Server Cluster

This article explains how to build a peer‑to‑peer, decentralized Eureka service‑registry cluster, covering the underlying architecture, CAP trade‑offs, Maven and YAML configurations for multiple peers, client load‑balancing, and a step‑by‑step test deployment.

Backend Developmenthigh availabilitypeer-to-peer
0 likes · 9 min read
Peer-to-Peer Decentralized Architecture and High‑Availability Configuration for Eureka Server Cluster
Java Interview Crash Guide
Java Interview Crash Guide
May 29, 2021 · Backend Development

How to Export Massive Excel Files Efficiently with Alibaba EasyExcel in Java

This article explains how to replace a custom, memory‑intensive Excel export implementation with Alibaba's EasyExcel library, demonstrating Maven setup, POJO definition, and three test scenarios for small, medium, and huge data sets, while offering performance tips and production‑ready code for Java backend systems.

Backend DevelopmentJavaLarge Data
0 likes · 17 min read
How to Export Massive Excel Files Efficiently with Alibaba EasyExcel in Java
Alibaba Cloud Native
Alibaba Cloud Native
May 28, 2021 · Backend Development

Resolving Dubbo‑Go Module Path Errors: From go‑mod replace to Pseudo‑Version Fixes

This article explains why changing dubbo-go's module path to dubbo.apache.org/dubbo-go/v3 caused CI failures, analyzes the version mismatch introduced by go‑mod replace, and provides a step‑by‑step fix that aligns major versions and clarifies Go's semantic import versioning, pseudo‑versions, and module nesting.

Backend DevelopmentCIGo
0 likes · 13 min read
Resolving Dubbo‑Go Module Path Errors: From go‑mod replace to Pseudo‑Version Fixes
Architecture Digest
Architecture Digest
May 27, 2021 · Backend Development

Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, Master/Worker Processes, and Memory Pool

This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool implementation, illustrating how these components together achieve scalability and low latency.

Backend DevelopmentWeb servermemory pool
0 likes · 10 min read
Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, Master/Worker Processes, and Memory Pool
macrozheng
macrozheng
May 27, 2021 · Backend Development

What’s New in Spring Boot 2.5? A Deep Dive into Features and Upgrades

Spring Boot 2.5 introduces major enhancements such as Java 16 support, Gradle 7 and Jetty 10 compatibility, HTTP/2 over TCP, a revamped datasource initialization mechanism, environment‑variable prefixes, Docker build improvements, layered WARs, actuator endpoint changes, extensive dependency upgrades, and several deprecations, while urging careful migration.

ActuatorBackend DevelopmentDocker
0 likes · 11 min read
What’s New in Spring Boot 2.5? A Deep Dive into Features and Upgrades
Java Interview Crash Guide
Java Interview Crash Guide
May 27, 2021 · Backend Development

How Nacos Powers Service Registration in Spring Cloud: Architecture & Mechanics

This article explains Nacos’s architecture, the principles of service registration, how Spring Cloud integrates Nacos during startup, the implementation details of NacosServiceRegistry, the heartbeat mechanism, and dynamic service address discovery, providing a comprehensive view of backend service discovery in microservice environments.

Backend DevelopmentNacosservice registry
0 likes · 9 min read
How Nacos Powers Service Registration in Spring Cloud: Architecture & Mechanics
Laravel Tech Community
Laravel Tech Community
May 24, 2021 · Backend Development

8 Essential Built‑in PHP Functions Every Developer Should Know

This article presents eight essential built‑in PHP functions—including variable‑argument handling, file searching with glob(), memory and CPU usage monitoring, system constants, unique ID generation, serialization, and string compression—complete with clear code examples to help developers write more efficient PHP code.

Backend DevelopmentCode ExamplesPHP
0 likes · 9 min read
8 Essential Built‑in PHP Functions Every Developer Should Know
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 23, 2021 · Backend Development

Designing Scalable Multi-Account Login: Strategies, Flows, and Database Schemas

This article outlines practical approaches for implementing multi‑account login, covering early‑stage username/password and phone‑based registration, detailed authentication flows, OAuth2 integration with third‑party providers, and comprehensive database schema designs to unify local and external user identities.

AuthenticationBackend DevelopmentDatabase Design
0 likes · 9 min read
Designing Scalable Multi-Account Login: Strategies, Flows, and Database Schemas
Programmer DD
Programmer DD
May 23, 2021 · Backend Development

Master Real-Time Push: Spring Boot WebSocket Integration Guide

This article walks through building a real‑time push system with Spring Boot by integrating WebSocket and MQTT, covering the protocol basics, Maven setup, configuration classes, server implementation, controller endpoints, front‑end testing page, common pitfalls, and deployment tips.

Backend DevelopmentJavaMQTT
0 likes · 12 min read
Master Real-Time Push: Spring Boot WebSocket Integration Guide
MaGe Linux Operations
MaGe Linux Operations
May 22, 2021 · Backend Development

Why Khan Academy Switched 500K Lines from Python to Go

Khan Academy’s Goliath project migrated over 500,000 lines of backend code from Python 2 to Go, citing performance, fast compilation, better tooling, and developer preference, while also discussing the challenges of Python’s EOL and the role of generics in Go.

Backend DevelopmentGoGoliath
0 likes · 3 min read
Why Khan Academy Switched 500K Lines from Python to Go
Top Architect
Top Architect
May 22, 2021 · Backend Development

Understanding RPC vs HTTP: Architecture, Protocols, and Popular Frameworks

This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture and sync/async calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo with traditional RESTful HTTP, and offers guidance on choosing the right approach for a project.

Backend DevelopmentDubboHTTP
0 likes · 8 min read
Understanding RPC vs HTTP: Architecture, Protocols, and Popular Frameworks
Programmer DD
Programmer DD
May 22, 2021 · Backend Development

What’s New in Spring Boot 2.5.0? Key Features, Updates & Deprecations

Spring Boot 2.5.0 introduces Java 16, Gradle 7, Jetty 10 support, enhanced Docker image building, dark‑mode docs, numerous configuration improvements, updated dependency versions, and several deprecations, providing developers with a richer, more modern backend framework.

ActuatorBackend DevelopmentDocker
0 likes · 6 min read
What’s New in Spring Boot 2.5.0? Key Features, Updates & Deprecations
Laravel Tech Community
Laravel Tech Community
May 21, 2021 · Backend Development

RabbitMQ Messaging Patterns and Exchange Types Overview

This article explains RabbitMQ's core messaging patterns—including simple, work queues, publish/subscribe, routing, topics, RPC, and publisher confirms—along with the four main exchange types, providing practical use‑case examples for each to help developers choose the appropriate pattern for their backend systems.

Backend DevelopmentDistributed SystemsMessaging
0 likes · 4 min read
RabbitMQ Messaging Patterns and Exchange Types Overview
MaGe Linux Operations
MaGe Linux Operations
May 21, 2021 · Backend Development

10 Compelling Reasons to Choose Django for Your Next Project

This article explains why Python’s Django framework is a top choice for backend development, outlining its popularity, benefits, essential system‑planning and web‑script skills, rapid prototyping, scientific computing, and the specific Python and Django expertise needed to become a proficient developer.

Backend DevelopmentDjangoPython
0 likes · 8 min read
10 Compelling Reasons to Choose Django for Your Next Project
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications

This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.

Backend DevelopmentJavaMyBatis
0 likes · 12 min read
Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 20, 2021 · Backend Development

Master Spring Boot: Core Concepts, Configuration, and Top Interview Questions

This article compiles essential Spring Boot interview questions, covering its definition, benefits, core configuration files, starter modules, auto‑configuration, embedded containers, actuator monitoring, security concerns, exception handling, differences from Spring MVC, and integration with tools like ELK and Docker.

Backend DevelopmentSpring Bootconfiguration
0 likes · 10 min read
Master Spring Boot: Core Concepts, Configuration, and Top Interview Questions
Programmer DD
Programmer DD
May 20, 2021 · Backend Development

Counting Web Page Visits with Redis: Hash, Bitset, and HyperLogLog Techniques

This article explains three Redis-based techniques—Hash, Bitset, and HyperLogLog—for efficiently counting daily page visits, detailing command usage, memory trade‑offs, and accuracy considerations, helping backend engineers implement scalable visitor statistics in high‑traffic environments like large e‑commerce platforms.

Backend DevelopmentBitsetHash
0 likes · 6 min read
Counting Web Page Visits with Redis: Hash, Bitset, and HyperLogLog Techniques
Alibaba Cloud Developer
Alibaba Cloud Developer
May 19, 2021 · Backend Development

Mastering Elegant Parameter Validation with Hibernate Validator

This article examines the challenges of repetitive if‑else parameter checks, introduces Hibernate Validator as a JSR‑303 implementation, demonstrates how to build a reusable validation module, and shares best‑practice patterns for integrating elegant, decoupled validation into Java backend systems.

Backend DevelopmentHibernate ValidatorJSR-303
0 likes · 10 min read
Mastering Elegant Parameter Validation with Hibernate Validator
Top Architect
Top Architect
May 18, 2021 · Databases

Understanding Database Connection Pools and ThreadLocal in Java for Transaction Management

This article explains the fundamental differences between database connection pools and ThreadLocal, how each is used in Java to improve performance and enable cross‑method transaction control, and provides practical code examples and best‑practice guidelines for managing connections in multi‑threaded applications.

Backend DevelopmentDatabase Connection PoolJava
0 likes · 7 min read
Understanding Database Connection Pools and ThreadLocal in Java for Transaction Management
Top Architect
Top Architect
May 15, 2021 · Backend Development

Using IntelliJ IDEA Live Templates to Simplify Java Stream Collectors

This article explains how to create and use IntelliJ IDEA live templates to replace repetitive Java Stream collector calls such as toList(), toSet(), and groupingBy() with concise shortcuts, improving code readability and productivity when migrating legacy code to Java 8 streams.

Backend DevelopmentIntelliJ IDEAJava
0 likes · 6 min read
Using IntelliJ IDEA Live Templates to Simplify Java Stream Collectors
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 15, 2021 · Backend Development

JVM Tuning Guide: Understanding GC, Memory Model, and Configuration Options

This article provides a comprehensive guide to JVM performance tuning, covering the JVM architecture, runtime data areas, various garbage collectors, configuration flags for heap and GC settings, and practical recommendations for selecting the optimal GC strategy based on workload characteristics.

Backend DevelopmentGarbage CollectionJVM
0 likes · 6 min read
JVM Tuning Guide: Understanding GC, Memory Model, and Configuration Options
Programmer DD
Programmer DD
May 15, 2021 · Backend Development

How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips

This article walks through a real‑world scenario of extending trial‑user eligibility rules, explains the logical flow using AND/OR short‑circuiting, and presents a modular Java rule engine design with abstract templates, concrete rules, a service builder, and a test case, highlighting its advantages and drawbacks.

Backend DevelopmentCode ExampleDesign Patterns
0 likes · 8 min read
How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips
Top Architect
Top Architect
May 14, 2021 · Backend Development

Understanding Spring MVC: From Servlets to DispatcherServlet and Request Handling

This article explains how Spring MVC evolved from basic Servlets to a sophisticated two‑level controller architecture, detailing the roles of DispatcherServlet, HandlerMapping, HandlerInterceptor, Handler, ModelAndView, ViewResolver, and View, while showing configuration examples and code snippets.

Backend DevelopmentDispatcherServletHandlerMapping
0 likes · 17 min read
Understanding Spring MVC: From Servlets to DispatcherServlet and Request Handling
Architect's Tech Stack
Architect's Tech Stack
May 14, 2021 · Backend Development

Integrating WebSocket in Spring Boot for Real‑Time Server Push

This tutorial demonstrates how to integrate Spring Boot with WebSocket to achieve server‑initiated real‑time message pushing, covering dependency setup, configuration, server implementation, controller and client page code, and troubleshooting initialization order issues.

Backend DevelopmentJavareal-time-communication
0 likes · 12 min read
Integrating WebSocket in Spring Boot for Real‑Time Server Push
政采云技术
政采云技术
May 13, 2021 · Frontend Development

Understanding the ESModule Specification and Its Implementation in Node.js and Browsers

This article explains the ESModule standard, compares it with CommonJS and AMD, describes how Node.js and modern browsers implement ESModules, discusses compatibility challenges with third‑party dependencies, and reviews next‑generation tools such as Snowpack and Vite that leverage native module loading.

Backend DevelopmentESModuleNode.js
0 likes · 14 min read
Understanding the ESModule Specification and Its Implementation in Node.js and Browsers
Architecture Digest
Architecture Digest
May 12, 2021 · Backend Development

Performance Optimization of a High‑Concurrency Python Web Service

This article documents a Python web service performance optimization case, detailing the initial bottlenecks, architectural redesign with caching and message queues, load‑testing methodology, Linux TCP time‑wait tuning, and the final results achieving 50k QPS with sub‑70 ms latency.

Backend DevelopmentCachingDatabase
0 likes · 9 min read
Performance Optimization of a High‑Concurrency Python Web Service
macrozheng
macrozheng
May 11, 2021 · Backend Development

Build a Full‑Stack Java Admin System Without Front‑End Code Using Erupt

This guide introduces Erupt, a low‑code full‑stack Java framework that lets you create enterprise‑level backend management systems without writing any front‑end code, covering installation, SpringBoot integration, CRUD generation, extended modules like scheduling, code generation, monitoring, NoSQL support, and online API development.

Backend DevelopmentCRUDErupt
0 likes · 19 min read
Build a Full‑Stack Java Admin System Without Front‑End Code Using Erupt
IT Architects Alliance
IT Architects Alliance
May 8, 2021 · Backend Development

Mastering API Full Lifecycle: From Object Modeling to Service Orchestration

This article explores comprehensive API lifecycle management, detailing how a lightweight API gateway works with a robust development platform that uses object‑driven modeling to automatically generate CRUD interfaces, map objects to databases, support testing, documentation, rule processing, service composition, code export, and microservice packaging.

API lifecycleBackend DevelopmentLow‑code platform
0 likes · 16 min read
Mastering API Full Lifecycle: From Object Modeling to Service Orchestration
Top Architect
Top Architect
May 8, 2021 · Backend Development

Implementing a Global Exception Handler in Spring Boot

This article explains how to replace repetitive try‑catch blocks in Spring Boot applications with a unified global exception handling solution by defining a standard AjaxResult response, a custom BusinessException, an error enumeration, and a @RestControllerAdvice handler, enabling clean, extensible error management.

Backend DevelopmentError HandlingJava
0 likes · 5 min read
Implementing a Global Exception Handler in Spring Boot
Java Architect Essentials
Java Architect Essentials
May 7, 2021 · Backend Development

Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More

This article provides a step‑by‑step tutorial on building a Spring Boot project, covering project generation, core starters, automatic Redis configuration, common annotations like @SpringBootApplication and @ControllerAdvice, web container and HTTPS settings, profile management, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, mail sending, and Swagger API documentation.

Backend DevelopmentMailMyBatis
0 likes · 18 min read
Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More
Meituan Technology Team
Meituan Technology Team
May 6, 2021 · Backend Development

GraphQL‑Based BFF Architecture with Metadata‑Driven Data Aggregation

The article describes a backend‑for‑frontend architecture that pushes GraphQL into the BFF layer, separates fetch and display units, drives execution with metadata, unifies query models, applies caching and parallel processing optimizations, and demonstrates over 50 % logic reuse and doubled development efficiency in production.

BFFBackend DevelopmentGraphQL
0 likes · 35 min read
GraphQL‑Based BFF Architecture with Metadata‑Driven Data Aggregation
NiuNiu MaTe
NiuNiu MaTe
May 2, 2021 · Fundamentals

How to Master Python Quickly: A Complete Learning Roadmap for 2024

This guide explains why Python is essential, presents a step‑by‑step learning roadmap covering beginner basics, backend web development, web crawling, data analysis, and machine learning, and provides curated resources and project links to help learners progress efficiently.

Backend DevelopmentData AnalysisWeb Scraping
0 likes · 8 min read
How to Master Python Quickly: A Complete Learning Roadmap for 2024
Top Architect
Top Architect
May 1, 2021 · Backend Development

Understanding RPC vs HTTP: Architecture, Protocols, and Popular Frameworks

This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.

Backend DevelopmentDubboHTTP
0 likes · 8 min read
Understanding RPC vs HTTP: Architecture, Protocols, and Popular Frameworks