1, Static load class and dynamic load class
-
Statically loaded class: new creates an object, which is a statically loaded class. All possible classes need to be loaded at compile time
-
Dynamically loading classes: loading at run time
Reflection is a mechanism for dynamically loading classes
2, Advantages and disadvantages of reflection
- Advantages: judgment of runtime type and dynamic loading of classes: it improves the flexibility of code and can modify functions without modifying the source code
- Disadvantages: there is a performance bottleneck: security checking and reflection are equivalent to a series of interpretation operations, which is slower than direct Java code
3, Understand the nature of generics through reflection
1. Generics only take effect during compilation
public class Test { public static void main(String[] args) { // 1. Verify generic erasure List list1 = new ArrayList(); List<String> list2 = new ArrayList<String>(); System.out.println(list1.getClass()==list2.getClass()); } } Copy code
Running result: true
2. Collection generics are used for type checking to avoid incorrect input
List<String> list2 = new ArrayList<String>(); list2.add("a"); list2.add(20); Copy code
Compilation error: int cannot be converted to Java lang.String
3. You can bypass the checking of generics and add different types of elements through reflection
List<String> list2 = new ArrayList<String>(); list2.add("a"); Class<?> c = list2.getClass(); Method method = c.getDeclaredMethod("add",Object.class); method.invoke(list2,20); System.out.println(list2.size()); Copy code
Operation result: 2
It can be seen that since the type checking of generics is only effective at compile time, the dynamic loading principle of reflection can bypass the checking of generics and add different types of elements to the collection
4, Application of reflection
1. Load database driver
// DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver()); Class.forName("com.mysql.cj.jdbc.Driver"); Copy code
2. Loading configuration files such as xml or properties
-
Spring loads beans through XML configuration patterns
- Load all XML or properties configuration files in the program into memory
- The Java class parses the contents of xml or properties to obtain the bytecode string and related attribute information of the corresponding entity class
- Use the reflection mechanism to obtain the Class instance of a Class according to this string
- Dynamically configure the properties of an instance
configuration file
className=com.example.reflectdemo.TestInvoke methodName=printlnState Copy code
Entity class
public class TestInvoke { private void printlnState(){ System.out.println("I am fine"); } } Copy code
Parsing profile content
// Parse the contents of xml or properties to get the bytecode string and attribute information of the corresponding entity class public static String getName(String key) throws IOException { Properties properties = new Properties(); FileInputStream in = new FileInputStream("D:\IdeaProjects\AllDemos\language-specification\src\main\resources\application.properties"); properties.load(in); in.close(); return properties.getProperty(key); } Copy code
Use reflection to obtain the Class instance of the entity Class, create the instance object of the entity Class, and call the method
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException { // Using the reflection mechanism, get the Class object from this string Class<?> c = Class.forName(getName("className")); System.out.println(c.getSimpleName()); // Acquisition method Method method = c.getDeclaredMethod(getName("methodName")); // Bypass security checks method.setAccessible(true); // Create instance object TestInvoke testInvoke = (TestInvoke)c.newInstance(); // Call method method.invoke(testInvoke); } Copy code
Operation results: