BestHub
Sign in
Tagged articles
5000 articles
Page 28 of 50
Architect's Guide
Architect's Guide
Dec 31, 2024 · Backend Development

Apollo Configuration Center: Concepts, Architecture, and Spring Boot Integration Guide

This article provides a comprehensive tutorial on Apollo, covering its basic concepts, architecture, four-dimensional configuration model, client design, high‑availability considerations, and step‑by‑step instructions for creating a Spring Boot project, integrating Apollo dependencies, configuring environments, testing dynamic updates, and deploying the application on Kubernetes.

ApolloConfiguration ManagementJava
0 likes · 22 min read
Apollo Configuration Center: Concepts, Architecture, and Spring Boot Integration Guide
Java Tech Enthusiast
Java Tech Enthusiast
Dec 30, 2024 · Backend Development

The Rise of Java: From Toy to Enterprise Powerhouse

A senior developer recounts switching from C# and Python to Java for web projects and higher pay, illustrating Java’s evolution from a “toy” language with early JVM limits to an enterprise powerhouse driven by JIT, Spring Boot, and robust performance that now rivals C++.

JVMJavaspring
0 likes · 9 min read
The Rise of Java: From Toy to Enterprise Powerhouse
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

Comprehensive Introduction to Domain-Driven Design (DDD)

This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.

Backend DevelopmentDDDDesign Patterns
0 likes · 6 min read
Comprehensive Introduction to Domain-Driven Design (DDD)
macrozheng
macrozheng
Dec 30, 2024 · Backend Development

Master Java Stream API: From Basics to Advanced Collection Operations

This article introduces Java Stream API introduced in JDK 8, explains its pipeline concept, and demonstrates practical operations such as traversal, filtering, deduplication, type conversion, collection‑to‑map transformations, pagination, matching, and parallel processing with clear code examples.

BackendCollectionsJava
0 likes · 15 min read
Master Java Stream API: From Basics to Advanced Collection Operations
Top Architect
Top Architect
Dec 29, 2024 · Backend Development

Replacing MyBatis with MyBatis‑Plus: Debugging Conversion Errors and Version Compatibility

This article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains the "Conversion not supported for type java.time.LocalDateTime" exception, shows how upgrading mysql‑connector‑java resolves the issue, and shares lessons learned from a production bug caused by an over‑optimistic validation change.

DebuggingJavaMyBatis-Plus
0 likes · 10 min read
Replacing MyBatis with MyBatis‑Plus: Debugging Conversion Errors and Version Compatibility
Architecture Digest
Architecture Digest
Dec 29, 2024 · Backend Development

Refactoring Spring MVC Controllers: Unified Return Structure, Response Advice, Parameter Validation, and Global Exception Handling

This article explains how to refactor the Spring MVC controller layer by introducing a unified response format, using ResponseBodyAdvice for automatic wrapping, fixing String conversion issues, applying JSR‑303 validation, creating custom validators, and handling exceptions globally to keep controller code clean and maintainable.

ControllerJavaexceptionhandling
0 likes · 18 min read
Refactoring Spring MVC Controllers: Unified Return Structure, Response Advice, Parameter Validation, and Global Exception Handling
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 29, 2024 · Backend Development

Deep Dive into Spring's @Autowired Annotation: Implementation and Injection Mechanism

This article provides a comprehensive analysis of Spring's @Autowired annotation, explaining its purpose, usage in constructor, field, and method injection, and detailing the underlying bean post‑processor logic, dependency resolution, and candidate selection that enable automatic dependency injection.

AutowiredBeanPostProcessorJava
0 likes · 10 min read
Deep Dive into Spring's @Autowired Annotation: Implementation and Injection Mechanism
Top Architect
Top Architect
Dec 28, 2024 · Backend Development

Building a Netty + WebSocket Message Push Server in Java

This article presents a step‑by‑step guide to building a Netty‑based WebSocket server in Java, covering server initialization, channel configuration, custom handlers, push‑message services, testing procedures, and includes complete source code, while also containing promotional material for unrelated AI services.

Javamessage pushspring
0 likes · 11 min read
Building a Netty + WebSocket Message Push Server in Java
Su San Talks Tech
Su San Talks Tech
Dec 28, 2024 · Backend Development

Master Spring Boot Multi‑DataSource Integration with MyBatis

This tutorial explains how to combine Spring Boot, MyBatis, and multiple databases using Druid connection pools, dynamic routing data sources, custom annotations, and AOP, providing complete configuration examples, code snippets, and best‑practice guidance for backend developers.

JavaMulti-DataSourceSpring Boot
0 likes · 17 min read
Master Spring Boot Multi‑DataSource Integration with MyBatis
JD Tech Talk
JD Tech Talk
Dec 27, 2024 · Backend Development

Log Sampling and Cross‑Thread Propagation in High‑Throughput Java Services

The article examines the performance impact of excessive logging in large‑scale Java systems and proposes request‑level sampling with cross‑thread identifier propagation, offering practical component‑based solutions, implementation considerations, and a concrete code example for backend developers.

BackendJavaLogging
0 likes · 7 min read
Log Sampling and Cross‑Thread Propagation in High‑Throughput Java Services
JD Cloud Developers
JD Cloud Developers
Dec 27, 2024 · Backend Development

How to Implement Cross-Thread Log Sampling in High-Throughput Java Services

Log volume can cripple high-throughput Java systems, especially during traffic spikes, so this article explores practical strategies for request-level log sampling, cross-thread trace propagation, and component-based APIs to balance observability with performance, including code examples and implementation considerations.

JavaThreadLocallog sampling
0 likes · 8 min read
How to Implement Cross-Thread Log Sampling in High-Throughput Java Services
Architect's Guide
Architect's Guide
Dec 27, 2024 · Backend Development

Fast‑Retry: High‑Performance Asynchronous Retry Framework for Java

Fast‑Retry is a high‑throughput Java retry library that enables asynchronous, non‑blocking retries for massive task volumes, offering programmable and annotation‑based APIs, custom retry policies, and significant performance gains over traditional synchronous frameworks like Spring‑Retry and Guava‑Retry.

BackendJavaRetry
0 likes · 11 min read
Fast‑Retry: High‑Performance Asynchronous Retry Framework for Java
IT Services Circle
IT Services Circle
Dec 26, 2024 · Fundamentals

Understanding the JDK Bug in Arrays.asList().toArray() and Its Fix in JDK 9

This article explains a long‑standing JDK bug where Arrays.asList().toArray() returns an Object[] that causes ArrayStoreException when modified, analyzes the underlying implementation differences between java.util.ArrayList and Arrays$ArrayList, and describes how the issue was finally fixed in JDK 9.

ArrayStoreExceptionArrays.asListJDK
0 likes · 9 min read
Understanding the JDK Bug in Arrays.asList().toArray() and Its Fix in JDK 9
Top Architect
Top Architect
Dec 26, 2024 · Information Security

OAuth2.0 Overview and Spring Boot Implementation Guide

This article introduces OAuth2.0 concepts, outlines its roles and grant types, and provides a step‑by‑step Spring Boot implementation of an authorization server, resource server, and test client, followed by test results and promotional information.

AuthorizationJavaSpring Boot
0 likes · 12 min read
OAuth2.0 Overview and Spring Boot Implementation Guide
Top Architect
Top Architect
Dec 26, 2024 · Backend Development

Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts

This article explains how to prevent brute‑force password attempts by locking an IP after three failed logins using a Spring Boot backend, Redis for distributed counters, and a Lua script to ensure atomic increment and expiration, while also providing a simple HTML login page for the front end.

JavaLoginRateLimitingLua
0 likes · 19 min read
Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts
Architecture Digest
Architecture Digest
Dec 26, 2024 · Backend Development

Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.

ConcurrencyJavaSpring Boot
0 likes · 7 min read
Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
FunTester
FunTester
Dec 26, 2024 · Fundamentals

Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword

This chapter introduces advanced Java multithreading concepts, explaining thread safety, the synchronized keyword, various synchronization techniques, and practical code examples such as object‑level, class‑level, method‑level synchronization and double‑checked locking to help solve concurrency problems in performance testing.

ConcurrencyJavaSynchronization
0 likes · 15 min read
Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword
Java Architect Essentials
Java Architect Essentials
Dec 25, 2024 · Backend Development

Understanding Java Connection Pools: Commons Pool 2, Jedis, and HikariCP Performance

This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library and its use in Redis client Jedis, compares pool and non‑pool performance with JMH benchmarks, and details the fast HikariCP database connection pool along with configuration tips and interview questions.

Commons-PoolConnection PoolHikariCP
0 likes · 15 min read
Understanding Java Connection Pools: Commons Pool 2, Jedis, and HikariCP Performance
Top Architect
Top Architect
Dec 25, 2024 · Backend Development

Replacing Tomcat with Undertow in Spring Boot: Configuration, Features, and Performance Comparison

This article explains how Spring Boot uses Tomcat by default, introduces Undertow as a high‑performance alternative, provides step‑by‑step Maven configuration to switch containers, compares Tomcat and Undertow on throughput and memory usage, and recommends Undertow for high‑concurrency Java web applications.

JavaSpringBootTomcat
0 likes · 9 min read
Replacing Tomcat with Undertow in Spring Boot: Configuration, Features, and Performance Comparison
macrozheng
macrozheng
Dec 25, 2024 · Backend Development

FastExcel: The New Java Library Replacing EasyExcel for High‑Performance Excel Processing

FastExcel, a Java‑based open‑source library announced after EasyExcel's discontinuation, offers fast, memory‑efficient Excel read/write, full compatibility with EasyExcel, simple APIs, MIT licensing for commercial use, easy Maven/Gradle integration, and clear code examples that have already attracted over 2,000 GitHub stars.

ExcelFastExcelGradle
0 likes · 8 min read
FastExcel: The New Java Library Replacing EasyExcel for High‑Performance Excel Processing
Architect
Architect
Dec 24, 2024 · Backend Development

12 MyBatisPlus Optimization Techniques for Efficient Database Operations

This article presents twelve practical MyBatisPlus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using EXISTS, safe ordering, LambdaQuery, between, index-aware sorting, pagination, null handling, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement—to write cleaner, faster, and more maintainable backend code.

Backend DevelopmentDatabase OptimizationJava
0 likes · 16 min read
12 MyBatisPlus Optimization Techniques for Efficient Database Operations
Raymond Ops
Raymond Ops
Dec 24, 2024 · Operations

How to Diagnose and Fix High CPU and Memory Usage in Java Applications

This guide walks through identifying Java processes that cause high CPU load, extracting the hottest threads with top and jstack, analyzing JVM memory regions, interpreting GC logs, and applying practical JVM tuning parameters and tools such as jmap, jstat, and MAT to resolve performance bottlenecks.

CPUJVMJava
0 likes · 18 min read
How to Diagnose and Fix High CPU and Memory Usage in Java Applications
Selected Java Interview Questions
Selected Java Interview Questions
Dec 24, 2024 · Backend Development

Design and Implementation of a Custom Distributed Job Scheduling Framework (k‑job)

This article introduces the motivation, architecture, technology choices, and key implementation details of a lightweight, highly extensible distributed job scheduling framework built on gRPC, Protobuf, a custom name‑server, and a bespoke message‑queue, addressing limitations of existing solutions like Quartz, XXL‑Job, and PowerJob.

Distributed SystemsJavaJob Scheduling
0 likes · 14 min read
Design and Implementation of a Custom Distributed Job Scheduling Framework (k‑job)
Tencent Cloud Developer
Tencent Cloud Developer
Dec 24, 2024 · Backend Development

From Java to Go: Key Differences Every Developer Must Know

This article compares Java and Go across syntax simplicity, type systems, object‑oriented features, pointers, error handling, concurrency, reflection, and community culture, providing concrete code examples and practical insights to help Java developers transition smoothly to Go.

Backend DevelopmentConcurrencyError Handling
0 likes · 14 min read
From Java to Go: Key Differences Every Developer Must Know
Architect's Guide
Architect's Guide
Dec 24, 2024 · Frontend Development

One‑Click Frontend Generation Tool for Backend Developers

This article introduces a free, low‑code web tool that lets backend developers instantly generate a functional admin‑type frontend UI from database schemas or Java/SQL description files, requiring only minimal configuration and no front‑end coding skills.

Backend ToolsFrontend GenerationJava
0 likes · 5 min read
One‑Click Frontend Generation Tool for Backend Developers
Su San Talks Tech
Su San Talks Tech
Dec 24, 2024 · Backend Development

10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend

Discover ten powerful MyBatis techniques—from dynamic SQL and resultMap customization to batch operations, pagination, annotation‑based mappers, caching, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—that can dramatically improve Java backend development efficiency and code quality.

Javaormperformance
0 likes · 10 min read
10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend
Architect
Architect
Dec 23, 2024 · Information Security

How to Implement Enterprise Data Desensitization with MyBatis and Fastjson

This article explains why data desensitization is essential for modern enterprises, compares masking, obfuscation and encryption techniques, and provides step‑by‑step implementations for database, log, and output layers using MyBatis interceptors, Fastjson filters, and Spring MVC configuration.

FastJSONJavaMyBatis
0 likes · 13 min read
How to Implement Enterprise Data Desensitization with MyBatis and Fastjson
DeWu Technology
DeWu Technology
Dec 23, 2024 · Fundamentals

Java Null Reference Handling Principles

Java’s ubiquitous NullPointerException stems from Tony Hoare’s 1965 introduction of the null reference—a design he later called his ‘billion-dollar mistake’—and the JVM mitigates its cost by forgoing proactive checks, instead relying on OS signals like SIGSEGV to detect nulls and throw the exception only when they actually occur.

Exception HandlingJVMJava
0 likes · 18 min read
Java Null Reference Handling Principles
JD Tech Talk
JD Tech Talk
Dec 23, 2024 · Backend Development

Asynchronous Timeout Implementation for CompletableFuture in JDK 8

This article proposes an asynchronous timeout implementation for CompletableFuture in JDK 8, addressing the lack of built-in timeout interruption capabilities and providing a solution for precise task timeout control.

Backend DevelopmentCompletableFutureJDK 8
0 likes · 10 min read
Asynchronous Timeout Implementation for CompletableFuture in JDK 8
JD Cloud Developers
JD Cloud Developers
Dec 23, 2024 · Backend Development

How to Add Asynchronous Timeout to CompletableFuture in JDK 8

This article explains why JDK 8's CompletableFuture lacks built‑in timeout interruption, analyzes common usage patterns and their limitations, and presents a custom asynchronous timeout solution that works in both JDK 8 and JDK 9 environments, complete with reusable utility code.

Async TimeoutBackend DevelopmentCompletableFuture
0 likes · 13 min read
How to Add Asynchronous Timeout to CompletableFuture in JDK 8
Architect's Guide
Architect's Guide
Dec 23, 2024 · Backend Development

Implementing API Request and Response Encryption/Decryption with Spring Boot and ControllerAdvice

This article walks through the design and implementation of symmetric AES encryption for both GET and POST API endpoints in a Spring Boot application, covering requirement analysis, data model definition, custom RequestBodyAdvice and ResponseBodyAdvice, serialization challenges with FastJSON vs Jackson, and final configuration to ensure consistent JSON output across encrypted and non‑encrypted responses.

AESBackendControllerAdvice
0 likes · 12 min read
Implementing API Request and Response Encryption/Decryption with Spring Boot and ControllerAdvice
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 23, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.

Garbage CollectionJVMJava
0 likes · 25 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Architect
Architect
Dec 22, 2024 · Backend Development

Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)

This article explains the concept of request debouncing, identifies which API endpoints need it, and provides a detailed tutorial on implementing distributed debounce using shared Redis cache or Redisson locks in a Spring Boot backend, complete with annotation design, unique key generation, and code examples.

DebounceJavaRedis
0 likes · 16 min read
Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)
IT Services Circle
IT Services Circle
Dec 22, 2024 · Backend Development

Various Strategies for Implementing Order Auto‑Cancellation in High‑Concurrency Systems

This article compares seven practical approaches—DelayQueue, database polling, Redis queues, Redis key expiration callbacks, RabbitMQ delayed messages, scheduled task frameworks, and event‑stream processing—for automatically cancelling unpaid orders, outlining their suitable scenarios, code examples, advantages, disadvantages, and optimization tips.

BackendDelayQueueJava
0 likes · 12 min read
Various Strategies for Implementing Order Auto‑Cancellation in High‑Concurrency Systems
Java Tech Enthusiast
Java Tech Enthusiast
Dec 22, 2024 · Backend Development

Common Java ThreadPool Pitfalls and How to Avoid Them

Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.

Best PracticesConcurrencyJava
0 likes · 8 min read
Common Java ThreadPool Pitfalls and How to Avoid Them
Architect's Guide
Architect's Guide
Dec 22, 2024 · Backend Development

Cool Request Plugin for IDEA: Tracing, MyBatis Function Tracking, and Custom Timing Features

The article introduces the Cool Request IDEA plugin, explains its tracing capabilities for arbitrary packages, automatic MyBatis function monitoring, customizable timing colors, script-based environment manipulation, and provides a Java code example for handling responses, highlighting its usefulness for backend developers.

BackendIDEAJava
0 likes · 4 min read
Cool Request Plugin for IDEA: Tracing, MyBatis Function Tracking, and Custom Timing Features
ITPUB
ITPUB
Dec 22, 2024 · Fundamentals

Why Does Comparing Two Integer Objects in Java Sometimes Return True?

This article explains why using the == operator on two Integer objects in Java can yield true for some values and false for others, covering Integer caching, the role of Integer.valueOf, and the correct way to compare Integer values with equals.

IntegerJavaObject Comparison
0 likes · 7 min read
Why Does Comparing Two Integer Objects in Java Sometimes Return True?
Architect
Architect
Dec 20, 2024 · Backend Development

Boost MyBatis-Plus Batch Inserts by 2000% with rewriteBatchedStatements and ID Pre‑Generation

By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.

Batch InsertJavaMyBatis-Plus
0 likes · 20 min read
Boost MyBatis-Plus Batch Inserts by 2000% with rewriteBatchedStatements and ID Pre‑Generation
IT Services Circle
IT Services Circle
Dec 20, 2024 · Backend Development

Best Practices for Parameter Validation in Backend Development

This article outlines ten practical guidelines for robust parameter validation in backend Java services, covering enumeration ranges, consistent length constraints, proper use of @NotBlank, synchronizing API documentation, comprehensive annotation usage, request object encapsulation, and the importance of self‑testing and authorization checks.

Code ReviewJavaParameter Validation
0 likes · 8 min read
Best Practices for Parameter Validation in Backend Development
Top Architect
Top Architect
Dec 20, 2024 · Backend Development

Optimizing Nested Loops in Java Using Map for Faster ID Matching

This article demonstrates how to replace inefficient nested for‑loops that match user IDs between two large lists with a map‑based lookup, showing code examples, performance measurements, and the impact of using break statements and O(1) hash map access to dramatically reduce execution time.

JavaMAPNested Loop
0 likes · 9 min read
Optimizing Nested Loops in Java Using Map for Faster ID Matching
Selected Java Interview Questions
Selected Java Interview Questions
Dec 20, 2024 · Backend Development

12 MyBatis‑Plus Optimization Tips for Efficient Database Operations

This article presents twelve practical MyBatis‑Plus optimization techniques—ranging from avoiding null checks and specifying select fields to batch operations, safe ordering, pagination, logical deletion, optimistic locking, and performance tracking—each illustrated with code examples and clear explanations to help backend developers write cleaner, faster, and more maintainable Java ORM queries.

BackendDatabase OptimizationJava
0 likes · 14 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
macrozheng
macrozheng
Dec 20, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common mistakes when using Java thread pools—such as unbounded queues, wrong thread counts, missing shutdown, and ignored exceptions—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

BackendBest PracticesConcurrency
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
Lobster Programming
Lobster Programming
Dec 20, 2024 · Backend Development

Filters vs Interceptors in Java Web Apps: Key Differences Explained

This article compares Java web filters and Spring MVC interceptors, detailing their implementation differences, origins, execution order, supported project types, and typical use‑cases, helping developers choose the right tool for request handling, security, logging, and other cross‑cutting concerns.

InterceptorJavaServlet Filter
0 likes · 5 min read
Filters vs Interceptors in Java Web Apps: Key Differences Explained
Lobster Programming
Lobster Programming
Dec 20, 2024 · Fundamentals

Unlocking Java’s Constant Pools: Class, Runtime, and String Explained

This article explains Java’s constant pools, detailing the class constant pool stored in .class files, its transformation into the runtime constant pool during JVM loading, and the specialized string constant pool that optimizes memory usage, including recent changes moving it to heap memory.

Constant PoolJVMJava
0 likes · 3 min read
Unlocking Java’s Constant Pools: Class, Runtime, and String Explained
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 20, 2024 · Backend Development

Integrating Tianditu Map Service with Java: Reverse Geocoding, Nearby Search, and Coordinate Conversion

This article explains how to replace a paid map service with the free Tianditu API by implementing reverse geocoding, nearby and text search, and coordinate system conversion in Java, providing complete code examples and practical considerations for cost‑effective map integration.

Backend DevelopmentGeocodingJava
0 likes · 17 min read
Integrating Tianditu Map Service with Java: Reverse Geocoding, Nearby Search, and Coordinate Conversion
Su San Talks Tech
Su San Talks Tech
Dec 20, 2024 · Backend Development

7 Proven Strategies to Auto‑Cancel Unpaid Orders in High‑Traffic Systems

This article examines seven practical approaches—including Java DelayQueue, database polling, Redis queues, key‑expiration callbacks, RabbitMQ delayed messages, scheduled‑task frameworks, and event‑stream processing—to automatically cancel unpaid orders, comparing their scenarios, advantages, drawbacks, and implementation tips for scalable systems.

Backend ArchitectureJavaOrder Cancellation
0 likes · 15 min read
7 Proven Strategies to Auto‑Cancel Unpaid Orders in High‑Traffic Systems
FunTester
FunTester
Dec 20, 2024 · Backend Development

Understanding Java ThreadFactory, Rejection Policies, and Dynamic Thread Pool Management

This article explains Java's ThreadFactory interface, demonstrates how to customize thread names, explores the four built‑in rejection policies of ThreadPoolExecutor with code examples, and shows techniques for dynamic adjustment of core and maximum pool sizes, including custom policies and blocking queue task submission.

DynamicThreadPoolJavaRejectionPolicy
0 likes · 19 min read
Understanding Java ThreadFactory, Rejection Policies, and Dynamic Thread Pool Management
Architecture Digest
Architecture Digest
Dec 19, 2024 · Backend Development

Comprehensive Overview of Spring Bean Lifecycle Extension Points

This article explains the Spring container's refresh process, details every extensible hook in a bean's lifecycle—from ApplicationContextInitializer to DisposableBean—provides usage scenarios, and includes complete Java code snippets illustrating how to implement each extension point for custom middleware and application development.

Extension PointsJavaSpring Boot
0 likes · 18 min read
Comprehensive Overview of Spring Bean Lifecycle Extension Points
JD Tech Talk
JD Tech Talk
Dec 19, 2024 · Backend Development

Optimizing Log4j2 Asynchronous Logging: Configuration, Diagnosis, and Load‑Testing

This article presents a detailed case study of a severe service outage caused by Log4j2 asynchronous logging bottlenecks, explains step‑by‑step diagnostics of JVM, disk, and RingBuffer metrics, and demonstrates how adjusting log4j2.asyncQueueFullPolicy and log4j2.discardThreshold dramatically improves recovery time during load testing.

JavaPerformance tuningRingBuffer
0 likes · 14 min read
Optimizing Log4j2 Asynchronous Logging: Configuration, Diagnosis, and Load‑Testing
macrozheng
macrozheng
Dec 19, 2024 · Backend Development

Master Java Optional: Clean Null Handling with Real-World Examples

This article introduces Java's Optional class, explains why null checks cause clutter, demonstrates how to replace traditional three‑level null‑checking with concise Optional chains, and provides detailed examples of all core Optional methods such as empty, of, ofNullable, isPresent, get, ifPresent, filter, map, flatMap, orElse, orElseGet, and orElseThrow.

BackendJavaOptional
0 likes · 11 min read
Master Java Optional: Clean Null Handling with Real-World Examples
FunTester
FunTester
Dec 19, 2024 · Backend Development

Mastering Custom Thread Pools: Choosing the Right Queue in Java

This article walks through Java thread‑pool queue options—LinkedBlockingQueue, SynchronousQueue, LinkedBlockingDeque, and PriorityBlockingQueue—explaining their characteristics, demonstrating code examples, and showing how to build multi‑priority executors with concrete output analysis.

BlockingQueueConcurrencyJava
0 likes · 12 min read
Mastering Custom Thread Pools: Choosing the Right Queue in Java
JD Tech
JD Tech
Dec 18, 2024 · Backend Development

Java Code Style Guide: Standards, Tools, and Best Practices

This article explains why consistent Java code style matters, reviews major industry style guides, shows how to choose and customize a style guide, and provides step‑by‑step instructions for configuring IntelliJ IDEA, Checkstyle, and Maven to enforce the standards in daily development.

Best PracticesIDEJava
0 likes · 13 min read
Java Code Style Guide: Standards, Tools, and Best Practices
vivo Internet Technology
vivo Internet Technology
Dec 18, 2024 · Big Data

Kafka Streams: Architecture, Configuration, and Monitoring Use Cases

Kafka Streams is a client library that enables low‑latency, fault‑tolerant real‑time processing of Kafka data through configurable topologies, time semantics, and state stores, and the article explains its architecture, essential configurations, monitoring‑focused ETL example, performance tuning, and strategies for handling partition skew.

Big DataETLJava
0 likes · 25 min read
Kafka Streams: Architecture, Configuration, and Monitoring Use Cases
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 18, 2024 · Backend Development

Design and Implementation of a Spring Boot Log Auditing Plugin Using AOP

This article details the design, architecture, and step‑by‑step implementation of a Spring Boot log auditing plugin built with AOP, Maven plugins, auto‑configuration, thread‑pool execution, and optional message‑queue streaming to improve operation logging and exception tracing in backend services.

AOPJavaLog Auditing
0 likes · 18 min read
Design and Implementation of a Spring Boot Log Auditing Plugin Using AOP
Top Architect
Top Architect
Dec 18, 2024 · Backend Development

Integrating Flowable Workflow Engine with Spring Boot: A Comprehensive Guide

This article introduces the evolution of Java-based workflow engines, compares Activiti, Flowable, and Camunda, explains core BPMN concepts, and provides a step‑by‑step tutorial for integrating Flowable into a Spring Boot project, including dependencies, BPMN diagram creation, service task implementation, and testing.

BPMNFlowableJava
0 likes · 21 min read
Integrating Flowable Workflow Engine with Spring Boot: A Comprehensive Guide
Top Architect
Top Architect
Dec 18, 2024 · Backend Development

OAuth 2.0 Introduction and Spring Boot Implementation Guide

This article provides a comprehensive overview of OAuth 2.0 concepts, grant types, and step‑by‑step instructions for building an authorization server and a resource server using Spring Boot, including configuration classes, token services, security settings, and testing procedures.

Authorization ServerBackend DevelopmentJava
0 likes · 12 min read
OAuth 2.0 Introduction and Spring Boot Implementation Guide
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 18, 2024 · Fundamentals

Understanding Bloom Filters and Their Support in Redis

This article explains the probabilistic Bloom filter data structure, its characteristics and typical use cases such as cache‑penetration prevention, details its simple implementation steps, demonstrates how Redis (via Redisson) provides built‑in Bloom filter support with Java code examples, and summarizes its practical benefits.

JavaRedisRedisson
0 likes · 7 min read
Understanding Bloom Filters and Their Support in Redis
DevOps Operations Practice
DevOps Operations Practice
Dec 17, 2024 · Backend Development

From CPU Alert to Resolution: A Step‑by‑Step Backend Performance Debugging Guide

This article recounts a midnight CPU alert incident and walks through systematic backend troubleshooting—from initial system checks and JVM profiling to algorithm refactoring, database indexing, Docker‑based isolation, and proactive monitoring—demonstrating how to restore service performance and prevent future outages.

DatabaseDockerJVM
0 likes · 7 min read
From CPU Alert to Resolution: A Step‑by‑Step Backend Performance Debugging Guide
Top Architect
Top Architect
Dec 17, 2024 · Backend Development

Understanding Plugin Mechanisms in Java and Spring Boot

This article explains Java and Spring Boot plugin mechanisms, covering benefits, common implementation strategies such as ServiceLoader, custom configuration files, and Spring Factories, and provides practical code examples and a real‑world case study to illustrate extensible architecture design.

JavaSPIServiceLoader
0 likes · 21 min read
Understanding Plugin Mechanisms in Java and Spring Boot
Selected Java Interview Questions
Selected Java Interview Questions
Dec 17, 2024 · Backend Development

Efficient and Elegant Null Checks in Java Using Utility Classes

This article explains how to perform efficient and elegant null checks in Java by first identifying the data type, then selecting the appropriate utility class such as StringUtils, ObjectUtils, Collections or CollectionUtils, and finally applying the class’s isEmpty method with code examples for strings, arrays, lists, maps, and more.

Backend DevelopmentJavaObjectUtils
0 likes · 7 min read
Efficient and Elegant Null Checks in Java Using Utility Classes
JD Tech Talk
JD Tech Talk
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article experimentally compares how a Java ExecutorService thread pool reacts to uncaught exceptions when tasks are submitted via execute versus submit, showing that execute removes the faulty thread and creates a new one while submit retains the thread and stores the exception in a Future.

ConcurrencyException HandlingExecutorService
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
JD Cloud Developers
JD Cloud Developers
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article examines how Java's ExecutorService thread pool reacts when a task throws an uncaught exception, comparing the behaviors of execute and submit methods, analyzing source code, and summarizing the impact on thread removal, creation, and exception retrieval.

ConcurrencyExecutorServiceJava
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
FunTester
FunTester
Dec 17, 2024 · Backend Development

Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques

This article examines why uncaught exceptions in Java thread pools cause runaway thread creation, then walks through five concrete strategies—try‑catch wrappers, Callable, afterExecute overrides, custom ThreadFactory, and a global default handler—each illustrated with runnable code and detailed analysis.

Backend DevelopmentConcurrencyException Handling
0 likes · 13 min read
Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques
Top Architect
Top Architect
Dec 16, 2024 · Backend Development

Replacing MyBatis with MyBatis‑Plus: Version Compatibility, Debugging, and Lessons Learned

This article walks through the process of swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains why upgrading MyBatis to 3.5.1 triggers a LocalDateTime conversion error, shows how updating mysql‑connector‑java resolves the issue, and shares the broader pitfalls of component upgrades and bug fixes.

DebuggingJavaMyBatis-Plus
0 likes · 10 min read
Replacing MyBatis with MyBatis‑Plus: Version Compatibility, Debugging, and Lessons Learned
macrozheng
macrozheng
Dec 16, 2024 · Backend Development

Boost Java Loop Performance: Replace Nested Loops with a HashMap

This article demonstrates how to dramatically speed up Java code that matches items between two large lists by eliminating nested loops, using early‑exit with break and, more effectively, pre‑building a HashMap for O(1) lookups, with concrete timing results and full code examples.

Backend DevelopmentHashMapJava
0 likes · 8 min read
Boost Java Loop Performance: Replace Nested Loops with a HashMap
JD Cloud Developers
JD Cloud Developers
Dec 16, 2024 · Operations

Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks

A Java service experienced occasional five‑minute latency spikes despite similar provider response times, prompting a systematic investigation of container memory usage, page‑cache behavior, young‑generation GC pauses, and network bottlenecks, ultimately revealing and mitigating the root causes.

ContainerJavagc
0 likes · 8 min read
Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 16, 2024 · Backend Development

Building a Japanese Language Analysis Tool with Java, Kotlin, Spring Boot, and Gradle (Multi‑module Project)

This article details the creation of a Japanese language analysis tool using Java, Kotlin, Spring Boot, and Gradle, explaining the multi‑module project structure, parent and child Gradle configurations, integration of Swing UI with an embedded Chromium engine, and practical tips for mixing Java and Kotlin code.

ChromiumGradleJava
0 likes · 11 min read
Building a Japanese Language Analysis Tool with Java, Kotlin, Spring Boot, and Gradle (Multi‑module Project)
Java Architect Essentials
Java Architect Essentials
Dec 15, 2024 · Operations

Simplify Java Project Build and Deployment with Jpom: A Hands‑On Guide

Jpom is a lightweight, low‑intrusion Java‑based platform that streamlines online building, automatic deployment, daily operations, and project monitoring, offering features such as node management, SSH terminal, Docker control, and multi‑environment packaging, with step‑by‑step installation commands and demo access details.

DevOpsDockerJava
0 likes · 7 min read
Simplify Java Project Build and Deployment with Jpom: A Hands‑On Guide
Java Tech Enthusiast
Java Tech Enthusiast
Dec 15, 2024 · Fundamentals

Java Serialization and Deserialization: Concepts and Practices

The article explains serialization and deserialization fundamentals, highlights pitfalls such as ambiguous binary streams and platform‑dependent field sizes, then compares Java’s native ObjectOutputStream, JSON libraries, Hessian binary RPC, and Google’s Protobuf, guiding readers to select the appropriate format based on performance, payload size, and type‑safety needs.

DeserializationHessianJSON
0 likes · 8 min read
Java Serialization and Deserialization: Concepts and Practices
Su San Talks Tech
Su San Talks Tech
Dec 14, 2024 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

This article explains the limitations of Java's Future, introduces CompletableFuture with its rich API for non‑blocking asynchronous programming, demonstrates practical usage including task creation, result retrieval, chaining, exception handling, and shows how RocketMQ leverages CompletableFuture to coordinate disk flush and replica sync tasks efficiently.

AsyncCompletableFutureConcurrency
0 likes · 16 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 14, 2024 · Backend Development

Spring Boot Request Logging, Request/Response Wrappers, OncePerRequestFilter, and AOP Utility Classes

This article explains how Spring Boot's built‑in logging filter, request and response caching wrappers, the OncePerRequestFilter base class, and AOP helper classes such as AopContext, AopUtils, and ReflectionUtils can be configured and used to record, modify, and monitor HTTP traffic and simplify proxy‑based programming.

AOPJavaOncePerRequestFilter
0 likes · 11 min read
Spring Boot Request Logging, Request/Response Wrappers, OncePerRequestFilter, and AOP Utility Classes
DaTaobao Tech
DaTaobao Tech
Dec 13, 2024 · Databases

MyBatis Boolean vs Boolean: Unexpected 0 Value and Fix

Because MyBatis reads a primitive boolean field directly when no getter exists, the default false value is bound as 0, causing an unexpected zero in the MySQL tinyint column; changing the field to the Boolean wrapper (initialized to true) or fixing the update logic resolves the issue.

DatabaseDebuggingJava
0 likes · 9 min read
MyBatis Boolean vs Boolean: Unexpected 0 Value and Fix