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.
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.
The 2021 JVM ecosystem report, based on responses from over 2,000 Java developers worldwide, shows OpenJDK now dominates with 77% market share, Java 11 surpasses Java 8 in production, Kotlin gains traction, IntelliJ IDEA leads IDE usage, and Maven remains the top build tool.
This article explains how to use Spring's built‑in StopWatch utility to record the start and end times of multiple code sections, generate a clear performance summary, and compares it with similar tools from Apache Commons and Guava.
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.
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.
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.
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.
This article examines four Spring Boot @Transactional test cases using a MySQL InnoDB database to determine whether each method rolls back or commits when exceptions are thrown or caught, providing code examples and inviting readers to vote on the outcomes.
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.
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.
This article explains how Spring 5.3.3 creates AOP proxy objects using Advisors, details the internal methods for locating and applying both bean-defined and @Aspect advisors, and demonstrates how to implement a custom Advisor to intercept methods annotated with @DS, including common pitfalls and solutions.
The article explains how Spring's automatic dependency injection initializes beans to avoid NullPointerExceptions, contrasting it with manual object creation using new, and provides example code demonstrating proper @Autowired usage versus manual instantiation.
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.
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.
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.
This article examines why Spring remains a top cloud‑native platform by exploring Java and JDK evolution, the competitive JVM language ecosystem, the maturity of Spring Boot and Spring Cloud for service‑oriented architectures, and Spring Reactive’s support for event‑driven designs.
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.
This article explains how to store and inject collection types such as List, Map, Set, and arrays from Spring configuration files using @Value, @ConfigurationProperties, and Spring Expression Language, while handling missing keys and reducing code‑configuration coupling.
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.
This article explains how to obtain a user's city from their IP address in a Java Spring backend, using the QQWry IP database, custom utility classes, and a login interceptor to count visits per city, with complete code examples and deployment considerations.
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.
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.
This article explains why the ELK stack is useful for large‑scale log collection and analysis, then provides detailed installation, configuration, and integration steps for Elasticsearch, Logstash, and Kibana on both macOS and Linux, including common pitfalls and memory‑tuning tips.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains the differences between Spring's @Autowired, @Resource, and @Inject annotations, the recommended injection methods, how the IDE warns against field injection, and best practices for constructor, setter, and field injection to write clean, maintainable Java code.
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.
This tutorial demonstrates how to create JavaBeans, DAO interfaces, and implementations, use JDK dynamic proxies to expose proxy classes, troubleshoot method‑level proxy failures, and apply Spring AOP with ProxyFactory or @Aspect, while also covering transaction pitfalls and best‑practice configurations.
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.
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.
This article explains the JSR‑250 @PostConstruct annotation, its specifications, how Spring implements its lifecycle handling, execution timing, practical code examples, the deprecation in Java 9+, and alternative approaches such as InitializingBean and DisposableBean.
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.
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.
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.
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.
This article explains Spring's Lifecycle and SmartLifecycle interfaces, shows how to implement custom beans that react to container start and stop events, provides complete code examples, and demonstrates the automatic startup and ordered shutdown behavior of SmartLifecycle in a Spring Boot application.
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.
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.
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.
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.
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.
This article explains the Same Origin Policy, introduces the CORS standard, details required response headers, and provides three practical Spring implementations—global config, filter, and annotation—to enable cross‑origin requests efficiently.
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.
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.
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.
This article explains the Template Method design pattern, illustrating its structure with Java drink‑making examples, discussing hook methods, and showing real‑world usages in JDK’s Comparable and Spring’s ApplicationContext, while highlighting advantages, drawbacks, and practical scenarios.
This article explains how to achieve database read‑write separation in a Spring application by using AbstractRoutingDataSource for routing, ThreadLocal for context, AOP interceptors for automatic switching, and provides a complete example with configuration, service code, and test cases.
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.
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.
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.
In a late-night deployment, the author traced a persistent ‘DataSource already closed’ error to an ungraceful RocketMQ consumer shutdown, explored Spring’s ShutdownHook behavior, and ultimately implemented a SmartLifecycle-based solution for orderly bean destruction.
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.
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.
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.
This article explains the two‑phase lifecycle of Spring beans, covering container startup tasks, metadata loading, bean definition registration, and the detailed instantiation process including object creation strategies, BeanWrapper, property injection, Aware interfaces, post‑processors, and custom init/destroy logic.
This article explains how the Spring IoC container prepares and creates Bean instances, detailing the two main phases—container startup and Bean instantiation—along with the roles of BeanDefinition, BeanFactoryPostProcessor, BeanWrapper, Aware interfaces, BeanPostProcessor, and custom initialization and destruction logic.
The 2020 State of Spring report reveals that the majority of Java developers favor Spring/Spring Boot, spending more time on unit testing, achieving higher code quality, and appreciating benefits such as easier web/API setup and robust testing support, with user adoption rising from 60% to 86%.
This article explains three typical situations where Spring's @Transactional annotation fails—non‑public methods, internal method calls, and caught exceptions—detailing the proxy‑based AOP mechanism, source code examples, and how to diagnose and resolve each issue.
This article explains how to achieve graceful shutdown for Dubbo services by leveraging operating‑system signals, Docker commands, JVM shutdown hooks, Spring event mechanisms, and Dubbo's own extensions, illustrating each layer with code examples and best‑practice recommendations.
This article explains three typical situations in which Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and caught exceptions—illustrates each case with runnable code examples, and dives into the underlying AOP and transaction‑management source code to show why the proxy logic is bypassed.
EasyJDBC is a Java library built on Spring's JdbcTemplate that adds JPA‑style annotations, dynamic entity mapping, chainable query APIs, and broad database support, with Maven coordinates for both core and Spring Boot starter packages and a detailed changelog for version 2.1.0.
This article explains the core concepts of Spring's Inversion of Control (IoC) and Dependency Injection (DI), illustrating how a container takes over object creation and wiring, why this reversal improves modularity and testability, and how the two ideas are essentially two views of the same design principle.
The article analyzes three typical situations—non‑public methods, internal self‑calls, and caught exceptions—that cause Spring's @Transactional annotation to be ineffective, explains the underlying proxy and AOP mechanisms, and provides Java code samples and test cases to illustrate each case.
This guide explains how to replace the legacy Alipay transfer API with the new alipay.fund.trans.uni.transfer interface by upgrading the SDK, configuring certificates, adding Maven dependencies, and implementing Spring components and utility classes for secure backend payment processing.
Explore ten practical Java scheduling options—from Linux crontab and JDK Thread/Timer to Spring Task, Quartz, and distributed frameworks like XXL‑Job, Elastic‑Job, Saturn and TBSchedule—detailing setup, code examples, advantages, drawbacks, and best‑fit scenarios for reliable task automation.
An in‑depth guide to the Spring framework covering its lightweight architecture, core principles such as IoC, DI, and AOP, key design patterns, module structure, bean lifecycle, circular dependency handling, and essential annotations for building robust Java backend applications.
This article provides a comprehensive overview of the Spring framework, covering its lightweight architecture, core principles such as Inversion of Control and Dependency Injection, AOP mechanisms, design goals, module structure, common design patterns, bean lifecycle, circular dependency handling, and the most frequently used Spring annotations with code examples.
This article outlines common situations that cause Spring @Transactional to fail—such as non‑public methods, internal method calls, unmanaged beans, non‑runtime exceptions, silent catches, incorrect propagation settings, and unsupported MySQL storage engines—and provides practical solutions to ensure transaction reliability.
This article explains Spring's warning about field injection, compares constructor, setter, and field injection methods, outlines the drawbacks of field injection, and recommends using constructor or setter injection for safer, more maintainable Java applications.
This article explains the main reasons why Spring's @Transactional annotation may become ineffective—including non‑public method modifiers, internal method calls, and swallowed exceptions—provides code examples, test cases, and a deep dive into the underlying proxy and AOP mechanisms.
The article demonstrates how to create a custom @ValidShop annotation and an AOP aspect that intercepts Spring MVC controller methods, extracts the annotated parameter via reflection, validates the shop code through a helper service, and proceeds only when the check succeeds.
This article introduces Alibaba Sentinel, an open‑source flow‑control framework for distributed services, covering Maven integration, dashboard setup, configuration of flow, degrade and hotspot rules, the @SentinelResource annotation, XCloud Sentinel starter usage, and a deep dive into its slot‑chain architecture and sliding‑window algorithm.
The article explains that MyBatis returns the constant -2147482646 when the executor type is set to BATCH, shows how to trace the source code to uncover this behavior, and provides a simple configuration change to restore correct update counts.
This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.
This article provides a curated collection of over 250 interview question links covering Java fundamentals, Spring framework, databases, Redis, messaging, concurrency, and system design, organized by issue numbers to help developers prepare for technical interviews.
This article explains the core principles of Spring transaction management, covering basic JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms (JDK dynamic proxy and CGLIB), transaction propagation attributes, isolation levels, nested transactions, and Spring Boot support, with practical code examples.
This article compiles 30 essential Java interview questions covering OOP fundamentals, collections, concurrency, JVM internals, Spring framework, and performance optimization, providing concise explanations and key concepts to help backend developers prepare effectively for technical interviews.
This article outlines five Spring-based approaches for using Apache RocketMQ—including Spring Messaging, Spring Cloud Stream, Spring Cloud Bus, Spring Cloud Data Flow, and Spring Cloud Function—detailing each project's features, typical use cases, and how they fit into modern Java microservice architectures.
This article walks through Spring’s container initialization, detailing the refresh method, XML parsing, BeanDefinition creation and registration, and the role of post‑processors, providing a clear roadmap for readers to understand and remember the core IoC workflow.
This comprehensive guide walks Java developers through setting up PowerMock and Mockito, demonstrates creating and spying on mocks, stubbing methods, using parameter matchers, verifying interactions—including static and private members—and explains essential annotations and best‑practice principles for robust, maintainable unit tests.
This article explains the five Spring AOP advice types, their execution order when combined in a single aspect, and provides a complete Java code example demonstrating before, after, after‑returning, after‑throwing, and around advices with normal and exceptional flows.
This article provides a comprehensive overview of Spring Expression Language (SpEL), detailing its supported expression types, case‑insensitive keywords, step‑by‑step usage flow, core interfaces, and concrete code examples for literals, arithmetic, relational, logical, ternary, Elvis, variable handling, and property navigation.
This article explains how to simplify complex Java code by using PowerMock and Mockito for unit testing, covering environment setup, mock, spy, when, parameter matchers, verification, static method mocking, private field and method handling, and essential annotations with practical code examples.
This article explains how Aspect‑Oriented Programming (AOP) can replace repetitive try‑catch blocks in Dubbo services, introduces core AOP concepts such as JoinPoint, Pointcut, and Advice, and compares static, JDK dynamic, and CGLIB dynamic proxy implementations with practical Java code examples.
The Spring nohttp project is an open‑source tool that scans and replaces insecure http:// URLs with HTTPS, preventing man‑in‑the‑middle attacks, updating Maven and documentation links, offering multiple modules and a command‑line interface, and providing example XML configuration for secure classpath resolution.
Integrating a React front‑end with a Java back‑end required fixing HTTPS‑to‑HTTP CORS errors by serving the React index.html from the backend, switching @RestController to @Controller for sub‑path routing, adding Thymeleaf, using a Chrome redirect plugin and crossorigin tags, and disabling lazy‑loaded asset URLs during local development, highlighting that true front‑end/back‑end separation remains elusive.
This article introduces seven open‑source OAuth/SSO solutions—including oauth2‑shiro, tkey, MaxKey, spring‑lhbauth, oauth2, oauthserver, and JustAuth—detailing their features, supported protocols, and repository links to help developers implement secure authentication and token management in web and mobile applications.
This article explains Spring's approach to resolving circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype bean limitations, provides a simplified implementation example, and draws an analogy to the classic two‑sum algorithm to illustrate the core concept.
This guide walks you through setting up Spring Authorization Server 0.1.0 on Spring Boot 2.4.2, covering Maven dependencies, bean configurations, token customization, and testing with curl commands for authorization code flow, token issuance, refresh, and revocation.
The article explains the core concept of Inversion of Control (IoC), how a third‑party container manages resources to reduce coupling, illustrates the idea with everyday examples, and clarifies the related terms dependency injection and control inversion, especially in the context of Spring.
