Prefacio:
Recientemente, la compañía está experimentando un proceso de componente comercial, y la implementación de enrutamiento utiliza el mecanismo de reflexión de Java. Como se usa, quiero estudiarlo y resumirlo cuidadosamente. De hecho, ya sea la versión anterior de EventBus 2.x 2.x, la modernización o el marco de anotación temprana, utiliza el mecanismo de reflexión de Java en mayor o menor medida.
¿Cuál es el mecanismo de reflexión de Java?
El mecanismo de reflexión de Java es que en el estado en ejecución, para cualquier clase, puede conocer todas las propiedades y métodos de esta clase; Para cualquier objeto, puede llamar a cualquier método de su método adquirido dinámicamente y llamar dinámicamente el método del objeto se llama mecanismo de reflexión Java.
¿Qué funciones proporciona el mecanismo de reflexión?
Clase de mecanismo de reflexión de Java:
java.lang.class; // clase java.lang.reflect.constructor; // Método del constructor java.lang.reflect.field; // variable de miembro de clase java.lang.reflect.method; // Método de clase java.lang.reflect.modifier; // Acceder a permisos
Implementación del mecanismo de reflexión de Java:
1.) Obtener objeto de clase
// El primer método es usar el método de getClass de objeto persona persona = nueva persona (); class <?> Class1 = persona.getClass (); // El segundo método es usar el atributo de clase class1 = persona.class; try {// El tercer método es usar el método estático de la clase de clase - FORNAM (ClassNotFoundException e) {E.PrintStackTrace2.) Obtenga la información resumida del objeto de clase
boolean isPrimitive = class1.isPrimitive (); // juzga si es el tipo básico boolean isArray = class1.isArray (); // juzga si es una clase de colección boolean isannotation = class1.isannotation (); // juzga si es una clase de anotación boolean isinterface = class1.isinterface (); // class1.iseNum (); // juzga si es una clase enum boolean isanonymousClass = class1.isanonyMousClass (); // juzga si es una clase anónima boolean boolean isannotationPresent = class1.isannotationPresent (despreciado.class); // Juez si está modificado por un cierto class de clases anotado className = class1.get (); Contiene la ruta de nombre del paquete paquete apackage = class1.getPackage (); // Obtener información de paquete de clases String simplename = class1.getSimplename (); // Obtener el nombre de clase de clase int modificadores = class1.getModifiers (); // Obtener la clase de acceso Class <?> [] declarado declarado = Class1.getDeclaredClasses (); // Inc. class1.getDeclaringClass (); // Clase externa
3.) Obtenga los atributos, métodos, constructores, etc. del objeto de clase
Campo [] allfields = class1.getDeClaredFields (); // Obtenga todos los atributos del campo de objeto de clase [] publicFields = class1.getFields (); // Obtenga el atributo público de la clase de objeto de clase {Field AgeField = class1.getDeclaredField ("Age"); // Obtener el atributo especificado de la clase Desfield Desfield) atributo de la clase} Catch (nosuchfieldException e) {E.PrintStackTrace ();} método [] métodos = class1.getDeClaredMethods (); // Obtenga todos los métodos de declaración del método de objeto de clase [] Allmethods = class1.getMethods (); // Obtenga todos los métodos de clase de clase que incluya el método de la clase de clases Class ClassClass = Class1. Class1.gets -GetscLass (); de class Object Class <?> [] interfaceClasses = class1.getInterfaces (); // Obtenga todas las interfaces de constructor de objetos de clase <?> [] allConstructors = class1.getDeClaredConductors (); // Obtenga todos los constructores de declaraciones de la clase Constructor de objetos <?> [] publicConstructors = class1.getConstructors (); // obteniendo el objeto de la clase de objeto <?> Constructor <?> Constructor = class1.getDeClaredConstructor (new class [] {String.class}); // Obtenga la declaración especificada Constructor publicConstructor = class1.getConstructor (new Class [] {}); // Obtenga la declaración de declaración especificada Public Constructor} Catch (NoSuchMethodException E) {E.PrintstAttAtTraTe ();};} anotaciones = class1.getAnnotations (); // Obtenga todas las anotaciones de la clase Annotación de objeto Annotación = class1.getAnnotation (deprecated.class); // Obtenga la anotación especificada de la clase Tipo de objeto GenericSuperClass = class1.getGenericsuperClass (); // Obtenga el tipo Todas las interfaces del objeto de clase 4.) Generación dinámica de objetos de clase
// El primer método de objeto de clase llama al método newInstance () para generar objs obj = class1.newinstance (); // El segundo método del objeto obtiene el objeto constructor correspondiente, y luego genera el constructor <?> Constructor = class1.getDeclaredConstructor (nueva clase [] {string.class}); // get el descorrador específico constructor constructor constructor constructor obj = obj = constructor.newinstance (nuevo objeto [] {"lcj"});5.) Funciones de llamadas dinámicas
Pruebe {// Genere un nuevo objeto: use el objeto de método newInStance () obj = class1.newinStance (); // juzga si el objeto es una subclase de la persona boolean isinstanceOf = obj instancia de persona; // En primer lugar, debe obtener el método correspondiente al método Método Método Método = Class1.getDeclaredMethod ("Setage", nueva clase [] {int.class}); // Llame a la función especificada y pase el método de parámetro.invoke (obj, 28); método = class1.getDeclaredMethod ("getage"); Resultado del objeto = método.invoke (obj, new class [] {});} capt (InstanciationException e) {E.PrintStackTrace ();} Catch (ilegalAccessexception e) {E.PrintStackTrace ();} Catch (nosuchMethodododeSception E.PrintStackTrace ();} 6.) Obtenga tipos genéricos a través del mecanismo de reflexión
Por ejemplo, la siguiente estructura
// People Class public class People <t> {} // La clase de persona hereda la persona de clase pública de las personas <T> extiende a las personas <string> implementa Personinterface <integer> {} // Interfaz de la persona Interfaz de interfaz pública Interfaz de persona <t> {}Obtener tipos genéricos
Persona <String> persona = nueva persona <> (); // La primera forma es usar el objeto getClass Method Class <?> Class1 = persona.getclass (); Type GenericSuperClass = class1.getGenericsuperClass (); // get typeType [] interfaceTyPes = class1.getGenericInterfaces (); // Obtenga la composición de todas las interfaces del objeto de clase getComponentType (GenericsuperClass); getComponentType (interfacetypes [0]);
GetComponentType Implementación
clase privada <?> getComponentType (tipo tipo) {class <?> ComponentType = null; if (type instanceOf parameterizedType) {// getActualTypeArGuments () Devuelve una matriz de objetos de tipo que representan los parámetros de tipo reales de este tipo. Type [] realTypearGuments = ((parameterizedType) type) .getActualTyPearGuments (); if (realTypearGuments! = null && realTypearGuments.length> 0) {componentType = (class <?>) RealTyPearGuments [0]; }} else if (type instancia de genericArrayType) {// Tipo de matriz que representa un tipo de elemento que es un tipo parametrizado o tipo variable componente componente = (class <?>) ((genicArrayType) type) .getGenericComponentType ();} else {componenteType = (class <?>) Type;} CommonentTyPeTyPe;};};} 6.) Obtenga información de anotación a través del mecanismo de reflexión
Aquí nos centramos en obtener la información de anotación del método como ejemplo
Pruebe {// En primer lugar, debe obtener el objeto de método correspondiente a este método Método del método = class1.getDeclaredMethod ("jumpptogoodsdetail", nueva clase [] {string.class, string.class}); Anotación [] anotaciones1 = método.getAnnotations (); // Obtener todo el método Información de anotación Anotación anotación1 = Method.getAnnotation (Routeruri.class); // Obtenga la información de anotación especificada ESTuías mecanografiables [] GuyevariAbles1 = Method.GetTypeparameters (); Anotación [] [] ParameterAnnotationsArray = Method.getParameterAnnotations (); // Obtener todas las anotaciones de parámetros Clase de información <?> [] ParametertyPes = Method.getParametertyPes (); // Get All Type Type Type de clase de parámetros de Parámetros <] Method.getReturnType (); // Obtenga el tipo de retorno del método int modificadores = método.getModifiers (); // Obtenga los permisos de acceso del método} Catch (nosuchmethodexception e) {e.printstacktrace ();}Escenarios de aplicación del mecanismo de reflexión:
Ventajas y desventajas del mecanismo de reflexión:
Ventajas: juicio del tipo de tiempo de ejecución, carga de clase dinámica y proxy dinámico de uso de proxy.
Desventajas: el rendimiento es un problema. La reflexión es equivalente a una serie de operaciones de explicación. Notificando a JVM sobre qué hacer, el rendimiento es mucho más lento que el código Java directo.
Resumir:
El mecanismo de reflexión de Java rara vez se usa en el desarrollo empresarial diario, pero se usa ampliamente en la construcción de algunos marcos básicos. Hoy lo resumí y aprendí brevemente, y todavía hay muchos conocimientos desconocidos que se utilizarán más tarde para complementarlo.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.