Reflection API

Java Reflection API is a powerful feature that allows programs to inspect and manipulate classes, methods, fields, and constructors at runtime. It is widely used in modern frameworks and tools to enable dynamic behavior.

---

What is Reflection API?

Reflection API in Java allows a program to inspect and manipulate classes, methods, fields, and constructors at runtime.

In simple words: It lets your program look inside itself and work dynamically, even if details are not known at compile time.

---

Why Reflection is Important

Reflection is widely used in real-world applications:

• Spring Framework → Dependency Injection
• Hibernate → Database mapping
• JUnit → Running test cases
• Jackson/Gson → JSON conversion

? It helps developers build flexible, reusable, and dynamic systems, which are very important in modern Java development.

---

Key Components of Reflection API

Java provides the java.lang.reflect package, which contains the core classes used in Reflection. These classes help you inspect and work with different parts of a program at runtime.

Main Classes:

• Class → Represents a class and provides information like class name, methods, fields, and constructors
• Field → Represents variables (fields) of a class and allows you to access or modify their values
• Method → Represents methods of a class and allows you to invoke them dynamically at runtime
• Constructor → Represents constructors and allows you to create objects dynamically

---

Step-by-Step Tutorial

Step 1: Accessing Classes

Reflection starts by getting the Class object, which represents the structure of a class at runtime.

class Person {}

public class Test {
    public static void main(String[] args) {
        Class<?> cls = Person.class;
        System.out.println(cls.getName());
    }
}

Explanation

• Person.class → Gets the Class object of the Person class
• Class<?> → Represents any type of class (generic type)
• getName() → Returns the full class name

Output

Person

---

Step 2: Accessing Fields

In this step, Reflection is used to access and read a private field from a class. Normally, private fields cannot be accessed directly, but Reflection allows you to bypass this restriction.

import java.lang.reflect.Field;

class Person {
    private String name = "Amit";
}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Person.class;
        Object obj = cls.getDeclaredConstructor().newInstance();

        Field field = cls.getDeclaredField("name");
        field.setAccessible(true);

        System.out.println(field.get(obj));
    }
}

Explanation

• getDeclaredField("name") → Accesses the private field name from the class
• setAccessible(true) → Bypasses access control to allow access to private fields
• field.get(obj) → Retrieves the value of the field from the object

Output

Amit

---

Step 3: Accessing Methods

In this step, Reflection is used to access and execute a method dynamically at runtime. This means you can call methods without directly using them in your code.

import java.lang.reflect.Method;

class Person {
    public void greet() {
        System.out.println("Hello!");
    }
}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Person.class;
        Object obj = cls.getDeclaredConstructor().newInstance();

        Method method = cls.getMethod("greet");
        method.invoke(obj);
    }
}

Explanation

• getMethod("greet") → Gets the public method greet from the class
• invoke(obj) → Executes the method on the given object

Output

Hello!

---

Step 4: Dynamic Object Creation

In this step, Reflection is used to load a class and create its object dynamically at runtime. This is useful when the class name is not known at compile time.

class Person {}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("Person");
        Object obj = cls.getDeclaredConstructor().newInstance();

        System.out.println(obj.getClass().getName());
    }
}

Explanation

• Class.forName("Person") → Loads the Person class at runtime using its name
• getDeclaredConstructor().newInstance() → Creates a new object dynamically
• obj.getClass().getName() → Gets the class name of the created object

Output

Person

---

Performance Considerations

Reflection is a powerful feature, but it is generally slower than normal Java code.

Why Reflection is Slower?

• Works at runtime instead of compile-time
• JVM cannot optimize reflection calls effectively
• Involves additional processing like method lookup and access checks

Tips to Use Reflection Efficiently

• Avoid using reflection inside loops or performance-critical code
• Cache methods and fields if they are used multiple times
• Prefer normal Java code when performance is important

? Reflection should be used carefully — it is best for flexibility, not for high-performance operations.

---

Security Concerns

Reflection can break Java’s built-in security and access control rules if not used carefully.

Risks

• Access private data
• Bypass encapsulation
• Modify sensitive fields

Example

field.setAccessible(true);

? This allows access to private variables, which are normally restricted.

Best Practice

• Use reflection only when required
• Avoid using it in security-sensitive systems

---

Common Mistakes to Avoid

• Using reflection everywhere unnecessarily
• Ignoring performance impact
• Not handling exceptions properly
• Hardcoding class names
• Misusing setAccessible(true)

---

Best Practices

• Use reflection mainly in frameworks and advanced use cases
• Cache reflection objects to improve performance
• Avoid using reflection in performance-critical applications
• Combine reflection with annotations for better design
• Keep the code simple, clean, and readable

---

Conclusion

Reflection API is a powerful feature in Java that enables runtime inspection and control of classes, methods, fields, and constructors.

• It is widely used in major frameworks like Spring, Hibernate, and testing tools.
• It supports dynamic object creation and method execution, making applications more flexible.
• However, it comes with performance and security trade-offs that developers must consider.