리플렉션 메타데이터

import java.lang.reflect.Field;

public final class FirstReflection {
    static final class Member {
        private String name;
        private int age;
    }

    public static void main(String[] args) {
        Class<Member> type = Member.class;
        System.out.println("class=" + type.getSimpleName());

        for (Field field : type.getDeclaredFields()) {
            System.out.println(field.getName() + ": "
                    + field.getType().getSimpleName());
        }
    }
}

class=Member
name: String
age: int

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public final class OpenEveryReflectiveMember {
    static void inspectAndCall(Object target) throws Exception {
        for (Field field : target.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            System.out.println(field.get(target));
        }
        for (Method method : target.getClass().getDeclaredMethods()) {
            method.setAccessible(true);
            if (method.getParameterCount() == 0) {
                method.invoke(target);
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("compile-only access bypass counterexample");
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;

public final class ReflectionTypeExplorer {
    static final class Catalog<T extends Number> {
        public List<String> names;
        private T value;
        int[] scores;

        public Catalog() {
        }

        private Catalog(T value) {
            this.value = value;
        }

        public List<T> values(T fallback) {
            return List.of(value == null ? fallback : value);
        }
    }

    static void printType(String label, Type type) {
        System.out.println(label + " type=" + type.getTypeName());
        if (type instanceof ParameterizedType parameterized) {
            System.out.println(label + " raw=" + parameterized.getRawType());
            System.out.println(label + " args="
                    + Arrays.toString(parameterized.getActualTypeArguments()));
        }
    }

    public static void main(String[] args) throws Exception {
        Class<Catalog> type = Catalog.class;
        System.out.println("name=" + type.getName());
        System.out.println("simple=" + type.getSimpleName());
        System.out.println("modifiers="
                + Modifier.toString(type.getModifiers()));
        System.out.println("typeParameters="
                + Arrays.toString(type.getTypeParameters()));

        Field names = type.getDeclaredField("names");
        Field scores = type.getDeclaredField("scores");
        printType("names", names.getGenericType());
        System.out.println("scores array=" + scores.getType().isArray());
        System.out.println("scores component="
                + scores.getType().getComponentType());
        System.out.println("int primitive=" + int.class.isPrimitive());

        Method values = type.getDeclaredMethod("values", Number.class);
        printType("return", values.getGenericReturnType());
        printType("parameter", values.getGenericParameterTypes()[0]);

        Constructor<?>[] constructors = type.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("constructor=" + constructor);
        }

        Object list = List.of("a", "b");
        System.out.println("runtime list class=" + list.getClass());
    }
}

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Set;

public final class SafeReflectiveInvoker {
    static final class Calculator {
        public int add(int left, int right) {
            return Math.addExact(left, right);
        }

        public int divide(int left, int right) {
            if (right == 0) {
                throw new IllegalArgumentException("zero divisor");
            }
            return left / right;
        }

        private int secret() {
            return 42;
        }
    }

    sealed interface CallResult permits Success, TargetFailure, Rejected {
    }

    record Success(Object value) implements CallResult {
    }

    record TargetFailure(String type, String message) implements CallResult {
    }

    record Rejected(String reason) implements CallResult {
    }

    private static final Set<String> ALLOWED = Set.of("add", "divide");
    private static final Map<String, Method> METHODS = discover();

    static CallResult invoke(Calculator target, String name,
                             int left, int right) {
        Method method = METHODS.get(name);
        if (method == null) {
            return new Rejected("operation not allowed");
        }
        try {
            return new Success(method.invoke(target, left, right));
        } catch (InvocationTargetException wrapper) {
            Throwable cause = wrapper.getCause();
            return new TargetFailure(
                    cause.getClass().getSimpleName(),
                    cause.getMessage());
        } catch (ReflectiveOperationException error) {
            throw new IllegalStateException("validated method became unusable", error);
        }
    }

    private static Map<String, Method> discover() {
        var methods = new java.util.LinkedHashMap<String, Method>();
        for (String name : ALLOWED) {
            try {
                Method method = Calculator.class.getMethod(
                        name,
                        int.class,
                        int.class);
                methods.put(name, method);
            } catch (NoSuchMethodException error) {
                throw new ExceptionInInitializerError(error);
            }
        }
        return Map.copyOf(methods);
    }

    public static void main(String[] args) {
        var calculator = new Calculator();
        System.out.println(invoke(calculator, "add", 7, 5));
        System.out.println(invoke(calculator, "divide", 8, 0));
        System.out.println(invoke(calculator, "secret", 0, 0));
    }
}