Many Java developers encounter reflection during their learning journey but often leave with only a vague understanding—or skip it entirely. This article demystifies what reflection is, how it works under the hood, and where it’s practically applied in real-world systems.

What Is Reflection?

According to Wikipedia, reflective programming refers to a program’s ability to inspect, analyze, and even modify its own structure and behavior while running. In Java, this translates to dynamically accessing classes, methods, fields, and constructors—even with out knowing their names at compile time.

Reflection goes beyond introspection (wich only allows inspection of metadata). It enables runtime modification: creating instances, invoking methods, or altering field values—all without hardcoding class references.

How Java Compilation and Loading Work

To understand reflection, you must first grasp how Java code becomes executable:

1. Lexical Analysis: Source code is tokenized.
2. Syntax Parsing: Tokens are structured into a Abstract Syntax Tree (AST).
3. Semantic Analysis: Validates type safety, variable declarations, etc.
4. Bytecode Generation: AST is compiled into platform-independent .class files.
5. Class Loading: JVM loads .class files via ClassLoader, preparing them for execution.
6. JIT Optimization & Execution: Bytecode may be compiled to native machine code for performance.

This pipeline ensures Java’s "write once, run anywhere" portability—and reflection operates atop this infrastructure.

"Forward" vs "Reflection" Instantiation

Normally, you instantiate known classes directly:

Fruit fruit = new Fruit();
fruit.setCost(5);

This is static, compile-time binding. With reflection, you defer decisions until runtime:

Class> clazz = Class.forName("com.example.Fruit");
Constructor> ctor = clazz.getConstructor();
Object instance = ctor.newInstance();
Method setter = clazz.getMethod("setCost", int.class);
setter.invoke(instance, 5);

Both achieve the same result—but the latter uses string-based class lookup and dynamic invocation, enabling flexibility impossible at compile time.

Three Ways to Obtain a Class Object

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // Method 1: via instance
        Student s1 = new Student();
        Class> c1 = s1.getClass();

        // Method 2: via .class literal
        Class> c2 = Student.class;

        // Method 3: via Class.forName (most common)
        Class> c3 = Class.forName("com.example.Student");

        System.out.println(c1 == c2); // true
        System.out.println(c2 == c3); // true
    }
}

All three approaches yield the same Class object—each useful in different contexts.

Practical Applications of Reflection

Reflection powers many foundational Java frameworks:

• Spring Framework: Uses reflection for dependency injection (IoC) and AOP proxies.
• MyBatis / Hibernate: Maps database rows to objects by inspecting class fields.
• Annotations: Frameworks read @Component, @Value, etc., via reflection to configure behavior.
• JDBC Drivers: Class.forName("com.mysql.cj.jdbc.Driver") dynamically loads database connectors.

Example: Dynamic Proxy with Reflection

public class LoggingProxy implements InvocationHandler {
    private final Object target;

    public LoggingProxy(Object obj) {
        this.target = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
        System.out.println("Invoking: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("Completed: " + method.getName());
        return result;
    }
}

This proxy logs method calls—made possible by reflecting on method signatures and invoking them dynamically.

Pros and Cons

Advantages:

• Enables flexible, decoupled architectures.
• Powers annotation processing and framework extensibility.
• Supports plugin systems and runtime class loading.

Disadvantages:

• Performance overhead due to lack of compile-time optimization.
• Bypasses compile-time checks (e.g., generics, access modifiers).
• Security risks if used carelessly (e.g., accessing private fields).