BestHub
Sign in
Tagged articles
5000 articles
Page 28 of 50
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 InsertPerformance Optimizationjava
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 reviewParameter Validationannotations
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.

MAPNested Loopjava
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 OptimizationMyBatisPlus
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.

BackendThreadPoolbest practices
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.

InterceptorServlet FilterSpring MVC
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 PoolJVMMemory Management
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.

GeocodingTianditubackend-development
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 ArchitectureOrder CancellationRabbitMQ
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.

DynamicThreadPoolRejectionPolicyThreadFactory
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 Pointsbean-lifecycledependency-injection
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.

Performance TuningRingBufferasynchronous logging
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.

Backendjavajava8
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.

BlockingQueueLinkedBlockingDequePriorityQueue
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.

IDEbest practicescheckstyle
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 DataETLStream Topology
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.

Log Auditingaopjava
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.

BPMNFlowableSpringBoot
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 ServerOAuth2.0Resource Server
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.

bloom-filtercache-penetrationjava
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.

DockerJVMdatabase
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.

SPIServiceLoaderjava
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.

ObjectUtilsStringUtilsbackend-development
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.

Exception HandlingExecutorServiceThreadPool
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.

ExecutorServiceThreadPoolconcurrency
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.

Exception HandlingThreadPoolbackend-development
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.

MySQLORMVersion Compatibility
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.

HashMapPerformance Optimizationalgorithm
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.

ContainerPerformancegc
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.

ChromiumGradleKotlin
0 likes · 11 min read
Building a Japanese Language Analysis Tool with Java, Kotlin, Spring Boot, and Gradle (Multi‑module Project)
Lobster Programming
Lobster Programming
Dec 16, 2024 · Fundamentals

How Many Objects Does Java Create for Different String Initializations?

This article explains how Java creates objects for various String assignments—using new String("long"), a literal "long", or concatenated literals "lo" + "ng"—detailing when one or two objects are allocated based on the presence of the literal in the string constant pool.

Constant PoolMemory ManagementObject Creation
0 likes · 3 min read
How Many Objects Does Java Create for Different String Initializations?
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.

CI/CDDevOpsDocker
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.

AsyncCompletableFutureFuture
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.

OncePerRequestFilterRequest LoggingResponse wrapper
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.

ORMbooleandatabase
0 likes · 9 min read
MyBatis Boolean vs Boolean: Unexpected 0 Value and Fix
Su San Talks Tech
Su San Talks Tech
Dec 13, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common Java thread‑pool pitfalls—such as using Executors shortcuts, misconfiguring thread counts, ignoring queue choices, and neglecting shutdown or monitoring—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

ThreadPoolbest practicesconcurrency
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
Java Architect Essentials
Java Architect Essentials
Dec 12, 2024 · Backend Development

Build a Secure SMS Verification Service with Spring Boot and Redis

This tutorial walks through creating a simulated SMS verification system using Spring Boot, Redis, and scheduled tasks, covering requirements, dependency setup, controller and service implementation, rate limiting, code expiration, validation logic, and daily reset of usage counters.

BackendCode ExampleSMS Verification
0 likes · 7 min read
Build a Secure SMS Verification Service with Spring Boot and Redis
Top Architect
Top Architect
Dec 12, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit

This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system example and complete Java code snippets, while also noting thread‑local considerations and promotional offers.

KafkaSpringBootTransactionSynchronizationManager
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit
Java Tech Enthusiast
Java Tech Enthusiast
Dec 12, 2024 · Backend Development

Java CompletableFuture: Asynchronous Programming Guide

Java's CompletableFuture, introduced in Java 8, replaces the blocking Future with a rich, non‑blocking API that supports asynchronous task creation, result retrieval via get/join, chaining callbacks, exception handling, task combination (AND/OR, allOf/anyOf), and recommends custom executors, timeouts, and proper saturation policies.

CompletableFutureasynchronous programmingbest practices
0 likes · 16 min read
Java CompletableFuture: Asynchronous Programming Guide
Java Tech Enthusiast
Java Tech Enthusiast
Dec 12, 2024 · Fundamentals

LeetCode 814: Binary Tree Pruning

The article explains LeetCode 814, where a binary tree of 0s and 1s is pruned by recursively removing subtrees lacking a 1, using a post‑order traversal that returns null for nodes with value 0 and no retained children, achieving O(n) time and O(h) space.

LeetCodePythonRecursion
0 likes · 6 min read
LeetCode 814: Binary Tree Pruning
Deepin Linux
Deepin Linux
Dec 12, 2024 · Backend Development

Understanding Zero‑Copy Architecture: Concepts, Techniques, and Applications

Zero‑copy eliminates CPU‑mediated data copies between user and kernel spaces by using DMA and memory‑mapping, dramatically improving I/O performance, reducing context switches, and enabling high‑throughput applications such as file servers, Kafka brokers, and Java networking frameworks.

DMAI/O optimizationLinux
0 likes · 28 min read
Understanding Zero‑Copy Architecture: Concepts, Techniques, and Applications
Architect
Architect
Dec 11, 2024 · Fundamentals

Mastering Code Refactoring: When, Why, and How to Clean Up Your Java Projects

This article explains the concept of refactoring, distinguishes it from performance optimization, outlines the purposes, timing, and challenges of refactoring, and provides concrete techniques, patterns, and IDE tools—complete with code examples—to help developers improve code structure, readability, and maintainability.

IDE toolsbest practicescode quality
0 likes · 30 min read
Mastering Code Refactoring: When, Why, and How to Clean Up Your Java Projects
JD Tech
JD Tech
Dec 11, 2024 · Backend Development

Optimizing SpringBoot Application Startup Speed: Diagnosis and Solutions

This article details how a SpringBoot advertising platform service with startup times of 400‑500 seconds was analyzed and optimized through Actuator monitoring, log inspection, Tomcat TLD scan disabling, asynchronous HBase warm‑up, custom BeanPostProcessors, async JSF consumer initialization, Tomcat version tuning, and hardware upgrades, achieving roughly a 60% reduction in launch time.

AsyncBackendBeanPostProcessor
0 likes · 20 min read
Optimizing SpringBoot Application Startup Speed: Diagnosis and Solutions
System Architect Go
System Architect Go
Dec 11, 2024 · Cloud Native

Kubernetes CPU Configuration and Linux CFS Interaction

This article explains how Kubernetes resource requests and limits map to Linux cgroup settings via the CFS scheduler, illustrates the underlying calculations for cpu.shares and cpu.cfs_quota_us, and discusses the impact on programming languages such as Go and Java within containers.

CFSKubernetescgroup
0 likes · 5 min read
Kubernetes CPU Configuration and Linux CFS Interaction
Code Ape Tech Column
Code Ape Tech Column
Dec 11, 2024 · Backend Development

Layered Architecture Design for SpringBoot Projects: Nine-Layer Structure and Detailed Implementation

This article explains the concept of layered architecture in Java backend projects, outlines five design dimensions, presents a nine‑layer SpringBoot module structure, and provides concrete code examples for each layer—including util, infrastructure, domain, service, integration, facade, client, controller, and boot—demonstrating how to achieve clean separation of concerns and maintainable code.

BackendDDDSpringBoot
0 likes · 18 min read
Layered Architecture Design for SpringBoot Projects: Nine-Layer Structure and Detailed Implementation
Java Architect Essentials
Java Architect Essentials
Dec 11, 2024 · Databases

Redis Expiration Listener: Scenario Testing and Performance Analysis

This article examines the pitfalls of using Redis key‑expiration notifications for delayed business actions, presents a Docker‑based benchmark, provides Spring‑Boot code for scheduling and listening to expirations, and analyzes how notification latency grows as the number of keys increases.

Key ExpirationPerformance Testingdatabase
0 likes · 11 min read
Redis Expiration Listener: Scenario Testing and Performance Analysis
Su San Talks Tech
Su San Talks Tech
Dec 11, 2024 · Fundamentals

8 Essential Design Patterns Every Java Developer Should Master

This article introduces eight core design patterns—Singleton, Factory, Strategy, Proxy, Observer, Decorator, Template Method, and Builder—explaining their concepts, providing Java code examples, and showing typical JDK and Spring framework usages to help developers write cleaner, more maintainable code.

BuilderDecoratorDesign Patterns
0 likes · 12 min read
8 Essential Design Patterns Every Java Developer Should Master
Architecture Digest
Architecture Digest
Dec 10, 2024 · Backend Development

Understanding Java Virtual Threads and Their Use in Spring Boot

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.

Java 21PerformanceVirtual Threads
0 likes · 7 min read
Understanding Java Virtual Threads and Their Use in Spring Boot
Top Architect
Top Architect
Dec 10, 2024 · Backend Development

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

This article explains how to replace Spring Boot's default embedded Tomcat with the high‑performance Undertow server, provides step‑by‑step Maven dependency changes, outlines Undertow's advantages, and presents benchmark results showing superior throughput and lower memory usage for high‑concurrency applications.

SpringBootTomcatjava
0 likes · 9 min read
Replacing Tomcat with Undertow in Spring Boot: Configuration, Features, and Performance Comparison
Java Tech Enthusiast
Java Tech Enthusiast
Dec 10, 2024 · Backend Development

Implementing a FIFO Export Queue in Spring Boot for Large Data Exports

The article demonstrates how to implement a bounded FIFO export queue in a Spring Boot application, using synchronized wait/notify methods to limit concurrent large‑data exports to ten threads, integrating with an abstract EasyExcel exporter and a controller that spawns export tasks, while noting future enhancements such as persistent storage and Redis‑based queues.

Export Queueconcurrencyeasyexcel
0 likes · 11 min read
Implementing a FIFO Export Queue in Spring Boot for Large Data Exports
Selected Java Interview Questions
Selected Java Interview Questions
Dec 10, 2024 · Backend Development

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

Java 21's virtual threads provide lightweight, high‑concurrency execution managed by the JVM, and this article explains their fundamentals, demonstrates basic creation, shows how to enable them in Spring Boot, and presents performance benchmarks comparing virtual threads to traditional threads.

JVMVirtual Threadsjava
0 likes · 8 min read
Introducing Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
IT Services Circle
IT Services Circle
Dec 10, 2024 · Fundamentals

Six Common Mistakes When Using Java BigDecimal and How to Avoid Them

This article explains six typical pitfalls when using Java's BigDecimal for precise calculations—such as initializing with floating‑point literals, neglecting scale in division, misusing equals, confusing scale with precision, ignoring immutability, and performance overhead—and provides clear code‑based solutions to each problem.

ArithmeticBigDecimalPerformance
0 likes · 7 min read
Six Common Mistakes When Using Java BigDecimal and How to Avoid Them
dbaplus Community
dbaplus Community
Dec 9, 2024 · Backend Development

Master Java Logging: Framework Choices, Best Practices, and Real-World Tips

This guide explains why System.out.println is unsuitable for production, compares Java logging frameworks such as Log4j2, Logback and SLF4J, shows how to integrate them with code and Lombok, and provides comprehensive best‑practice recommendations on log levels, formatting, volume control, rolling policies, asynchronous logging and log aggregation.

best practicesjavalog4j2
0 likes · 18 min read
Master Java Logging: Framework Choices, Best Practices, and Real-World Tips
Architect
Architect
Dec 9, 2024 · Backend Development

Step‑by‑Step Guide: Integrating Flowable BPMN with Spring Boot for Leave Approval Workflow

This article walks through the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, and provides a complete Spring Boot integration tutorial—including Maven setup, BPMN modeling, service task implementation, diagram generation, unit testing and common troubleshooting—using a concrete leave‑request example.

BPMNFlowableProcess Engine
0 likes · 22 min read
Step‑by‑Step Guide: Integrating Flowable BPMN with Spring Boot for Leave Approval Workflow
IT Services Circle
IT Services Circle
Dec 9, 2024 · Backend Development

Optimized Snowflake ID Generation with Seata: Solving MyBatis-Plus Duplicate Key Issues

This article analyzes why MyBatis-Plus generates duplicate primary keys in clustered Docker/K8S environments due to worker‑id and datacenter‑id collisions, introduces Seata's improved Snowflake algorithm that decouples from the OS clock, explains its implementation with Java code, and shows how to integrate it as a global ID generator to improve database performance and avoid page splits.

Database PerformanceSeataSnowflake algorithm
0 likes · 18 min read
Optimized Snowflake ID Generation with Seata: Solving MyBatis-Plus Duplicate Key Issues
Selected Java Interview Questions
Selected Java Interview Questions
Dec 9, 2024 · Backend Development

Hot Deployment Techniques for Spring Boot: IDEA Configuration, Spring DevTools, and JRebel

This article explains three hot‑deployment methods for Spring Boot—IDEA's configuration options, the spring‑boot‑devtools library, and the JRebel plugin—detailing how to set them up, their underlying mechanisms, and best‑practice recommendations to avoid costly full restarts during development.

DevToolsHot DeploymentIDEA
0 likes · 4 min read
Hot Deployment Techniques for Spring Boot: IDEA Configuration, Spring DevTools, and JRebel
Architecture Digest
Architecture Digest
Dec 9, 2024 · Fundamentals

Efficient Null Checks in Java Using Utility Classes

This article explains how to efficiently perform null checks in Java by selecting appropriate utility classes such as StringUtils, ObjectUtils, Collections, and CollectionUtils for different data types, and also includes a brief notice about a free programmer book giveaway.

CollectionsObjectUtilsStringUtils
0 likes · 9 min read
Efficient Null Checks in Java Using Utility Classes
macrozheng
macrozheng
Dec 9, 2024 · Backend Development

Mastering the Chain of Responsibility Pattern in Spring Boot: 3 Practical Implementations

This article explains the Chain of Responsibility design pattern, outlines typical use cases, and demonstrates three concrete ways to implement it in Spring Boot with full Java code examples, unit tests, and execution results, helping developers build clean, extensible backend workflows.

Chain of ResponsibilityDesign Patternsbackend-development
0 likes · 11 min read
Mastering the Chain of Responsibility Pattern in Spring Boot: 3 Practical Implementations
Java Tech Enthusiast
Java Tech Enthusiast
Dec 8, 2024 · Backend Development

Performance Comparison of Spring Boot Native Image, JAR, Go, and Rust Deployments

The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.

GoPerformanceRust
0 likes · 9 min read
Performance Comparison of Spring Boot Native Image, JAR, Go, and Rust Deployments
Top Architect
Top Architect
Dec 7, 2024 · Backend Development

Integrating Flowable Workflow Engine with Spring Boot: A Comprehensive Guide

This article provides a detailed tutorial on using Flowable as a BPMN workflow engine within a Spring Boot application, covering the history of workflow engines, core concepts, Maven dependencies, BPMN diagram creation, process deployment, task configuration, service task implementation, and troubleshooting tips.

BPMNFlowableSpringBoot
0 likes · 20 min read
Integrating Flowable Workflow Engine with Spring Boot: A Comprehensive Guide
Top Architect
Top Architect
Dec 7, 2024 · Information Security

OAuth 2.0 Overview and Spring Boot Implementation Guide

This article introduces OAuth 2.0 concepts, roles, and grant types, then provides a step‑by‑step Spring Boot implementation for an authorization server and a resource server, including configuration classes, Maven dependencies, test endpoints, and screenshots of the authentication and token‑validation process.

Authorization ServerResource Serverjava
0 likes · 12 min read
OAuth 2.0 Overview and Spring Boot Implementation Guide
Java Tech Enthusiast
Java Tech Enthusiast
Dec 7, 2024 · Interview Experience

Solve LeetCode 739 ‘Daily Temperatures’ Using a Monotonic Stack

This article explains the LeetCode 739 'Daily Temperatures' problem, describing how to compute the next warmer day for each temperature using a monotonic stack, and provides complete implementations in Java, C++, and Python, along with step‑by‑step analysis and example walkthroughs.

Daily TemperaturesLeetCodeMonotonic Stack
0 likes · 6 min read
Solve LeetCode 739 ‘Daily Temperatures’ Using a Monotonic Stack
Java Tech Enthusiast
Java Tech Enthusiast
Dec 7, 2024 · Backend Development

Elegant Parameter Validation in Spring Boot with Hibernate Validator

Spring Boot leverages Hibernate Validator to replace repetitive manual checks with declarative annotations on DTO fields, automatically enforcing constraints via @Valid, while a global exception handler formats failures into clear JSON, and advanced features such as validation groups and custom annotations further enhance maintainability and user‑friendly error reporting.

Hibernate ValidatorParameter Validationjava
0 likes · 9 min read
Elegant Parameter Validation in Spring Boot with Hibernate Validator
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 7, 2024 · Backend Development

Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details

This article introduces an online SQL-to-ER diagram tool, explains its advantages, provides step‑by‑step usage instructions, showcases example SQL and Java code for parsing and generating ER diagrams, and discusses the underlying design‑pattern architecture such as Strategy, Factory, Dependency Injection, and Singleton.

Design PatternsER Diagrambackend-development
0 likes · 17 min read
Online SQL-to-ER Diagram Tool: Features, Usage, and Implementation Details
21CTO
21CTO
Dec 6, 2024 · Backend Development

What’s New in JDK 24? 24 Features Shaping the Future of Java

JDK 24, slated for a March 2025 release, introduces over twenty‑four enhancements—including a fourth preview of structured concurrency, quantum‑resistant cryptography, and a compact object header—while being a non‑LTS release that builds on the capabilities of JDK 23 and sets the stage for JDK 25.

JDK 24New FeaturesQuantum‑Resistant Cryptography
0 likes · 13 min read
What’s New in JDK 24? 24 Features Shaping the Future of Java
ITPUB
ITPUB
Dec 6, 2024 · Backend Development

Why ChatGPT Uses Server-Sent Events (SSE) and How to Implement SSE in Spring Boot

This article explains why ChatGPT adopts Server-Sent Events for streaming responses, compares SSE with WebSocket, outlines SSE's core principles and best‑practice considerations, and provides a complete Spring Boot example—including server‑side Java code and client‑side HTML—to demonstrate real‑time data push.

SSEServer-Sent Eventsjava
0 likes · 14 min read
Why ChatGPT Uses Server-Sent Events (SSE) and How to Implement SSE in Spring Boot
Top Architect
Top Architect
Dec 6, 2024 · Backend Development

Java Plugin Architecture: SPI, ServiceLoader, and Spring Boot Integration

This article explains how to implement plugin mechanisms in Java using SPI and ServiceLoader, demonstrates custom configuration approaches, and shows how Spring Boot’s spring.factories can be leveraged for extensible services, providing practical code examples and step‑by‑step guidance for building modular backend applications.

ArchitectureSPISpringBoot
0 likes · 23 min read
Java Plugin Architecture: SPI, ServiceLoader, and Spring Boot Integration
Java Tech Enthusiast
Java Tech Enthusiast
Dec 6, 2024 · Backend Development

Migrating MyBatis to MyBatis-Plus: Debugging LocalDateTime Conversion Issues

When migrating an old Java project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, a test failed with “Conversion not supported for type java.time.LocalDateTime” because MyBatis 3.5.1 stopped handling Java 8 time types and the existing mysql‑connector‑java 5.1.26 driver lacked support, which was resolved by upgrading the connector to version 5.1.37 or later, highlighting the need for thorough compatibility testing during framework upgrades.

LocalDateTimeMyBatis-PlusMySQL
0 likes · 7 min read
Migrating MyBatis to MyBatis-Plus: Debugging LocalDateTime Conversion Issues
Architecture Digest
Architecture Digest
Dec 6, 2024 · Backend Development

EasyExcel Wrapper for Simplified Import and Export in Spring Boot Backend

This article demonstrates how to encapsulate Alibaba's EasyExcel library within a Spring Boot backend, providing step‑by‑step environment setup, entity annotations, service interfaces, implementation details, usage examples, and solutions to common issues such as date conversion and template‑based export limitations.

ExcelImportExportSpringBooteasyexcel
0 likes · 13 min read
EasyExcel Wrapper for Simplified Import and Export in Spring Boot Backend
Selected Java Interview Questions
Selected Java Interview Questions
Dec 6, 2024 · Backend Development

Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications

This article introduces a lightweight, extensible Java framework that uses custom annotations to translate relational data, dictionaries, collections, and nested objects, detailing its background, architecture, core annotation design, usage examples, advanced features, Spring Boot integration, ORM support, and provides the open‑source repository link.

BackendData TranslationFramework
0 likes · 17 min read
Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications
Su San Talks Tech
Su San Talks Tech
Dec 6, 2024 · Fundamentals

6 Common BigDecimal Mistakes in Java and How to Avoid Them

This article explains six typical pitfalls when using Java's BigDecimal—such as initializing with floating‑point literals, ignoring scale in division, misusing equals, misunderstanding scale, overlooking immutability, and performance costs—and provides clear code examples and best‑practice solutions to prevent precision loss and inefficiency.

ArithmeticBigDecimalPerformance
0 likes · 7 min read
6 Common BigDecimal Mistakes in Java and How to Avoid Them
FunTester
FunTester
Dec 5, 2024 · Backend Development

Understanding Aeron: A High‑Performance Messaging Framework and Its Advantages

Aeron is an open‑source, low‑latency, high‑throughput messaging framework that leverages zero‑copy memory, shared‑memory IPC and UDP transport to deliver microsecond‑level latency for finance, gaming, and distributed systems, offering a simple API and powerful performance features.

AeronDistributed SystemsHigh-Performance Messaging
0 likes · 9 min read
Understanding Aeron: A High‑Performance Messaging Framework and Its Advantages
Lobster Programming
Lobster Programming
Dec 5, 2024 · Fundamentals

How Does Java’s JVM Load Classes and Execute Code? A Deep Dive

This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.

Garbage CollectionJVMRuntime Data Area
0 likes · 9 min read
How Does Java’s JVM Load Classes and Execute Code? A Deep Dive
Java Architect Essentials
Java Architect Essentials
Dec 4, 2024 · Backend Development

Spring Boot Project Initialization, Version Management, and Common Scaffold Code Guide

This article walks through initializing a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common scaffolding code such as global exception handling, logging, CORS configuration, and recommends useful tools like Maven, embedded Redis, MyBatis‑Plus, and MapStruct for backend development.

Kafkabackend-developmentjava
0 likes · 9 min read
Spring Boot Project Initialization, Version Management, and Common Scaffold Code Guide
Top Architect
Top Architect
Dec 4, 2024 · Fundamentals

Comprehensive Guide to IntelliJ IDEA Debugging Features

This article provides a detailed walkthrough of IntelliJ IDEA's debugging capabilities, covering preparation, main interface components, step controls, variable inspection, conditional breakpoints, expression evaluation, frame dropping, force return, multithreaded and stream debugging, as well as remote debugging techniques, supplemented by a Java code example.

IDEIntelliJ IDEAdebugging
0 likes · 18 min read
Comprehensive Guide to IntelliJ IDEA Debugging Features
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

Java concurrencyPerformance TestingThreadPool
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
Architect
Architect
Dec 3, 2024 · Information Security

How to Secure Third‑Party APIs with AK/SK, Signatures, and Token Strategies

This guide presents a comprehensive design for securing third‑party API calls, covering Access Key/Secret Key generation, permission granularity, timestamp and nonce based replay protection, signature creation and verification, token handling, TLS encryption, rate limiting, logging, and practical Java code examples.

API SecurityAccess KeyReplay attack
0 likes · 28 min read
How to Secure Third‑Party APIs with AK/SK, Signatures, and Token Strategies