Breve descrição
Sempre me preocupei com a falta de mecanismo de delegação de Java. Felizmente, tenho algum tempo recentemente e escrevi um módulo de delegação simples com reflexão para referência.
API do módulo
Classe pública Delegater () // Construção de parâmetros vazios, esta classe gerencia a instância delegada e implementa o método delegado // Adicione um delegado de método estático e retorna o ID do valor inteiro para representar a instância composta pelo método e parâmetros. Se falhar, retorne -1. public sincronizado int addFunctionDelegate (classe <?> srcclass, string métodname, objeto ... params); // Adicione um delegado de método de instância, retorne o ID do valor inteiro para representar a instância composta do método e dos parâmetros. Se falhar, retorne -1. public sincronizado int addFunctionDelegate (objeto srcobj, string métodname, objeto ... params); // exclua um método delegado da instância delegada com base no ID inteiro e retorna se é bem -sucedido sincronizado público, sincronizado compensar a instituição em que o registro); InvoKeAllMethod (); // Converte a tabela de parâmetro em parâmetro TIPO TABELA Classe privada <?> [] getParamTypes (Object [] params); // Obtenha a instância do método Private Method da classe especificada, nome do método e parâmetro TIPO TABELA MÉTODO PRIVADO GetDSTMETHOD (classe <?> SRCClass (StringName MethodName, Class <? params) // classe Delegatenode descreve uma delegação de método estática quando não está usando a construção de objetos, incluindo instâncias de método e tabelas de parâmetros. Classe Delegatenode (objeto Srcobj, Método refmethod, objeto [] params) // classe Delegatenode descreve uma delegação de método de instância ao usar a construção de objetos, incluindo instâncias de classe, instâncias de método e tabelas de parâmetros public void Invokemethod (); // A delegação do método que executa a descrição do Node é
código -fonte
importar java.lang.reflect.invocationTargeTexception; importar java.lang.reflect.method; importar java.util.hashtable;/** classe de delegater usa rtti e reflexão para implementar o mecanismo de delegate in java*@author brick***/ Variável Hashtable <Inteiro, Delegatenode> NodeTable; // Gerenciar ID e o contêiner do delegado correspondente Public delegater () {nodeTable = new Hashtable <Inteiro, Delegatenode> ();} // Adicione o método estático delegato public syncronsel, IntfunctionDelEgate (Class. {Classe <?> [] Paramtypes = getParamTypes (params); método refmethod; if ((refMethod = getdstmethod (srcclass, métodname, paramtypes))! Método delega public sincronizado int addFunctionDelegate (objeto srcobj, string métodname, objeto ... params) {class <?> [] paramtypes = getParamTypes (params); método refmethod; if ((refmethod = getdstmethod (srcobj.getclass; {Register ++; nodeTable.put (registro, new Delegatenode (srcobj, refMethod, params)); retorno registro;} else {return -1;}} // excluir um método delegado public syncronized boolean removeMethod (int registerId) {if (nodetable.containstyId); false;} // Execute o método delegado não ordenado não ordenado public Syncronized void InvoKeAllMethod () {for (Nó deLegatenode: nodetable.Values ()) {node.invokemethod (); getty}} // Convert the Parameter tabela em um parâmetro TAPLET Class <?> [] []; = nova classe <?> [params.length]; para (int i = 0; i <params.length; i ++) {paramtypes [i] = params [i] .getclass ();} retornar paramtypes;} // obtenha uma instância do método baseada em classe de classe, nome do método e tabela de parapeters), o método stractMTSTMETHOD (Classe Str [? {Resultado do método = null; tente {resultado = srcclass.getMethod (MethodName, Paramtypes); if (resultado.getReturntype ()! = Void.class) {System.out.println ("AVISO, Método:"+Metodname+"tem um valor de retorno! {System.out.println ("Não pode encontrar o método:"+MethodName+", verifique se ele existe e visível!");} Resultado de retorno;}} classe delegatenode {objeto srcobj; método refmethod; objeto [] params; public DelegEnode (Method receModod, object []; this.params = params;} public Delegatenode (objeto srcobj, método refmethod, objeto [] params) {this.srcobj = srcobj; this.RefMethod = refMethod; this.params = params;} public void InvoKemethod () {try {refMethod.invoke (srcobj, params);} catch (ilegalAccessException | ilegalArgumentException | InvocationTargeTexception e) {Systeming.println ("Método"+refMhod.Tocation.ToST.ToTexcept.Teste de módulo
classe pública Delegatertest {public void showInfo () {System.out.println ("Hello Delegate!");} public void showCustominfo (String info) {System.out.println (info);} public static void showstaticInfo () {System.out.printlnnnnnnn; ShowCustomStaticInfo (String info) {System.out.println (info);} public static void main (string [] args) {delegater delee = new Delegater (); Delegatertest Tester = new Delegatertest (); int id = deLe.addfunctionDelegate (testador, "showinfo"); dele.addfunctionDelegate (tester, "ShowCustominfo", "Custom!"); DELE.AddFunctionDelegate (delegatertest.class, "Showstaticinfo); DeLeadddFunti onDelegate(DelegaterTest.class,"showCustomStaticInfo","StaticCustom!");dele.invokeAllMethod();dele.removeMethod(ID);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Resultados da execução:
Staticcustom!
Staticdelegate!
Personalizado!
HELLODELEGATE!
----------------------
Staticcustom!
Staticdelegate!
Personalizado!
Outros assuntos
Alguns métodos públicos usam sincronizados para garantir a segurança do encadeamento das variáveis de registro, para que não cometam erros devido a vários threads.
Um aviso será emitido para delegados com valores de retorno, mas o módulo ainda aceita essas delegações, mas você não receberá o valor de retorno ao executar a delegação.
O valor máximo do delegado adicionado é o processo de tolerância a falhas após o número inteiro.MAX_VALUE-INTEGER.MIN_VALUE não é considerado (geralmente não há tantas funções que requerem delegado.
A execução delegada é desordenada e, quando os requisitos de desempenho forem necessários, tente não bloquear a função delegada, caso contrário, afetará a execução de outras funções delegadas.
Quaisquer outras perguntas podem ser postadas para discutir.
Resumir
O exposto acima é toda a explicação detalhada deste artigo sobre a implementação do Código do Mecanismo Delegado em Java por meio de reflexão. Espero que seja útil para todos. Os amigos interessados podem continuar se referindo a outros tópicos relacionados a Java neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!