Reflection is one of the features of the Java program development language. It allows a running Java program to obtain its own information and access Java at runtime. Object properties, methods, constructors, etc.
Application scenarios
Develop universal frameworks - The most important use of reflection is to develop various universal frameworks. For example, Spring configures JavaBeans, Filters, etc. through XML files. In order to ensure the versatility of the framework, they may need to load different objects or classes and call different methods according to the configuration file. In this case, reflection must be used - dynamic loading at runtime is required. The loaded object. Dynamic proxy - In aspect programming (AOP), it is necessary to intercept specific methods. Usually, the dynamic proxy method is chosen. Annotation - The annotation itself only serves as a mark. It needs to use the reflection mechanism to call the annotation interpreter according to the annotation mark and execute the behavior. Without reflection, annotations are no more useful than annotations. Extensibility features - Applications can use external user-defined classes by creating extensibility object instances using their fully qualified names. Disadvantages
Performance overhead Large - The performance of reflective operations is worse than that of non-reflective operations and should be avoided in frequently called code segments in performance-sensitive applications. Breaking encapsulation - Permission checks can be ignored when calling methods through reflection, thus potentially breaking encapsulation and causing security issues. Internal Exposure - Because reflection allows code to perform operations that are illegal in non-reflected code, such as accessing private fields and methods, the use of reflection can cause unintended side effects, which can cause the code to malfunction and potentially break portability. Reflective code breaks abstractions and therefore may change behavior as the platform is upgraded. Class object
To use reflection, you first need to obtain the Class object corresponding to the class to be operated on.
The essence of reflection: at runtime, various attributes in each Java class are mapped into Java objects.
If the following code is defined:
User user = new User();
1. When the JVM loads the method and encounters new User(), the JVM will User's fully qualified name to load User.class;
2. The JVM will search for the User.class file on the local disk and load it into the JVM memory.
3. The JVM automatically creates the Class object corresponding to this class by calling the class loader, and stores it in the method area of the JVM.
Three ways to obtain Class:
(1) Use the forName static method of the Class class
Application scenarios
Developing a general framework - reflection is the most important The purpose is to develop various general frameworks. For example, Spring configures JavaBeans, Filters, etc. through XML files. In order to ensure the versatility of the framework, they may need to load different objects or classes and call different methods according to the configuration file. In this case, reflection must be used - dynamic loading at runtime is required. The loaded object. Dynamic proxy - In aspect programming (AOP), it is necessary to intercept specific methods. Usually, the dynamic proxy method is chosen. Annotation - The annotation itself only serves as a mark. It needs to use the reflection mechanism to call the annotation interpreter according to the annotation mark and execute the behavior. Without reflection, annotations are no more useful than annotations. Extensibility features - Applications can use external user-defined classes by creating extensibility object instances using their fully qualified names. Disadvantages
Performance overhead Large - The performance of reflective operations is worse than that of non-reflective operations and should be avoided in frequently called code segments in performance-sensitive applications. Breaking encapsulation - Permission checks can be ignored when calling methods through reflection, thus potentially breaking encapsulation and causing security issues. Internal Exposure - Because reflection allows code to perform operations that are illegal in non-reflected code, such as accessing private fields and methods, the use of reflection can cause unintended side effects, which can cause the code to malfunction and potentially break portability. Reflective code breaks abstractions and therefore may change behavior as the platform is upgraded. Class object
To use reflection, you first need to obtain the Class object corresponding to the class to be operated on.
The essence of reflection: at runtime, various attributes in each Java class are mapped into Java objects.
If the following code is defined:
User user = new User();
1. When the JVM loads the method and encounters new User(), the JVM will User's fully qualified name to load User.class;
2. The JVM will search for the User.class file on the local disk and load it into the JVM memory.
3. The JVM automatically creates the Class object corresponding to this class by calling the class loader, and stores it in the method area of the JVM.
Three ways to obtain Class:
(1) Use the forName static method of the Class class
(2) Call the getClass method of Object
Reflection creates instance object
Use newInstance of Class object method. Use the newInstance method of the Constructor object
The core interface and class of the java.lang.reflect package
Member interface - reflect about a single member (field or method) Or the identification information of the constructor. Field class - Provides information about a class's fields and an interface for accessing the fields of a class. Method class - Provides information about a class's methods and an interface for accessing the class's methods. Constructor class - Provides information about a class's constructor and an interface to access the class's constructor. Array class - This class provides methods to dynamically generate and access JAVA arrays. Modifier class - Provides static methods and constants to decode class and member access modifiers. Proxy class - Provides static methods to dynamically generate proxy classes and class instances.
[Recommended courses:Java related courses]
The above is the detailed content of A brief introduction to java basic reflection Reflection. For more information, please follow other related articles on the PHP Chinese website!
