[Java avanzado] aprendizaje de reflexión de dos reflexiones

1. Empezando con la reflexión

Hay tales objetos en el área de métodos llamados objetos de clase . Ellos representan todas las clases que escribimos. Cuando creamos nuevos objetos, crearemos instancias para nosotros basados en estos objetos de clase y llamaremos a sus métodos de construcción.

El mecanismo de reflexión JAVA está en estado de ejecución , para cualquier clase, puede conocer todos los atributos y métodos de esta clase ; para cualquier objeto, puede llamar a cualquiera de sus métodos y atributos; este tipo de información adquirida dinámicamente y llamadas dinámicas La función del método del objeto se denomina mecanismo de reflexión del lenguaje java.

En pocas palabras: una clase tiene múltiples componentes, como: variables miembro, métodos, métodos de construcción, etc. La reflexión es cargar la clase y analizar los diversos componentes de la clase .

El mecanismo de reflexión de Java proporciona principalmente las siguientes funciones:

Juzgue la clase a la que pertenece cualquier objeto en tiempo de ejecución;
Construya un objeto de cualquier clase en tiempo de ejecución;
Juzgue las variables miembro y los métodos de cualquier clase en tiempo de ejecución;
Llame a cualquier método de objeto en tiempo de ejecución; genere un proxy dinámico

Dos, introducción a la API de reflexión

Breve descripción: Todas las clases que escribimos serán cargadas en el área de métodos de la memoria JVM por AppClassLoader para generar un objeto de tipo Class . Todas son clases que escribiste, pero al mismo tiempo también son instancias de Class. También se llama manual de instrucciones.

La clase se llama manual del manual, nos dice cómo escribir el manual, por ejemplo, puede tener métodos, atributos, etc.

Nuestras clases son todas manuales, que explican los métodos y propiedades de una determinada cosa.

No se requieren muchas clases para la reflexión de Java, principalmente la clase java.lang.Class y las clases Field, Constructor, Method y Annotation en el paquete java.lang.reflect . Nota: La clase Class es el origen de la reflexión de Java. Para cualquier clase que desee explorar, primero debe generar un objeto Class para ella, y luego puede obtener otra información que desee a través del objeto Class .

1. El método de obtención de objetos de clase

1、使用类
Class clazz = Dog.class;

2、使用全类名
Class aClass = Class.forName("com.xinzhi.Day");

3、使用对象
Dog dog = new Dog();
Class clazz = dog.getClass();

2. Operar en objetos de clase

//获取类名字
String name = clazz.getName();
//获取类加载器
ClassLoader classLoader = clazz.getClassLoader();
//获取资源
URL resource = clazz.getResource("");
//得到父类
Class superclass = clazz.getSuperclass();
//判断一个类是不是接口，数组等等
boolean array = clazz.isArray();
boolean anInterface = clazz.isInterface();

//重点，使用class对象实例化一个对象
Object instance = clazz.newInstance();

3. Obtenga el campo y opere

Campo

(1) Obtener campos

//获取字段，只能获取公共的字段（public）
Field name = clazz.getField("type");
Field[] fields = clazz.getFields();
//能获取所有的字段包括private
Field color = clazz.getDeclaredField("color");
Field[] fields = clazz.getDeclaredFields();

System.out.println(color.getType());

(2) Obtenga los atributos del objeto

Dog dog = new Dog();
dog.setColor("red");
Class clazz = Dog.class;
Field color = clazz.getDeclaredField("color");
System.out.println(color.get(dog));

Por supuesto, si conoce el tipo, también puede utilizar los siguientes métodos,

Int i = age.getInt(dog);
xxx.getDouble(dog);
xxx.getFloat(dog);
xxx.getBoolean(dog);
xxx.getChar(dog);
//每一种基本类型都有对应方法

(3) Establecer las propiedades del objeto

Dog dog = new Dog();
dog.setColor("red");
Class clazz = Dog.class;
Field color = clazz.getDeclaredField("color");
color.set(dog,"blue");
System.out.println(dog.getColor());

Por supuesto, si conoce el tipo correspondiente, podemos hacer esto

xxx.setBoolean(dog,true);
xxx.getDouble(dog，1.2);
xxx.getFloat(dog,1.2F);
xxx.getChar(dog,'A');
//每一种基本类型包装类都有对应方法

Field color = dogClass.getDeclaredField("color");
//暴力注入
color.setAccessible(true);
color.set(dog,"red");

3. Método

(1) Cómo obtener

//根据名字和参数类型获取一个方法
Method method = clazz.getMethod("eat",String.class);
Method[] methods = clazz.getMethods();

Method eat = clazz.getDeclaredMethod("eat", String.class);
Method[] declaredMethods = clazz.getDeclaredMethods();

(2) Operación del método

Dog dog = new Dog();
dog.setColor("red");
Class clazz = Dog.class;
//获取某个方法，名字，后边是参数类型
Method method = clazz.getMethod("eat",String.class);
//拿到参数的个数
int parameterCount = method.getParameterCount();
//拿到方法的名字
String name = method.getName();
//拿到参数的类型数组
Class<?>[] parameterTypes = method.getParameterTypes();
//拿到返回值类型
Class<?> returnType = method.getReturnType();
//重点。反射调用方法，传一个实例，和参数
method.invoke(dog,"热狗");

        Class dogClass = Class.forName("com.xinzhi.Dog");
        Object dog = dogClass.newInstance();

        Method eat = dogClass.getMethod("eat");
        eat.invoke(dog);

        Method eat2 = dogClass.getMethod("eat",String.class);
        eat2.invoke(dog,"meat");

        Method eat3 = dogClass.getMethod("eat",String.class,int.class);
        eat3.invoke(dog,"meat",12);

4. Constructor

(1) Obtener y construir objetos

Constructor[] constructors = clazz.getConstructors();
Constructor constructor = clazz.getConstructor();
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
Constructor declaredConstructor = clazz.getDeclaredConstructor();


Object obj = constructor.newInstance();

5. Anotación

Nota: si no está familiarizado con las anotaciones, puede echar un vistazo primero: [Java Advanced] Reflexión Aprendizaje One-Annotations

(1) Obtenga anotaciones de métodos, campos y clases

//元注解 要加上runtime
//类上
Annotation annotation = clazz.getAnnotation(Bean.class);
Annotation[] annotations = clazz.getAnnotations();

//字段上
Annotation annotation = field.getAnnotation(Bean.class);
Annotation[] annotations = field.getAnnotations();

//方法上
Annotation annotation = method.getAnnotation(Bean.class);
Annotation[] annotations = method.getAnnotations();

Enlace: https://www.jianshu.com/p/87a2731aaf2f