Uma breve discussão sobre a reflexão e proxy de Java

O mecanismo de reflexão de Java e o proxy dinâmico tornam o Java mais poderoso. Os principais conceitos da Spring IOC e AOP são implementados por meio do mecanismo de reflexão e proxy dinâmico.

1 Reflexão Java

Exemplo:

 Usuário do usuário = new User (); User.SetTime5Flag ("Test"); Classe <?> Cls = classe.ForName ("com.test.user"); // A interface deve ser pública, independentemente de ser usado internamente nesta classe! Use cls.getDecLaredMethod () ou Traverse para modificar o método de acessibilidade Método = cls.getMethod ("gettime5flag"); String res1 = (string) métod.invoke (usuário); System.out.println (res1); // Se você envolver tipos básicos como int, use int.class! Integer.class! = Int.class! método = cls.getMethod ("setTime5flag", string.class); método.invoke (usuário, "rollen"); método = cls.getMethod ("gettime5flag"); String res2 = (string) method.invoke (user); system.out.println (res2);

Obtenha o pacote completo e o nome da classe através de um objeto:

 user.getClass (). getName (); // Classe de caminho completo Nome User.getClass (). getSImplename (); // Nome da classe sem nome

Obtenha aula:

 Class.ForName ("com.test.user"); com.test.user.class; user.getclass ();

Instanciar um objeto através da classe

 Usuário do usuário = (usuário) cls.newInstance (); // deve haver um construtor de parâmetro

Obtenha todos os construtores

 Construtor <?> CONS [] = cls.getConstructors (); // retorna contras [0] .NewInstance () em ordem de declaração; // Nenhuma declaração de exibição, então há um construtor padrão

Ter todas as interfaces implementadas por uma classe

 Classe <?> INTES [] = cls.getInterfaces ();

Obtenha a classe pai

 cls.getsuperclass ();

Obtenha o modificador

 int mo = cls.getModifiers (); int mo = contras [0] .getModifiers (); int mo = métod.getModifiers (); modifier.toString (mo);

Obtenha parâmetros do método

 métod.getParameters (); contras [0] .getParameters ();

Get Método Tipo de parâmetro

 Method.getParameTortypes (); contras [0] .getParameTortypes ();

Ter todos os tipos de exceção jogados pela declaração do método

 Method.GetexceptionTypes ();

Obtenha todas as propriedades declaradas nesta classe

 Campo [] campo = cls.getDecLaredFields (); // inclui privatefield [0] .getModifiers (); campo [0] .getType ();

Obtenha todos os atributos públicos desta classe, incluindo declaração de classe pai, declaração de interface e todos os atributos públicos dessa declaração de classe

 cls.getfields ();

Defina o atributo especificado para o acesso

 field.setAccessible (true); field.set (obj, 'ces'); field.get (obj);

* A diferença entre getfields () e getDecLaredFields (): getfields () pode acessar apenas campos declarados como públicos na classe. Ele não pode acessar campos privados e pode acessar campos públicos herdados de outras classes. getDecLaredFields () pode acessar todos os campos da classe, que não tem nada a ver com público, privado e proteger, mas não pode acessar os campos herdados de outras classes.

* A diferença entre getMethods () e getDecLaredMethods (): getMethods () pode acessar apenas métodos declarados como públicos na classe, e métodos privados não podem ser acessados ​​e podem acessar métodos públicos herdados de outras classes; getDecLaredMethods () pode acessar todos os campos da classe, que não tem nada a ver com público, privado e proteger, e não pode acessar métodos herdados de outras classes.

* A diferença entre getConstructors () e getDecLaredConstructors (): getConstructors () pode acessar apenas construtores declarados como públicos na classe; getDecLaredConstructors () pode acessar todos os construtores da classe e não tem nada a ver com público, privado e proteger.

Obtenha e modifique as informações da matriz através da reflexão

 int [] temp = {1,2,3,4,5}; classe <?> Demo = temp.getclass (). getComponentType (); system.out.println ("Array Type:"+Demo.getName ()); "+Array.getLength (temp)); // 5system.out.println (" O primeiro elemento da matriz: "+Array.get (temp, 0)); // 1array.set (temp, 0, 100); system.out.println (" O primeiro elemento da matriz após a modificação é: "+Array.get.get.

Obtenha o tipo de matriz

 cls.getComponentType ();

Determinar se é um tipo de matriz

 cls.isarray ();

2 Java Agent

O modelo proxy é um modelo de design Java comumente usado. Sua característica é que a classe de proxy e a classe Delegate tenham a mesma interface. A classe de proxy é principalmente responsável por pré -processamento de mensagens, filtrar mensagens, encaminhar mensagens para a classe Delegate e processando mensagens após o evento. Geralmente, existe uma associação entre a classe proxy e a classe Delegate. O objeto de uma classe de proxy está associado ao objeto de uma classe delegada. O objeto da classe de proxy em si não implementa realmente o serviço, mas fornece serviços específicos chamando os métodos relevantes do objeto de classe Delegate.

De acordo com o período da criação do agente, as classes dos agentes podem ser divididas em dois tipos.

• Proxy estático: criado por programadores ou gera automaticamente o código -fonte por ferramentas específicas e o compila. Antes da execução do programa, já existe o arquivo .class da classe proxy.

• Proxy dinâmico: quando o programa está em execução, o bytecode é gerado dinamicamente pelo mecanismo de reflexão Java.

2.1 Proxy estático

 contagem pública de interface {public void QueryCount ();} classe pública CountImpl implementa contagem {public void queryCount () {System.out.println ("Exibir o método da conta ..."); }} // Classe de proxy Classe public CountProxy implementa a contagem {private contouMPL CountImpl; public CountProxy (CountImpl countImpl) {this.CountImpl = CountImpl; } @Override public void queryCount () {System.out.println ("Antes do processamento da transação"); condimpl.QueryCount (); // Ligue para o método da classe Delegate; System.out.println ("Após o processamento da transação"); }} // classe de teste classe public TestCount {public static void main (string [] args) {countImpl countImpl = new countImpl (); Contagemproxy countProxy = new countProxy (condouMPL); CountProxy.QueryCount (); }}

Observe o código e constate que cada classe de proxy pode servir apenas uma interface, para que muitos proxy ocorram inevitavelmente no desenvolvimento do programa. Além disso, todas as operações de procuração, exceto pelos diferentes métodos de chamada, todas as outras operações são as mesmas, portanto o código deve ser repetido neste momento. A melhor maneira de resolver esse problema é concluir todas as funções de proxy por meio de uma classe proxy, para que isso seja feito usando proxy dinâmico no momento.

2.2 Agente dinâmico

O bytecode da classe dinâmica de proxy é gerado dinamicamente pelo mecanismo de reflexão Java quando o programa é executado, sem a necessidade de os programadores escreverem seu código -fonte manualmente. As classes dinâmicas de proxy não apenas simplificam a programação, mas também melhoram a escalabilidade dos sistemas de software, porque o mecanismo de reflexão Java pode gerar qualquer tipo de classes dinâmicas de proxy.

2.2.1 proxy dinâmico JDK

A classe de proxy e as interfaces InvocationHandler no pacote java.lang.reflect fornecem a capacidade de gerar classes dinâmicas de proxy.

Interface InvocationHandler:

Public Interface InvocationHandler {
Public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso;
}

Descrição do parâmetro:

Proxy de objeto: refere -se ao objeto que está sendo procurado.
Método do método: o método a ser chamado
Objeto [] args: os parâmetros necessários ao chamar o método

Você pode pensar em uma subclasse da interface InvocationHandler como a classe de operação final de um proxy, substituindo o ProxySubject.

Classe de proxy:

A classe de proxy é uma classe de operação especializada no proxy. Ele pode gerar dinamicamente classes de implementação para uma ou mais interfaces através desta classe. Esta classe fornece os seguintes métodos de operação:

Objeto estático público NewProxyInstance (Classloader carregador, classe <?> [] interfaces, InvocationHandler h) lança ilegalArgumentException

Descrição do parâmetro:

Carregador de classe: carregador de classe
Classe <?> [] Interfaces: Obtenha todas as interfaces
InvocationHandler H: Obtenha a instância da subclasse da interface InvocationHandler

Se você deseja concluir um proxy dinâmico, primeiro precisará definir uma subclasse da interface InvocationHandler para concluir a operação específica do proxy.

 Assunto da interface {public string diz (nome da string, Int Age);} classe realSubject implementa o assunto {@Override public String diz (nome da string, int Age) {Nome de retorno + "" + Age; }} // JDK Classe de proxy dinâmico MyInvocationHandler implementa InvocationHandler {Private Object Target = null; // vincula o objeto delegado e retorna uma classe de proxy Public Object Bind (Object Target) {this. Target = Target; return proxy.newproxyInstance (Target.getClass (). getClassLoader (), Target.getClass (). getInterfaces (), this); // vincula a interface (cglib compensa isso)} @Override public Object Invoke (proxy do objeto, método do método, objeto [] args) lança arremesso {System.out.println ("antes do método!"); Objeto temp = métod.invoke (alvo, args); System.out.println ("After Method!"); retornar temp; }} classe hello {public static void main (string [] args) {myInvocationHandler Demo = new MyInvocationHandler (); Assunto sub = (sujeito) Demo.bind (novo realSubject ()); String info = sub.say ("rollen", 20); System.out.println (info); }}

No entanto, o proxy dinâmico do JDK se baseia na implementação da interface. Se algumas classes não implementarem interfaces, elas não podem usar o proxy JDK, portanto, precisam usar o proxy dinâmico do CGLIB.

2.2.2 Proxy dinâmico do CGLIB

O mecanismo dinâmico de proxy do JDK pode apenas proxy as classes que implementam interfaces, enquanto as classes que não implementam interfaces não podem implementar o proxy dinâmico do JDK.

O CGLIB implementa proxy para classes. Seu princípio é gerar uma subclasse para a classe de destino especificada e substituir o aprimoramento da implementação do método. No entanto, como a herança é usada, a classe modificada final não pode ser proxyed.

 Public Interface Bookfacade {public void addbook (); } classe pública bookfacadeImpl1 {public void addbook () {System.out.println ("Método Ordinário para adicionar livros ..."); }} importar java.lang.reflect.method; importação net.sf.cglib.proxy.enhancer; importação net.sf.cglib.proxy.methodintercept; importação net.sf.cglib.proxy.methodProxy; // Classe de proxy dinâmica CGLIB Public Classe bookfacadecGlib implementa MethodInterceptor {Private Object Target; // vincula o objeto delegado e retorna uma classe de proxy Public Object GetInstance (Object Target) {this.target = Target; Intensificador intensificador = new intensancer (); intensancer.SetSuperclass (this.target.getClass ()); // Método de retorno de chamada aprimorador.setCallback (this); // crie proxy objeto retornar intensificador.create (); } @Override // Método de retorno de chamada Public Object Intercept (object Obj, método do método, objeto [] args, MethodProxy Proxy) lança Throwable {System.out.println ("função start"); Objeto temp = proxy.invokesuper (obj, args); System.out.println ("Função de Função"); retornar temp; }} classe pública testCglib {public static void main (string [] args) {bookfacadecglib cglib = new bookfacadecGlib (); BookfacadeImpl1 bookcglib = (bookfacadeImpl1) cglib.getInstance (novo bookfacadeImpl1 ()); bookcglib.addbook (); }}

A breve discussão acima sobre a reflexão e proxy do Java é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.