CKTIS / Java
Výběr a volání konstruktoru pomocí reflexe
Vyber jediný konstruktor označený `@Inject`, nebo použij bezparametrický konstruktor, pokud žádný označený není. Před voláním ověř typy parametrů a přístup.
Verze: Java SE 21
Syntaxe
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[]V Java SE 21 reprezentuje java.lang.reflect.Constructor<T> jeden konkrétní konstruktor. Class.getDeclaredConstructors() vrací i neveřejné konstruktory a nezaručuje žádné pořadí; Class.getConstructors() vrací pouze veřejné. Vyber jediný konstruktor označený @Inject. Pokud jich je více, ohlas nejednoznačnost místo výběru prvního. Pokud není označen žádný, použij Class.getDeclaredConstructor(); neexistuje-li bezparametrický konstruktor, metoda vyvolá NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) ověřuje, zda má zadanou anotaci viditelnou za běhu samotný konstruktor, nikoli jeho parametry. Příklad definuje vlastní značku @Inject s RetentionPolicy.RUNTIME; anotace sama závislosti neposkytuje. Constructor.getParameterTypes() vrací Class<?>[] v pořadí deklarace, bez parametrů prázdné pole. Obsahuje typy po vymazání typových parametrů, nikoli hodnoty argumentů ani podrobnosti o generických typech. Vyhledání pomocí getDeclaredConstructor(...) vyžaduje přesné typy: pro int použij int.class, ne Integer.class.
Constructor.setAccessible(true) potlačí kontroly přístupu jazyka Java pro tento reflexní objekt, aniž změní modifikátory konstruktoru. Nejprve ověř canAccess(null). Pro soukromý konstruktor v jiném modulu musí být balíček otevřen volajícímu modulu; samotný export nestačí. Pokud pravidla přístupu mezi moduly nedovolují kontroly potlačit, setAccessible(true) vyvolá InaccessibleObjectException, zatímco trySetAccessible() vrátí false. Správce zabezpečení může kterékoli z těchto volání zamítnout výjimkou SecurityException. Nezávisle na správci zabezpečení vyvolá setAccessible(true) u konstruktoru třídy java.lang.Class výjimku SecurityException, i když je balíček otevřený. U takového konstruktoru vrátí trySetAccessible() hodnotu false, pokud správce zabezpečení volání nezamítne. setAccessible(false) kontroly pro tento objekt obnoví.
Constructor.newInstance(Object...) zavolá již vybraný konstruktor a vrátí novou instanci; nevybírá přetížení. Argumenty předej v pořadí parametrů. Je povoleno rozbalení obalových typů a rozšiřující převod primitivních typů, nikoli zužující převod. Pro parametr varargs konstruktoru předej jako poslední argument jediné pole: vlož je do vnějšího Object[] nebo je přetypuj na Object, aby reflexní volání nepovažovalo jeho prvky za samostatné argumenty. U vnitřní třídy deklarované v nestatickém kontextu předej nejprve instanci obklopující třídy.
IllegalArgumentException může znamenat chybný počet argumentů nebo nekompatibilní typy. IllegalAccessException znamená, že volání nepovolily aktivní kontroly přístupu, a InstantiationException značí pokus o vytvoření instance abstraktní třídy. Výjimka vyvolaná konstruktorem je zabalena do InvocationTargetException; podívej se na getCause(). Selhání vybraného konstruktoru není důvodem přejít na bezparametrický konstruktor.
Příklady
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";
}
}Výsledek
config no-arg
`Service` používá soukromý konstruktor s `@Inject`, přestože má i bezparametrický. `Fallback` nemá žádné označení, a proto používá bezparametrický konstruktor. Příklad předává `"config"` pouze pro signaturu s jediným parametrem `String`.
Související lekce
- Java · Lekce 59 · Pokročilá · Verze: 2