BestHub
Sign in
Tagged articles

spring

1855 articles · Page 7 of 19
JavaEdge
JavaEdge
May 7, 2024 · Backend Development

Mastering Product Management: Build SPU/SKU CRUD with Snowflake IDs in Java

This guide walks through implementing a complete product management module in a Java e‑commerce system, covering Snowflake distributed ID generation, database schema design for SPU and SKU tables, CRUD operations, category‑brand linking, audit workflow, status toggling, batch processing, and logical deletion, all with concrete code examples.

CRUDE‑commerceJava
0 likes · 16 min read
Mastering Product Management: Build SPU/SKU CRUD with Snowflake IDs in Java
Su San Talks Tech
Su San Talks Tech
May 7, 2024 · Backend Development

9 Common Reasons Why @Async Doesn’t Work in Spring and How to Fix Them

This article explains nine typical scenarios that cause the Spring @Async annotation to fail—ranging from missing @EnableAsync to improper method visibility, return types, static or final modifiers, missing @Service, manual object creation, and incorrect component scanning—providing clear explanations and code examples for each case.

AOPAsyncCommon pitfalls
0 likes · 10 min read
9 Common Reasons Why @Async Doesn’t Work in Spring and How to Fix Them
Top Architect
Top Architect
May 6, 2024 · Operations

Graceful Service Shutdown and Deployment Strategies for Java Applications

This article explains how to achieve graceful service startup and shutdown in Java projects, covering monolithic and microservice architectures, Spring and SpringBoot mechanisms, service registration with Eureka and Nacos, Kubernetes probes, thread‑pool and MQ graceful termination, and provides practical code examples for each scenario.

JavaKubernetesgraceful shutdown
0 likes · 27 min read
Graceful Service Shutdown and Deployment Strategies for Java Applications
Java Captain
Java Captain
May 4, 2024 · Backend Development

Implementing a FIFO Export Queue for Large Data Exports in Java

This article explains how to design and implement a fixed‑size FIFO export queue in a Java Spring application to control concurrent MySQL data exports, detailing the related entities, code implementation with EasyExcel, a test controller, and observed results.

EasyExcelExport QueueJava
0 likes · 10 min read
Implementing a FIFO Export Queue for Large Data Exports in Java
Programmer XiaoFu
Programmer XiaoFu
Apr 30, 2024 · Backend Development

Lombok Tricks: Using @onX, @Delegate, @Cleanup, @Singular/@Builder, and @With

This article showcases several handy Lombok annotations—@onX for custom constructor injection, @Delegate for method delegation, @Cleanup for automatic resource release, the @Singular/@Builder combo for fluent object creation, and @With for immutable copies—illustrating their usage with Spring and Java code examples while warning against overuse.

JavaLombokannotations
0 likes · 7 min read
Lombok Tricks: Using @onX, @Delegate, @Cleanup, @Singular/@Builder, and @With
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 30, 2024 · Backend Development

Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive

This article explains Spring AOP fundamentals, demonstrates XML‑based and annotation‑based configurations, and provides a comprehensive guide to using ProxyFactoryBean—including its properties, proxy‑interface and proxy‑class scenarios, CGLIB considerations, and wildcard interceptor matching—complete with runnable code examples.

AOPCGLIBProxyFactoryBean
0 likes · 9 min read
Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive
Selected Java Interview Questions
Selected Java Interview Questions
Apr 29, 2024 · Backend Development

Why Spring BeanUtils.copyProperties Is Discouraged and MapStruct Is Preferred for Java Object Mapping

The article explains the limitations of Spring's BeanUtils.copyProperties—such as type mismatches, null overwriting, and reflection overhead—and demonstrates how MapStruct provides a faster, compile‑time generated alternative for copying properties between Java objects, with usage examples and Maven setup.

BeanUtilsJavaObject Mapping
0 likes · 6 min read
Why Spring BeanUtils.copyProperties Is Discouraged and MapStruct Is Preferred for Java Object Mapping
DaTaobao Tech
DaTaobao Tech
Apr 29, 2024 · Backend Development

Refactoring Cache Logic with Spring Cache Annotations

The article explains how moving cache operations out of business code and into Spring Cache annotations—@Cacheable, @CachePut, and @CacheEvict—creates a clean, loosely‑coupled design, simplifies maintenance, and enables custom extensions such as breakdown protection and multi‑level caching for high‑concurrency applications.

AOPJavaspring
0 likes · 6 min read
Refactoring Cache Logic with Spring Cache Annotations
Code Ape Tech Column
Code Ape Tech Column
Apr 29, 2024 · Backend Development

Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With

This article explains several powerful Lombok annotations—including @onX, @Delegate, @Cleanup, @Builder with @Singular, and @With—showing how they simplify Spring‑based Java code through automatic constructor generation, method delegation, resource management, and fluent builders, while also warning against overuse.

JavaLombokannotations
0 likes · 7 min read
Advanced Lombok Annotations: @onX, @Delegate, @Cleanup, @Builder/@Singular, and @With
Architect
Architect
Apr 28, 2024 · Backend Development

Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache

This article explains how Spring solves circular dependencies by using a three‑level cache system, walks through the underlying source‑code execution flow, clarifies the purpose of each cache level, and discusses why the design is essential for AOP‑enabled beans.

AOPBeanFactoryCircular Dependency
0 likes · 12 min read
Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache
Cognitive Technology Team
Cognitive Technology Team
Apr 27, 2024 · Backend Development

Using @Transactional and @Async Together in Spring: Interaction, Transaction Propagation, and Best Practices

This article explains how Spring's @Transactional and @Async annotations can be applied to the same service methods, the implications for transaction boundaries across threads, and the precautions developers must take to maintain data consistency and proper transaction management.

JavaThreadLocalTransaction Management
0 likes · 4 min read
Using @Transactional and @Async Together in Spring: Interaction, Transaction Propagation, and Best Practices
Code Ape Tech Column
Code Ape Tech Column
Apr 27, 2024 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, discusses the three traditional reasons for using interfaces, explains why they often do not hold up, and proposes practical structuring alternatives for single‑ and multi‑implementation scenarios.

DAOJavaService Layer
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? When to Use Them in Spring Projects
Java High-Performance Architecture
Java High-Performance Architecture
Apr 26, 2024 · Backend Development

Mastering Spring Transaction Hooks: Safely Sync Kafka Messages After Commit

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system case study and complete code examples.

JavaSpring BootTransactionSynchronizationManager
0 likes · 9 min read
Mastering Spring Transaction Hooks: Safely Sync Kafka Messages After Commit
DeWu Technology
DeWu Technology
Apr 24, 2024 · Backend Development

State Machine Integration for New Product Onboarding

The article details how Dewu’s new product onboarding workflow was refactored into a Spring StateMachine‑driven architecture that separates channel‑specific logic via a Strategy‑pattern operation layer, defines clear enum status domains, and uses guards, actions, and choice states to achieve maintainable, extensible, and idempotent state transitions.

Design PatternsWorkflowproduct onboarding
0 likes · 20 min read
State Machine Integration for New Product Onboarding
Su San Talks Tech
Su San Talks Tech
Apr 24, 2024 · Backend Development

Master Spring’s Core Features: Resource Management, Environment, Type Conversion and More

This article provides a comprehensive guide to Spring’s essential infrastructure, covering Java and Spring resource management, environment property handling, type conversion APIs, data binding mechanisms, generic type inspection with ResolvableType, internationalization support, the BeanFactory and ApplicationContext architecture, and the built‑in event system, all illustrated with code examples and diagrams.

ApplicationContextJavadata-binding
0 likes · 39 min read
Master Spring’s Core Features: Resource Management, Environment, Type Conversion and More
Architecture Digest
Architecture Digest
Apr 23, 2024 · Backend Development

14 Practical Code Optimization Tips for Java Backend Development

This article presents fourteen actionable Java backend code‑optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modularization, exception handling, database query reduction, null‑avoidance, strategic use of design patterns, IDE shortcuts, and efficient collection handling—to help developers write cleaner, more maintainable, and higher‑performance code.

JavaLombokbackend
0 likes · 7 min read
14 Practical Code Optimization Tips for Java Backend Development
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 23, 2024 · Backend Development

Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies

This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.

ComponentConfigurationJava
0 likes · 9 min read
Understanding @Configuration vs @Component in Spring: Bean Creation and Proxies
Sanyou's Java Diary
Sanyou's Java Diary
Apr 22, 2024 · Backend Development

Master Spring’s Core: Resource Management, Environment, Type Conversion, and More

Explore a comprehensive guide to Spring’s core mechanisms—including resource handling, environment configuration, type conversion, data binding, generic processing, internationalization, BeanFactory, ApplicationContext, and event publishing—complete with detailed explanations, code demos, diagrams, and practical insights for mastering backend development with Spring.

ApplicationContextEvent Publishingdata-binding
0 likes · 40 min read
Master Spring’s Core: Resource Management, Environment, Type Conversion, and More
IT Niuke
IT Niuke
Apr 19, 2024 · Backend Development

Why You Should Switch from RestTemplate to Spring’s Official WebClient

The article explains that RestTemplate is deprecated in Spring 5+, outlines WebClient’s non‑blocking I/O, functional style, streaming support and improved error handling, and provides step‑by‑step code examples for synchronous and asynchronous requests, timeout configuration, and error processing.

JavaWebClienterror-handling
0 likes · 13 min read
Why You Should Switch from RestTemplate to Spring’s Official WebClient
Code Ape Tech Column
Code Ape Tech Column
Apr 18, 2024 · Backend Development

Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously after transaction commit, illustrated with a payment‑system logging scenario and complete Java code examples.

AsynchronousJavaKafka
0 likes · 10 min read
Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing
Architect's Tech Stack
Architect's Tech Stack
Apr 16, 2024 · Backend Development

Should the Service Layer Use Interfaces? A Critical Discussion

This article examines whether a Service layer in Java Spring projects truly requires interfaces, debunking common arguments, exploring development workflows without interfaces, discussing project structuring for single and multiple implementations, and concluding when interfaces are beneficial or unnecessary.

JavaService Layerarchitecture
0 likes · 7 min read
Should the Service Layer Use Interfaces? A Critical Discussion
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 16, 2024 · Backend Development

Speed Up Spring Startup with Parallel Bean Initialization

This article introduces Spring 6.2’s Parallel Bean Initialization feature, explains its benefits for reducing startup time, provides step‑by‑step code examples for configuring background bean initialization and a bootstrap executor, compares traditional and concurrent initialization timings, and details the underlying implementation in the Spring container.

JavaParallel Bean InitializationPerformance Optimization
0 likes · 7 min read
Speed Up Spring Startup with Parallel Bean Initialization
Architect
Architect
Apr 14, 2024 · Backend Development

How to Dynamically Load and Unload Java Governance Tasks with Custom ClassLoaders and XXL‑Job

This article explains how to design a plug‑in architecture for a data‑governance service that can start, stop, add, or upgrade individual tasks at runtime without restarting the whole service, using a custom URLClassLoader, Spring bean registration, XXL‑Job integration, dynamic configuration updates, and a clean unload process.

ClassLoaderDynamic LoadingJava
0 likes · 26 min read
How to Dynamically Load and Unload Java Governance Tasks with Custom ClassLoaders and XXL‑Job
Shepherd Advanced Notes
Shepherd Advanced Notes
Apr 11, 2024 · Backend Development

How Spring Event Elegantly Decouples Business Logic: Principles, Usage, and Pitfalls

This article explains how Spring Event provides a publish‑subscribe mechanism to decouple Spring components, details its default synchronous behavior, shows how to make listeners asynchronous, demonstrates ordering and error handling, compares it with message‑queue solutions, and offers practical guidelines for safe usage.

DecouplingPublish-SubscribeSpring Boot
0 likes · 22 min read
How Spring Event Elegantly Decouples Business Logic: Principles, Usage, and Pitfalls
Code Ape Tech Column
Code Ape Tech Column
Apr 10, 2024 · Backend Development

Understanding and Comparing Java, Spring, and Dubbo SPI Mechanisms

This article explains the concept of Service Provider Interface (SPI), demonstrates how Java's ServiceLoader, Spring's SpringFactoriesLoader, and Dubbo's ExtensionLoader implement SPI, compares their configurations and capabilities, and discusses advanced features such as adaptive extensions, IOC/AOP integration, wrappers, and auto‑activation.

DubboExtensionLoaderJava
0 likes · 15 min read
Understanding and Comparing Java, Spring, and Dubbo SPI Mechanisms
JavaEdge
JavaEdge
Apr 9, 2024 · Fundamentals

What’s New in IntelliJ IDEA 2024.1? Full‑Line Completion, Java 22 Support and More

IntelliJ IDEA 2024.1 introduces full‑line code completion powered by a local deep‑learning model, Java 22 language support, a revamped terminal, sticky lines in the editor, enhanced Maven handling, improved debugging, richer Spring assistance, advanced HTTP client features, and new database tools, all aimed at boosting developer productivity and safety.

DebuggingIDE FeaturesIntelliJ IDEA
0 likes · 15 min read
What’s New in IntelliJ IDEA 2024.1? Full‑Line Completion, Java 22 Support and More
IT Services Circle
IT Services Circle
Apr 9, 2024 · Backend Development

ByteDance Backend Interview Experience: Key Topics and Knowledge Points

This article shares a detailed ByteDance backend interview experience covering three rounds, summarizing essential topics such as Java HashMap internals, Spring circular dependencies, MySQL indexing, OS process/thread concepts, networking protocols, TLS handshake, HTTP/2 features, and common design patterns, providing concise explanations and practical tips.

Design PatternsInterviewJava
0 likes · 25 min read
ByteDance Backend Interview Experience: Key Topics and Knowledge Points
Selected Java Interview Questions
Selected Java Interview Questions
Apr 9, 2024 · Backend Development

Applying the Chain of Responsibility Pattern for Multi‑Level Product Validation and Workflow in Java

This article explains the Chain of Responsibility design pattern, demonstrates its use for multi‑step product validation and a reimbursement workflow in Java with Spring, provides UML diagrams, configuration handling, concrete handler implementations, client execution code, and discusses the pattern’s advantages and drawbacks.

Chain of ResponsibilityDesign PatternJava
0 likes · 18 min read
Applying the Chain of Responsibility Pattern for Multi‑Level Product Validation and Workflow in Java
Java Tech Enthusiast
Java Tech Enthusiast
Apr 9, 2024 · Backend Development

Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls

Spring supports constructor, setter, and field injection, but field injection is discouraged; @Autowired (Spring‑specific, by‑type) and @Resource (standard, by‑name) differ in defaults and IDE warnings, so prefer constructor injection for required beans, setter injection for optional ones, and only use @Resource for unavoidable field injection to lessen container coupling.

AutowiredJavaResource
0 likes · 5 min read
Understanding Spring DI: @Autowired vs @Resource and Field Injection Pitfalls
Architecture Digest
Architecture Digest
Apr 8, 2024 · Backend Development

Design and Implementation of a Flexible Java Download Library for Spring MVC/WebFlux

This article introduces a Java library that simplifies file and resource download handling in Spring MVC and WebFlux by using annotations, reactive programming, customizable handlers, source factories, concurrent loading, compression, response writing, and event‑driven logging to support a wide range of download scenarios.

DownloadJavabackend
0 likes · 15 min read
Design and Implementation of a Flexible Java Download Library for Spring MVC/WebFlux
Java High-Performance Architecture
Java High-Performance Architecture
Apr 8, 2024 · Backend Development

Dynamic Multi-DataSource Switching & Transaction Management in Spring

This article explores solutions for managing multiple data sources in a Spring application, covering dynamic routing with AbstractRoutingDataSource, configuration‑file and database‑table approaches, AOP‑based source switching, and custom multi‑transaction handling to ensure consistency across heterogeneous databases.

JavaMulti-Database Transactionabstractroutingdatasource
0 likes · 15 min read
Dynamic Multi-DataSource Switching & Transaction Management in Spring
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2024 · Backend Development

Dynamic Multi-DataSource Management and Transaction Handling in Spring

This article explains how to dynamically manage multiple data sources and ensure transaction consistency across a master and several application databases in Spring by extending AbstractRoutingDataSource, using configuration‑file and database‑table solutions, and implementing a custom multi‑database transaction manager.

DataSourceDynamicRoutingJava
0 likes · 15 min read
Dynamic Multi-DataSource Management and Transaction Handling in Spring
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 29, 2024 · Backend Development

Mastering Spring BeanWrapper: Set, Get, and Convert Bean Properties Efficiently

This article introduces Spring's BeanWrapper, explains how to set and retrieve simple and nested properties, demonstrates indexed and key‑based access, covers automatic and custom type conversion using PropertyEditorSupport and Converter, and clarifies conversion priority and registration details for backend developers.

BeanWrapperJavaPropertyEditor
0 likes · 9 min read
Mastering Spring BeanWrapper: Set, Get, and Convert Bean Properties Efficiently
Code Ape Tech Column
Code Ape Tech Column
Mar 28, 2024 · Backend Development

A Reactive Download Library for Spring MVC and WebFlux: Design, Implementation, and Usage

This article introduces a Java library that simplifies file download in Spring applications by using a @Download annotation, supporting various source types, reactive and servlet environments, concurrent loading, compression, and customizable handlers, and details its architecture, code examples, and practical considerations.

AnnotationFile DownloadJava
0 likes · 16 min read
A Reactive Download Library for Spring MVC and WebFlux: Design, Implementation, and Usage
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 26, 2024 · Backend Development

Mastering Spring's UriComponentsBuilder: Build and Encode URIs Efficiently

This guide demonstrates how to use Spring's UriComponentsBuilder and related classes—UriBuilderFactory, ServletUriComponentsBuilder, and MvcUriComponentsBuilder—to construct, encode, and link URIs in various scenarios, providing clear code examples for each step, including handling templates, query parameters, and servlet contexts.

JavaURIUriComponentsBuilder
0 likes · 6 min read
Mastering Spring's UriComponentsBuilder: Build and Encode URIs Efficiently
IT Services Circle
IT Services Circle
Mar 23, 2024 · Backend Development

Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts

This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.

InterviewJavaRedis
0 likes · 19 min read
Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts
Java Architect Essentials
Java Architect Essentials
Mar 21, 2024 · Backend Development

Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java

This article explains how to improve large‑file upload experiences by using instant transfer (MD5‑based deduplication), chunked upload, and resumable upload techniques, and provides complete Java backend implementations with Redis coordination and code examples using RandomAccessFile and MappedByteBuffer.

Chunked UploadJavaRedis
0 likes · 14 min read
Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java
macrozheng
macrozheng
Mar 19, 2024 · Backend Development

What’s New in IntelliJ IDEA 2024.1 EAP 5? Boost Your Spring & Backend Workflow

IntelliJ IDEA 2024.1 EAP 5 introduces a suite of enhancements—including richer Spring, Quarkus, and Micronaut support, smarter Spring Bean autocompletion, improved HTTP Client with PKCE and Netty, and advanced GitHub Actions assistance—designed to streamline backend development, debugging, and CI/CD workflows.

GitHub ActionsHTTP clientIntelliJ IDEA
0 likes · 7 min read
What’s New in IntelliJ IDEA 2024.1 EAP 5? Boost Your Spring & Backend Workflow
Architecture Digest
Architecture Digest
Mar 18, 2024 · Backend Development

Creating a Simple HTTP Service with Spring 6 HTTP Interface

This article introduces Spring 6's new HTTP Interface feature, walks through building a Spring Boot project with a User entity, a REST controller, an HTTP Interface definition, and a test using WebClient, while explaining related annotations and the need for Spring Reactive Web dependencies.

JavaSpring BootWebClient
0 likes · 6 min read
Creating a Simple HTTP Service with Spring 6 HTTP Interface
DaTaobao Tech
DaTaobao Tech
Mar 15, 2024 · Backend Development

Common Java Development Pitfalls and Solutions

The article surveys frequent Java development mistakes—such as NullPointerExceptions, unsafe object equality, improper null handling, manual mapping errors, thread‑safety and thread‑pool misuse, swallowed exceptions, Spring bean initialization problems, memory leaks, performance traps, and transaction misconfigurations—while offering practical fixes like annotations, Optional, MapStruct, concurrent utilities, immutable wrappers, bounded executors, unified logging, and proper AOP usage.

Javabest practicesbug
0 likes · 18 min read
Common Java Development Pitfalls and Solutions
Architect's Tech Stack
Architect's Tech Stack
Mar 14, 2024 · Backend Development

Spring 6 HTTP Interface Demo: Defining and Invoking HTTP Services with Java Interfaces

This article demonstrates how to use Spring Framework 6's new HTTP Interface feature by creating a simple Spring Boot application, defining a User entity and controller, implementing an HTTP Interface with @GetExchange, and testing the service via a WebClient proxy, while covering required dependencies and key annotations.

JavaWebClientbackend development
0 likes · 7 min read
Spring 6 HTTP Interface Demo: Defining and Invoking HTTP Services with Java Interfaces
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 12, 2024 · Backend Development

Master Spring’s Essential Utility Classes: From Resources to AOP

This article provides a comprehensive guide to Spring 5.3.30 utility classes, covering resource handling, object and array utilities, number conversion, stream operations, system property resolution, collection helpers, AOP proxy tools, BeanFactory shortcuts, annotation processing, bean manipulation, validation, XML/HTML parsing, web utilities, and URI handling, all illustrated with clear code examples.

JavaUtility Classesbackend development
0 likes · 9 min read
Master Spring’s Essential Utility Classes: From Resources to AOP
Java Architect Essentials
Java Architect Essentials
Mar 11, 2024 · Backend Development

Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring

To prevent performance degradation during large MySQL data exports, this article presents a Java Spring implementation of a bounded FIFO export queue, detailing the ExportQueue class, abstract export handling with EasyExcel, concrete service and controller code, and test results demonstrating queue limits and concurrency considerations.

EasyExcelExportJava
0 likes · 11 min read
Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring
Java Tech Enthusiast
Java Tech Enthusiast
Mar 10, 2024 · Backend Development

Comprehensive Guide to Spring Validation in Spring Boot

This guide explains how to configure and use Spring Validation (JSR‑303) in Spring Boot, covering dependency setup, @Valid vs @Validated, request body and parameter validation, group, nested and collection checks, custom constraints, programmatic validation, fail‑fast mode, and underlying implementation details.

APIHibernateValidatorJava
0 likes · 16 min read
Comprehensive Guide to Spring Validation in Spring Boot
IT Services Circle
IT Services Circle
Mar 9, 2024 · Backend Development

Java Backend Interview Guide: Networks, Data Structures, MySQL Logs, Elasticsearch, Kafka, Microservices, and Spring Essentials

This article compiles a comprehensive Java backend interview guide covering network protocols, HTTP characteristics, core data structures and algorithms, MySQL logging mechanisms, Elasticsearch full‑text search, Kafka reliability and deduplication, common micro‑service components, load‑balancing algorithms, and essential Spring concepts such as IoC, AOP, transactions, and MVC workflow.

ElasticsearchInterviewJava
0 likes · 22 min read
Java Backend Interview Guide: Networks, Data Structures, MySQL Logs, Elasticsearch, Kafka, Microservices, and Spring Essentials
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

How Spring Scans and Registers Custom Annotations

This article explains how the Spring framework discovers and registers custom annotations by using @ComponentScan, ClassPathScanningCandidateComponentProvider, and TypeFilter mechanisms, guiding developers to configure package scanning, apply meta‑annotations, and optionally implement custom filters for flexible bean management.

Custom AnnotationsJavaTypeFilter
0 likes · 5 min read
How Spring Scans and Registers Custom Annotations
Java Tech Enthusiast
Java Tech Enthusiast
Mar 2, 2024 · Backend Development

Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration

The article presents a Java Spring solution that uses a custom URLClassLoader to dynamically load, register, and unload governance task JARs as Spring beans and XXL‑Job handlers at runtime, with configuration persistence via YAML or Nacos and Maven Shade packaging for seamless updates without service restarts.

Custom ClassLoaderDynamic LoadingJava
0 likes · 21 min read
Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration
Architect's Guide
Architect's Guide
Mar 1, 2024 · Backend Development

Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions

The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.

CompletableFutureJavaProgrammaticTransaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Architecture Digest
Architecture Digest
Feb 29, 2024 · Backend Development

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

This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.

JavaSpring Bootannotations
0 likes · 12 min read
Comprehensive Guide to Spring MVC, Spring Bean, and Spring Boot Annotations
Java High-Performance Architecture
Java High-Performance Architecture
Feb 25, 2024 · Backend Development

Mastering Spring’s @ConfigurationProperties and @PropertySources for Clean Config Management

This article explains how Spring's @ConfigurationProperties and @PropertySources annotations work, compares their purposes, and provides step‑by‑step examples for binding external configuration to Java beans and loading multiple property files in a Spring Boot application.

ConfigurationPropertiesJavaPropertySources
0 likes · 11 min read
Mastering Spring’s @ConfigurationProperties and @PropertySources for Clean Config Management
Architect
Architect
Feb 23, 2024 · Backend Development

Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest

This article explains the seven Spring transaction propagation levels, shows how nested @Transactional methods interact under each level, and provides concrete code‑level examples that illustrate when transactions are merged, suspended, started anew, or rolled back, helping developers choose the right strategy for reliable enterprise applications.

JavaTransactionalpropagation
0 likes · 14 min read
Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest
Architect
Architect
Feb 20, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java

This article demonstrates how to prevent API abuse in a Java Spring application by using a custom HandlerInterceptor combined with Redis to track request counts per IP and URI, covering basic implementation, configuration, custom annotations, reflection for flexible limits, and discusses potential pitfalls and improvements.

InterceptorJavaannotations
0 likes · 19 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java
Architect
Architect
Feb 19, 2024 · Information Security

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

This article walks through the fundamentals of HTTP session handling, the challenges of session sharing in clustered environments, and presents a step‑by‑step design of a Single Sign‑On solution using CAS, including concrete code examples, Redis‑based session storage, and a comparison with OAuth2.

AuthenticationCASJava
0 likes · 17 min read
Mastering Single Sign-On: From Session Basics to CAS Implementation
Selected Java Interview Questions
Selected Java Interview Questions
Feb 19, 2024 · Backend Development

Eight Ways to Implement Asynchronous Programming in Java

This article introduces eight common Java asynchronous implementation techniques—including raw threads, thread pools, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—explains their use cases, advantages, and limitations, and provides concrete code examples for each method.

AsynchronousCompletableFutureJava
0 likes · 11 min read
Eight Ways to Implement Asynchronous Programming in Java
High Availability Architecture
High Availability Architecture
Feb 19, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

This article explains Spring's seven transaction propagation behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how nested transactional methods interact, when new transactions are created or suspended, and how exceptions influence commit and rollback across different propagation settings.

JavaTransactionalpropagation
0 likes · 10 min read
Understanding Spring Transaction Propagation Mechanisms
Top Architect
Top Architect
Feb 18, 2024 · Backend Development

Designing Business Operation Logging: From AOP Annotations to Binlog‑Based Solutions

This article explores the motivations, benefits, and step‑by‑step implementations of business operation logging, starting with a simple AOP‑annotation approach, advancing to AOP combined with Spring Expression Language for richer context, and finally leveraging MySQL binlog and time‑window techniques for low‑level, reliable change capture.

AOPLoggingSpEL
0 likes · 18 min read
Designing Business Operation Logging: From AOP Annotations to Binlog‑Based Solutions
Programmer DD
Programmer DD
Feb 17, 2024 · Backend Development

What’s New in IntelliJ IDEA 2024.1 EAP? Top Features for Spring, HTTP, and GitHub Actions

The IntelliJ IDEA 2024.1 EAP 5 release brings powerful enhancements for Spring and other Java frameworks, richer HTTP client capabilities, improved GitHub Actions support, and various productivity tweaks such as JSON schema handling and automatic header completion, all aimed at boosting backend developers' efficiency.

GitHub ActionsHTTP clientIntelliJ IDEA
0 likes · 6 min read
What’s New in IntelliJ IDEA 2024.1 EAP? Top Features for Spring, HTTP, and GitHub Actions
Java Captain
Java Captain
Feb 16, 2024 · Backend Development

Differences Between Spring and Spring Boot: A Comprehensive Comparison

Spring Boot, an evolution of the Spring framework, simplifies project setup, offers built-in web servers, provides production-ready features, and enhances development efficiency, distinguishing it from traditional Spring which requires extensive XML configuration and external servlet containers, making Boot the preferred choice for modern Java backend development.

JavaSpring Bootbackend development
0 likes · 4 min read
Differences Between Spring and Spring Boot: A Comprehensive Comparison
Architect
Architect
Feb 15, 2024 · Backend Development

Mastering State Patterns with Spring State Machine: From Theory to Order Workflow

This article explains the classic State design pattern, demonstrates a traffic‑light example, compares Spring State Machine with COLA, and walks through building a complete order‑status workflow in Spring Boot using enums, configuration, listeners, services, and a test controller, while highlighting trade‑offs and alternatives.

Design PatternJavaOrder Workflow
0 likes · 14 min read
Mastering State Patterns with Spring State Machine: From Theory to Order Workflow
Su San Talks Tech
Su San Talks Tech
Feb 15, 2024 · Backend Development

How to Ensure Transaction Rollback in Spring Multithreaded Operations

This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.

JavaMyBatisRollback
0 likes · 10 min read
How to Ensure Transaction Rollback in Spring Multithreaded Operations
Architect
Architect
Feb 14, 2024 · Backend Development

Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP

This article explains the fundamentals of finite state machines, demonstrates how to model order states using Spring Statemachine, shows persistence options with in‑memory and Redis stores, and provides advanced techniques such as exception handling, extended state tracking, and AOP‑based result logging for reliable state transitions.

AOPJavaPersistence
0 likes · 23 min read
Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP
Su San Talks Tech
Su San Talks Tech
Feb 13, 2024 · Backend Development

How to Ensure Transaction Consistency When Async Threads Fail in Spring

This article explains how to guarantee transactional integrity when importing a 100,000‑row Excel file with asynchronous threads in Spring, covering double‑async optimization, Future and CompletableFuture handling, @Transactional pitfalls, manual transaction control, and a complete solution for cross‑thread transaction management.

AsyncCompletableFutureExcel import
0 likes · 18 min read
How to Ensure Transaction Consistency When Async Threads Fail in Spring
Java Tech Enthusiast
Java Tech Enthusiast
Feb 12, 2024 · Backend Development

Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration

The solution introduces a plug‑in architecture that uses a custom URLClassLoader to load governance task JARs at runtime, registers their Spring beans and @XxlJob handlers with XXL‑Job, and provides unload logic to deregister jobs, destroy beans, and update configuration via YAML or Nacos without restarting the service.

ClassLoaderDynamic LoadingJava
0 likes · 21 min read
Dynamic Loading and Unloading of Java Governance Tasks with Custom ClassLoader and XXL‑Job Integration
Architect
Architect
Feb 8, 2024 · Backend Development

From AOP Annotations to Binlog: Evolving Business Operation Logging Strategies

This article examines the progressive design of business operation logging—from a basic AOP‑annotation approach, through an AOP‑SpEL enhancement, to a binlog‑based time‑window solution—detailing each method's implementation steps, trade‑offs, and practical considerations for robust audit and monitoring in enterprise systems.

AOPLoggingSpEL
0 likes · 19 min read
From AOP Annotations to Binlog: Evolving Business Operation Logging Strategies
Java Tech Enthusiast
Java Tech Enthusiast
Feb 7, 2024 · Backend Development

How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation

This article provides a comprehensive analysis of Spring's @Autowired annotation, covering its usage, the bean lifecycle stages where it operates, the core classes and methods that implement it, and a comparison with other injection annotations such as @Resource, all illustrated with runnable code examples.

Annotation ProcessingAutowiredBean Lifecycle
0 likes · 27 min read
How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation
macrozheng
macrozheng
Feb 7, 2024 · Backend Development

Master Spring’s Essential Utility Classes: Assert, StringUtils, BeanUtils & More

This comprehensive guide walks you through the most useful Spring framework utility classes—including Assert, StringUtils, CollectionUtils, ObjectUtils, ClassUtils, BeanUtils, ReflectionUtils, Base64Utils, SerializationUtils, HttpStatus, and HtmlUtils—showing practical code examples and explaining when and how to use each to streamline Java backend development.

JavaUtility Classesspring
0 likes · 15 min read
Master Spring’s Essential Utility Classes: Assert, StringUtils, BeanUtils & More
Code Ape Tech Column
Code Ape Tech Column
Feb 7, 2024 · Backend Development

Dynamic Loading and Unloading of Data Governance Tasks in Java with Custom ClassLoader and XXL‑Job Integration

This article explains how to implement dynamic loading, upgrading, and unloading of data‑governance tasks in a Java Spring application using a custom URLClassLoader, integrate the tasks with the XXL‑Job scheduler, manage Spring bean registration, and persist configuration changes via local YAML or Nacos.

Dynamic Class LoadingJavaNacos
0 likes · 17 min read
Dynamic Loading and Unloading of Data Governance Tasks in Java with Custom ClassLoader and XXL‑Job Integration
Yum! Tech Team
Yum! Tech Team
Feb 6, 2024 · Information Security

Log Data Masking Solution for Java Spring Applications

This article analyzes the growing risk of personal data leakage, defines data masking, compares common log‑masking techniques, and presents a comprehensive Java‑Spring solution that combines annotation‑based marking, custom Jackson serializers, and extended SLF4J methods to achieve precise, low‑overhead log masking.

data maskinglog maskingslf4j
0 likes · 8 min read
Log Data Masking Solution for Java Spring Applications
Code Ape Tech Column
Code Ape Tech Column
Feb 6, 2024 · Backend Development

Comprehensive Guide to Spring Validation: Best Practices and Implementation Principles

This article provides an in‑depth tutorial on Spring Validation, covering simple usage, requestBody and requestParam/PathVariable validation, unified exception handling, advanced techniques such as group, nested, collection and custom validation, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.

Hibernate ValidatorJavaSpring Boot
0 likes · 17 min read
Comprehensive Guide to Spring Validation: Best Practices and Implementation Principles
Selected Java Interview Questions
Selected Java Interview Questions
Feb 5, 2024 · Backend Development

Designing Business Operation Logging with AOP, SpEL, and Binlog: From Basic to Advanced Solutions

This article explores the evolution of business operation logging in a Java backend, starting from a simple AOP‑annotation approach, advancing to AOP combined with Spring Expression Language for richer context, and finally leveraging MySQL binlog with time‑window processing to achieve comprehensive, low‑intrusion audit trails.

AOPJavaLogging
0 likes · 15 min read
Designing Business Operation Logging with AOP, SpEL, and Binlog: From Basic to Advanced Solutions
Java Captain
Java Captain
Feb 4, 2024 · Backend Development

Understanding and Implementing Idempotency in Backend Services with Java and Redis

This article explains the concept of idempotency, identifies which API requests are naturally idempotent, discusses why idempotency is essential for retries, asynchronous callbacks, and message queues, and provides a step‑by‑step Java Spring implementation using custom annotations, AOP, and Redis for token management.

AOPJavaRedis
0 likes · 9 min read
Understanding and Implementing Idempotency in Backend Services with Java and Redis
Java Captain
Java Captain
Feb 4, 2024 · Fundamentals

Understanding Aspect-Oriented Programming (AOP) with a Spring Example

Aspect-Oriented Programming (AOP) separates cross‑cutting concerns such as logging, transactions, and security from core business logic, improving modularity, maintainability, and reusability, and the article explains its concepts, benefits, implementation methods (dynamic/static proxies, dedicated languages) and provides a Spring AOP code example.

AOPJavaaspect-oriented-programming
0 likes · 4 min read
Understanding Aspect-Oriented Programming (AOP) with a Spring Example
Selected Java Interview Questions
Selected Java Interview Questions
Feb 4, 2024 · Backend Development

Dynamic Loading and Unloading of Governance Tasks in Java Using a Custom ClassLoader and XXL‑Job

This article explains how to design a plug‑in style architecture for data‑governance tasks by creating a custom URLClassLoader, dynamically loading JARs into a Spring context, registering and deregistering XXL‑Job handlers, updating configuration via YAML or Nacos, and finally unloading resources without restarting the service.

Custom ClassLoaderDynamic Class LoadingJava
0 likes · 17 min read
Dynamic Loading and Unloading of Governance Tasks in Java Using a Custom ClassLoader and XXL‑Job
Su San Talks Tech
Su San Talks Tech
Feb 1, 2024 · Backend Development

Boost Your Java Backend: Essential Spring Utility Classes Explained

This article introduces the most useful Spring framework utility classes—including Assert, StringUtils, CollectionUtils, ObjectUtils, ClassUtils, BeanUtils, ReflectionUtils, Base64Utils, SerializationUtils, HttpStatus, and HtmlUtils—providing clear explanations, code examples, and practical tips to improve development efficiency and code quality.

JavaUtility Classesbackend development
0 likes · 16 min read
Boost Your Java Backend: Essential Spring Utility Classes Explained
Architect
Architect
Jan 31, 2024 · Backend Development

How to Build Distributed Multi‑Rule Rate Limiting with Redis and Spring AOP

This article explains how to implement multi‑rule rate limiting in a distributed Java application using Redis, covering String‑based counters, Zset timestamp storage, Lua scripts for atomic checks, custom @RateLimiter annotations, key generation logic, and an AOP interceptor that enforces the limits.

AOPJavaLua
0 likes · 12 min read
How to Build Distributed Multi‑Rule Rate Limiting with Redis and Spring AOP