Spring

A roadmap from dependency injection and bean lifecycle through AOP, transactions, MVC, Boot, and source-code reading.

A conceptual map of Spring Core/Beans/Context, AOP, data/transactions, web MVC/reactive, testing, and integration modules.

Spring application-event publication, listener execution, transactions, asynchrony, and coupling considerations.

Singleton, prototype, request/session and other Spring bean scopes, including lifecycle and thread-safety implications.

Pointcuts, advice, proxies, aspect ordering, and the self-invocation limitation of proxy-based Spring AOP.

Dependency injection through components/configuration with constructor injection, explicit dependencies, and container-managed lifecycle.

Dependency resolution by type/qualifier/name metadata and the BeanPostProcessor infrastructure behind annotation injection.

Proxy/interceptor transaction flow from metadata lookup to transaction manager begin/commit/rollback.

From bean definition and instantiation through dependency injection, post-processors, initialization, proxies, use, and destruction.

Spring's proxy-based aspect-oriented programming model: join points, pointcuts, advice, aspects, and proxies.

Inversion of Control and dependency injection as moving object construction/wiring policy from business classes to a container.

注解作用 @Configuration 相当于之前的applicationContext.xml，就是一个配置文件 @ComponentScan 配置扫描包，如果有@Controller，@Service，@Repositiry，@Component修饰的，则把它加入ioc容器中 @Bean 配合@

REQUIRED, REQUIRES_NEW, NESTED and other propagation modes as policies for existing versus new transaction contexts.

BeanFactory as Spring's dependency-container contract and its relationship with ApplicationContext.

Declarative transaction boundaries, rollback rules, proxy limitations, isolation, timeouts, and external side effects.

Constructor versus setter/field cycles, early references, proxy complications, and why redesign is usually preferable.

How to express real bean dependencies instead of relying on incidental initialization order.

High-level ApplicationContext refresh flow from environment/bean definitions through post-processors and singleton initialization.

How BeanFactoryPostProcessor customizes bean definitions/container metadata before ordinary bean instantiation.

Why BeanPostProcessors must be registered before ordinary singleton creation and what lifecycle extension they provide.

How Spring resolves bean dependencies, creates singleton instances, applies lifecycle processors, and caches exposed objects.

A conceptual map of Spring container interfaces and extension points rather than a version-frozen UML diagram.

How annotation-driven AOP enables an auto-proxy BeanPostProcessor, described as versioned Spring internals.

Lifecycle of Spring's AOP auto-proxy creator as an infrastructure bean and BeanPostProcessor.

End-to-end Spring AOP model from infrastructure registration and advisor discovery to proxy creation and interceptor invocation.

Where auto-proxy creation participates in the bean lifecycle and why early references matter for some dependency graphs.

Advisor matching and creation of JDK-interface or class-based proxies around eligible Spring beans.

Interceptor-chain execution around a proxied target method and how proceed composes advice.