Reflection em Java: quando o código olha para si mesmo

Vamos explorar o que é Reflections, seus usos e cuidados, e como aplicá-lo na prática.

O que é Reflection?

Normalmente, quando você escreve código em Java, precisa saber de antes com quais classes está lidando. Você chama usuario.getNome() porque sabe que existe uma classe Usuario com esse método.

Reflection quebra essa regra. Com ela, o código consegue inspecionar e manipular classes, campos, métodos e construtores em tempo de execução, mesmo que você não conheça a classe na hora de compilar, e mesmo que os membros sejam privados.

É uma ferramenta poderosa para situações dinâmicas, onde você não sabe de antes com o que vai trabalhar. Mas, como veremos mais para frente, é poder que vem com responsabilidade rs.

Onde ela aparece?

Você provavelmente já usou Reflection sem perceber, porque ela está por trás de várias ferramentas que usamos todo dia:

Frameworks e bibliotecas. O JUnit usa Reflection para encontrar e rodar seus métodos de teste automaticamente. É por isso que basta anotar um método com @Test para ele ser executado, sem você precisar registrar nada manualmente.

Conversão de objetos. Bibliotecas como Jackson e Gson transformam objetos em JSON sem conhecer suas classes. Elas recebem um objeto qualquer, olham os campos dele em tempo de execução e montam o JSON a partir disso.

Carregar coisas dinamicamente. Sistemas de plugins, por exemplo, precisam instanciar classes que só são conhecidas quando o programa já está rodando.

O ponto em comum nesses casos é sempre o mesmo: a ferramenta não sabe de antemão com qual classe vai lidar. É aí que Reflection brilha.

Na prática

Vamos fazer algo parecido com o que o Jackson faz: uma função que recebe qualquer objeto e mostra os campos dele com seus valores, sem conhecer a classe.

Imagine uma classe simples:

public class Usuario {
    private String nome = "Marcelo";
    private int idade = 27;
    private boolean ativo = true;
}

Agora a função que inspeciona qualquer objeto:

import java.lang.reflect.Field;

public class Inspetor {

    public static void descrever(Object obj) {
        Class<?> classe = obj.getClass();
        System.out.println("Tipo: " + classe.getSimpleName());

        for (Field campo : classe.getDeclaredFields()) {
            campo.setAccessible(true); // libera o acesso mesmo se o campo for privado
            try {
                Object valor = campo.get(obj);
                System.out.println(campo.getName() + " = " + valor);
            } catch (IllegalAccessException e) {
                System.out.println("Não consegui ler o campo " + campo.getName());
            }
        }
    }
}

Chamando assim:

Inspetor.descrever(new Usuario());

A saída é:

Tipo: Usuario
nome = Marcelo
idade = 27
ativo = true

Repare que o Inspetor não sabe nada sobre a classe Usuario. Ele descobre tudo na hora. Se você passar um Produto, um Pedido ou qualquer outra classe, ele funciona do mesmo jeito. Esse é o tipo de problema em que Reflection é a escolha certa: quando a estrutura do objeto é genuinamente desconhecida.

Entendendo o fluxo

1. getClass() devolve um objeto Class, que é o ponto de partida de quase tudo em Reflection.
2. getDeclaredFields() lista os campos declarados na classe.
3. setAccessible(true) libera o acesso a campos privados. Sem isso, o Java bloqueia a leitura.
4. field.get(obj) lê o valor daquele campo no objeto que passamos.

---

Ferramentas principais da classe Reflection

O pacote java.lang.reflect oferece várias classes e métodos que tornam possível manipular dinamicamente os elementos de uma classe. Aqui estão algumas das ferramentas mais importantes:

Class: O ponto de partida

A classe Class é usada para obter informações e manipular classes. É frequentemente a porta de entrada para outras operações de Reflection.

Métodos úteis:

getDeclaredFields(): Retorna todos os campos declarados na classe.
getDeclaredMethods(): Retorna todos os métodos declarados na classe.
getDeclaredConstructors(): Retorna todos os construtores declarados na classe.
getSuperclass(): Obtém a superclasse da classe.
getInterfaces(): Retorna as interfaces implementadas pela classe.

---

Os cuidados

Reflection é útil, mas mexe em garantias que o Java normalmente oferece. Por isso, alguns pontos de atenção:

Quebra o encapsulamento. Você consegue acessar campos e métodos privados, ignorando os modificadores de acesso. Aquele private que protegia o campo deixa de proteger.

Os erros aparecem só ao rodar. Em código normal, se você erra o nome de um método, o compilador avisa na hora. Com Reflection, esses erros só aparecem em tempo de execução, o que torna bugs mais difíceis de pegar.

Tem custo de desempenho. Chamadas via Reflection são mais lentas que chamadas normais. Na maioria dos casos isso é irrelevante, mas em código que roda milhões de vezes pode pesar.

A regra prática é simples: antes de usar Reflection, pergunte se não existe um jeito mais direto de resolver. Muitas vezes uma interface, um Map ou um pouco de polimorfismo resolvem o problema sem abrir mão das garantias da linguagem. Reflection é ótima quando você realmente não tem como saber a estrutura de antemão, e é uma má ideia quando você está só contornando uma modelagem que poderia ser mais simples.

Conclusão

Reflection é uma ferramenta poderosa que permite ao código se inspecionar e se manipular em tempo de execução. É o que dá flexibilidade para frameworks, bibliotecas de serialização e sistemas de plugins funcionarem de forma genérica.

Mas esse poder tem um preço: ela abre mão de garantias importantes que o compilador normalmente oferece. Entender quando ela é a ferramenta certa, e principalmente quando não é, é o que faz a diferença para usá-la bem.