1 views collected around this technical thread.
This article explains how the Spring @Value annotation can automatically inject configuration values from property files, support default values and SpEL expressions, and streamline environment-specific settings in Spring Boot applications, while also providing practical code examples and usage tips.
This article provides a detailed walkthrough of Spring and Spring Boot's core concepts, explains the bean container refresh process, and enumerates all major extension interfaces—including ApplicationContextInitializer, BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, InstantiationAwareBeanPostProcessor, SmartInstantiationAwareBeanPostProcessor, various *Aware interfaces, @PostConstruct, InitializingBean, FactoryBean, SmartInitializingSingleton, CommandLineRunner, DisposableBean, and ApplicationListener—accompanied by code samples and usage scenarios.
This article explains the purpose, usage patterns, and internal mechanics of Spring's @Import annotation, including importing regular classes, ImportSelector implementations, and ImportBeanDefinitionRegistrar implementations, with complete code examples and a discussion of how Spring processes these imports at runtime.
This article presents fifteen useful Spring techniques—including bean retrieval, event handling, custom interceptors, retry mechanisms, global exception handling, startup initialization, bean lifecycle methods, resource cleanup, dynamic configuration injection, conditional bean registration, caching, transaction management, bean loading order, AOP aspects, and conditional bean creation—each illustrated with clear Java code examples.
In Spring Boot, a class annotated with @Service can act as a web controller if it is discovered by component scanning and carries @RequestMapping (or method‑level mapping) annotations, allowing HTTP requests to be handled just like a traditional @Controller‑annotated bean.
This article explains Java's built‑in Service Provider Interface (SPI) mechanism, demonstrates how to implement and test SPI with sample code, analyzes its internal workings and limitations, and then shows how Spring extends SPI using spring.factories with comparable examples and source‑code insights.
This article explains the most frequent SpringBoot BeanCreationException scenarios—including missing beans, duplicate beans, constructor issues, circular dependencies, and bean overriding—provides clear code examples, and offers practical solutions to resolve each problem.
This article explains how Lombok's @RequiredArgsConstructor can replace repetitive @Autowired field injections in Spring services by generating a constructor for final fields, demonstrates the underlying annotation‑processing mechanism, and provides practical code examples for applying this technique in backend Java projects.
This article provides a comprehensive explanation of Spring Boot's startup process, detailing each lifecycle extension point, the order of execution, common pitfalls with RPC/MQ/HTTP traffic, and includes runnable code examples to help developers master Spring initialization.
This article provides an in‑depth explanation of the Spring Boot startup process, enumerates the key extension points, demonstrates their execution order with sample code and logs, and offers practical recommendations for correctly initializing RPC, MQ, and HTTP traffic.
This article thoroughly explains the Spring Boot startup sequence, detailing each lifecycle extension point, common pitfalls with early RPC, HTTP, and MQ traffic, and provides code examples and answers to eleven critical questions to help developers master Spring initialization and avoid runtime failures.
This article provides a comprehensive overview of the most frequently used Spring and Spring Boot annotations, explaining their purposes, usage scenarios, and includes practical Java code examples for core, MVC/REST, stereotype, data access, scheduling, asynchronous, and testing annotations.
This article provides a detailed overview of the most frequently used Spring annotations—including core, MVC/REST, Boot, stereotype, data access, scheduling, and testing annotations—explaining their purposes, usage rules, and providing Java code examples for each.
The Android Chain framework decouples business modules by turning call points into annotated extension points, generating interface‑to‑implementation mappings at compile time, merging them via a Gradle plugin, and exposing them through a runtime singleton that supports priority, dynamic proxies, custom URL protocols, and ProGuard‑safe automatic registration.
This article provides a comprehensive overview of the most frequently used Spring annotations, covering core dependency‑injection annotations, MVC/REST mapping, Spring Boot configuration, stereotype components, transaction management, task scheduling, asynchronous execution, and testing support, with clear code examples for each.
This article explains how .NET's Microsoft.Extensions.ObjectPool framework can be used to reuse objects, customize pooling policies, integrate with dependency injection, and extend pooling to collections, StringBuilder, arrays and memory buffers, thereby minimizing garbage‑collection pressure and boosting application throughput.
This article explains how to transform a large Android project into a componentized architecture by modularizing code, configuring Gradle for independent debugging, using ARouter for page navigation and service communication, handling fragment instances, distributing Application lifecycle events, and migrating legacy projects.
This article introduces the most commonly used Spring framework annotations—including core, MVC/REST, Boot, stereotype, data access, scheduling, and testing annotations—explains their purposes, usage scenarios, and provides Java code examples illustrating how to apply them in typical Spring applications.
This article provides a comprehensive overview of the most commonly used Spring Framework annotations, including core, stereotype, Spring Boot, MVC/REST, data access, scheduling, and testing annotations, with explanations and code examples illustrating their usage in Java backend development.
This article explains the complete Spring Bean lifecycle—including definition via XML, various initialization methods, three ways to obtain and use a bean, and bean destruction techniques—illustrated with Java code snippets and a diagram for clear understanding.