BestHub
Sign in
Tagged articles

spring

1810 articles · Page 7 of 19
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.

Redisbackendconcurrency
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 UploadRedisbackend
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.

Backend DevelopmentGitHub ActionsHTTP Client
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.

Spring BootWebClientbackend
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.

Best Practicesbugjava
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.

Backend DevelopmentWebClienthttp-interface
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.

Backend DevelopmentCode examplesUtility Classes
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.

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

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

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

Backend DevelopmentCustom AnnotationsTypeFilter
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 ClassLoaderMavenXxl-Job
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.

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

Backend DevelopmentSpring 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.

PropertySourcesSpring Bootconfigurationproperties
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.

@TransactionalSpring FrameworkTransaction
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.

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

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

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

@TransactionalTransactionjava
0 likes · 10 min read
Understanding Spring Transaction Propagation Mechanisms
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 19, 2024 · Backend Development

Understanding the Thread‑Safety Mechanism of MyBatis SqlSessionTemplate in Spring Integration

This article explains why MyBatis' default SqlSession implementation is not thread‑safe, how Spring‑MyBatis integration introduces SqlSessionTemplate and its dynamic proxy, and how transaction‑bound ThreadLocal management ensures safe SqlSession usage across multiple threads.

MyBatisThreadLocalTransactionManagement
0 likes · 11 min read
Understanding the Thread‑Safety Mechanism of MyBatis SqlSessionTemplate in Spring Integration
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.

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

Backend DevelopmentGitHub ActionsHTTP Client
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.

Backend DevelopmentSpring Bootjava
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.

Order WorkflowState MachineState Pattern
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.

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

AOPOrder ManagementPersistence
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.

MavenNacosXxl-Job
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.

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

Spring FrameworkUtility Classesjava
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.

Backend DevelopmentDynamic Class LoadingNacos
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 MaskingSLF4Jlog masking
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 ValidatorSpring BootValidation
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.

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

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

AOPaspect-oriented-programmingcross-cutting-concerns
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 LoadingXxl-Job
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.

Backend DevelopmentUtility Classesjava
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.

AOPLuadistributed systems
0 likes · 12 min read
How to Build Distributed Multi‑Rule Rate Limiting with Redis and Spring AOP
Architect
Architect
Jan 29, 2024 · Backend Development

How to Implement Robust Request Debounce in Java Backend with Redis and Redisson

This article explains why request debounce is essential for preventing duplicate submissions, outlines which APIs need protection, and walks through two distributed‑lock solutions—shared Redis cache and Redisson—showing concrete annotations, key‑generation logic, and Spring‑AOP code with full test results.

Distributed LockRedisbackend
0 likes · 19 min read
How to Implement Robust Request Debounce in Java Backend with Redis and Redisson
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 29, 2024 · Backend Development

Why Spring Transactions Fail and How to Fix Them

This article examines common scenarios that cause Spring transaction management to fail—such as non‑public methods, swallowed exceptions, incorrect rollback settings, self‑invocation, final methods, wrong propagation, asynchronous threads, unsupported database engines, and misuse of @Transactional—and provides concrete code‑level solutions to ensure reliable transactional behavior.

@TransactionalBackend DevelopmentTransaction Management
0 likes · 10 min read
Why Spring Transactions Fail and How to Fix Them
Architecture Digest
Architecture Digest
Jan 28, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis

This article demonstrates how to build a Spring‑based API rate‑limiting solution using an Interceptor and Redis, covering the basic principle, project setup, code implementation, custom annotation with reflection for flexible limits, handling path‑parameter keys, real‑IP acquisition, and practical considerations for production use.

Redisbackendinterceptor
0 likes · 18 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis
Architect
Architect
Jan 26, 2024 · Backend Development

Dynamic Hot‑Pluggable AOP in Spring: Managing Advice at Runtime

This article explains how to implement a hot‑pluggable AOP mechanism in Spring by dynamically adding or removing Advice through custom endpoints and event listeners, covering core concepts, implementation code, a demonstration, and best‑practice considerations for backend developers.

AOPAdviceBackend Development
0 likes · 10 min read
Dynamic Hot‑Pluggable AOP in Spring: Managing Advice at Runtime
Su San Talks Tech
Su San Talks Tech
Jan 25, 2024 · Backend Development

Six Powerful Strategies for Implementing Scheduled Tasks in Java

This article reviews six practical approaches for scheduling recurring jobs in Java—including custom threads, JDK ScheduledExecutorService, Spring @Scheduled, Quartz, Elastic‑Job, and XXL‑JOB—highlighting their usage, configuration steps, and considerations for clustering and concurrency.

Distributed SchedulingQuartzjava
0 likes · 6 min read
Six Powerful Strategies for Implementing Scheduled Tasks in Java
Java High-Performance Architecture
Java High-Performance Architecture
Jan 24, 2024 · Backend Development

8 Powerful Ways to Implement Asynchronous Execution in Java

Understanding asynchronous execution in Java can dramatically reduce latency for tasks such as sending SMS, emails, or updating data, and this article walks through eight practical implementations—from raw Threads and Futures to Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—complete with code samples and best‑practice tips.

CompletableFutureGuavaMessageQueue
0 likes · 13 min read
8 Powerful Ways to Implement Asynchronous Execution in Java
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 20, 2024 · Backend Development

Mastering Spring’s Event System: Decoupling, Asynchronous Handling, and Generic Events

This article explains Spring’s event mechanism, covering its observer‑based design, benefits such as decoupling and asynchronous handling, standard framework events, and advanced generic event techniques using subclassing or ResolvableTypeProvider to achieve type‑safe, flexible event publishing.

Backend DevelopmentGeneric Typesevent handling
0 likes · 7 min read
Mastering Spring’s Event System: Decoupling, Asynchronous Handling, and Generic Events
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 16, 2024 · Backend Development

Spring 6: HTTP Interfaces, RestClient, i18n ProblemDetail, Virtual Threads

This guide walks through Spring 6’s new capabilities—including Java 17 baseline, Jakarta namespace migration, HTTP interface proxies with @HttpExchange, WebClient integration via JDK HttpClient, internationalized ProblemDetail handling, the RestClient API, and executing asynchronous tasks on virtual threads—all demonstrated with concise code examples.

HTTPProblemDetailRestClient
0 likes · 7 min read
Spring 6: HTTP Interfaces, RestClient, i18n ProblemDetail, Virtual Threads
Java Captain
Java Captain
Jan 15, 2024 · Backend Development

Custom Exception Handling for Feign Calls in Spring Distributed Services

This article explains how to implement unified, user‑friendly exception handling for Feign‑based service calls in a Spring distributed architecture by customizing ErrorDecoder, defining result objects, and using global @ControllerAdvice to return clear error codes and messages to front‑end users.

backendexception handlingjava
0 likes · 12 min read
Custom Exception Handling for Feign Calls in Spring Distributed Services
Java Captain
Java Captain
Jan 15, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis

This article explains how to prevent API abuse by using a Spring Interceptor combined with Redis to count requests per IP and URI, demonstrates step‑by‑step code implementations, discusses custom annotations, mapping rules, time‑window challenges, path‑parameter handling, and real‑IP extraction for robust backend rate limiting.

AnnotationRedisbackend
0 likes · 15 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis
Architect
Architect
Jan 13, 2024 · Backend Development

Mastering API Retry Strategies in Java: 8 Proven Techniques

This article walks through eight practical ways to implement retry mechanisms for remote API calls in Java, covering simple loops, recursion, Apache HttpClient settings, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries, while highlighting trade‑offs and best‑practice guidelines.

Best PracticesHttpClientResilience4j
0 likes · 18 min read
Mastering API Retry Strategies in Java: 8 Proven Techniques
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 12, 2024 · Backend Development

Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development

This article explores Spring 5.3.23’s core utility classes—including ID generators, concurrent LRU cache, concurrency throttling, StopWatch timing, digest calculation, method invocation, reflection helpers, route matching, collection utilities, and placeholder parsing—providing code examples, usage guidelines, and best practices to boost backend development efficiency.

CacheID Generatorconcurrency
0 likes · 12 min read
Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development
Java High-Performance Architecture
Java High-Performance Architecture
Jan 9, 2024 · Backend Development

How to Build a Flexible API Rate‑Limiting System with Spring Interceptor and Redis

This article demonstrates step‑by‑step how to prevent API abuse in a Spring MVC application by using an Interceptor combined with Redis for counting requests, customizing limits per endpoint through annotations and reflection, handling mapping rules, path‑parameter challenges, and obtaining the real client IP.

AnnotationRedisReflection
0 likes · 19 min read
How to Build a Flexible API Rate‑Limiting System with Spring Interceptor and Redis
Java Architect Essentials
Java Architect Essentials
Jan 8, 2024 · Backend Development

Using MapStruct for Efficient Java Bean Copying and Mapping

This article explains why manual property copying in Java is inefficient, compares several runtime bean‑copy utilities, and demonstrates how MapStruct provides a compile‑time, type‑safe, high‑performance solution for shallow and deep object mapping, including handling of collections and ignored fields.

CGLIBMavenObject Copy
0 likes · 13 min read
Using MapStruct for Efficient Java Bean Copying and Mapping
Java Tech Enthusiast
Java Tech Enthusiast
Jan 8, 2024 · Backend Development

Migrating from RestTemplate to Spring WebClient: Benefits and Code Samples

Spring developers should replace the deprecated RestTemplate with the reactive WebClient, which offers non‑blocking I/O, a fluent functional API, streaming support, richer error handling and configurable timeouts, while still allowing synchronous calls via block(), as demonstrated by practical Spring Boot 3 code examples.

HTTPReactiveWebClient
0 likes · 11 min read
Migrating from RestTemplate to Spring WebClient: Benefits and Code Samples
vivo Internet Technology
vivo Internet Technology
Jan 3, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

Spring’s transaction propagation defines seven behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how methods join, create, suspend, or nest transactions, and the article explains each type, practical scenarios, and how proper selection ensures atomicity, consistency, and correct rollback handling.

@TransactionalTransactionjava
0 likes · 9 min read
Understanding Spring Transaction Propagation Mechanisms
HomeTech
HomeTech
Jan 3, 2024 · Backend Development

Design and Implementation of a Generic Data‑Change Tracking and Dynamic Display System

This article presents a comprehensive solution for decoupled operation‑log recording in multi‑project backend systems, detailing the design goals, technology choices such as AOP, annotations, SpringEL and MongoDB, the system architecture, implementation steps, a practical case study, and future enhancements.

AOPAnnotationMongoDB
0 likes · 11 min read
Design and Implementation of a Generic Data‑Change Tracking and Dynamic Display System
IT Xianyu
IT Xianyu
Jan 2, 2024 · Backend Development

Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions

This article explains how to execute two dependent tasks in parallel, guarantee their successful completion before a final step, and maintain transaction consistency across multiple threads in Spring by using CompletableFuture, programmatic transaction management, and a custom transaction‑resource copying mechanism.

CompletableFutureProgrammaticTransactionTransaction
0 likes · 18 min read
Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions
IT Niuke
IT Niuke
Jan 2, 2024 · Fundamentals

How to Use the Chain of Responsibility Pattern for Real‑World Data Filtering

This article explains the Chain of Responsibility design pattern, defines its three core roles, compares external and internal composition, demonstrates a lead‑filtering use case with Java and Spring code, and discusses benefits, drawbacks, and differences from the Strategy pattern.

Chain of ResponsibilityDependency InjectionDesign Patterns
0 likes · 9 min read
How to Use the Chain of Responsibility Pattern for Real‑World Data Filtering
JD Retail Technology
JD Retail Technology
Jan 2, 2024 · Backend Development

Optimizing Spring Application Startup Time and Performance: Analysis, Tools, and Practical Steps

This article examines the causes of slow startup in large Spring applications, presents visual analysis techniques and a toolbox—including Arthas, JVM Sandbox, Async Profiler, and Spring Startup Analyzer—and provides concrete installation, configuration, and optimization procedures that can reduce startup time by 70‑80% while improving development efficiency and resource utilization.

Jar SlimmingPerformanceProfiling
0 likes · 14 min read
Optimizing Spring Application Startup Time and Performance: Analysis, Tools, and Practical Steps
DaTaobao Tech
DaTaobao Tech
Dec 29, 2023 · Backend Development

Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects

The article outlines how the Taobao “Calm Guard” project accelerates rapid‑iteration development by employing reusable patterns—including a Spring‑based Strategy registry, a hierarchical fatigue‑control framework, generic cache upsert via functional parameters, and precise AOP aspects—resulting in faster, more stable, and maintainable code.

AOPBackend DevelopmentDesign Patterns
0 likes · 29 min read
Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects
Architect
Architect
Dec 28, 2023 · Backend Development

How to Implement Distributed Multi‑Rule Rate Limiting with Redis and Lua

This article explains how to design and implement a distributed rate‑limiting solution that supports multiple concurrent rules—such as per‑minute and per‑hour limits—by analyzing the shortcomings of simple string counters, introducing atomic Lua scripts and Zset structures, and providing complete Java annotation and AOP code examples.

AOPLuaRedis
0 likes · 13 min read
How to Implement Distributed Multi‑Rule Rate Limiting with Redis and Lua
JD Tech
JD Tech
Dec 28, 2023 · Backend Development

Optimizing Spring Application Startup Speed and Performance: Analysis, Tools, and Best Practices

This article explores the challenges of slow Spring application startup in large Java projects, presents detailed analysis techniques, visualizations, and a suite of tools—including Spring Startup Analyzer, Arthas, and Async Profiler—to identify bottlenecks, and provides step‑by‑step optimization methods such as bean lazy loading, jar slimming, and configuration tweaks that can reduce startup time by up to 80% while improving resource utilization and deployment efficiency.

ProfilingStartup Optimizationlazy-loading
0 likes · 16 min read
Optimizing Spring Application Startup Speed and Performance: Analysis, Tools, and Best Practices
Architecture Digest
Architecture Digest
Dec 28, 2023 · Backend Development

Step-by-Step Alipay Payment Integration in Java with Spring Boot

This guide walks through configuring the Alipay sandbox, adding Maven dependencies, setting up application.yml, implementing Java configuration classes, creating controller endpoints for payment, handling asynchronous callbacks, processing refunds, and using RabbitMQ delayed queues to auto‑cancel unpaid orders, all with complete code examples.

AlipayPayment IntegrationRabbitMQ
0 likes · 12 min read
Step-by-Step Alipay Payment Integration in Java with Spring Boot
JD Cloud Developers
JD Cloud Developers
Dec 27, 2023 · Backend Development

7 Hidden Pitfalls of Spring BeanUtils.copyProperties You Must Avoid

This article explains seven subtle issues when using Spring's BeanUtils.copyProperties—such as type mismatches, null overwrites, wrong imports, inner‑class copying failures, shallow copy side effects, and performance drawbacks—providing code examples and recommendations to avoid them.

BeanUtilsCopyPropertiesbackend
0 likes · 10 min read
7 Hidden Pitfalls of Spring BeanUtils.copyProperties You Must Avoid
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 27, 2023 · Backend Development

How @Nullable Prevents Spring Bean Injection Failures

Learn how to use Spring's @Nullable annotation (or its Java equivalents) to safely handle missing beans during dependency injection, avoiding startup errors, with code examples, underlying mechanism details, and comparisons to other approaches like required=false, Optional, and ObjectFactory.

@NullableBackend DevelopmentDependency Injection
0 likes · 6 min read
How @Nullable Prevents Spring Bean Injection Failures
Architect
Architect
Dec 25, 2023 · Backend Development

Implementing API Idempotency Checks with Design Patterns in Java

This article explains the concept of idempotency, why it is essential for API reliability, and demonstrates four practical idempotency strategies—including database primary keys, optimistic locking, token validation, and Redis caching—implemented via custom annotations and the Strategy pattern in a Spring‑Boot Java project.

APIDesign Patternsidempotency
0 likes · 23 min read
Implementing API Idempotency Checks with Design Patterns in Java
phodal
phodal
Dec 25, 2023 · Artificial Intelligence

Can AI Write Perfect Unit Tests? Inside AutoDev’s Prompt‑Fine‑Tune Pipeline

This article explains how the open‑source AutoDev plugin builds an end‑to‑end AI‑assisted coding solution that fine‑tunes open LLMs, constructs a Unit Eval dataset, engineers prompts for unit‑test generation, and enforces quality through a unified write‑evaluate pipeline.

AIModel Fine‑tuningUnit Testing
0 likes · 9 min read
Can AI Write Perfect Unit Tests? Inside AutoDev’s Prompt‑Fine‑Tune Pipeline
Top Architect
Top Architect
Dec 24, 2023 · Backend Development

Design and Implementation of a Configurable Approval Workflow System

This article explains how to design a flexible approval workflow with serial, parallel, conditional, and mixed processes, defines the required database tables, shows UI mock‑ups, and provides Java Spring code for handling approval actions, including auto‑pass, delegation, and rule‑based field visibility.

Backend DevelopmentDatabase DesignRole-Based Access
0 likes · 25 min read
Design and Implementation of a Configurable Approval Workflow System
Selected Java Interview Questions
Selected Java Interview Questions
Dec 23, 2023 · Backend Development

Common Pitfalls When Using Spring BeanUtils.copyProperties

This article outlines common pitfalls of using Spring's BeanUtils.copyProperties for object property copying in Java backend development, including type mismatches, null overwrites, incorrect imports, inner class issues, shallow copy behavior, and performance drawbacks, and advises caution when employing this utility.

BeanUtilsCopyPropertiesbackend
0 likes · 8 min read
Common Pitfalls When Using Spring BeanUtils.copyProperties
Architecture Digest
Architecture Digest
Dec 22, 2023 · Backend Development

Understanding @Transactional(readOnly = true) in Spring: Mechanics, Performance Benefits, and Usage Considerations

This article explains how Spring's @Transactional(readOnly = true) works internally, shows the performance and memory advantages it brings, compares service‑layer and repository‑layer usage with concrete connection‑pool tests, and provides guidance on when to apply it in JPA‑based backend applications.

@TransactionalPerformancebackend
0 likes · 9 min read
Understanding @Transactional(readOnly = true) in Spring: Mechanics, Performance Benefits, and Usage Considerations
政采云技术
政采云技术
Dec 20, 2023 · Backend Development

MyBatis Cache Issues

This article explains MyBatis's first‑level and second‑level cache mechanisms, illustrates common consistency problems caused by default cache settings in both distributed and single‑session scenarios, and provides practical recommendations such as adjusting localCacheScope or deep‑copying results to avoid cache pitfalls.

CacheMyBatisORM
0 likes · 12 min read
MyBatis Cache Issues