Java Reflection Explained: Classes, Methods, Fields, and Framework Use

🔍 What Is It?

Core Reflection Classes:

• →Class<T> — represents a class; get with obj.getClass() or MyClass.class
• →Method — represents a method; invoke with method.invoke(target, args)
• →Field — represents a field; get/set with field.get(obj) / field.set(obj, value)
• →Constructor<T> — represents a constructor; create with constructor.newInstance(args)
• →Annotation — represents an annotation; read with element.getAnnotation(type)

Getting Class Information:

Class<?> clazz = String.class;
clazz.getName()                // "java.lang.String"
clazz.getSimpleName()          // "String"
clazz.getDeclaredFields()      // all fields (including private)
clazz.getFields()              // only public fields (including inherited)
clazz.getDeclaredMethods()     // all methods (including private)
clazz.getMethods()             // only public methods (including inherited)
clazz.getDeclaredAnnotations() // annotations on this class
clazz.getSuperclass()          // parent class
clazz.getInterfaces()          // implemented interfaces

Java 9+ Module System:

Reflection on non-exported packages requires: --add-opens module/package=ALL-UNNAMED or explicit module configuration. Frameworks are adapting to this.

🎯 Why Do We Need It?

Reflection enables generic frameworks:

• →Spring DI — scans classpath for @Component, injects @Autowired fields
• →JPA/Hibernate — maps @Entity fields to database columns
• →Jackson — serializes/deserializes by reading field names and types
• →JUnit — finds @Test methods and invokes them
• →Lombok — generates code based on annotations (at compile time, not reflection)

Without reflection, these frameworks would require explicit configuration for every class — defeating their purpose.

🏗️ What Happens in Real Projects?

As an application developer, you use reflection indirectly:

• →When Spring injects @Autowired dependencies
• →When Jackson serializes your @JsonProperty fields
• →When JPA maps your @Column fields to SQL
• →When you write custom annotation processors

You write reflection code directly for: custom frameworks, testing utilities, serialization libraries, and AOP implementations.

⚙️ How It Works

Reflection Performance:

Reflection is slower than direct code because:

• →Method lookup requires searching the class hierarchy
• →Type checking is done at runtime, not compile time
• →JIT optimization is limited for reflective calls

Mitigation:

• →Cache Method/Field objects after first lookup
• →Use MethodHandles (Java 7+) — faster than reflection for repeated calls
• →Use invokedynamic — how lambdas are implemented

Access Control:

field.setAccessible(true) bypasses private/protected access modifiers. This is how Spring injects @Autowired private fields. In Java 9+, this requires module system permissions.

💻 Example

Reflection in Practice — How reflection powers framework features and how to use it safely.

// Inspect a class at runtime
Class<?> clazz = Employee.class;

// Get all declared fields (including private)
for (Field field : clazz.getDeclaredFields()) {
    System.out.printf("Field: %s %s%n", 
        field.getType().getSimpleName(), field.getName());
}

// Read a private field value
Employee emp = new Employee(1L, "Alice", "Engineering");
Field nameField = Employee.class.getDeclaredField("name");
nameField.setAccessible(true);  // bypass private access
String name = (String) nameField.get(emp);
System.out.println(name);  // Alice

// Invoke a private method
Method method = Employee.class.getDeclaredMethod("calculateBonus", BigDecimal.class);
method.setAccessible(true);
BigDecimal bonus = (BigDecimal) method.invoke(emp, new BigDecimal("100000"));

// Create instance dynamically
Class<?> serviceClass = Class.forName("com.example.OrderService");
Constructor<?> constructor = serviceClass.getDeclaredConstructor();
Object service = constructor.newInstance();

// Read annotations
for (Method m : clazz.getDeclaredMethods()) {
    if (m.isAnnotationPresent(Deprecated.class)) {
        System.out.println("Deprecated method: " + m.getName());
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits