Dynamicznie Utwórz obiekt w Javie z nazwy klasy i ustaw pola klasy za pomocą listy z danymi

Dynamiczne tworzenie instancji obiektów może być dość złożone, a twój scenariusz dotyka kilku aspektów:

• Konwersja wartości obiektu z String na odpowiedni typ
• Ładowanie właściwej klasy z nazwy klasy i tworzenie instancji
• przypisanie tych wartości do obiektu

[15]}dokładne omówienie każdego z tych punktów zajmowałoby cały rozdział w bez wątpienia interesującym traktowaniu Javy jako języka dynamicznego. Ale, zakładając, że nie masz czasu na poznanie tych zawiłości lub uzależnienie od jakiejś ogromnej biblioteki stron trzecich, stwórzmy coś, co zabierze cię na Twoją drogę. Proszę trzymać ręce w pojeździe przez cały czas, ponieważ jazda będzie wyboista.

Zajmijmy się najpierw kwestią konwersji typów. Wartości są dostarczane jako Strings, ale obiekt będzie je przechowywać jako double, long, int, itd. Więc potrzebujemy funkcji, która parsuje String do odpowiedniego celu "type": "content"]}

static Object convert(Class<?> target, String s) {
    if (target == Object.class || target == String.class || s == null) {
        return s;
    }
    if (target == Character.class || target == char.class) {
        return s.charAt(0);
    }
    if (target == Byte.class || target == byte.class) {
        return Byte.parseByte(s);
    }
    if (target == Short.class || target == short.class) {
        return Short.parseShort(s);
    }
    if (target == Integer.class || target == int.class) {
        return Integer.parseInt(s);
    }
    if (target == Long.class || target == long.class) {
        return Long.parseLong(s);
    }
    if (target == Float.class || target == float.class) {
        return Float.parseFloat(s);
    }
    if (target == Double.class || target == double.class) {
        return Double.parseDouble(s);
    }
    if (target == Boolean.class || target == boolean.class) {
        return Boolean.parseBoolean(s);
    }
    throw new IllegalArgumentException("Don't know how to convert to " + target);
}

Ugh. To jest brzydkie i obsługuje tylko typy wewnętrzne. Ale nie szukamy tu doskonałości, prawda? Więc proszę poprawić odpowiednio. Zauważ, że konwersja z String na inny typ jest w rzeczywistości formą deserializacji, więc nakładasz ograniczenia na swoich klientów (ktokolwiek daje ci Strings), aby dostarczyć ich wartości w określonych formatach. W tym przypadku formaty są definiowane przez zachowanie metod parse. Ćwiczenie 1: w pewnym momencie w w przyszłości zmień format w sposób niezgodny Wstecz, aby wywołać czyjś gniew.

Teraz zróbmy rzeczywistą instancję:

static Object instantiate(List<String> args, String className) throws Exception {
    // Load the class.
    Class<?> clazz = Class.forName(className);

    // Search for an "appropriate" constructor.
    for (Constructor<?> ctor : clazz.getConstructors()) {
        Class<?>[] paramTypes = ctor.getParameterTypes();

        // If the arity matches, let's use it.
        if (args.size() == paramTypes.length) {

            // Convert the String arguments into the parameters' types.
            Object[] convertedArgs = new Object[args.size()];
            for (int i = 0; i < convertedArgs.length; i++) {
                convertedArgs[i] = convert(paramTypes[i], args.get(i));
            }

            // Instantiate the object with the converted arguments.
            return ctor.newInstance(convertedArgs);
        }
    }

    throw new IllegalArgumentException("Don't know how to instantiate " + className);
}

Idziemy na skróty, ale to nie jest Kaplica Sykstyńska, którą tworzymy. Wystarczy załadować klasę i wyszukać konstruktor, którego liczba parametrów odpowiada liczbie argumentów (np. arity). Przeciążeni konstruktorzy o tej samej arytmetyce? Nie, Nie zadziała. Varargs? Nie, Nie zadziała. Konstruktorzy niepubliczni? Nie, Nie zadziała. A jeśli nie możesz zagwarantować, że twoja klasa dostarczy konstruktor, który ustawia wszystkie pola tak, jak robi to twój przykład TempStruct, to kończę z tym dniem i napiję się piwa, ponieważ takie podejście jest DOA.

Gdy znajdziemy konstruktor, wykonaj pętlę nad argami String, Aby przekonwertować je na typy oczekiwane przez konstruktor. Zakładając, że to działa, wywołujemy konstruktora poprzez odbicie, machamy magiczną różdżką i mówimy Abrakadabra. Voilà: masz nowy obiekt.

Let ' s spróbuj z bardzo wymyślnym przykładem:

public static void main(String[] args) throws Exception {
    TempStruct ts =
        (TempStruct)instantiate(
            Arrays.asList("373.15", "Kelvin"),
            TempStruct.class.getName());

    System.out.println(
        ts.getClass().getSimpleName() + " " +
        ts.tempValue + " " +
        ts.unitOfMeasurement);
}

Wyjście:

TempStruct 373.15 Kelvin

GLORIOUS