Java - método chamarMetodo() - método utilitário para chamar um método qualquer dinamicamente em Java via Reflection
Oi pessoal,
Hoje vou mostrar um método utilitário para chamar um método qualquer dinamicamente em Java via Reflection:
/**
* Chama um método dinamicamente (via Reflection).
*
* @param classeExecutora - A Classe onde está o método a ser chamado.
* @param objetoExecutor - Uma instância da classeExecutora que irá executar o método. Se o
* método a ser chamado for um método static, neste parâmetro deve vir null.
* @param nomeMetodo - O nome do método a ser chamado.
* @param arrayClassesParametros - Um array com as Classes dos parâmetros do método a ser
* chamado.
* @param arrayObjetosParametros - Um array com as instâncias (os valores) dos parâmetros do
* método a ser chamado.
* @return Object - o retorno do método desejado (se o mesmo tiver algum retorno, senão
* retorna null)
*/
@SuppressWarnings("unchecked")
public static Object chamarMetodo(Class classeExecutora, Object objetoExecutor,
String nomeMetodo, Class[] arrayClassesParametros, Object[] arrayObjetosParametros) {
if (nomeMetodo == null || "".equals(nomeMetodo.trim())) {
throw new RuntimeException(
"chamarMetodo() - O nome do método que deveria ser chamado está vazio.");
}
if (arrayClassesParametros == null) {
// se o araryClassesParametros estah null, cria um array vazio
arrayClassesParametros = new Class[] {};
}
if (arrayObjetosParametros == null) {
// se o arrayObjetosParametros estah null, cria um array vazio
arrayObjetosParametros = new Object[] {};
}
Object retorno = null;
// vai chamar o método desejado
Method metodo;
try {
metodo = classeExecutora.getMethod(nomeMetodo, arrayClassesParametros);
} catch (NullPointerException e) {
throw new RuntimeException(
"chamarMetodo() - A classeExecutora (a classe que deveria chamar " +
"o método desejado) está nula. Error: " + e);
} catch (NoSuchMethodException e) {
throw new RuntimeException("chamarMetodo() - O método chamado (" +
classeExecutora.getName() + "." + nomeMetodo + "()" +
") não foi encontrado. Error: " + e);
}
try {
retorno = metodo.invoke(objetoExecutor, arrayObjetosParametros);
} catch (InvocationTargetException e) {
throw new RuntimeException(
"chamarMetodo() - Erro desconhecido ao chamar o método \"" +
nomeMetodo + "\" com os parâmetros \"" + arrayObjetosParametros +
"\".\n\nExceção gerada: " + e + " ##### Target do Erro: " +
e.getTargetException());
} catch (IllegalAccessException e) {
throw new RuntimeException(
"chamarMetodo() - Erro desconhecido ao chamar o método \"" +
nomeMetodo + "\" com os parâmetros \"" + arrayObjetosParametros +
"\".\n\nExceção gerada: " + e);
}
return retorno;
}
Com este método, fica muito mais fácil chamar um método qualquer via Reflection. Veja como funciona com os exemplos abaixo:
1 - Digamos que eu tenho uma classe MeuTeste com o seguinte método:
public Map testando(String nome, TesteVO testeVO);
Para chamar o método, fazemos o seguinte:
MeuTeste meuTeste = new MeuTeste();
TesteVO testeVO = new TesteVO();
Map mapaRetorno = (Map)chamarMetodo(MeuTeste.class, meuTeste, "testando", new Class[] { String.class, TesteVO.class }, new Object[] { "Rodison", testeVO });
Dessa forma, o método será chamado via Reflection.
Chamar um método desta forma permite muitas possibilidades, principalmente se você está fazendo métodos utilitários que poderão ser reutilizados em N projetos para automatizar trechos de código.
Vamos para o segundo exemplo.
2 - Vamos chamar a mesma função mas sem parâmetros:
public Map testando2();
Para chamar o método, fazemos o seguinte:
MeuTeste meuTeste = new MeuTeste();
Map mapaRetorno = (Map)chamarMetodo(MeuTeste.class, meuTeste, "testando2", null, null);
3 - Chamando um método void:
public void testando3();
Para chamar o método, fazemos o seguinte:
MeuTeste meuTeste = new MeuTeste();
chamarMetodo(MeuTeste.class, meuTeste, "testando3", null, null);
4 - Chamando um método estático:
public static RetornoVO testandoEstatico(String texto);
Para chamar o método, fazemos o seguinte:
RetornoVO retornoVO = (RetornoVO)chamarMetodo(MeuTeste.class, null, "testandoEstatico", new Class[] {String.class}, new Object[] {"texto qualquer"});
Para chamar um método estático repare que o segundo argumento do chamarMetodo deve ser null (pois um método estácio é chamado diretamente sem precisar a classe do método).
Bem, é isso. Mais uma funçãozinha pra facilitar a vida da gente :)
flw,
Rodison
