0Pricing
Java Academy · Aula

Processamento de Anotações em Tempo de Execução

Leia anotações em tempo de execução usando reflexão para implementar lógica de validação, roteamento ou injeção.

Processamento de Anotações em Tempo de Execução é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Lendo anotações no nível da classe

Recupere anotações de uma classe usando Class.getAnnotation() (uma) ou getAnnotations() (todas). Retorna null quando a anotação está ausente.

@Service
@RequestMapping("/api")
public class UserController {}

RequestMapping rm = UserController.class.getAnnotation(RequestMapping.class);
if (rm != null) System.out.println(Arrays.toString(rm.value())); // ["/api"]

Lendo anotações de métodos

Obtenha anotações de métodos por meio de method.getAnnotation(). Percorra getDeclaredMethods() para examinar todos os métodos de uma classe.

for (Method m : UserController.class.getDeclaredMethods()) {
    GetMapping gm = m.getAnnotation(GetMapping.class);
    if (gm != null) System.out.println(m.getName() + " -> " + Arrays.toString(gm.value()));
}

Lendo anotações de campos

Anotações de campos são usadas por estruturas de validação e ORM. Percorra getDeclaredFields() e verifique cada anotação relevante.

for (Field f : User.class.getDeclaredFields()) {
    Column col = f.getAnnotation(Column.class);
    if (col != null) System.out.println(f.getName() + " -> column: " + col.name());
}

Lendo anotações de parâmetros

Anotações de parâmetros estão disponíveis por meio de method.getParameterAnnotations() — uma matriz bidimensional (uma linha por parâmetro e uma entrada por anotação).

Method m = UserController.class.getDeclaredMethod("create", UserDto.class);
Annotation[][] pa = m.getParameterAnnotations();
for (Annotation a : pa[0]) System.out.println(a.annotationType().getSimpleName()); // e.g. Valid

isAnnotationPresent

Use isAnnotationPresent(AnnotationType.class) como uma verificação rápida e segura contra null antes de ler o valor da anotação.

if (m.isAnnotationPresent(Transactional.class)) {
    beginTransaction();
    m.invoke(target, args);
    commitTransaction();
}

Criando um contêiner simples de injeção de dependências

Explore um pacote em busca de classes anotadas com @Component, instancie-as por reflexão e armazene-as em um mapa — um contêiner Spring simplificado.

Map<Class<?>, Object> beans = new HashMap<>();
for (Class<?> cls : scanPackage("com.example")) {
    if (cls.isAnnotationPresent(Component.class)) {
        beans.put(cls, cls.getDeclaredConstructor().newInstance());
    }
}

Injetando campos anotados com @Inject

Depois de construir os beans, procure campos anotados com @Inject e defina seus valores usando reflexão — imitando a injeção em campos.

for (Object bean : beans.values()) {
    for (Field f : bean.getClass().getDeclaredFields()) {
        if (f.isAnnotationPresent(Inject.class)) {
            f.setAccessible(true);
            f.set(bean, beans.get(f.getType()));
        }
    }
}

Validação em tempo de execução com valores de anotações

Leia os valores das anotações de restrição (como @Range(min=1, max=100)) e valide o valor do campo em relação a eles em tempo de execução.

for (Field f : dto.getClass().getDeclaredFields()) {
    Range range = f.getAnnotation(Range.class);
    if (range != null) {
        f.setAccessible(true);
        int val = (int) f.get(dto);
        if (val < range.min() || val > range.max())
            throw new ValidationException(f.getName() + " out of range");
    }
}

Lendo anotações repetíveis

Para anotações @Repeatable, use getAnnotationsByType() para recuperar de forma transparente todas as instâncias da anotação contêiner.

Tag[] tags = MyClass.class.getAnnotationsByType(Tag.class);
for (Tag t : tags) System.out.println(t.value());

Explorando um pacote com bibliotecas de ClassPath

A reflexão padrão do Java não consegue listar todas as classes de um pacote. Use bibliotecas como Reflections, ClassGraph ou o ClassPathScanningCandidateComponentProvider do Spring para explorar as entradas do caminho de classes.

Reflections reflections = new Reflections("com.example.service");
Set<Class<?>> services = reflections.getTypesAnnotatedWith(Service.class);
services.forEach(System.out::println);

Processamento de anotações em tempo de execução: resumo

O processamento de anotações em tempo de execução possibilita injeção de dependências, validação, roteamento e ORM. Esse trabalho ocorre durante a inicialização — processe as anotações uma vez na inicialização, armazene os resultados em cache e evite reflexão em caminhos percorridos a cada solicitação.

Verificação rápida

Qual método recupera todas as instâncias de uma anotação @Repeatable?

Recapitulação

Use getAnnotation/isAnnotationPresent para anotações individuais. Explore métodos e campos com getDeclared*. Use getAnnotationsByType para anotações repetíveis. Processe na inicialização e armazene os resultados em cache.

Perguntas Frequentes

A aula “Processamento de Anotações em Tempo de Execução” é grátis?

Sim — o texto completo de “Processamento de Anotações em Tempo de Execução” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Processamento de Anotações em Tempo de Execução”?

Leia anotações em tempo de execução usando reflexão para implementar lógica de validação, roteamento ou injeção. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Processamento de Anotações em Tempo de Execução”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definição de Anotações: Elementos e Valores Padrão
  2. Políticas de Retenção e Tipos de Destino
  3. Processamento de Anotações em Tempo de Execução
  4. Processadores de Anotações em Tempo de Compilação
← Voltar para Java Academy