Detailed Explanation of Java Reflection Mechanism#

The Java reflection mechanism is one of the core foundations of backend development. It supports dynamically obtaining class information, calling object methods/operating properties at runtime, and is the core underlying technology of framework design (Spring/MyBatis). This article comprehensively explains the use and application of the reflection mechanism from definitions, core functions, API usage to practical cases.

1. What is the Reflection Mechanism#

The reflection mechanism refers to the ability, in the runtime state, to know all the properties and methods of any class, and to call any method and property of any object. This function of dynamically obtaining information and dynamically calling object methods is called the reflection mechanism of the Java language.

Reflection breaks the compile-time binding limit of Java, allowing the program to determine the class/object to operate only at runtime, realizing dynamic programming. It is also the key to achieving decoupling and dynamic configuration in Java frameworks.

2. What Can the Reflection Mechanism Do#

The reflection mechanism provides Java with dynamic operation capabilities at runtime, and its core functions include the following 5 points:

Determine the class to which any object belongs at runtime;
Construct an object of any class at runtime;
Determine all member variables and methods of any class at runtime;
Call any method of any object at runtime;
Implement dynamic proxy based on reflection (core principle of AOP).

Reflection is a runtime operation that skips some compile-time checks and has slightly lower performance than direct calls. At the same time, reflection can access private members, which may damage the encapsulation of the class, so permission control should be done well when using it.

3. Relevant APIs of the Reflection Mechanism#

The core APIs of Java reflection are all located in the java.lang.reflect package, and java.lang.Class is the entry class of reflection (all reflection operations need to obtain the Class object first). The following are the practical usages of commonly used reflection APIs, and all codes are accompanied by line numbers and running result explanations.

3.1 Obtain the Complete Package Name and Class Name Through an Object#

The fully qualified name (package name + class name) of the class to which the object belongs can be obtained through Object.getClass().getName(), which is the most basic reflection operation.

1
package net.xsoftlab.baike;
2
public class TestReflect {
3
    public static void main(String[] args) throws Exception {
4
        TestReflect testReflect = new TestReflect();
5
        System.out.println(testReflect.getClass().getName());
6
        // Running result: net.xsoftlab.baike.TestReflect
7
    }
8
}

3.2 Instantiate a Class Object#

Class is the core entry of reflection. There are 3 ways to obtain a Class object, among which Class.forName("fully qualified name") is the most commonly used method (supports dynamic class loading).

1
package net.xsoftlab.baike;
2
public class TestReflect {
3
    public static void main(String[] args) throws Exception {
4
        Class<?> class1 = null;
5
        Class<?> class2 = null;
6
        Class<?> class3 = null;
7
        // Method 1: Class.forName(fully qualified name) → Recommended, dynamically load class
8
        class1 = Class.forName("net.xsoftlab.baike.TestReflect");
9
        // Method 2: object.getClass()
10
        class2 = new TestReflect().getClass();
11
        // Method 3: ClassName.class → Determined at compile time, static loading
12
        class3 = TestReflect.class;
13
        // The three methods obtain the same Class object
14
        System.out.println("Class name: " + class1.getName());
15
        System.out.println("Class name: " + class2.getName());
16
        System.out.println("Class name: " + class3.getName());
17
    }
18
}

3.3 Obtain the Parent Class and Implemented Interfaces of an Object#

The parent Class object is obtained through Class.getSuperclass(), and all implemented interfaces are obtained through Class.getInterfaces() (returns a Class array).

1
package net.xsoftlab.baike;
2
import java.io.Serializable;
3
// Implement the Serializable interface, the default parent class is Object
4
public class TestReflect implements Serializable {
5
    private static final long serialVersionUID = -2862585049955236662L;
6
    public static void main(String[] args) throws Exception {
7
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
8
        // Get parent class
9
        Class<?> parentClass = clazz.getSuperclass();
10
        System.out.println("The parent class of clazz is: " + parentClass.getName());
11
        // Running result: The parent class of clazz is: java.lang.Object
12
        // Get all implemented interfaces
13
        Class<?> intes[] = clazz.getInterfaces();
14
        System.out.println("The interfaces implemented by clazz are:");
15
        for (int i = 0; i < intes.length; i++) {
16
            System.out.println((i + 1) + ": " + intes[i].getName());
17
        }
18
        // Running result: 1: java.io.Serializable
19
    }
20
}

3.4 Instantiate Class Objects & Obtain Constructors Through Reflection#

Reflection supports instantiating objects through no-argument constructors and parameterized constructors. You need to first obtain all public constructors through Class.getConstructors(), and then create objects through Constructor.newInstance().

To access private constructors, you need to use Class.getDeclaredConstructors() and break the encapsulation through setAccessible(true).

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Constructor;
3
public class TestReflect {
4
    public static void main(String[] args) throws Exception {
5
        Class<?> class1 = Class.forName("net.xsoftlab.baike.User");
6
        // Method 1: Instantiate through no-argument constructor, then assign values using setter
7
        User user = (User) class1.newInstance();
8
        user.setAge(20);
9
        user.setName("Rollen");
10
        System.out.println(user);
11
        // Running result: User [age=20, name=Rollen]
12

13
        // Method 2: Get all constructors and instantiate through parameterized constructors
14
        Constructor<?> cons[] = class1.getConstructors();
15
        // Traverse and print the parameter types of all constructors
16
        for (int i = 0; i < cons.length; i++) {
17
            Class<?> clazzs[] = cons[i].getParameterTypes();
18
            System.out.print("cons[" + i + "] (");
19
            for (int j = 0; j < clazzs.length; j++) {
20
                if (j == clazzs.length - 1)
21
                    System.out.print(clazzs[j].getName());
22
                else
23
                    System.out.print(clazzs[j].getName() + ",");
24
            }
25
            System.out.println(")");
26
        }
27
        // Running result: cons[0] (java.lang.String) | cons[1] (int,java.lang.String) | cons[2] ()
28

29
        // Instantiate through single-parameter constructor
30
        user = (User) cons[0].newInstance("Rollen");
31
        System.out.println(user); // User [age=0, name=Rollen]
32
        // Instantiate through double-parameter constructor
33
        user = (User) cons[1].newInstance(20, "Rollen");
34
        System.out.println(user); // User [age=20, name=Rollen]
35
    }
36
}
37
// Custom User class with multiple constructors
38
class User {
39
    private int age;
40
    private String name;
41
    public User() {}
42
    public User(String name) { this.name = name; }
43
    public User(int age, String name) { this.age = age; this.name = name; }
44
    // getter/setter & toString
45
    public int getAge() { return age; }
46
    public void setAge(int age) { this.age = age; }
47
    public String getName() { return name; }
48
    public void setName(String name) { this.name = name; }
49
    @Override
50
    public String toString() { return "User [age=" + age + ", name=" + name + "]"; }
51
}

3.5 Obtain All Properties of a Class#

Class.getDeclaredFields() is used to obtain all properties of the current class (including private ones), Class.getFields() is used to obtain only public properties (including public properties of parent classes/interfaces). Combined with java.lang.reflect.Modifier, the access modifiers (public/private/static, etc.) of the properties can be parsed.

1
package net.xsoftlab.baike;
2
import java.io.Serializable;
3
import java.lang.reflect.Field;
4
import java.lang.reflect.Modifier;
5
public class TestReflect implements Serializable {
6
    private static final long serialVersionUID = -2862585049955236662L;
7
    public static void main(String[] args) throws Exception {
8
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
9
        System.out.println("===============Current Class Properties===============");
10
        // Get all properties of the current class (including private ones)
11
        Field[] field = clazz.getDeclaredFields();
12
        for (int i = 0; i < field.length; i++) {
13
            // Parse access modifiers
14
            int mo = field[i].getModifiers();
15
            String priv = Modifier.toString(mo);
16
            // Get property type
17
            Class<?> type = field[i].getType();
18
            System.out.println(priv + " " + type.getName() + " " + field[i].getName() + ";");
19
        }
20
        System.out.println("==========Public Properties of Implemented Interfaces/Parent Class==========");
21
        // Get only public properties (including parent classes/interfaces)
22
        Field[] filed1 = clazz.getFields();
23
        for (int j = 0; j < filed1.length; j++) {
24
            int mo = filed1[j].getModifiers();
25
            String priv = Modifier.toString(mo);
26
            Class<?> type = filed1[j].getType();
27
            System.out.println(priv + " " + type.getName() + " " + filed1[j].getName() + ";");
28
        }
29
    }
30
}

3.6 Obtain All Methods of a Class & Call Methods#

3.6.1 Obtain All Methods#

Class.getMethods() is used to obtain all public methods (including public methods of parent classes), and Class.getDeclaredMethods() is used to obtain all methods of the current class (including private ones). The return value, parameters, exceptions, modifiers and other information of the method can be parsed.

3.6.2 Call Methods#

Methods are dynamically called through Method.invoke(Object obj, Object... args). The first parameter is the instance object (pass null for static methods), and the subsequent parameters are the input parameters of the method.

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Method;
3
public class TestReflect {
4
    public static void main(String[] args) throws Exception {
5
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
6
        // Call the no-argument method reflect1
7
        Method method = clazz.getMethod("reflect1");
8
        method.invoke(clazz.newInstance());
9
        // Running result: Java Reflection Mechanism - Calling a method of a class 1.
10

11
        // Call the parameterized method reflect2 (int + String)
12
        method = clazz.getMethod("reflect2", int.class, String.class);
13
        method.invoke(clazz.newInstance(), 20, "Zhang San");
14
        // Running result: Java Reflection Mechanism - Calling a method of a class 2. | age -> 20. name -> Zhang San
15
    }
16
    // No-argument test method
17
    public void reflect1() {
18
        System.out.println("Java Reflection Mechanism - Calling a method of a class 1.");
19
    }
20
    // Parameterized test method
21
    public void reflect2(int age, String name) {
22
        System.out.println("Java Reflection Mechanism - Calling a method of a class 2.");
23
        System.out.println("age -> " + age + ". name -> " + name);
24
    }
25
}

3.7 Operate Private Properties of a Class#

Reflection can break the encapsulation of a class and directly operate private properties. The core is to turn off access checks through Field.setAccessible(true), then assign values through Field.set(Object obj, Object value) and get values through Field.get(Object obj).

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Field;
3
public class TestReflect {
4
    // Private property
5
    private String proprety = null;
6
    public static void main(String[] args) throws Exception {
7
        Class<?> clazz = Class.forName("net.xsoftlab.baike.TestReflect");
8
        Object obj = clazz.newInstance();
9
        // Get private property
10
        Field field = clazz.getDeclaredField("proprety");
11
        // Turn off access checks and break encapsulation
12
        field.setAccessible(true);
13
        // Assign value to private property
14
        field.set(obj, "Java Reflection Mechanism");
15
        // Get the value of the private property
16
        System.out.println(field.get(obj));
17
        // Running result: Java Reflection Mechanism
18
    }
19
}

3.8 Dynamic Proxy of Reflection Mechanism#

Dynamic proxy is one of the core applications of reflection. Java’s native dynamic proxy is implemented based on java.lang.reflect.Proxy and java.lang.reflect.InvocationHandler, and only supports proxy for interfaces.

Define the target interface; 2. Implement the real class of the target interface; 3. Implement InvocationHandler and rewrite the invoke method (proxy logic); 4. Create a proxy object through Proxy.newProxyInstance.

1
package net.xsoftlab.baike;
2
import java.lang.reflect.InvocationHandler;
3
import java.lang.reflect.Method;
4
import java.lang.reflect.Proxy;
5
// 1. Define the target interface
6
interface Subject {
7
    public String say(String name, int age);
8
}
9
// 2. Implement the real class
10
class RealSubject implements Subject {
11
    public String say(String name, int age) {
12
        return name + "  " + age;
13
    }
14
}
15
// 3. Implement InvocationHandler and write proxy logic
16
class MyInvocationHandler implements InvocationHandler {
17
    private Object obj = null;
18
    // Bind the real object
19
    public Object bind(Object obj) {
20
        this.obj = obj;
21
        // 4. Create proxy object: class loader + interface array + proxy handler
22
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
23
                                      obj.getClass().getInterfaces(),
24
                                      this);
25
    }
26
    // Rewrite invoke to execute the proxy method
27
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
28
        // Execute the method of the real object
29
        Object temp = method.invoke(this.obj, args);
30
        return temp;
31
    }
32
}
33
// Test class
34
public class TestReflect {
35
    public static void main(String[] args) throws Exception {
36
        MyInvocationHandler demo = new MyInvocationHandler();
37
        Subject sub = (Subject) demo.bind(new RealSubject());
38
        String info = sub.say("Rollen", 20);
39
        System.out.println(info);
40
        // Running result: Rollen  20
41
    }
42
}

Extension: Explanation of Class Loaders#

There are three types of class loaders in Java, and dynamic proxy needs to specify the class loader of the real object:

Bootstrap ClassLoader (implemented in C++, loads JDK core classes);
Extension ClassLoader (loads extension classes under the JRE/lib/ext directory);
AppClassLoader (loads classes under ClassPath, the default class loader).

4. Practical Examples of the Reflection Mechanism#

The reflection mechanism is widely used in actual development, especially in scenarios such as framework design, dynamic configuration, and generic breakthroughs. The following are 4 classic practical cases covering high-frequency scenarios in daily development.

4.1 Break Generic Restrictions: Store String in ArrayList of Integer#

Java’s generics are compile-time syntactic sugar and will be erased at runtime. Therefore, the type restriction of generics can be broken through reflection, and the add(Object) method of ArrayList can be directly called to add objects of any type.

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Method;
3
import java.util.ArrayList;
4
public class TestReflect {
5
    public static void main(String[] args) throws Exception {
6
        // ArrayList with generic type Integer
7
        ArrayList<Integer> list = new ArrayList<Integer>();
8
        // Obtain the add method of ArrayList (parameter is Object) through reflection
9
        Method method = list.getClass().getMethod("add", Object.class);
10
        // Call the add method to add a String type object
11
        method.invoke(list, "Java Reflection Mechanism Example.");
12
        // Get and print the element
13
        System.out.println(list.get(0));
14
        // Running result: Java Reflection Mechanism Example.
15
    }
16
}

4.2 Operate Arrays Through Reflection: Obtain/Modify Array Information & Dynamically Modify Array Size#

Java reflection provides the java.lang.reflect.Array class, which is specially used for operating arrays at runtime. It supports obtaining array type, length, modifying elements, and dynamically expanding/shrinking arrays.

4.2.1 Obtain and Modify Basic Information of Arrays#

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Array;
3
public class TestReflect {
4
    public static void main(String[] args) throws Exception {
5
        int[] temp = { 1, 2, 3, 4, 5 };
6
        // Get the component type of the array (array element type)
7
        Class<?> demo = temp.getClass().getComponentType();
8
        System.out.println("Array type: " + demo.getName()); // int
9
        System.out.println("Array length: " + Array.getLength(temp)); // 5
10
        System.out.println("The first element of the array: " + Array.get(temp, 0)); // 1
11
        // Modify the element at the specified position of the array
12
        Array.set(temp, 0, 100);
13
        System.out.println("The first element of the array after modification: " + Array.get(temp, 0)); // 100
14
    }
15
}

4.2.2 Dynamically Modify Array Size#

1
package net.xsoftlab.baike;
2
import java.lang.reflect.Array;
3
public class TestReflect {
4
    public static void main(String[] args) throws Exception {
5
        int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
6
        // Expand the array to 15 bits
7
        int[] newTemp = (int[]) arrayInc(temp, 15);
8
        print(newTemp);
9
        String[] atr = { "a", "b", "c" };
10
        // Expand the string array to 8 bits
11
        String[] str1 = (String[]) arrayInc(atr, 8);
12
        print(str1);
13
    }
14
    // Universal array expansion method: supports arrays of any type
15
    public static Object arrayInc(Object obj, int len) {
16
        // Get array element type
17
        Class<?> arr = obj.getClass().getComponentType();
18
        // Create a new array of specified length
19
        Object newArr = Array.newInstance(arr, len);
20
        // Copy the content of the original array to the new array
21
        int co = Array.getLength(obj);
22
        System.arraycopy(obj, 0, newArr, 0, co);
23
        return newArr;
24
    }
25
    // Universal array printing method
26
    public static void print(Object obj) {
27
        Class<?> c = obj.getClass();
28
        if (!c.isArray()) {
29
            return;
30
        }
31
        System.out.println("Array length: " + Array.getLength(obj));
32
        for (int i = 0; i < Array.getLength(obj); i++) {
33
            System.out.print(Array.get(obj, i) + " ");
34
        }
35
        System.out.println();
36
    }
37
}

4.3 Optimize Factory Pattern with Reflection: Realize Non-intrusive Subclass Expansion#

The problem of the traditional simple factory pattern is that the factory class must be modified when adding subclasses, which violates the open-closed principle; the factory pattern implemented through reflection can dynamically add any subclass without modifying the factory class, only by passing the fully qualified name of the class.

1
package net.xsoftlab.baike;
2
// Product interface
3
interface Fruit {
4
    public abstract void eat();
5
}
6
// Specific product: Apple
7
class Apple implements Fruit {
8
    public void eat() {
9
        System.out.println("Eating apple");
10
    }
11
}
12
// Specific product: Orange
13
class Orange implements Fruit {
14
    public void eat() {
15
        System.out.println("Eating orange");
16
    }
17
}
18
// Reflection factory class: no modification required, supports any Fruit subclass
19
class Factory {
20
    public static Fruit getInstance(String className) {
21
        Fruit f = null;
22
        try {
23
            // Dynamically instantiate objects through reflection
24
            f = (Fruit) Class.forName(className).newInstance();
25
        } catch (Exception e) {
26
            e.printStackTrace();
27
        }
28
        return f;
29
    }
30
}
31
// Test class
32
public class TestReflect {
33
    public static void main(String[] args) throws Exception {
34
        // Instantiate Apple: pass the fully qualified name
35
        Fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");
36
        if (f != null) {
37
            f.eat(); // Running result: Eating apple
38
        }
39
        // When adding a new Banana subclass, you only need to implement the Fruit interface without modifying the Factory
40
        // Fruit f2 = Factory.getInstance("net.xsoftlab.baike.Banana");
41
    }
42
}

In actual development, the fully qualified name of the class can be configured in the properties configuration file, and the class name can be dynamically obtained by reading the configuration file to achieve complete dynamic configuration. The core principle of Spring’s Bean factory is based on this.

Summary#

The core of reflection is the java.lang.Class class, and all reflection operations need to obtain the Class object first;
Reflection supports dynamically operating classes/objects at runtime, and is the core technology of framework design, dynamic proxy, and generic erasure breakthrough;
Reflection can break encapsulation, but it should be used with caution (damaging class encapsulation and slightly lower performance);
Classic applications of reflection: Spring IOC/DI, MyBatis mapping, dynamic proxy (AOP), factory pattern optimization.

Reflection is a necessary foundation for Java backend development. Understanding the principle and use of reflection can help you truly understand the underlying implementation of mainstream frameworks and achieve the leap from “using frameworks” to “understanding frameworks”.