🪞 Reflection Layer — How Spring Sees and Wires Your Code¶

Essence: The Reflection Layer is the foundation of Spring. It’s how Spring discovers, creates, and connects your classes at runtime — turning plain Java code into a self-managing system.

🌱 1. Concept Overview¶

Java’s Reflection API lets code inspect and manipulate itself at runtime. Spring builds on that to power @ComponentScan, @Autowired, @Bean, and most of its container magic.

source (.java)
   ↓ compiler
bytecode (.class)
   ↓ ClassLoader
Class<?> object in Metaspace
   ↓ Reflection
Spring inspects, instantiates, and injects beans

🧩 2. Core Reflection API — Java’s Runtime Mirror¶

Everything starts with the Class<?> object.

Class<?> clazz = PaymentService.class;
Class<?> clazz2 = Class.forName("com.app.PaymentService");

🔍 Inspecting a Class¶

clazz.getName();           // "com.app.PaymentService"
clazz.getDeclaredFields(); // all fields
clazz.getDeclaredMethods();
clazz.getSuperclass();
clazz.getAnnotations();

Spring uses this to find annotations like @Component, @Service, or @Bean.

🧠 3. Creating Objects Reflectively¶

Constructor<?> ctor = clazz.getDeclaredConstructor();
Object instance = ctor.newInstance();

With parameters:

Constructor<?> ctor = clazz.getDeclaredConstructor(AuditService.class);
Object obj = ctor.newInstance(new AuditService());

That’s what Spring does when it creates beans from your classes — it calls constructors reflectively based on metadata from scanning.

⚙️ 4. Accessing Private Members¶

Reflection can bypass visibility restrictions.

Field f = clazz.getDeclaredField("audit");
f.setAccessible(true);
f.set(instance, new AuditService());

This is the essence of dependency injection — Spring sets fields without needing public setters.

🧬 5. Invoking Methods¶

Method m = clazz.getDeclaredMethod("process", String.class);
m.setAccessible(true);
m.invoke(instance, "Alice");

Used internally for:

• Lifecycle hooks (@PostConstruct, @PreDestroy)
• Configuration methods (@Bean)
• Event listeners (@EventListener)

⚡ 6. Annotations in Reflection¶

if (clazz.isAnnotationPresent(Service.class)) {
    Annotation a = clazz.getAnnotation(Service.class);
}

Field or method level:

Field f = clazz.getDeclaredField("repo");
if (f.isAnnotationPresent(Autowired.class)) {
    // inject dependency reflectively
}

Reflection lets Spring read annotation metadata and decide what to do with it.

🤝 7. @Autowired — Reflection Meets IoC¶

@Autowired is the declarative interface to reflection. It tells Spring: “Find me something of this type and assign it here.”

Field Injection¶

@Autowired
private AuditService audit;

Spring finds a matching bean and executes:

Field f = PaymentService.class.getDeclaredField("audit");
f.setAccessible(true);
f.set(paymentServiceInstance, auditInstance);

Constructor Injection¶

@Autowired
public PaymentService(AuditService audit) {
    this.audit = audit;
}

If there’s only one constructor, @Autowired is optional — Spring assumes it.

Under the hood:

Constructor<?> ctor = clazz.getDeclaredConstructor(AuditService.class);
Object bean = ctor.newInstance(auditBean);

Setter Injection¶

@Autowired
public void setAuditService(AuditService audit) {
    this.audit = audit;
}

Spring reflectively calls:

Method m = clazz.getDeclaredMethod("setAuditService", AuditService.class);
m.invoke(instance, auditBean);

🧮 8. Dependency Resolution Rules¶

When resolving an @Autowired dependency:

1. By Type — find one matching bean in the ApplicationContext.

2. If multiple found:

3. Prefer @Primary

4. Or match name with field/parameter
5. Or use @Qualifier("beanName")

6. If none found:

7. Throw NoSuchBeanDefinitionException

8. Unless @Autowired(required = false) is used

Qualifiers and Primary¶

@Primary
@Service
public class EmailNotifier implements Notifier {}

@Service("smsNotifier")
public class SmsNotifier implements Notifier {}

@Service
public class PaymentService {
    @Autowired
    @Qualifier("smsNotifier")
    private Notifier notifier;
}

Optional & Lazy Variants¶

@Autowired(required = false)
private Optional<AuditService> audit;

@Autowired
@Lazy
private HeavyService heavy; // proxy until first call

🧭 9. Internal Flow (Simplified Pseudocode)¶

for (Field field : clazz.getDeclaredFields()) {
    if (field.isAnnotationPresent(Autowired.class)) {
        Object dependency = context.getBean(field.getType());
        field.setAccessible(true);
        field.set(beanInstance, dependency);
    }
}

Spring does this reflection once during startup — then caches results for efficiency.

🧱 10. Reflection in Bean Lifecycle¶

Scan classes → detect annotations → create Class<?> objects
→ register BeanDefinitions → construct beans via reflection
→ inject dependencies via reflection
→ invoke @PostConstruct → ready

Reflection is used heavily during startup — once the context is ready, execution runs as normal Java code.

⚙️ 11. Dynamic Proxies (Advanced Reflection)¶

Spring uses reflection again to generate proxies for beans with AOP features:

MyService proxy = (MyService) Proxy.newProxyInstance(
    clazz.getClassLoader(),
    new Class[]{MyService.class},
    (proxyObj, method, args) -> {
        System.out.println("Before call");
        return method.invoke(targetBean, args);
    });

Used for:

• Transactions (@Transactional)
• Async execution (@Async)
• Caching (@Cacheable)
• Security (@PreAuthorize)

🧩 12. Common Pitfalls¶

🧭 13. Performance Considerations¶

• Reflection is slower than direct calls, but Spring caches all reflective lookups.
• The reflection cost happens only once — at startup.
• During runtime, calls go through direct references (or proxies).

🧩 14. Quick Reference Summary¶

🔗 Related¶

• Concept: Reflection & @Autowired
• Cheatsheet: bean-lifecycle.md
• Cheatsheet: aop-proxy-types.md

🪞 Core Takeaway¶

Reflection gives Spring its eyes; @Autowired gives it its hands. Together they let the framework see your classes, build your objects, and connect them into a living application — all before your code ever runs.