The Java reflection mechanism allows dynamic operation of class members at runtime, obtain class information through Class objects, call methods and access fields, and is suitable for framework development and other scenarios. Use reflection to get the Class object first. Common methods include class names, objects and fully qualified names loading. Class.forName() is the most commonly used and supports class loading control. Then you can create objects and call methods dynamically, pay attention to parameter matching, private methods need to set setAccessible(true), and static method calls to pass null; field operations also need to obtain Field objects and set access permissions; reflection performance is low, and it is recommended to be used for initialization or cache usage in high-frequency scenarios, which is commonly found in frameworks such as Spring and Hibernate.

The Java reflection mechanism is a knowledge point that many developers cannot avoid when they advance. It allows you to dynamically obtain class information at runtime and manipulate class properties, methods, constructors, etc., which is very useful in framework development, dependency injection, annotation processing and other scenarios.

However, although the reflection is powerful, it also has a certain threshold to use, especially for students who are new to Java, it is easy to get stuck. Let’s start from several practical perspectives and talk about the basic usage of Java reflection and some precautions.

Getting Class object is the first step

To use reflection, first you need to get a Class object of a class. This is the basis of reflection, and there are several common ways:

• By class name: Class> clazz = String.class;
• Pass object: Class> clazz = obj.getClass();
• Loading through the fully qualified name of the class: Class> clazz = Class.forName("java.lang.String");

The third one is the most commonly used, especially when the class name is specified in the configuration file or annotation, which is more flexible in writing.

Note: If the class has not been loaded, Class.forName() will try to load the class and initialize it. If you do not want to trigger initialization, you can use a version with three parameters:

 Class.forName("com.example.MyClass", false, classLoader);

Dynamically create objects and call methods

After you get Class object, you can create instances, access fields, and call methods through reflection.

For example, creating an object:

 Object obj = clazz.newInstance(); // Abandoned, suitable for parameterless constructors

Or use a constructor (recommended):

 Constructor<?> constructor = clazz.getConstructor(String.class);
Object obj = constructor.newInstance("hello");

Example of calling methods:

 Method method = clazz.getMethod("methodName", paramTypes);
method.invoke(obj, params);

A few points to note here:

• The method name and parameter type must match exactly
• If the method is private, you need to use getDeclaredMethod() and cooperate with setAccessible(true)
• When calling a static method, the first parameter of invoke passes null

For example, if you want to call a private method of a certain class:

 Method privateMethod = clazz.getDeclaredMethod("secretMethod");
privateMethod.setAccessible(true);
privateMethod.invoke(instance);

Field operations and access control

In addition to methods, you can also read or modify the value of a field through reflection.

The basic steps are as follows:

1. Get field object: Field field = clazz.getDeclaredField("fieldName");
2. Set accessibility (if it is a private field): field.setAccessible(true);
3. Read or set the value:
   • Object value = field.get(instance);
   • field.set(instance, newValue);

This is especially useful for testing, serialization/deserialization tools. For example, some JSON libraries can be assigned through reflection even if the fields are private when deserialized.

But pay attention to the issue of permission control. Frequent use of setAccessible(true) may affect performance and may also pose security risks, especially in production environments.

Performance and applicable scenarios

Many people say that the reflex is slow, but it is not too exaggerated. Reflective calls are indeed slower than direct calls, as additional checks and encapsulation are involved. But in most business scenarios, this performance difference is acceptable, especially when reflections are only used in the initialization phase.

Common reflection application scenarios include:

• Framework design (such as Spring uses reflection for dependency injection)
• Annotation processor
• ORM framework (such as Hibernate maps database fields to entity classes by reflection)
• Unit testing tools (such as JUnit)

If you are using reflection in high-frequency loops, consider cacheing Method or Field objects to avoid the overhead of repeated searches.

Basically that's it. The Java reflection mechanism looks complicated, but as long as you master several core classes (Class, Method, Field, Constructor) and practice with actual scenarios, it is actually not difficult to get started. Just remember to weigh the pros and cons during use, and don’t abuse it.

The above is the detailed content of Java reflection tutorial. For more information, please follow other related articles on the PHP Chinese website!