Introdução ao mecanismo de reflexão e cenários de aplicação do aprendizado de java

Prefácio:

Recentemente, a empresa está passando por um processo de componente de negócios e a implementação de roteamento usa o mecanismo de reflexão da Java. Como é usado, quero estudá -lo e resumir com cuidado. De fato, seja a versão anterior do EventBus 2.x, a retrofit ou a estrutura de anotação de visualização antecipada, ele usa o mecanismo de reflexão de Java em maior ou menor grau.

Qual é o mecanismo de reflexão Java?

O mecanismo de reflexão Java é que, no estado de corrida, para qualquer classe, você pode conhecer todas as propriedades e métodos dessa classe; Para qualquer objeto, você pode chamar qualquer método de seu método adquirido dinamicamente e dinamicamente o método do objeto é chamado de mecanismo de reflexão Java.

Que funções o mecanismo de reflexão fornece?

• Determine a classe à qual qualquer objeto pertence ao tempo de execução
• Construir objetos de qualquer classe em tempo de execução;
• Determinar as variáveis ​​e métodos de membro de qualquer classe em tempo de execução;
• Chamada de métodos de qualquer objeto em tempo de execução;
• Gerar proxy dinâmico;

Classe de mecanismo de reflexão de Java:

 java.lang.class; // classe java.lang.reflect.Constructor; // método construtor java.lang.reflect.field; // variável de membro da classe java.lang.reflect.method; // Método da classe java.lang.reflect.modifier; // Permissões de acesso

Implementação do mecanismo de reflexão de Java:
1.) Obter objeto de classe

 // O primeiro método é usar o objeto getclass métod Person = new pessoa (); classe <?> Class1 = pessoa.getclass (); // O segundo método é usar o atributo de classe Class1 = pessoa.class; tente {// O terceiro método é usar o método estático da classe de classe - forname () para implementar class1 = classe.Forname (" (ClassNotFoundException e) {E.PrintStackTrace ();}

2.) Obtenha as informações resumidas do objeto de classe

 boolean isPrimitive = Class1.isPrimitive (); // julga se é o tipo básico booleano isarray = classe1.isarray (); // julga se é uma classe de coleta booleana isannotation = class1.isannotation (); // julgamento se é uma classificação ou a classe ISINTERFAFF = Class1.isface ();); Class1.isenum (); // julga se é uma classe de enum booleana isanonymousClass = classe1.isanonymousClass (); // julga se é uma classe interna anônima/stringsn (classnatation.EnTesent = Class1. Nome do pacote Pacote de caminho apackage = classe1.getpackage (); // obtenha informações de informações do pacote de classe string simplename = classe1.getSimpleName (); // obtenha o nome da classe de classe int modificadores = classe1.getModImiers (); // obtendo classe de acesso a classe (; Class1.getDecLaringClass (); // Classe externa

3.) Obtenha os atributos, métodos, construtores, etc. do objeto de classe

 Campo [] allfields = classe1.getDecLaredFields (); // obtém todos os atributos do campo de objeto de classe [] publicfields = class1.getfields (); // obtendo o atributo público do objeto de classe (field signefield = class1.getDecLeard ("idade" // obtenha "field the fieldfield da classe do campo da classe; atributo da classe} catch (nosuchfieldException e) {e.printStackTrace ();} métodos [] métodos = classe1.getDecLaredMethods (); // obtém todos os métodos de declaração dos métodos do objeto de classe [] allmethods = classe. Class1.getSuperclass (); // Obtenha a classe pai da classe de objeto de classe <?> [] interfaceclasses = classe1.getInterfaces (); // obtendo todas as interfaces dos construtores de objeto de classe <? [] AllConstructors = Class1.GetDecLeedores (); Class1.getConstructors (); // Obtenha o objeto public Construtor Try {construtor <?> construtor = classe1.getDecLaredConstructor (nova classe [] {string.class}); // obtenha o construtor de declarações especificadas; (NoschmethodException e) {e.printStackTrace ();} anotação [] anotações = classe1.getAnnoTations (); // obtém todas as anotações da classificação de objeto de classe/classificação de classificação. TypeType [] interfacetypes = classe1.getGenericInterfaces (); // Obtenha a coleção de tipos de todas as interfaces do objeto de classe

4.) Geração dinâmica de objetos de classe

 // O primeiro método do objeto de classe chama o método newInstance () para gerar objeto obj = classe1.newInstance (); // O segundo método do objeto obtém o objeto construtor correspondente e, em seguida, gera o construtor <? construtor.newInstance (novo objeto [] {"lcj"});

5.) Funções de chamada dinamicamente

 tente {// gerar um novo objeto: use o objeto newInstance () método obj = classe1.newInstance (); // julga se o objeto é uma subclasse da pessoa booleana isinsanceof = obj instância de pessoa; // Primeiro de tudo, você precisa obter o método correspondente ao método do método do método Método = classe1.getDecLaredMethod ("setage", nova classe [] {int.class}); // Ligue para a função especificada e passe o método do parâmetro.invoke (obj, 28); método = classe1.getDecLaredMethod ("getage"); Objeto resultado = method.invoke (obj, nova classe [] {});} catch (instantiationException e) {e.printStackTrace ();} catch (ilegalAccessException E) {E.PrintStackTrace ();} Catch (NosuchModException E) {E.PrintStackTrace (); E.PrintStackTrace ();}

6.) Obtenha tipos genéricos através do mecanismo de reflexão

Por exemplo, a seguinte estrutura

 // class class public class People <t> {} // classe Pessoa Irde a classe de classe Public Pessoa <t> estende pessoas <string> implementa PersonInterface <Teger> {} // interface pública de interface PersonInterface

Obtenha tipos genéricos

 Pessoa <String> pessoa = nova pessoa <> (); // A primeira maneira é usar a classe de método getClass do objeto <?> Class1 = pessoa.getclass (); TIPE GENERICSUPERCLASS = CLASS1.GETGenericSuperclass (); // Obtenha o TypeType [] interfacetypes = Class1.getGenericInterfaces (); // Obtenha o tipo de tempo de todas as interfaces do objeto de classe getComponentType (GenricSuperclass); getComponentType (interfacetipos [0]);

implementação getComponentType

 classe privada <?> getComponentType (tipo tipo) {classe <?> componentType = null; if (type Instânciaof parameterizedtype) {// getActualTyPearguments () retorna uma matriz de objetos de tipo que representa os parâmetros de tipo real deste tipo. Tipo [] realTyPearguments = (((ParameterizedType) tipo) .getActualTyPearguments (); if (realTyPearguments! = NULL && ATALTYPEARGUMGENTS.LENGLED> 0) {componentType = (classe <?>) realTyPearguments [0]; }} else if (digite a instância de genicarytype) {// Tipo de matriz que representa um tipo de elemento que é um tipo parametrizado ou tipo variável componentType = (classe <?>) ((genicarTrayTyPe).

6.) Obtenha informações de anotação através do mecanismo de reflexão

Aqui nos concentramos em obter as informações de anotação do método como um exemplo

 tente {// Primeiro de tudo, você precisa obter o objeto Método correspondente a este método do método do método = classe1.getDecLaredMethod ("jumptogoodsDetail", nova classe [] {string.class, string.class}); Anotação [] anotações1 = method.getannotações (); // obtenha todos os métodos anotações anotações anotação1 = métod.getannotation (routeruri.class); // obtendo as informações de anotação especificadas tipariable [] typevariables1 = method.gettypePeParameters (); Anotação [] [] parameterAnnoTationArray = métod.getParameterAnnoTations (); // Obtenha todas as anotações de parâmetros classe de informação <?> [] ParameterTypes = method.getParameterTyPes (); // obtenha todos os parâmetros de classe Tipo [] genérico, allTeettyPes = MethodEgGeNeRericPeterTyPesPes; Method.getRenterType (); // Obtenha o tipo de retorno do método int modificadores = Method.getModifiers (); // Obtenha as permissões de acesso do método} catch (noschmethodException e) {e.printstacktrace ();}

Cenários de aplicação do mecanismo de reflexão:

• Código reverso, como descompilação
• Estruturas combinadas com anotações como retrofit
• Mecanismo de reflexão simples Estrutura de aplicação, como EventBus 2.x
• Estruturas de classe geradas dinamicamente, como GSON
  

Vantagens e desvantagens do mecanismo de reflexão:

Vantagens: julgamento do tipo de tempo de execução, carregamento de classe dinâmica e reflexão dinâmica de uso de proxy.

Desvantagens: o desempenho é um problema. A reflexão é equivalente a uma série de operações de explicação. Notificar a JVM sobre o que fazer, o desempenho é muito mais lento que o código Java direto.

Resumir:

O mecanismo de reflexão do Java é raramente usado no desenvolvimento diário de negócios, mas é amplamente utilizado na construção de algumas estruturas básicas. Hoje resumi e aprendi brevemente, e ainda há muito conhecimento desconhecido a ser usado posteriormente para complementá -lo.

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.