Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Wybór i wywołanie konstruktora przez refleksję

Wybierz jedyny konstruktor oznaczony `@Inject` albo użyj konstruktora bezargumentowego, jeśli nie ma oznaczenia. Sprawdź typy parametrów i dostęp przed wywołaniem.

Wersja: Java SE 21

Składnia

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[]

W Java SE 21 obiekt java.lang.reflect.Constructor<T> reprezentuje jeden konkretny konstruktor. Class.getDeclaredConstructors() zwraca konstruktory zadeklarowane w klasie, również niepubliczne, w nieokreślonej kolejności; Class.getConstructors() zwraca tylko publiczne. Wybierz jedyny konstruktor z @Inject. Jeśli oznaczono kilka, zgłoś niejednoznaczność zamiast brać pierwszy. Jeśli nie oznaczono żadnego, użyj Class.getDeclaredConstructor(); brak konstruktora bezargumentowego oznacza NoSuchMethodException.

Constructor.isAnnotationPresent(Inject.class) sprawdza, czy ten konstruktor, a nie jego parametry, ma wskazaną adnotację widoczną w czasie wykonywania. Przykład definiuje własny znacznik @Inject z RetentionPolicy.RUNTIME; sama adnotacja nie dostarcza zależności. Constructor.getParameterTypes() zwraca Class<?>[] w kolejności deklaracji, pustą dla konstruktora bez parametrów. Zwraca typy po wymazaniu, nie wartości argumentów ani szczegóły generyczne. Wyszukiwanie przez getDeclaredConstructor(...) wymaga dokładnych typów, np. int.class, a nie Integer.class dla parametru int.

Constructor.setAccessible(true) wyłącza kontrole dostępu języka Java dla tego obiektu refleksji, nie zmieniając modyfikatorów konstruktora. Sprawdź najpierw canAccess(null). Dla prywatnego konstruktora w innym module pakiet musi być otwarty dla modułu wywołującego; sam eksport nie wystarcza. Gdy reguły dostępu między modułami nie pozwalają wyłączyć kontroli, setAccessible(true) zgłasza InaccessibleObjectException, a trySetAccessible() zwraca false. Menedżer bezpieczeństwa może odmówić wykonania każdej z tych operacji, zgłaszając SecurityException. Niezależnie od menedżera bezpieczeństwa, dla konstruktora klasy java.lang.Class wywołanie setAccessible(true) zgłasza SecurityException nawet wtedy, gdy pakiet jest otwarty. Dla takiego konstruktora trySetAccessible() zwraca false, o ile menedżer bezpieczeństwa nie odmówi wykonania operacji. setAccessible(false) przywraca kontrole dla tego obiektu.

Constructor.newInstance(Object...) wywołuje już wybrany konstruktor i zwraca nowy obiekt; nie dobiera przeciążenia. Podaj argumenty w kolejności parametrów. Dopuszczalne jest rozpakowanie i rozszerzenie typu prymitywnego, ale nie zawężenie. Parametr varargs konstruktora wymaga jednej tablicy jako ostatniego argumentu; umieść ją w zewnętrznej tablicy Object[] albo rzutuj na Object, aby wywołanie refleksyjne nie potraktowało jej elementów jako osobnych argumentów. Dla klasy wewnętrznej zadeklarowanej w kontekście niestatycznym pierwszym argumentem jest instancja otaczająca.

IllegalArgumentException może oznaczać złą liczbę lub niezgodne typy argumentów; IllegalAccessException oznacza niedozwolone wywołanie przy aktywnych kontrolach, a InstantiationException — próbę utworzenia instancji klasy abstrakcyjnej. Wyjątek rzucony przez konstruktor jest opakowany w InvocationTargetException; sprawdź getCause(). Błąd wybranego konstruktora nie jest powodem do przejścia na konstruktor bezargumentowy.

Przykłady

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";
    }
}

Wynik

config
no-arg

`Service` używa prywatnego konstruktora z `@Inject`, mimo że ma też bezargumentowy. `Fallback` nie ma oznaczenia, więc używa bezargumentowego. Przykład przekazuje `"config"` tylko dla sygnatury z jednym parametrem `String`.

Powiązane lekcje

  • Java · Lekcja 59 · Zaawansowany · Wersja: 2

Źródła