Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Acesso a campos por reflexão em Java

Identifica um campo anotado, consulta o seu tipo declarado e atribui-lhe uma dependência já construída, respeitando as regras de acesso de Java SE 21.

Versão: Java SE 21

Sintaxe

java.lang.reflect.Field — instance methods in Java SE 21
Class<?> getType()
boolean isAnnotationPresent(Class<? extends java.lang.annotation.Annotation> annotationClass)
void set(Object obj, Object value) throws IllegalArgumentException, IllegalAccessException
void setAccessible(boolean flag)

java.lang.reflect.Field descreve um campo, não o seu valor num objeto em particular. Class.getDeclaredFields() devolve os campos declarados na classe, incluindo os privados, mas não os herdados. Field.isAnnotationPresent(Inject.class) devolve true se a anotação de declaração @Inject estiver presente no campo. Uma anotação própria precisa de @Retention(RetentionPolicy.RUNTIME) para ser visível por reflexão. A leitura destes metadados não exige a supressão das verificações de acesso.

Field.getType() devolve o tipo declarado como Class<?>, não o tipo do valor atual. Para List<String> devolve List.class; para int, devolve int.class. Usa getGenericType() para consultar os argumentos de tipo genéricos declarados. Para injetar uma dependência num campo, determina pelo tipo o que construir, termina a construção recursiva da dependência e só depois a atribui.

Field.setAccessible(true) suprime, quando permitido, as verificações de acesso da linguagem Java para esse objeto Field; false restabelece-as. Não altera os modificadores do campo. Para aceder desta forma a um campo private a partir de outro módulo, o pacote tem de estar aberto ao módulo que faz a chamada; exports não basta. Se as verificações não puderem ser suprimidas, o método lança InaccessibleObjectException; nesse caso, trySetAccessible() devolve false. Ambos os métodos podem lançar SecurityException se um gestor de segurança ativo negar a permissão.

Field.set(obj, value) escreve o valor. Num campo de instância, obj tem de ser uma instância compatível: null provoca NullPointerException e um recetor de tipo errado provoca IllegalArgumentException. Num campo static, obj é ignorado e pode ser null. O valor deve ser compatível com o tipo do campo; para um campo primitivo, o método extrai o valor do invólucro e admite conversão de alargamento, não de estreitamento. Um valor incompatível provoca IllegalArgumentException.

IllegalAccessException é uma exceção verificada lançada na escrita quando o acesso é negado ou quando um campo final não pode ser alterado. Suprimir as verificações não permite escrever em campos static final nem em campos final de records ou classes ocultas. Evita escrever em campos final; se controlares a classe, prefere a injeção por construtor.

Exemplos

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws ReflectiveOperationException {
        System.out.println(build(Service.class).message());
    }

    private static <T> T build(Class<T> type) throws ReflectiveOperationException {
        T instance = type.getDeclaredConstructor().newInstance();
        for (Field field : type.getDeclaredFields()) {
            if (!field.isAnnotationPresent(Inject.class)) {
                continue;
            }
            Object dependency = build(field.getType());
            field.setAccessible(true);
            field.set(instance, dependency);
        }
        return instance;
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Inject {}

class Service {
    @Inject
    private Repository repository;

    String message() {
        return repository.message();
    }
}

class Repository {
    String message() {
        return "ready";
    }
}

Resultado

ready

`build` cria `Service`, deteta `@Inject` e cria `Repository` recursivamente antes de escrever no campo privado `repository`. A saída esperada é `ready`. O exemplo limita-se a classes concretas com construtores acessíveis sem argumentos; não trata ciclos nem escolhe implementações para interfaces.

Lições relacionadas

  • Java · Lição 59 · Avançado · Versão: 2

Fontes