⚙️ Spring Core Quick-Starter — All-in-One Cheatsheet¶

Essence: Everything that powers Spring — from reflection and beans to IoC, lifecycle, AOP, and events — condensed for daily reference. Think of it as your cockpit dashboard: every switch labeled, no theory required.

🌱 1. Reflection — How Spring Sees Your Code¶

Core Idea¶

Spring uses Java reflection to discover, instantiate, and wire classes at runtime.

Java Basics¶

Class<?> c = PaymentService.class;
Object o = c.getDeclaredConstructor().newInstance();
Field f = c.getDeclaredField("audit");
f.setAccessible(true);
f.set(o, new AuditService());

In Spring¶

Key Annotation¶

@Autowired — tells Spring to inject a dependency automatically.

🧩 2. Bean Anatomy — What Spring Manages¶

Definition¶

A bean is any Java object managed by Spring — created, wired, and destroyed inside the ApplicationContext.

Lifecycle Overview¶

instantiate → inject → initialize → active → destroy

Lifecycle Hooks¶

Core Annotations¶

🧠 3. Dependency Injection — How Beans Connect¶

Injection Styles¶

Qualifiers¶

Optional/Lazy¶

@Autowired(required = false)
@Lazy
private ExpensiveService heavy;

Spring injects a proxy, creates bean only when used.

🧬 4. IoC Container — Who Controls the Show¶

Philosophy¶

Inversion of Control (IoC) means the framework controls object creation, not you.

Core Interfaces¶

Common Context Classes¶

Useful Methods¶

ctx.getBean(MyService.class);
ctx.containsBean("auditService");
ctx.getEnvironment().getActiveProfiles();
ctx.close();

BeanDefinition Metadata¶

🧭 5. Application Context Lifecycle — From Start to Stop¶

Spring Boot run()
  ↓
create ApplicationContext
  ↓
scan classpath
  ↓
register BeanDefinitions
  ↓
instantiate + inject
  ↓
post-process + initialize
  ↓
publish ContextRefreshedEvent
  ↓
ready to serve
  ↓
(ContextClosedEvent → destroy hooks)

Key Events¶

⚙️ 6. AOP — How Spring Adds Behavior Dynamically¶

Core Idea¶

Aspect-Oriented Programming (AOP) lets Spring weave extra behavior (transactions, caching, logging) around method calls.

Key Components¶

Common Annotations¶

Proxy Types¶

Built-in Use Cases¶

📡 7. Events — How Spring Talks Internally¶

Publish & Listen¶

@Component
public class AppReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    public void onApplicationEvent(ApplicationReadyEvent e) {
        System.out.println("App started!");
    }
}

Or annotation-style:

@EventListener
public void handle(ContextClosedEvent e) {
    System.out.println("Context closed.");
}

Custom Events¶

class OrderCreatedEvent extends ApplicationEvent { ... }

ctx.publishEvent(new OrderCreatedEvent(this));

🧩 8. Common Gotchas¶

🔍 9. Useful Debugging Tricks¶

List all beans:

Arrays.stream(ctx.getBeanDefinitionNames()).forEach(System.out::println);

Trace events:

@Component
public class EventsTracer implements ApplicationListener<ApplicationEvent> {
    public void onApplicationEvent(ApplicationEvent e) {
        System.out.println("Event → " + e.getClass().getSimpleName());
    }
}

Inspect proxy target:

AopUtils.getTargetClass(bean);

🧬 10. Hierarchy Map¶

[Reflection Layer]
   ├─ Reflection API
   └─ @Autowired injection
        ↓
[Beans Layer]
   ├─ Bean annotations & lifecycle
   └─ BeanDefinition metadata
        ↓
[Container Layer]
   ├─ Dependency injection & ApplicationContext
   └─ BeanFactory, IoC flow
        ↓
[AOP Layer]
   ├─ Aspects & proxies
        ↓
[Events Layer]
   └─ Application events & listeners

🪞 Core Takeaway¶

Spring turns static Java code into a living ecosystem. Reflection lets it see your classes, IoC lets it control their creation, AOP lets it enrich their behavior, and the event system lets it coordinate the whole show.

🔗 Related¶

• Conceptual Overview: concepts/frameworks/spring/core/quick-start.md
• Blueprint: meta/blueprint.md
• Next: explore beans/bean-lifecycle.md and container/applicationcontext.md for deeper operational detail.