Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

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

Zdroje