CKTIS / Java
Selecionar e invocar um construtor por reflexão
Seleciona o único construtor anotado com `@Inject` ou recorre ao construtor sem argumentos se nenhum estiver marcado. Verifica os tipos dos parâmetros e o acesso antes da invocação.
Versão: Java SE 21
Sintaxe
import java.lang.reflect.Constructor;
Constructor<?>[] candidates = type.getDeclaredConstructors();
Constructor<?> ctor = type.getDeclaredConstructor(parameterTypes); // Class<?>...; exact signature
Class<?>[] formalTypes = ctor.getParameterTypes();
boolean marked = ctor.isAnnotationPresent(Inject.class);
if (!ctor.canAccess(null)) {
ctor.setAccessible(true);
}
Object instance = ctor.newInstance(arguments); // arguments is Object[]Em Java SE 21, java.lang.reflect.Constructor<T> representa um construtor específico. Class.getDeclaredConstructors() inclui os construtores não públicos e não garante qualquer ordem; Class.getConstructors() devolve apenas os públicos. Seleciona o único construtor marcado com @Inject. Se houver vários, assinala a ambiguidade em vez de escolher o primeiro. Se não houver nenhum marcado, usa Class.getDeclaredConstructor(); se não existir um construtor sem argumentos, é lançada NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) verifica se o próprio construtor, e não os seus parâmetros, tem a anotação indicada, visível em tempo de execução. O exemplo define o seu próprio marcador @Inject com RetentionPolicy.RUNTIME; a anotação não fornece dependências. Constructor.getParameterTypes() devolve um Class<?>[] pela ordem de declaração, vazio se não houver parâmetros. Contém os tipos após o apagamento de tipos, não os valores dos argumentos nem os pormenores dos tipos genéricos. A pesquisa com getDeclaredConstructor(...) exige tipos exatos: para int, usa int.class, não Integer.class.
Constructor.setAccessible(true) desativa as verificações de acesso da linguagem Java para esse objeto de reflexão, sem alterar os modificadores do construtor. Verifica primeiro canAccess(null). Para um construtor privado noutro módulo, o pacote tem de estar aberto ao módulo que faz a chamada; exportá-lo não é suficiente. Se as regras de acesso entre módulos impedirem a desativação das verificações, setAccessible(true) lança InaccessibleObjectException, ao passo que trySetAccessible() devolve false. Um gestor de segurança pode recusar qualquer uma das chamadas com SecurityException. Independentemente do gestor de segurança, setAccessible(true) lança SecurityException para um construtor de java.lang.Class, mesmo que o pacote esteja aberto. Para um construtor dessa classe, trySetAccessible() devolve false, a menos que um gestor de segurança recuse o pedido. setAccessible(false) repõe as verificações para esse objeto.
Constructor.newInstance(Object...) invoca o construtor já selecionado e devolve uma nova instância; não escolhe entre sobrecargas. Passa os argumentos pela ordem dos parâmetros. São permitidos o unboxing e o alargamento de tipos primitivos, mas não o estreitamento. Para um parâmetro varargs do construtor, passa um único array como último argumento: coloca-o num Object[] exterior ou converte-o em Object com um cast, para que a chamada por reflexão não trate os seus elementos como argumentos separados. Para uma classe interna declarada num contexto não estático, passa primeiro a instância envolvente.
IllegalArgumentException pode indicar um número incorreto de argumentos ou tipos incompatíveis. IllegalAccessException indica que a invocação foi recusada com as verificações ativas, e InstantiationException indica uma tentativa de instanciar uma classe abstrata. Uma exceção lançada pelo construtor é encapsulada em InvocationTargetException; consulta getCause(). Uma falha no construtor selecionado não é motivo para recorrer ao construtor sem argumentos.
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.Constructor;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
@interface Inject {}
public class Main {
static <T> T create(Class<T> type) throws ReflectiveOperationException {
Constructor<?> selected = null;
for (Constructor<?> candidate : type.getDeclaredConstructors()) {
if (candidate.isAnnotationPresent(Inject.class)) {
if (selected != null) {
throw new IllegalArgumentException("Multiple @Inject constructors");
}
selected = candidate;
}
}
if (selected == null) {
selected = type.getDeclaredConstructor();
}
Class<?>[] parameters = selected.getParameterTypes();
Object[] arguments;
if (parameters.length == 0) {
arguments = new Object[0];
} else if (parameters.length == 1 && parameters[0] == String.class) {
arguments = new Object[] {"config"};
} else {
throw new IllegalArgumentException("Unsupported constructor signature");
}
if (!selected.canAccess(null)) {
selected.setAccessible(true);
}
return type.cast(selected.newInstance(arguments));
}
public static void main(String[] args) throws ReflectiveOperationException {
System.out.println(create(Service.class).name);
System.out.println(create(Fallback.class).name);
}
}
final class Service {
final String name;
Service() {
this("no-arg");
}
@Inject
private Service(String name) {
this.name = name;
}
}
final class Fallback {
final String name;
Fallback() {
name = "no-arg";
}
}Resultado
config no-arg
`Service` usa o construtor privado anotado com `@Inject`, embora também tenha um sem argumentos. `Fallback` não tem o marcador e usa o construtor sem argumentos. O exemplo passa `"config"` apenas para a assinatura com um único parâmetro `String`.
Lições relacionadas
- Java · Lição 59 · Avançado · Versão: 2