BestHub
Sign in
Tagged articles

spring

1810 articles · Page 14 of 19
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 16, 2021 · Backend Development

Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations

This article explains Spring's pointcut implementations, covering static and dynamic pointcuts, regular‑expression based pointcuts, the RegexpMethodPointcutAdvisor, control‑flow pointcuts, and how to create custom pointcuts by subclassing Spring’s abstract pointcut classes, with full XML and Java code examples.

AOPBackend DevelopmentPointcut
0 likes · 9 min read
Mastering Spring AOP Pointcuts: Static, Dynamic, and Custom Implementations
Code Ape Tech Column
Code Ape Tech Column
Aug 8, 2021 · Backend Development

Master Spring @Async: Custom Thread Pools and Real-World Usage

This guide explains how Spring's @Async annotation works, compares built-in executors, shows how to configure custom thread pools via AsyncConfigurer or AsyncConfigurerSupport, and demonstrates various async method signatures including void, Future and CompletableFuture with practical code examples.

asyncbackendconcurrency
0 likes · 9 min read
Master Spring @Async: Custom Thread Pools and Real-World Usage
Xianyu Technology
Xianyu Technology
Aug 5, 2021 · Backend Development

Applying SWAK Framework in Xianyu Search: Architecture and Implementation

The article explains how Xianyu’s search service refactors tightly‑coupled, if‑else‑heavy code by applying the lightweight SWAK framework—defining @SwakInterface and @SwakTag annotations, registering proxy beans, using AOP and CGLIB proxies to route business logic via request‑derived tag groups, achieving clean, modular routing.

AOPDynamicProxySWAK
0 likes · 13 min read
Applying SWAK Framework in Xianyu Search: Architecture and Implementation
Java Interview Crash Guide
Java Interview Crash Guide
Aug 5, 2021 · Backend Development

Mastering Java ThreadPoolExecutor: 4 Rejection Policies Explained & When to Use Them

Java's ThreadPoolExecutor offers four rejection policies—AbortPolicy, DiscardPolicy, DiscardOldestPolicy, and CallerRunsPolicy—each handling task overflow differently; this article explains their behavior, default setting, code examples, and how to configure them via Spring's ThreadPoolTaskExecutor for various business scenarios.

ThreadPoolExecutorconcurrencyjava
0 likes · 9 min read
Mastering Java ThreadPoolExecutor: 4 Rejection Policies Explained & When to Use Them
Java High-Performance Architecture
Java High-Performance Architecture
Aug 4, 2021 · Backend Development

Top 10 Common Spring Framework Mistakes and How to Fix Them

This article outlines the ten most frequent errors developers make when using the Spring framework—ranging from over‑focusing on low‑level details to neglecting proper testing—and provides concrete best‑practice solutions with code examples to improve code quality, maintainability, and reliability.

Backend Developmentjavaspring
0 likes · 17 min read
Top 10 Common Spring Framework Mistakes and How to Fix Them
Top Architect
Top Architect
Jul 31, 2021 · Backend Development

Understanding Spring Bean Instantiation Process

This article explains how Spring's IoC container creates and manages beans, covering the container startup phase, bean definition loading, BeanFactoryPostProcessor and BeanPostProcessor extensions, object creation strategies, property injection, Aware interfaces, and bean lifecycle callbacks.

BeanDependency InjectionIOC
0 likes · 14 min read
Understanding Spring Bean Instantiation Process
Architect's Tech Stack
Architect's Tech Stack
Jul 29, 2021 · Databases

Quick Start Guide to Data Encryption (Masking) with Apache ShardingSphere in Spring and Spring Boot

This article explains how to use Apache ShardingSphere's encryption module to transparently store and query sensitive customer data such as ID numbers and bank cards by configuring encryption rules in Spring or Spring Boot, eliminating manual SQL encryption and simplifying compliance for legacy systems.

Database SecuritySQL MaskingShardingSphere
0 likes · 9 min read
Quick Start Guide to Data Encryption (Masking) with Apache ShardingSphere in Spring and Spring Boot
Programmer DD
Programmer DD
Jul 29, 2021 · Databases

Secure Sensitive Data in ShardingSphere: Quick Start Guide for Spring

This tutorial explains why encrypting sensitive fields like ID numbers and bank cards is required, outlines common pain points, and shows how to configure ShardingSphere's data‑desensitization module using Spring namespace or Spring Boot with full code examples and configuration files.

Database SecurityShardingSpheredata encryption
0 likes · 8 min read
Secure Sensitive Data in ShardingSphere: Quick Start Guide for Spring
Fulu Network R&D Team
Fulu Network R&D Team
Jul 27, 2021 · Databases

Understanding Flyway: Database Migration Tool Overview and Spring Integration

Flyway is an open‑source database migration tool that version‑controls SQL scripts, supports many databases, and integrates with Maven and Spring to automate schema changes across environments, offering commands such as migrate, clean, info, validate, baseline, undo and repair, with detailed configuration examples.

MavenSQLdatabase migration
0 likes · 9 min read
Understanding Flyway: Database Migration Tool Overview and Spring Integration
Java Interview Crash Guide
Java Interview Crash Guide
Jul 27, 2021 · Backend Development

Mastering Spring AOP: From Basics to Advanced Real‑World Examples

This article introduces Aspect‑Oriented Programming in Spring, explains core concepts such as pointcut, advice, aspect, join point and weaving, and provides step‑by‑step code examples—including a simple @GetMapping logger, a custom permission annotation with multiple aspects, and detailed usage of @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing annotations—illustrated with diagrams and runnable snippets.

AOPannotationsaspect-oriented-programming
0 likes · 19 min read
Mastering Spring AOP: From Basics to Advanced Real‑World Examples
Top Architect
Top Architect
Jul 26, 2021 · Backend Development

Performance Optimization of Java Backend Services: Reducing CPU Load, Improving Hystrix Circuit Breaking, and Fixing Spring Data Binding Issues

This article describes how a Java backend service suffered high CPU usage and load, how the team diagnosed the problems with jtop and thread stacks, optimized JSON/Bean processing, re‑engineered Hystrix circuit‑breaker settings, reduced logging overhead, and fixed Spring data‑binding exceptions to double the QPS and achieve stable recovery after traffic spikes.

Hystrixcircuit breakerjava
0 likes · 15 min read
Performance Optimization of Java Backend Services: Reducing CPU Load, Improving Hystrix Circuit Breaking, and Fixing Spring Data Binding Issues
Selected Java Interview Questions
Selected Java Interview Questions
Jul 23, 2021 · Backend Development

Global Exception Handling in Spring MVC Using @ControllerAdvice and @ExceptionHandler

This article explains why global exception handling is needed in Spring MVC, outlines its application scenarios, compares AOP with the simpler @ControllerAdvice/@ExceptionHandler approach, and provides detailed code examples for custom response objects, validation handling, and transaction rollback strategies to improve code cleanliness and maintainability.

@ControllerAdviceValidationbackend
0 likes · 11 min read
Global Exception Handling in Spring MVC Using @ControllerAdvice and @ExceptionHandler
Top Architect
Top Architect
Jul 23, 2021 · Backend Development

Design Patterns in the Spring Framework: A Comprehensive Overview

This article provides a detailed overview of how the Spring framework implements classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—illustrated with code snippets and explanations of their roles in Spring's dependency injection and bean lifecycle management.

Dependency InjectionDesign PatternsSingleton
0 likes · 14 min read
Design Patterns in the Spring Framework: A Comprehensive Overview
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 21, 2021 · Backend Development

Mastering Spring @Autowired: 9 Powerful Injection Techniques

This guide explains how Spring's @Autowired annotation works across constructors, methods, fields, arrays, collections, maps, optional dependencies, and built‑in Spring components, providing code examples and tips for handling required and optional beans in a Spring 5.2.15 environment.

AutowiredBackend DevelopmentDependency Injection
0 likes · 7 min read
Mastering Spring @Autowired: 9 Powerful Injection Techniques
Top Architect
Top Architect
Jul 21, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.

@TransactionalAOPBackend Development
0 likes · 10 min read
Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics
Top Architect
Top Architect
Jul 21, 2021 · Databases

How to Perform Streaming Queries with MyBatis Cursor and Keep the Database Connection Open

This article explains the concept of streaming queries, introduces MyBatis' Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or the @Transactional annotation—to keep the database connection alive during iteration.

DatabaseMyBatisStreaming Query
0 likes · 7 min read
How to Perform Streaming Queries with MyBatis Cursor and Keep the Database Connection Open
Java Captain
Java Captain
Jul 21, 2021 · Backend Development

Integrating Alipay’s New Transfer API (alipay.fund.trans.uni.transfer) in a Java Spring Application

This guide explains how to integrate Alipay’s new secure transfer API (alipay.fund.trans.uni.transfer) into a Java Spring application, covering SDK upgrade, certificate placement, configuration files, Maven dependency, bean injection, and utility classes with full code examples for payment and transfer operations.

API integrationAlipaybackend
0 likes · 11 min read
Integrating Alipay’s New Transfer API (alipay.fund.trans.uni.transfer) in a Java Spring Application
Code Ape Tech Column
Code Ape Tech Column
Jul 21, 2021 · Backend Development

Understanding Spring @Transactional Annotation: Implementation Principles and Source Code Analysis

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP creates proxy objects, the role of BeanPostProcessor, advisors, interceptors, and the TransactionInterceptor, and walks through key source code snippets that manage transaction boundaries.

@TransactionalAOPTransaction Management
0 likes · 9 min read
Understanding Spring @Transactional Annotation: Implementation Principles and Source Code Analysis
Java Backend Technology
Java Backend Technology
Jul 20, 2021 · Backend Development

How to Implement Efficient MyBatis Streaming Queries in Spring

Streaming queries return an iterator instead of a full result set, reducing memory usage, but require keeping the database connection open; this guide explains MyBatis’s Cursor interface, its methods, and three practical ways—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform MyBatis streaming queries in Spring.

DatabaseMyBatisStreaming Query
0 likes · 7 min read
How to Implement Efficient MyBatis Streaming Queries in Spring
Programmer DD
Programmer DD
Jul 20, 2021 · Backend Development

Understanding @Autowired, @Resource, and @Inject: When and How to Use Spring DI Annotations

This article explains the differences between Spring's @Autowired, @Resource, and @Inject annotations, describes the injection order and rules, shows code examples for each approach, and discusses why constructor‑based injection is recommended over field injection for cleaner, more maintainable applications.

AutowiredConstructor InjectionDependency Injection
0 likes · 13 min read
Understanding @Autowired, @Resource, and @Inject: When and How to Use Spring DI Annotations
Top Architect
Top Architect
Jul 18, 2021 · Backend Development

Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics

This article explains the @Autowired annotation in Spring, covering its various usage forms such as constructor, setter, method, field, and collection injection, and delves into the underlying implementation details within Spring's AutowiredAnnotationBeanPostProcessor, including metadata handling, reflection-based injection, and common pitfalls.

AutowiredBackend DevelopmentDependency Injection
0 likes · 19 min read
Understanding the @Autowired Annotation in Spring: Usage, Implementation, and Underlying Mechanics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 14, 2021 · Backend Development

Understanding Spring Cloud RefreshScope: How Dynamic Configuration Refresh Works

This article explains the inner workings of Spring Cloud's RefreshScope, detailing its source code, registration process, refresh endpoint activation, event-driven refresh mechanism, and how beans annotated with @RefreshScope or @ConfigurationProperties are dynamically reloaded without restarting the application.

@RefreshScopeCloudSpringBoot
0 likes · 11 min read
Understanding Spring Cloud RefreshScope: How Dynamic Configuration Refresh Works
Top Architect
Top Architect
Jul 11, 2021 · Backend Development

Implementing Request Logging with Spring AOP: A Practical Guide

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures request parameters, response data, execution time, and error information, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

AOPAspectJLogging
0 likes · 12 min read
Implementing Request Logging with Spring AOP: A Practical Guide
Programmer DD
Programmer DD
Jul 11, 2021 · Databases

Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close

This article demystifies MyBatis transaction handling by explaining the true JDBC methods—setAutoCommit, commit, rollback—and clarifying common misconceptions about create, begin, close, and suspend, while exploring MyBatis’s Transaction, TransactionFactory, and practical code examples that illustrate how commits, rollbacks, and connection closing behave in various scenarios.

DatabaseJDBCMyBatis
0 likes · 10 min read
Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close
Programmer DD
Programmer DD
Jul 9, 2021 · Backend Development

Why Catching an Exception Doesn't Prevent Spring Transaction Rollback

This article explains why a caught javax.validation.ConstraintViolationException in a Spring @Transactional method does not stop the transaction from rolling back, and shows how to debug the flow with logs and breakpoints to understand the underlying commit process.

Transaction Managementdebuggingexception handling
0 likes · 4 min read
Why Catching an Exception Doesn't Prevent Spring Transaction Rollback
Code Ape Tech Column
Code Ape Tech Column
Jul 9, 2021 · Backend Development

How to Keep MyBatis Streaming Queries Alive: Three Practical Solutions

This article explains the concept of MyBatis streaming queries, why keeping the database connection open is essential, and provides three concrete approaches—using SqlSessionFactory, TransactionTemplate, or @Transactional—to ensure cursors remain usable without premature closure.

DatabaseMyBatisStreaming Query
0 likes · 7 min read
How to Keep MyBatis Streaming Queries Alive: Three Practical Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 3, 2021 · Backend Development

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

The article explains how to abstract remote data location logic using an RPC framework built on Spring and Dubbo, demonstrates proxy injection and service registration, and shows how similar principles are applied to Redis Cluster to reduce request redirection and improve scalability.

Backend DevelopmentRedisdistributed systems
0 likes · 12 min read
Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster
Code Ape Tech Column
Code Ape Tech Column
Jul 2, 2021 · Backend Development

Mastering Java Object Copying: Apache vs Spring BeanUtils Compared

This article explains the difference between shallow and deep copying in Java, demonstrates how Apache Commons BeanUtils and Spring Framework BeanUtils perform property copying with code examples, highlights performance concerns, and recommends more efficient alternatives for backend development.

BeanUtilsObjectCopyapache
0 likes · 8 min read
Mastering Java Object Copying: Apache vs Spring BeanUtils Compared
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 1, 2021 · Backend Development

Mastering Spring @Scope: Custom Scopes, Prototypes, and Injection Techniques

This guide explains how Spring's @Scope annotation determines bean lifecycles, shows the underlying source code handling singleton and prototype scopes, demonstrates creating and registering a custom scope, and provides practical examples of using custom and prototype-scoped beans with proper proxy configuration in Spring Boot.

Custom ScopeDependency InjectionPrototype
0 likes · 7 min read
Mastering Spring @Scope: Custom Scopes, Prototypes, and Injection Techniques
Wukong Talks Architecture
Wukong Talks Architecture
Jun 29, 2021 · Backend Development

Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware

This article introduces Spring Cache as a framework‑agnostic caching abstraction that eliminates manual cache code, explains its core concepts, annotations, configuration options, and demonstrates practical usage with Redis and custom key, condition, and eviction strategies in Spring Boot applications.

CacheEhcacheRedis
0 likes · 15 min read
Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware
Code Ape Tech Column
Code Ape Tech Column
Jun 28, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, examines its underlying implementation via reflection, and provides detailed code examples illustrating field, constructor, setter, and collection injection, while also discussing annotation lifecycle and best practices.

AutowiredDependency InjectionReflection
0 likes · 17 min read
Understanding and Implementing Spring's @Autowired Annotation
Top Architect
Top Architect
Jun 27, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, explores its underlying implementation using reflection, analyzes the core processing classes in the Spring framework, and answers common questions about its lifecycle, bean relationships, and why static injection is discouraged.

AutowiredDependency InjectionReflection
0 likes · 17 min read
Understanding and Implementing Spring's @Autowired Annotation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 25, 2021 · Cloud Native

Is Spring Still the Best Cloud‑Native Platform? 5 Key Reasons Explained

Spring remains a leading cloud‑native platform because of rapid JDK evolution, a thriving JVM language ecosystem, mature Spring Boot and Spring Cloud for service‑oriented architectures, and Spring Reactive’s support for event‑driven designs, all of which address cost, performance, and modern development needs.

Reactivecloud-nativejava
0 likes · 19 min read
Is Spring Still the Best Cloud‑Native Platform? 5 Key Reasons Explained
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 25, 2021 · Backend Development

How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator

This article walks through Spring’s AOP proxy creation process, detailing how enabling @EnableAspectJAutoProxy registers AnnotationAwareAspectJAutoProxyCreator, how it decides whether to wrap a bean, and the internal methods—wrapIfNecessary, isInfrastructureClass, shouldSkip, and advisor discovery—that together generate the dynamic proxies used at runtime.

AOPAspectJproxy
0 likes · 15 min read
How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator
Programmer DD
Programmer DD
Jun 25, 2021 · Backend Development

How Spring Solves Circular Dependencies: Inside the Three‑Level Cache

This article explains why Spring’s default singleton beans can handle circular references, describes the three‑level cache mechanism that makes it possible, shows prototype limitations, provides a minimal implementation example, and even relates the solution to the classic two‑sum algorithm.

Dependency InjectionPrototypeThree-level Cache
0 likes · 9 min read
How Spring Solves Circular Dependencies: Inside the Three‑Level Cache
Tencent Cloud Developer
Tencent Cloud Developer
Jun 23, 2021 · Backend Development

Understanding Java Web Backend: Servlets, JSP, Tomcat, Listeners, Filters, Spring, Spring Boot, and Spring Cloud

Understanding Java web backend requires grasping how Tomcat parses HTTP requests, dispatches them through servlets, JSPs, listeners and filters, and then leverages Spring’s IoC, AOP, MVC, Boot’s auto‑configuration, and Cloud’s micro‑service tools to build robust, industrial‑grade applications.

ServletSpring BootWeb Development
0 likes · 24 min read
Understanding Java Web Backend: Servlets, JSP, Tomcat, Listeners, Filters, Spring, Spring Boot, and Spring Cloud
Programmer DD
Programmer DD
Jun 22, 2021 · Backend Development

Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue

This article presents a full‑stack Java mall project with distribution features, detailing its object‑oriented advantages, comprehensive backend and frontend technology stack, project structure, implemented modules such as member management, product editing, promotion, order and system management, deployment environment, and provides source code and documentation for developers.

Backend DevelopmentMyBatisVue
0 likes · 6 min read
Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue
Top Architect
Top Architect
Jun 20, 2021 · Backend Development

Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)

This article explains the concepts of Inversion of Control (IoC) and Dependency Injection (DI) in the Spring framework, describing how containers manage object creation, reduce coupling, improve testability, and embody the Hollywood principle for more flexible Java backend development.

Dependency InjectionIOCInversion of Control
0 likes · 9 min read
Understanding Spring IoC (Inversion of Control) and Dependency Injection (DI)
Java Tech Enthusiast
Java Tech Enthusiast
Jun 18, 2021 · Backend Development

Spring Annotation-Based Bean Registration Guide

The guide explains how Spring’s annotation-driven configuration—using @Configuration and @Bean to define beans, @ComponentScan for automatic detection, and additional annotations such as @Scope, @Lazy, @Conditional, @Import and FactoryBean—replaces verbose XML, streamlining bean registration and lifecycle management.

BeanDependency Injectionannotations
0 likes · 10 min read
Spring Annotation-Based Bean Registration Guide
Top Architect
Top Architect
Jun 16, 2021 · Backend Development

Implementing Request Logging with Spring AOP: Aspect Code and Best Practices

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures IP, URL, HTTP method, parameters, results, execution time, and error details, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

AOPAspectJLogging
0 likes · 12 min read
Implementing Request Logging with Spring AOP: Aspect Code and Best Practices
Programmer DD
Programmer DD
Jun 14, 2021 · Backend Development

Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.

AOPBean LifecycleDependency Injection
0 likes · 45 min read
Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained
Top Architect
Top Architect
Jun 13, 2021 · Backend Development

Implementing AOP in a Custom Spring‑like Framework

This article explains the principles and step‑by‑step implementation of Aspect‑Oriented Programming (AOP) in a lightweight Spring‑style container, covering core concepts, advice and pointcut design, weaving mechanisms, proxy creation, observer integration, and practical code examples.

AOPDependency InjectionDesign Patterns
0 likes · 16 min read
Implementing AOP in a Custom Spring‑like Framework
Top Architect
Top Architect
Jun 12, 2021 · Backend Development

Zheng: A Comprehensive J2EE Enterprise Development Framework and Architecture Guide

The article presents Zheng, a full‑stack J2EE enterprise solution that integrates Spring, MyBatis, Dubbo, and a rich set of micro‑service modules, detailing its architecture, technology stack, environment setup, deployment procedures, and coding conventions for building scalable backend systems.

Enterprise ArchitectureOpen Sourcejava
0 likes · 16 min read
Zheng: A Comprehensive J2EE Enterprise Development Framework and Architecture Guide
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

Connection PoolJedisPerformance
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
Java Tech Enthusiast
Java Tech Enthusiast
Jun 8, 2021 · Backend Development

Introduction to AOP (Aspect Oriented Programming) in Java

This article introduces Aspect‑Oriented Programming in Java, explaining how AOP separates cross‑cutting concerns like logging using join points, pointcuts, advice, and aspects, and demonstrates dynamic proxies, various advice types, XML configuration, and aspect ordering within Spring AOP.

AOPAdviceAspectJ
0 likes · 20 min read
Introduction to AOP (Aspect Oriented Programming) in Java
Java Interview Crash Guide
Java Interview Crash Guide
Jun 8, 2021 · Backend Development

Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking

After a week of intermittent API hangs in an internal sandbox, we traced the issue to Redis connection pool blocking caused by missing max‑wait configuration, leading to threads waiting indefinitely; by adjusting Jedis pool settings, using proper connection release, and avoiding unsupported commands, the deadlock was resolved.

Connection PoolJedisRedis
0 likes · 9 min read
Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking
Programmer DD
Programmer DD
Jun 8, 2021 · Backend Development

Mastering Request Logging with Spring AOP: A Complete Guide

Learn how to implement a robust request logging aspect in Spring using AOP annotations, covering pointcut definition, before/around/after advice, handling high concurrency, serializing logs, capturing errors, and adding traceId support for better traceability in backend services.

AOPRequest Loggingbackend
0 likes · 14 min read
Mastering Request Logging with Spring AOP: A Complete Guide
Code Ape Tech Column
Code Ape Tech Column
Jun 8, 2021 · Backend Development

Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It

The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.

@TransactionalAOPSpringBoot
0 likes · 8 min read
Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It
Programmer DD
Programmer DD
Jun 6, 2021 · Backend Development

Fastest Java Bean Mapper? BeanUtils, Dozer, Orika, BeanCopier Compared

This article compares the usage, performance, and internal implementation of popular Java bean‑mapping tools—Spring BeanUtils, Apache BeanUtils, CGLIB BeanCopier, Dozer, and Orika—providing benchmark results, code examples, and detailed analysis to help developers choose the most efficient solution for their layered architectures.

DozerOrikabean-mapping
0 likes · 33 min read
Fastest Java Bean Mapper? BeanUtils, Dozer, Orika, BeanCopier Compared
Programmer DD
Programmer DD
Jun 5, 2021 · Backend Development

When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions

This article explains Alibaba’s Java guidelines for using @Transactional, categorizes checked and unchecked exceptions, shows how Spring’s default rollback behavior works, and provides practical examples of configuring rollback rules, avoiding common pitfalls, and best practices for applying @Transactional in backend Java applications.

@TransactionalBackend Developmentexception handling
0 likes · 5 min read
When Does @Transactional Roll Back? Mastering Spring Transaction Exceptions
Java Tech Enthusiast
Java Tech Enthusiast
Jun 3, 2021 · Backend Development

Master Spring IoC: From Bean Creation to Dependency Injection

This tutorial explains the concept of Inversion of Control in Spring, demonstrates how to configure beans with XML, compares BeanFactory and ApplicationContext, explores bean scopes and lifecycle, and provides detailed examples of constructor, static‑factory, instance‑factory, and collection injection techniques.

Backend DevelopmentBeanDependency Injection
0 likes · 19 min read
Master Spring IoC: From Bean Creation to Dependency Injection
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Jun 2, 2021 · Backend Development

How to Build a User‑Customizable Scheduled Task System with Java’s ScheduledExecutor

This article explains how to design and implement a user‑customizable scheduled‑task component in Java, addressing the limitations of open‑source frameworks by separating task creation, loading, scheduling, and execution, and provides practical code examples for robust backend task management.

ScheduledExecutorconcurrencyjava
0 likes · 11 min read
How to Build a User‑Customizable Scheduled Task System with Java’s ScheduledExecutor
Java Interview Crash Guide
Java Interview Crash Guide
Jun 1, 2021 · Backend Development

How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management

This article explains the purpose and inner workings of Spring’s @Transactional annotation, detailing how AOP creates proxies, defines pointcuts, and orchestrates transaction management through BeanPostProcessors, advisors, interceptors, and the TransactionInterceptor, illustrated with source code snippets and diagrams.

AOPAnnotationBackend Development
0 likes · 10 min read
How Does Spring’s @Transactional Work? A Deep Dive into AOP and Transaction Management
Selected Java Interview Questions
Selected Java Interview Questions
May 31, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow

This article explains the purpose of Spring's @Transactional annotation, how it leverages AOP and dynamic proxies to manage transactions, and walks through the core source‑code components—including BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle—illustrated with concrete code examples.

@TransactionalAOPDynamic Proxy
0 likes · 9 min read
Understanding Spring's @Transactional Annotation: AOP‑Based Implementation and Transaction Management Flow
Top Architect
Top Architect
May 31, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects

This article examines whether Service and DAO layers in Java backend projects require interfaces, arguing that with dependency‑injection frameworks like Spring the interfaces are often unnecessary, while outlining development workflows, project structures, and scenarios where interfaces remain useful.

Dependency Injectionbackend-architectureinterface design
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects
Programmer DD
Programmer DD
May 30, 2021 · Backend Development

When to Prefer Spring BeanUtils Over Apache BeanUtils for Object Copying

This article explains the difference between shallow and deep copying in Java, compares Apache BeanUtils and Spring BeanUtils with code examples, highlights performance and safety concerns, and recommends using Spring BeanUtils or alternative libraries for efficient property transfer between objects.

BeanUtilsDeepCopyObjectCopy
0 likes · 10 min read
When to Prefer Spring BeanUtils Over Apache BeanUtils for Object Copying
Top Architect
Top Architect
May 28, 2021 · Backend Development

Injecting Specific Service Implementations in Spring with @Autowired, @Qualifier, and @Resource

This article explains three methods to inject a specific service implementation into a Spring controller—using @Autowired with @Qualifier, using @Resource with type, and using named @Service beans combined with @Resource(name), including code examples and differences between @Autowired and @Resource.

Dependency Injectionannotationsjava
0 likes · 4 min read
Injecting Specific Service Implementations in Spring with @Autowired, @Qualifier, and @Resource
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications

This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.

Backend DevelopmentMyBatisTemplate Method
0 likes · 12 min read
Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications
macrozheng
macrozheng
May 20, 2021 · Backend Development

10 Powerful Java Scheduling Techniques for Every Scenario

This article walks through ten practical scheduling solutions—from Linux crontab and JDK utilities to Spring Task, Spring Quartz, and distributed frameworks like XXL‑Job and Elastic‑Job—explaining their usage, configuration, code examples, and pros and cons so developers can pick the right tool for any business need.

DistributedSchedulingcron
0 likes · 24 min read
10 Powerful Java Scheduling Techniques for Every Scenario
Top Architect
Top Architect
May 19, 2021 · Databases

MyBatis Streaming Query: Cursor Interface and Practical Implementations

This article explains MyBatis streaming queries using the Cursor interface, demonstrates how to define a Mapper that returns a Cursor, shows common pitfalls with closed connections, and provides three solutions—manual SqlSession handling, TransactionTemplate, and @Transactional—to keep the database connection open while iterating results.

DatabaseMyBatisStreaming Query
0 likes · 7 min read
MyBatis Streaming Query: Cursor Interface and Practical Implementations
Programmer DD
Programmer DD
May 19, 2021 · Backend Development

Can You Build a Mini Spring Framework from Scratch? A Step‑by‑Step Guide

This article explains Spring's core concepts such as IOC, DI, and AOP, demonstrates building a simple Hello World with SpringBoot, then shows how to recreate the same functionality using raw Servlets and a handcrafted mini‑Spring framework with full code examples.

Dependency InjectionInversion of ControlMini Framework
0 likes · 20 min read
Can You Build a Mini Spring Framework from Scratch? A Step‑by‑Step Guide
Top Architect
Top Architect
May 17, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical situations where Spring @Transactional annotations fail—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, caught exceptions without rethrow, incorrect propagation settings, and unsupported MyISAM storage—and provides concrete code examples and fixes to ensure proper transaction behavior.

AOPTransactionexception handling
0 likes · 10 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 13, 2021 · Backend Development

Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts

This article provides a comprehensive overview of the Spring framework, covering its core modules, version compatibility, core concepts such as IoC and AOP, proxy implementations, bean factories, lifecycle management, transaction handling, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.

AOPIOCbackend
0 likes · 34 min read
Spring Framework Core Components, IOC, AOP, Bean Lifecycle and Related Concepts
Top Architect
Top Architect
May 11, 2021 · Backend Development

Implementing CORS Cross‑Origin Requests in Java Backend (Spring MVC)

This article explains why browsers enforce same‑origin restrictions, defines cross‑origin requests, lists the limitations of non‑same‑origin interactions, and presents five practical Java backend solutions—including a global CorsFilter bean, WebMvcConfigurer override, @CrossOrigin annotation, manual response headers, and a custom filter—complete with code examples.

CORSCross-Originfilter
0 likes · 7 min read
Implementing CORS Cross‑Origin Requests in Java Backend (Spring MVC)
Top Architect
Top Architect
May 10, 2021 · Backend Development

Understanding Java SPI, Dubbo SPI, and Spring SPI Mechanisms

This article explains the Service Provider Interface (SPI) concept, demonstrates how Java's built‑in SPI, Dubbo's enhanced SPI, and Spring's SPI work with code examples, compares their strengths and limitations, and discusses classpath ordering and extension loading issues.

DubboExtensionSPI
0 likes · 13 min read
Understanding Java SPI, Dubbo SPI, and Spring SPI Mechanisms
Programmer DD
Programmer DD
May 10, 2021 · Backend Development

Doubling QPS and Fixing Hystrix Bottlenecks in a Java Service

This article describes how a Java backend service suffering from high CPU load and unstable Hystrix circuit breaking was diagnosed and optimized—using jtop for JVM profiling, refactoring JSON/Bean handling, switching Hystrix isolation modes, improving logging, and tweaking circuit‑breaker settings—to double its QPS capacity and achieve rapid recovery after traffic spikes.

Hystrixjavajvm
0 likes · 15 min read
Doubling QPS and Fixing Hystrix Bottlenecks in a Java Service
Code Ape Tech Column
Code Ape Tech Column
May 10, 2021 · Backend Development

Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests

This article explains why browsers enforce the same‑origin policy, defines cross‑origin requests, outlines the restrictions of non‑same‑origin interactions, and presents five practical methods—including a global CorsFilter, WebMvcConfigurer, @CrossOrigin annotation, manual header setting, and a custom filter—to implement CORS in Java Spring backends.

CORSCross-OriginWebMvcConfigurer
0 likes · 8 min read
Mastering CORS in Spring: 5 Ways to Enable Cross‑Origin Requests
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 8, 2021 · Backend Development

Graceful Shutdown of RocketMQ Consumer in Spring Applications

The article recounts a production incident caused by an ungraceful RocketMQ consumer shutdown, analyzes the root cause involving Spring's bean destruction order and ShutdownHook behavior, and presents two solutions—using the official Spring‑Boot starter with SmartLifecycle or handling ContextClosedEvent—to achieve orderly termination.

Graceful ShutdownRocketMQShutdownHook
0 likes · 5 min read
Graceful Shutdown of RocketMQ Consumer in Spring Applications
Top Architect
Top Architect
May 7, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical reasons why @Transactional may not work in Spring applications—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, swallowed exceptions, wrong propagation settings, and unsupported MySQL storage engines—and provides concrete code examples and fixes for each case.

AOPMySQLTransaction
0 likes · 11 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

MyBatisbackendjava
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Wukong Talks Architecture
Wukong Talks Architecture
Apr 29, 2021 · Backend Development

Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions

This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.

Redisbackendconcurrency
0 likes · 16 min read
Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions