BestHub
Sign in
Tagged articles

spring

1810 articles · Page 10 of 19
Su San Talks Tech
Su San Talks Tech
Apr 3, 2023 · Backend Development

Mastering MapStruct: Fast, Type‑Safe Java Bean Mapping with Real‑World Examples

This article introduces MapStruct, a compile‑time Java bean‑mapping code generator, explains its core concepts, shows step‑by‑step examples—including Maven dependencies, entity and DTO definitions, mapper interfaces, custom conversions, and advanced configurations—while comparing its performance to other copy utilities and highlighting deep‑copy behavior.

JavaMavenbean-mapping
0 likes · 13 min read
Mastering MapStruct: Fast, Type‑Safe Java Bean Mapping with Real‑World Examples
macrozheng
macrozheng
Mar 31, 2023 · Backend Development

Implementing Multi‑Tenant Isolation in MyBatis‑Plus: A Step‑by‑Step Guide

Learn how to implement multi‑tenant isolation in a SaaS application using MyBatis‑Plus, covering database schema design, Maven dependencies, configuration of pagination interceptors, tenant handler logic, request‑header propagation, async thread handling, selective filtering, and common pitfalls with bean copying and join queries.

JavaMulti‑tenantmybatis-plus
0 likes · 9 min read
Implementing Multi‑Tenant Isolation in MyBatis‑Plus: A Step‑by‑Step Guide
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 31, 2023 · Backend Development

How Alibaba’s Custom Three‑Layer Distribution Boosts Scheduled Task Efficiency

This article walks through Alibaba's evolution from single‑machine scheduled jobs to a customized three‑layer distributed task framework, detailing classifications, Spring scheduling examples, batch processing integration, cluster distribution mechanics, and optimization techniques that maximize resource utilization and achieve smooth, balanced task execution.

Antschedulerdistributed systemsspring
0 likes · 16 min read
How Alibaba’s Custom Three‑Layer Distribution Boosts Scheduled Task Efficiency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 27, 2023 · Backend Development

Master Spring Transaction Abstraction: Platform & Reactive Managers

This article explains Spring's transaction abstraction, detailing the roles of PlatformTransactionManager and ReactiveTransactionManager, the TransactionDefinition attributes, TransactionStatus interface, resource synchronization techniques, declarative transaction management with AOP, rollback rules, and provides XML and Java configuration examples for both JDBC and Hibernate environments.

Backend DevelopmentDeclarative TransactionsJava
0 likes · 16 min read
Master Spring Transaction Abstraction: Platform & Reactive Managers
macrozheng
macrozheng
Mar 24, 2023 · Backend Development

Unlock the Full Power of Spring’s @Autowired: Advanced Techniques and Common Pitfalls

This article explores Spring’s @Autowired annotation in depth, covering default wiring, handling multiple beans, using @Qualifier and @Primary, various injection targets, advanced collection injection, common pitfalls, and differences from @Resource, providing practical code examples and solutions for real‑world projects.

AutowiredDependency InjectionJava
0 likes · 15 min read
Unlock the Full Power of Spring’s @Autowired: Advanced Techniques and Common Pitfalls
Sohu Tech Products
Sohu Tech Products
Mar 22, 2023 · Backend Development

Understanding @Autowired Injection Issues and Alternative Approaches in Spring

The article explains common problems with Spring's @Autowired injection, compares it with @Resource, and presents alternative injection methods—including setter, constructor, and Lombok-based approaches—while providing code examples and best‑practice recommendations for reliable bean initialization.

AutowiredConstructor InjectionDependency Injection
0 likes · 5 min read
Understanding @Autowired Injection Issues and Alternative Approaches in Spring
Top Architect
Top Architect
Mar 21, 2023 · Backend Development

Understanding @Autowired vs @Resource and Injection Methods in Spring

The article explains common pitfalls of using Spring's @Autowired, compares it with the standard @Resource annotation, and demonstrates various injection techniques—including field, setter, constructor, and Lombok-based constructor injection—through detailed code examples and best‑practice recommendations.

AutowiredBackendDependency Injection
0 likes · 6 min read
Understanding @Autowired vs @Resource and Injection Methods in Spring
Su San Talks Tech
Su San Talks Tech
Mar 19, 2023 · Backend Development

Master 8 Ways to Implement Asynchronous Programming in Java

This article explains why asynchronous execution is essential for tasks like sending SMS or emails, defines async concepts, and walks through eight practical Java implementations—including Thread, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—complete with code examples and usage tips.

CompletableFutureFutureGuava
0 likes · 14 min read
Master 8 Ways to Implement Asynchronous Programming in Java
Architect's Guide
Architect's Guide
Mar 18, 2023 · Backend Development

Eight Ways to Implement Asynchronous Execution in Java

This article introduces eight common methods for implementing asynchronous execution in Java, including threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture, and provides code examples and usage considerations.

CompletableFutureFutureJava
0 likes · 14 min read
Eight Ways to Implement Asynchronous Execution in Java
macrozheng
macrozheng
Mar 17, 2023 · Backend Development

Java Backend Nightmares: Async Misuse, Bad Practices, and Lock Bugs

The author inherited a poorly engineered Java backend project riddled with massive methods, missing abstractions, unsafe async handling with Thread.sleep, ineffective @Async annotations, and a broken distributed lock implementation, highlighting how such technical debt creates a maintenance nightmare.

Javaasyncspring
0 likes · 6 min read
Java Backend Nightmares: Async Misuse, Bad Practices, and Lock Bugs
Java Architect Essentials
Java Architect Essentials
Mar 14, 2023 · Backend Development

Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration

The article explains how Spring's @Async annotation works, compares synchronous and asynchronous calls, reviews the built‑in executors such as SimpleAsyncTaskExecutor, discusses their drawbacks, and provides detailed guidance on creating custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a TaskExecutor bean, including code examples.

CustomExecutorasyncconcurrency
0 likes · 9 min read
Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration
Top Architect
Top Architect
Mar 14, 2023 · Backend Development

Understanding Caching in Spring: Local vs Distributed Cache and GuavaCacheManager

This article explains the concept and purpose of caching, compares local and centralized cache approaches, introduces Spring's cache support and various CacheManager implementations, details GuavaCacheManager configuration and expiration strategies, demonstrates @Cacheable usage, and discusses common pitfalls such as cache miss due to internal method calls.

BackendCacheJava
0 likes · 8 min read
Understanding Caching in Spring: Local vs Distributed Cache and GuavaCacheManager
Selected Java Interview Questions
Selected Java Interview Questions
Mar 13, 2023 · Backend Development

Understanding Java SPI and Spring SPI Mechanisms

This article explains the Java Service Provider Interface (SPI) concept, demonstrates how to implement and test SPI with ServiceLoader, compares its limitations, and shows how Spring extends SPI using spring.factories for more flexible and efficient service loading.

Backend DevelopmentJavaSPI
0 likes · 6 min read
Understanding Java SPI and Spring SPI Mechanisms
Su San Talks Tech
Su San Talks Tech
Mar 12, 2023 · Backend Development

Unlocking Spring’s Hidden Extension Points: From FactoryBean to @Import and Beyond

This article provides a comprehensive guide to Spring’s extension mechanisms, covering FactoryBean, @Import, bean lifecycle callbacks, BeanPostProcessor, BeanFactoryPostProcessor, the SPI system, Spring Boot startup hooks, event publishing, and custom XML namespaces, complete with runnable code examples and diagrams.

BeanPostProcessorEventfactorybean
0 likes · 37 min read
Unlocking Spring’s Hidden Extension Points: From FactoryBean to @Import and Beyond
JD Cloud Developers
JD Cloud Developers
Mar 8, 2023 · Backend Development

Mastering Web Pagination: Database, Backend, and Frontend Techniques

This article explores web pagination across database, backend, and frontend layers, detailing MySQL LIMIT syntax, Java pagination implementations with PageHelper and Spring Data JDBC, and UI approaches using Thymeleaf and Element UI, providing code examples and comparative insights for developers.

Element UIJavaMySQL
0 likes · 9 min read
Mastering Web Pagination: Database, Backend, and Frontend Techniques
Top Architect
Top Architect
Feb 27, 2023 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization

This article explains how Spring enables transaction management through @EnableTransactionManagement, details the underlying proxy mechanism, outlines the basic and detailed execution flow, describes transaction propagation types and their classifications, and shows how to force rollback and use TransactionSynchronization for custom callbacks.

Backend DevelopmentJavaSynchronization
0 likes · 13 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization
Java Architect Essentials
Java Architect Essentials
Feb 23, 2023 · Backend Development

Using Spring and Apache Commons StopWatch for Precise Code Execution Timing in Java

This article explains why simple System.currentTimeMillis() timing is often insufficient, introduces Spring's org.springframework.util.StopWatch and Apache Commons' org.apache.commons.lang3.time.StopWatch, provides Maven dependencies and complete Java examples, and discusses important usage notes such as thread‑safety and task management.

Apache CommonsStopwatchspring
0 likes · 11 min read
Using Spring and Apache Commons StopWatch for Precise Code Execution Timing in Java
JD Tech
JD Tech
Feb 23, 2023 · Backend Development

Comprehensive Guide to Scheduling Tasks: Algorithms, Java Implementations, and Distributed Solutions

This article provides an in‑depth overview of scheduled task processing, covering common business scenarios, fundamental principles, single‑machine algorithms such as min‑heap and time‑wheel, Java utilities like Timer, DelayQueue, ScheduledExecutorService, Spring Task, Quartz, and distributed approaches using Redis, Elastic‑Job, and XXL‑Job.

Task schedulingTime Wheelcron
0 likes · 22 min read
Comprehensive Guide to Scheduling Tasks: Algorithms, Java Implementations, and Distributed Solutions
Java High-Performance Architecture
Java High-Performance Architecture
Feb 22, 2023 · Backend Development

8 Powerful Ways to Implement Asynchronous Programming in Java

This article explores eight Java asynchronous programming techniques—from raw threads and Future to CompletableFuture, Spring @Async, event-driven approaches, message queues, Hutool ThreadUtil, and Guava ListenableFuture—detailing their concepts, advantages, limitations, and providing complete code examples for each.

CompletableFutureFutureJava
0 likes · 14 min read
8 Powerful Ways to Implement Asynchronous Programming in Java
MaGe Linux Operations
MaGe Linux Operations
Feb 18, 2023 · Backend Development

8 Powerful Ways to Implement Asynchronous Programming in Java

This article explains why asynchronous execution improves latency in common scenarios like sending SMS or emails, and presents eight Java techniques—including threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, third‑party utilities, and Guava—to implement robust asynchronous programming.

CompletableFutureFutureMessage Queue
0 likes · 14 min read
8 Powerful Ways to Implement Asynchronous Programming in Java
Code Ape Tech Column
Code Ape Tech Column
Feb 13, 2023 · Backend Development

Performance Comparison and Source Analysis of Java Bean Copy Utilities

This article analyzes the performance and implementation differences of various Java object‑copy utilities—including Apache BeanUtils, PropertyUtils, Spring BeanCopier, and Spring BeanUtils—by examining source code, benchmarking copy operations, and recommending alternatives to avoid the inefficiencies of Apache BeanUtils.

BeanUtilsJavaObjectCopy
0 likes · 11 min read
Performance Comparison and Source Analysis of Java Bean Copy Utilities
Top Architect
Top Architect
Feb 11, 2023 · Backend Development

Comprehensive Guide to User Login Flow, Token Management, and Anonymous Access in Backend Systems

This article explains the complete user login process, including mobile verification, token generation, token expiration policies, request‑rate limiting with Redis, anonymous request handling, blacklist management, and provides full Java Spring code examples for implementing these backend authentication mechanisms.

API SecurityBackendRedis
0 likes · 11 min read
Comprehensive Guide to User Login Flow, Token Management, and Anonymous Access in Backend Systems
The Dominant Programmer
The Dominant Programmer
Feb 9, 2023 · Backend Development

Simplify Java Bean Mapping with MapStruct: A Step‑by‑Step Guide

This article explains how to replace repetitive getter/setter code with MapStruct by showing dependency setup, defining source and target classes, creating mapper interfaces with @Mapping annotations, testing the conversion, and handling common integration issues such as Swagger conflicts.

bean-mappingmappermapstruct
0 likes · 6 min read
Simplify Java Bean Mapping with MapStruct: A Step‑by‑Step Guide
Code Ape Tech Column
Code Ape Tech Column
Feb 8, 2023 · Backend Development

Enhancing MVC Architecture with a Manager Layer in Java

The article explains the classic three‑layer MVC pattern, its shortcomings in complex Java projects, and proposes adding a Manager layer to separate generic business processing, reduce transaction scope, and improve code organization, illustrated with Spring‑based code examples.

JavaMVCService
0 likes · 9 min read
Enhancing MVC Architecture with a Manager Layer in Java
Java Captain
Java Captain
Feb 7, 2023 · Backend Development

A Sarcastic Critique of Overengineered Enterprise Java Architecture

The article humorously deconstructs an overly complex Java enterprise setup, illustrating how excessive use of interfaces, abstract classes, factories, dependency injection, XML configuration, and heavyweight IDE tooling leads to bloated, hard‑to‑maintain code that ultimately fails in production.

Dependency InjectionDesign PatternsEnterprise Architecture
0 likes · 5 min read
A Sarcastic Critique of Overengineered Enterprise Java Architecture
Architect's Journey
Architect's Journey
Feb 6, 2023 · Backend Development

Simplify Kafka Consumer Code with a Custom Method Argument Resolver

The article demonstrates how to use Spring's HandlerMethodArgumentResolver to automatically convert Kafka messages into typed method parameters, eliminating repetitive JSON parsing code and showing a complete implementation, usage example, and notes on version support and performance considerations.

HandlerMethodArgumentResolverJavaKafka
0 likes · 6 min read
Simplify Kafka Consumer Code with a Custom Method Argument Resolver
Java Backend Technology
Java Backend Technology
Feb 6, 2023 · Backend Development

Master the 11 Most Powerful Spring Extension Points for Advanced Backend Development

This article explores Spring's eleven most commonly used extension points—including custom interceptors, bean factory access, global exception handling, type converters, configuration imports, startup runners, bean definition tweaks, bean post‑processing, initialization methods, shutdown hooks, and custom scopes—providing code examples and practical guidance for Java backend developers.

Backend DevelopmentJavaextension-points
0 likes · 16 min read
Master the 11 Most Powerful Spring Extension Points for Advanced Backend Development
Code Ape Tech Column
Code Ape Tech Column
Jan 31, 2023 · Backend Development

Applying the Service Locator Pattern to Decouple File Parsers in Java

This article explains how to replace tightly‑coupled if‑else or switch‑case logic for selecting file parsers (JSON, CSV, XML) with a Service Locator Pattern using Spring's ServiceLocatorFactoryBean, demonstrating a clean, extensible solution that follows the Open/Closed principle.

BackendDependency InjectionJava
0 likes · 8 min read
Applying the Service Locator Pattern to Decouple File Parsers in Java
Sanyou's Java Diary
Sanyou's Java Diary
Jan 30, 2023 · Backend Development

Mastering Spring Bean Injection: 5 Ways to Register Beans in the Container

This article comprehensively reviews the various techniques for injecting beans into the Spring container—including XML and properties configuration files, annotation-based declarations, manual BeanDefinition registration, direct singleton registration, and FactoryBean usage—providing code examples, underlying principles, and practical guidance for each method.

Backend DevelopmentDependency InjectionSpring Framework
0 likes · 18 min read
Mastering Spring Bean Injection: 5 Ways to Register Beans in the Container
IT Architects Alliance
IT Architects Alliance
Jan 27, 2023 · Backend Development

Mastering Session Management and SSO: From Cookies to CAS with Redis

This article analyzes the limitations of traditional HTTP session mechanisms in single‑server and clustered environments, explains why session sharing is essential for multi‑system products, and presents practical solutions such as session replication and centralized Redis storage, followed by a detailed walkthrough of CAS‑based single sign‑on implementation with Java Spring code examples and a comparison to OAuth2.

CASJavaRedis
0 likes · 15 min read
Mastering Session Management and SSO: From Cookies to CAS with Redis
Code Ape Tech Column
Code Ape Tech Column
Jan 18, 2023 · Backend Development

Eight Ways to Implement Asynchronous Execution in Java

This article introduces eight practical techniques for achieving asynchronous processing in Java—including raw threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture—complete with code examples and discussion of their advantages and limitations.

FutureGuavaJava
0 likes · 14 min read
Eight Ways to Implement Asynchronous Execution in Java
Java Architect Essentials
Java Architect Essentials
Jan 12, 2023 · Backend Development

How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping

This article examines why duplicate code harms maintainability, then demonstrates three practical techniques—using factory and template method patterns, leveraging custom annotations with reflection, and applying bean‑copy utilities—to refactor Java business logic and dramatically reduce redundancy.

Code RefactoringDesign PatternsJava
0 likes · 29 min read
How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping
Sohu Tech Products
Sohu Tech Products
Jan 11, 2023 · Backend Development

Understanding ThreadPoolExecutor in Java: Usage, Implementation Details, and Practical Scenarios

This article provides an in‑depth overview of Java's ThreadPoolExecutor, covering why thread pools are needed, various creation methods via Executors, core parameters, internal workflow, source‑code analysis, monitoring, shutdown procedures, and real‑world applications such as Spring @Async and Dubbo integration.

DubboThreadPoolExecutorexecutorservice
0 likes · 34 min read
Understanding ThreadPoolExecutor in Java: Usage, Implementation Details, and Practical Scenarios
Selected Java Interview Questions
Selected Java Interview Questions
Jan 10, 2023 · Backend Development

Hot Deployment of Java Interface Implementations Using Reflection and Spring

This article explains how to let users upload a JAR that implements a predefined Java interface, then dynamically load, register, and switch the implementation at runtime using both reflection‑based and Spring‑annotation‑based hot‑deployment techniques, complete with code examples and utility methods.

Hot DeploymentJavaReflection
0 likes · 8 min read
Hot Deployment of Java Interface Implementations Using Reflection and Spring
DaTaobao Tech
DaTaobao Tech
Dec 30, 2022 · Backend Development

Practical Guide to Upgrading Java 8 to JDK 11 with G1 GC: Benefits, Steps, and New Features

The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.

G1GCJDK11Java
0 likes · 32 min read
Practical Guide to Upgrading Java 8 to JDK 11 with G1 GC: Benefits, Steps, and New Features
Code Ape Tech Column
Code Ape Tech Column
Dec 26, 2022 · 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 in multi‑step product creation validation and expense‑approval workflows with concrete Java/Spring code, and discusses configuration, dynamic composition, advantages, drawbacks, and testing scenarios.

BackendChain of ResponsibilityJava
0 likes · 21 min read
Applying the Chain of Responsibility Pattern for Multi‑Level Product Validation and Workflow in Java
macrozheng
macrozheng
Dec 17, 2022 · Fundamentals

Master 9 Essential Design Patterns for Cleaner Java Code

This article explains nine widely used design patterns—Singleton, Builder, Factory, Strategy, Template Method, Chain of Responsibility, Proxy, Adapter, and Observer—detailing their concepts, typical use‑cases, and concrete Java code examples drawn from popular open‑source projects such as Spring, Dubbo, MyBatis and Guava.

BuilderFactoryJava
0 likes · 27 min read
Master 9 Essential Design Patterns for Cleaner Java Code
Architecture Digest
Architecture Digest
Dec 16, 2022 · Backend Development

PowerJob: A Next‑Generation Distributed Task Scheduling and Computing Framework – Introduction and Quick‑Start Guide

PowerJob is a third‑generation distributed job scheduler that adds workflow orchestration, map‑reduce style computation and rich execution modes to traditional CRON‑based scheduling, and this guide explains its advantages, core features, architecture, and provides step‑by‑step instructions with code samples to get started quickly.

Distributed SchedulingJavaMapReduce
0 likes · 11 min read
PowerJob: A Next‑Generation Distributed Task Scheduling and Computing Framework – Introduction and Quick‑Start Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 16, 2022 · Backend Development

Key Spring Filters: FormContent, ForwardedHeader, Shallow ETag, CORS & Encoding

This guide explains Spring 5.3’s built‑in servlet filters—including FormContentFilter for handling form data in PUT/PATCH/DELETE, ForwardedHeaderFilter for adjusting request URLs behind proxies, ShallowEtagHeaderFilter for lightweight caching, the CORS filter for cross‑origin requests, and CharacterEncodingFilter for enforcing request/response encoding—along with configuration tips and security considerations.

BackendJavaServlet Filters
0 likes · 7 min read
Key Spring Filters: FormContent, ForwardedHeader, Shallow ETag, CORS & Encoding
IT Architects Alliance
IT Architects Alliance
Dec 13, 2022 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Principles, Propagation Mechanisms, and Forced Rollback

This article explains how Spring's @EnableTransactionManagement activates transaction support by registering advisors and proxy beans, details the core execution flow of transactional methods, explores various propagation scenarios with code examples, and demonstrates forced rollback and transaction synchronization techniques.

@TransactionalAOPJava
0 likes · 10 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Principles, Propagation Mechanisms, and Forced Rollback
Su San Talks Tech
Su San Talks Tech
Dec 9, 2022 · Backend Development

Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async

This article introduces asynchronous programming concepts in Java, explaining the shift from synchronous to asynchronous execution, and demonstrates practical implementations using raw threads, ThreadPoolExecutor, Future, FutureTask, CompletableFuture, and Spring's @Async annotation, along with event handling and message queue integration for high‑throughput systems.

CompletableFutureJavaasynchronous
0 likes · 16 min read
Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async
转转QA
转转QA
Dec 8, 2022 · Backend Development

Applying AOP to Reduce Coupling in a Data Construction Platform

This article explains how Aspect‑Oriented Programming (AOP) was introduced into a data construction platform to address high development effort, strong business coupling, and maintenance difficulty by isolating cross‑cutting concerns such as logging, thereby improving modularity, development speed, and code maintainability.

AOPData PlatformSoftware Architecture
0 likes · 5 min read
Applying AOP to Reduce Coupling in a Data Construction Platform
IT Architects Alliance
IT Architects Alliance
Dec 8, 2022 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Propagation, and Synchronization

This article explains how Spring enables transaction management with @EnableTransactionManagement, details the underlying beans and proxy mechanisms, describes the basic execution flow, explores transaction propagation scenarios, shows how to force rollbacks, and demonstrates using TransactionSynchronization for lifecycle callbacks.

JavaSynchronizationpropagation
0 likes · 11 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Propagation, and Synchronization
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 7, 2022 · Backend Development

Master Bean Validation in Spring 5: From Basics to Custom Constraints

Learn how to integrate Bean Validation with Spring 5.2.23, configure the validator, inject it, create custom constraints, and enable method‑level validation using MethodValidationPostProcessor, with complete code examples and execution results, including handling of constraint violations and bean registration steps.

BackendBean ValidationCustom Constraints
0 likes · 7 min read
Master Bean Validation in Spring 5: From Basics to Custom Constraints
IT Architects Alliance
IT Architects Alliance
Dec 4, 2022 · Backend Development

Mastering Retry Logic in Java: Spring‑Retry vs Guava‑Retry

This guide explains how to implement declarative retry mechanisms in Java using Spring‑Retry and Guava‑Retry, covering dependency setup, template and annotation usage, various retry and back‑off policies, test examples, and a comparative analysis of their flexibility and configuration options.

BackendBackoffGuava
0 likes · 17 min read
Mastering Retry Logic in Java: Spring‑Retry vs Guava‑Retry
Architect's Tech Stack
Architect's Tech Stack
Dec 4, 2022 · Backend Development

Unified Exception Handling in Spring Boot Using @ControllerAdvice, Assert, and Enum‑Based Business Errors

This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom Assert utilities, enum‑based error codes, and standardized response objects to improve code readability, maintainability, and internationalisation.

EnumExceptionHandlingJava
0 likes · 21 min read
Unified Exception Handling in Spring Boot Using @ControllerAdvice, Assert, and Enum‑Based Business Errors
Code Ape Tech Column
Code Ape Tech Column
Nov 28, 2022 · Backend Development

Resolving Long Transactions and Connection‑Closed Issues in Spring with Druid

This article analyzes why a Spring service encounters "connection closed" errors during long‑running transactions, explains how MyBatis and Druid manage connections, and provides a programmatic‑transaction solution that splits large operations into smaller units to prevent connection leaks and timeouts.

Backend DevelopmentDatabase ConnectionDruid
0 likes · 11 min read
Resolving Long Transactions and Connection‑Closed Issues in Spring with Druid
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 28, 2022 · Backend Development

Understanding Spring’s Parent and Child Container Initialization in XML Config

This article explains how Spring configures its parent and child application contexts using web.xml, ContextLoaderListener, and DispatcherServlet, detailing the loading of configuration files, context class determination, bean definition processing, and the refresh cycle that ultimately stores the WebApplicationContext in the ServletContext.

Backend DevelopmentContextLoaderListenerDispatcherServlet
0 likes · 12 min read
Understanding Spring’s Parent and Child Container Initialization in XML Config
Selected Java Interview Questions
Selected Java Interview Questions
Nov 27, 2022 · Backend Development

Strategy Pattern in Java: Theory, Advantages, Drawbacks, and Practical Payment Service Implementation

This article explains the Strategy design pattern, its structure, advantages and drawbacks, and demonstrates a practical Java implementation for payment processing using Spring beans, including interface definitions, concrete payment strategies, and a controller that selects the appropriate strategy at runtime.

Dependency InjectionDesign PatternsJava
0 likes · 6 min read
Strategy Pattern in Java: Theory, Advantages, Drawbacks, and Practical Payment Service Implementation
Sanyou's Java Diary
Sanyou's Java Diary
Nov 24, 2022 · Backend Development

Why Does Redis Increment Return Null Inside @Transactional? The Hidden Interaction Explained

This article investigates a production issue where Redis increment operations return null each morning, explores hypotheses about Redis pipelines, transactions, and Spring @Transactional interaction, reproduces the bug, analyzes the source code, and proposes two practical solutions to prevent null returns.

@TransactionalBackend DevelopmentRedis
0 likes · 10 min read
Why Does Redis Increment Return Null Inside @Transactional? The Hidden Interaction Explained
Su San Talks Tech
Su San Talks Tech
Nov 24, 2022 · Backend Development

Master Spring Validation: From Basic to Advanced Parameter Checks

This article explains how to use Spring Validation for automatic request parameter checks in Java web applications, covering basic setup, DTO annotations, requestBody and requestParam validation, unified exception handling, and advanced features like group, nested, collection, custom, and fail‑fast validation.

BackendHibernate ValidatorJava
0 likes · 18 min read
Master Spring Validation: From Basic to Advanced Parameter Checks
dbaplus Community
dbaplus Community
Nov 23, 2022 · Backend Development

Why Redis Increment Returns Null with @Transactional and How to Fix It

A production microservice failed each morning because Redis's increment operation returned null when generating IDs, and restarting the service temporarily fixed it; the article investigates the root cause—Redis transaction support combined with Spring @Transactional—and presents two concrete remediation strategies.

@TransactionalRedisspring
0 likes · 10 min read
Why Redis Increment Returns Null with @Transactional and How to Fix It
Java Captain
Java Captain
Nov 23, 2022 · Backend Development

Best Practices for Designing an Excellent Controller Layer in Spring MVC

The article presents comprehensive best‑practice guidelines for building a clean, maintainable Controller layer in Spring MVC, covering its essential responsibilities, common pitfalls, unified response structures, parameter validation with JSR‑303, custom validators, and centralized exception handling to improve code simplicity and robustness.

BackendControllerExceptionHandling
0 likes · 19 min read
Best Practices for Designing an Excellent Controller Layer in Spring MVC
Java Captain
Java Captain
Nov 23, 2022 · Backend Development

Free Comprehensive Collection of Big‑Tech Interview Questions and Answers (Java, Spring, Redis, MyBatis, etc.)

This post shares a free, extensive compilation of interview questions and detailed explanations covering Java fundamentals, multithreading, Spring framework, Redis, MyBatis and other backend technologies, encouraging systematic preparation and offering a QR‑code method to obtain the full document.

Backend DevelopmentInterview QuestionsJava
0 likes · 8 min read
Free Comprehensive Collection of Big‑Tech Interview Questions and Answers (Java, Spring, Redis, MyBatis, etc.)
Su San Talks Tech
Su San Talks Tech
Nov 22, 2022 · Backend Development

Deep Dive into Spring Transaction: Source Code Walkthrough and Execution Flow

This article walks through the fundamentals of Spring's transaction management, presenting a practical example, detailed execution workflow, and step‑by‑step source‑code analysis—including bean creation, AOP proxy generation, transaction attribute retrieval, transaction start, commit, and rollback – to help developers master Spring transaction internals.

AOPBackend DevelopmentJava
0 likes · 12 min read
Deep Dive into Spring Transaction: Source Code Walkthrough and Execution Flow
Architecture Digest
Architecture Digest
Nov 16, 2022 · Backend Development

Comprehensive Collection of Interview Questions and Answers for Major Tech Companies (Java, Spring, Redis, MyBatis, etc.)

This article compiles over a thousand interview questions and detailed explanations covering core Java fundamentals, multithreading, Spring framework, Redis, MyBatis, and related backend technologies, offering a free downloadable resource to help candidates prepare effectively for major tech company interviews.

Interview QuestionsJavaMyBatis
0 likes · 8 min read
Comprehensive Collection of Interview Questions and Answers for Major Tech Companies (Java, Spring, Redis, MyBatis, etc.)
Java Architect Essentials
Java Architect Essentials
Nov 15, 2022 · Backend Development

Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, and More

This article provides a comprehensive overview of Spring Framework utility classes, covering assertion methods, object and collection utilities, string manipulation, file and resource handling, reflection, and AOP helpers, with code examples illustrating their usage for robust backend development.

Reflectionassertionsspring
0 likes · 10 min read
Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, and More
Programmer DD
Programmer DD
Nov 14, 2022 · Fundamentals

What’s New in Java: JDK 20, Loom Updates, and Upcoming JEPs

This roundup covers the latest Java developments, including JEP 434’s move to candidate status, second‑preview updates for virtual threads and structured concurrency, the JDK 20 release schedule, and new releases across Spring, GraalVM, Open Liberty, Vert.x, TomEE, JReleaser, Hibernate, PrimeFaces, JDKMon, and EclipseCon.

GraalVMJEPLoom
0 likes · 11 min read
What’s New in Java: JDK 20, Loom Updates, and Upcoming JEPs
Architect's Guide
Architect's Guide
Nov 11, 2022 · Databases

Database Sharding: Table Partitioning, Horizontal and Vertical Splitting, and Implementation with Sharding-JDBC and Mycat

This article explains why high‑concurrency big‑data systems need database sharding, describes table‑level partitioning methods (modulus and range), shows how to implement them with MySQL and Java code, compares vertical and horizontal database splitting, and evaluates middleware solutions such as Sharding‑JDBC and Mycat.

JavaMySQLSharding
0 likes · 11 min read
Database Sharding: Table Partitioning, Horizontal and Vertical Splitting, and Implementation with Sharding-JDBC and Mycat
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 10, 2022 · Backend Development

Designing a Modular Backend Service with DDD, Caching, Dynamic Proxies and Extensible Configuration

This article explains how to build a modular backend service in Java using domain‑driven design, configurable modules, dynamic proxies, cache adapters, lambda‑based query conditions, and Spring‑based conditional bean loading to enable flexible extensions without altering existing code.

BackendCachingDomain-Driven Design
0 likes · 25 min read
Designing a Modular Backend Service with DDD, Caching, Dynamic Proxies and Extensible Configuration
Code Ape Tech Column
Code Ape Tech Column
Nov 10, 2022 · Backend Development

Designing an Excellent Controller Layer in Spring MVC

This article explains how to improve the Controller layer in Spring applications by separating responsibilities, implementing unified response structures with Result wrappers, handling String response issues via ResponseBodyAdvice, applying parameter validation with JSR‑303, customizing validators, and centralizing exception handling for cleaner, more maintainable backend code.

ControllerExceptionHandlingJava
0 likes · 18 min read
Designing an Excellent Controller Layer in Spring MVC
Selected Java Interview Questions
Selected Java Interview Questions
Nov 7, 2022 · Backend Development

Comprehensive Guide to Spring Validation: RequestBody, RequestParam, and Advanced Techniques

This article provides a detailed tutorial on using Spring Validation in Spring Boot applications, covering simple and advanced usage such as requestBody and requestParam parameter checks, group validation, nested and collection validation, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms.

Hibernate ValidatorJavaSpring Boot
0 likes · 16 min read
Comprehensive Guide to Spring Validation: RequestBody, RequestParam, and Advanced Techniques
Code Ape Tech Column
Code Ape Tech Column
Nov 7, 2022 · Information Security

Understanding Session-Based Authentication and Single Sign-On (SSO) with CAS and OAuth2

This article explains the challenges of multiple product systems, reviews traditional session mechanisms and their limitations in clustered environments, compares session replication and centralized storage using Redis, and details the design and implementation of Single Sign-On using CAS and OAuth2 with Java Spring code examples.

CASJavaSSO
0 likes · 13 min read
Understanding Session-Based Authentication and Single Sign-On (SSO) with CAS and OAuth2
Cognitive Technology Team
Cognitive Technology Team
Oct 31, 2022 · Backend Development

Analysis of MyBatis First-Level and Second-Level Caches and Their Configuration

This article explains MyBatis's first-level (SqlSession-scoped) and second-level (Mapper-scoped) caching mechanisms, their default behaviors, key generation, configuration options, and the impact of Spring integration, and provides recommendations for disabling caches in distributed environments to avoid data inconsistency.

Backend DevelopmentCacheJava
0 likes · 9 min read
Analysis of MyBatis First-Level and Second-Level Caches and Their Configuration
Architect's Guide
Architect's Guide
Oct 31, 2022 · Databases

Robustdb: A Client‑Side Read‑Write Splitting Solution for MySQL

This article introduces Robustdb, a lightweight client‑side read‑write splitting framework built with only a dozen classes, explains its architecture, routing logic, method‑level transaction handling, dynamic data‑source management, and presents performance comparisons with the legacy Atlas proxy.

JavaRead‑Write Splittingdatabase routing
0 likes · 17 min read
Robustdb: A Client‑Side Read‑Write Splitting Solution for MySQL
Top Architect
Top Architect
Oct 27, 2022 · Backend Development

Redis Cache Expiration Avalanche and Mitigation Strategies

The article explains how Redis cache expiration can cause a request avalanche that overloads databases, and presents mitigation techniques such as semaphore rate limiting, per‑key locking, fault‑tolerant cache rebuilding, and example Java code using Spring and Redis.

CacheJavaRedis
0 likes · 8 min read
Redis Cache Expiration Avalanche and Mitigation Strategies
DaTaobao Tech
DaTaobao Tech
Oct 27, 2022 · Backend Development

Applying the Strategy Pattern in Java Backend Development: Best Practices and Iterations

The article demonstrates how to replace fragile if‑else shop‑ranking logic in a Java backend with the Strategy pattern, progressing from simple factories and enums to Spring‑auto‑wired and generic factories, highlighting improved extensibility, reduced coupling, Open‑Closed compliance, and the trade‑off of added abstraction complexity.

Backend DevelopmentFactory PatternJava
0 likes · 16 min read
Applying the Strategy Pattern in Java Backend Development: Best Practices and Iterations
Java High-Performance Architecture
Java High-Performance Architecture
Oct 26, 2022 · Information Security

How to Build a Secure High‑Performance User Login System with Token Management

This article walks through the complete design and implementation of a high‑performance user login system, covering client‑side verification, server‑side token generation, token expiration strategies, gateway authentication, logout handling, anonymous request allowances, rate‑limited auth tokens, and blacklist management, illustrated with diagrams and Java Spring code examples.

Backendspring
0 likes · 9 min read
How to Build a Secure High‑Performance User Login System with Token Management
DaTaobao Tech
DaTaobao Tech
Oct 25, 2022 · Backend Development

MapStruct and Lombok Integration: Maven Dependency Order and Advanced Usage

The article explains that when using MapStruct with Lombok, Maven must list Lombok before MapStruct (or define annotationProcessorPaths) so Lombok’s annotation processor runs first, and then demonstrates basic and advanced mapping techniques, Spring integration, and singleton caching strategies.

Annotation ProcessingJavaLombok
0 likes · 17 min read
MapStruct and Lombok Integration: Maven Dependency Order and Advanced Usage
Top Architect
Top Architect
Oct 24, 2022 · Backend Development

Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle

This article provides a detailed walkthrough of Spring and Spring Boot's bean lifecycle, explaining each extension point—from ApplicationContextInitializer to CommandLineRunner—illustrating their usage with code examples and describing practical scenarios for customizing bean creation, initialization, and destruction.

Bean LifecycleDependency InjectionJava
0 likes · 17 min read
Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle
Top Architect
Top Architect
Oct 22, 2022 · Backend Development

Unified Exception Handling in Spring Using @ControllerAdvice and Custom Assertions

This article explains how to replace repetitive try‑catch blocks in Spring applications with a unified exception handling mechanism based on @ControllerAdvice, custom assertion utilities, and enum‑driven business exceptions, while also showing how to standardize response structures and integrate internationalization.

@ControllerAdviceEnumExceptionHandling
0 likes · 11 min read
Unified Exception Handling in Spring Using @ControllerAdvice and Custom Assertions
Architect's Tech Stack
Architect's Tech Stack
Oct 21, 2022 · Backend Development

Unified Exception Handling in Spring: @ControllerAdvice, Assert, and Enum‑Based Business Exceptions

This article explains how to centralize exception handling in Spring applications using @ControllerAdvice, replace repetitive null‑checks with Assert utilities, and combine enums with custom BusinessException classes to create a clean, maintainable backend error‑handling strategy.

@ControllerAdviceEnumExceptionHandling
0 likes · 10 min read
Unified Exception Handling in Spring: @ControllerAdvice, Assert, and Enum‑Based Business Exceptions