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

CKTIS / Java

Reflexão em Java: acesso a campos e métodos

Em Java SE 21, `Field` e `Method` permitem consultar metadados e anotações, alterar campos e invocar métodos. Encontrar um membro privado não concede acesso, e `setAccessible(true)` está sujeito às regras dos módulos.

Versão: Java SE 21

Sintaxe

Java SE 21 — java.lang.reflect
Field f = Owner.class.getDeclaredField("count");
Method m = Owner.class.getDeclaredMethod("add", int.class);
f.setAccessible(true);
m.setAccessible(true);

// Field instance methods
void setAccessible(boolean flag)
void set(Object receiver, Object value)
Object get(Object receiver)
String getName()
Class<?> getType()
void setInt(Object receiver, int value)
int getInt(Object receiver)
<T extends Annotation> T getAnnotation(Class<T> annotationType)

// Method instance methods
void setAccessible(boolean flag)
Object invoke(Object receiver, Object... args) throws IllegalAccessException, InvocationTargetException
boolean isAnnotationPresent(Class<? extends Annotation> annotationType)
String getName()

Field e Method, do pacote java.lang.reflect, representam membros de uma classe. getDeclaredField(name) procura o nome exato do campo; getDeclaredMethod(name, parameterTypes...) seleciona o método pelo nome exato e pelos tipos declarados dos parâmetros, por ordem. int.class e Integer.class selecionam sobrecargas distintas. A JVM permite que, na mesma classe, existam métodos com o mesmo nome e os mesmos tipos de parâmetros, mas com tipos de retorno diferentes. Se o tipo de retorno de um dos métodos encontrados for mais específico do que todos os outros, getDeclaredMethod seleciona esse método; caso contrário, seleciona arbitrariamente um dos métodos encontrados. Ambas as pesquisas incluem membros privados, mas não os herdados; se não houver correspondência, lançam NoSuchFieldException ou NoSuchMethodException, respetivamente. Encontrar um membro não concede acesso.

Se setAccessible(true) tiver êxito num Field ou Method, desativa as verificações de acesso da linguagem Java para esse objeto de reflexão, sem alterar o modificador do membro. setAccessible(false) repõe as verificações. Para um membro privado, é possível desativá-las dentro do mesmo módulo. Entre módulos, o pacote que declara o membro tem de estar aberto ao módulo que faz a chamada (opens); exportá-lo (exports) não basta. Se o módulo impedir a operação, setAccessible(true) lança InaccessibleObjectException, enquanto trySetAccessible() devolve false. Se um gestor de segurança instalado recusar o pedido, ambos os métodos podem lançar SecurityException.

Field.getName() devolve o nome simples do campo e getType() o seu tipo declarado como Class<?>, por exemplo int.class. get(receiver) encapsula um valor primitivo num objeto; set(receiver, value) extrai de um objeto compatível o valor a escrever num campo primitivo. getInt(receiver) devolve um int de um campo int ou de um campo primitivo cujo tipo possa ser alargado para int. setInt(receiver, value) escreve um int num campo int ou de um tipo primitivo mais amplo. Estas operações não fazem conversões de estreitamento. Desativar as verificações não permite escrever em campos static final, nem em campos final de records ou de classes ocultas.

Method.getName() devolve o nome simples do método. invoke(receiver, args...) chama o método já selecionado: extrai valores primitivos dos argumentos quando necessário e pode alargar os seus tipos. Encapsula um resultado primitivo e devolve null para void. Para ler, escrever ou invocar, passa uma instância compatível; num membro static, o recetor é ignorado e pode ser null. Um recetor null para um membro de instância provoca NullPointerException; um recetor, um valor ou uma lista de argumentos incompatíveis provocam IllegalArgumentException. Se o acesso for recusado durante a operação, ocorre IllegalAccessException. Uma exceção lançada pelo método invocado fica encapsulada em InvocationTargetException; podes obtê-la com getCause().

Field.getAnnotation(Label.class) devolve a anotação da declaração do campo ou null. Method.isAnnotationPresent(Label.class) verifica se a anotação está presente na declaração do método sem a devolver. Define o tipo da anotação com @Retention(RetentionPolicy.RUNTIME) para que fique visível por reflexão. Consultar estes metadados não exige desativar as verificações de acesso.

Exemplos

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface Label {
    String value();
}

final class Owner {
    @Label("items")
    private int count = 1;

    @Label("operation")
    private int add(int delta) {
        return count + delta;
    }
}

public class ReflectionMembersDemo {
    public static void main(String[] args) throws ReflectiveOperationException {
        Owner owner = new Owner();
        Field field = Owner.class.getDeclaredField("count");
        Method method = Owner.class.getDeclaredMethod("add", int.class);

        try {
            field.get(owner);
            throw new AssertionError("Private field was readable before override");
        } catch (IllegalAccessException expected) {
            System.out.println("field access denied");
        }
        try {
            method.invoke(owner, 5);
            throw new AssertionError("Private method was callable before override");
        } catch (IllegalAccessException expected) {
            System.out.println("method access denied");
        }

        field.setAccessible(true);
        method.setAccessible(true);

        System.out.println(field.getName() + ":" + field.getType().getName()
                + " label=" + field.getAnnotation(Label.class).value());
        field.set(owner, Integer.valueOf(7));
        System.out.println("get=" + field.get(owner));
        field.setInt(owner, 11);
        System.out.println("getInt=" + field.getInt(owner));
        System.out.println(method.getName() + " annotated="
                + method.isAnnotationPresent(Label.class));
        System.out.println("invoke=" + method.invoke(owner, 5));
    }
}

Resultado

field access denied
method access denied
count:int label=items
get=7
getInt=11
add annotated=true
invoke=16

`Owner` e `ReflectionMembersDemo` são classes distintas de nível superior no mesmo módulo. A primeira leitura e a primeira chamada são recusadas. Depois de desativar as verificações, o exemplo escreve `7` e `11`; `add(5)` devolve `16` sem alterar `count`.

Lições relacionadas

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

Fontes