User user = new User();
user.setName("张三");

// 编译期：不知道类名、方法名、参数类型，全部来自运行期的字符串
Class<?> clazz = Class.forName(className);          // 来自配置文件或注解
Object obj = clazz.getDeclaredConstructor().newInstance();
Method m = clazz.getMethod("setName", String.class);
m.invoke(obj, "张三");                              // 运行期才做参数校验与分派

public class ClassObtainDemo {
    static class Holder {
        static { System.out.println("Holder 静态块执行"); }
        public static final String NAME = "holder";
    }

    public static void main(String[] args) throws Exception {
        // 1. 类字面量：编译期已知类型，不触发初始化
        Class<Holder> c1 = Holder.class;
        System.out.println("方式1 拿到: " + c1.getName());

        // 2. 对象.getClass()：需要已有实例，实例创建时必然已完成初始化
        Class<? extends Holder> c2 = new Holder().getClass();

        // 3. Class.forName：运行期按全限定名加载，默认触发静态初始化
        Class<?> c3 = Class.forName("ClassObtainDemo$Holder");

        System.out.println(c1 == c2 && c2 == c3);   // true，同一个 Class 对象
    }
}

public class PrimitiveClassDemo {
    public static void main(String[] args) {
        System.out.println(int.class);                 // int
        System.out.println(Integer.class);             // class java.lang.Integer
        System.out.println(Integer.TYPE);              // int  —— 等价于 int.class
        System.out.println(int.class == Integer.TYPE); // true
        System.out.println(int.class == Integer.class);// false，完全不同的两个 Class

        System.out.println(void.class);                // void
        System.out.println(int[].class.getName());     // [I
        System.out.println(String[].class.getName());  // [Ljava.lang.String;
        System.out.println(int[][].class.getName());   // [[I

        // 数组类型的 Class 可以用 Class.forName 按 JVM 内部名获取
        try {
            Class<?> arr = Class.forName("[Ljava.lang.String;");
            System.out.println(arr == String[].class); // true
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class ConstructorDemo {
    public static class User {
        private String name;
        private int age;
        public User() {}
        private User(String name, int age) { this.name = name; this.age = age; }
        @Override public String toString() { return name + ":" + age; }
    }

    public static void main(String[] args) throws Exception {
        Class<User> c = User.class;

        // getConstructor 只能拿 public 构造；getDeclaredConstructor 可以拿任意修饰符
        Constructor<User> pub = c.getConstructor();
        Constructor<User> priv = c.getDeclaredConstructor(String.class, int.class);
        priv.setAccessible(true);   // 暴力访问，突破 private

        User u1 = pub.newInstance();
        User u2 = priv.newInstance("李四", 20);
        System.out.println(u2);                     // 李四:20

        // Class.newInstance() 自 JDK 9 起已废弃：它只调无参构造，且会吞掉受检异常
        // User u3 = c.newInstance();               // Deprecated，不要用
    }
}

public class FieldDemo {
    public static class Account {
        private String owner = "默认";
        private static int total = 0;
        private final String id = "A001";   // final 实例字段
        public static final String TYPE = "ACCOUNT";
    }

    public static void main(String[] args) throws Exception {
        Class<Account> c = Account.class;
        Account a = new Account();

        // 1. 读写 private 实例字段
        Field owner = c.getDeclaredField("owner");
        owner.setAccessible(true);
        System.out.println(owner.get(a));           // 默认
        owner.set(a, "王五");
        System.out.println(owner.get(a));           // 王五

        // 2. 静态字段：get/set 的对象参数传 null
        Field total = c.getDeclaredField("total");
        total.setAccessible(true);
        total.set(null, 100);
        System.out.println(total.get(null));        // 100

        // 3. 基本类型字段可以用 setInt/getInt 避免装箱
        System.out.println(total.getInt(null));     // 100

        // 4. final 字段：JDK 8~11 对实例 final 字段 setAccessible(true) 后通常可改，
        //    但读取方可能已被 JIT 常量折叠，读到旧值；JDK 12+ 对静态 final、
        //    record / hidden class 的 trusted final 字段一律拒绝。
        Field id = c.getDeclaredField("id");
        id.setAccessible(true);
        id.set(a, "A002");
        System.out.println(a.id);                   // 很可能仍是 A001（常量折叠）
    }
}

public class MethodDemo {
    public static class Calc {
        public int add(int a, int b) { return a + b; }
        private String join(String sep, String... parts) { return String.join(sep, parts); }
        public static void ping() { System.out.println("pong"); }
    }

    public static void main(String[] args) throws Exception {
        Class<Calc> c = Calc.class;
        Calc calc = new Calc();

        // 1. 参数类型必须精确匹配：getMethod 只找 public（含继承），getDeclaredMethod 找本类全部
        Method add = c.getMethod("add", int.class, int.class);
        Object r = add.invoke(calc, 1, 2);
        System.out.println(r);                       // 3，基本类型被自动装箱成 Integer

        // 2. 可变参数：字节码层面就是数组，参数类型写数组类型
        Method join = c.getDeclaredMethod("join", String.class, String[].class);
        join.setAccessible(true);
        // 关键：可变参数必须再包一层 Object[]，否则会被展开成三个参数
        System.out.println(join.invoke(calc, new Object[]{"-", new String[]{"a", "b", "c"}}));

        // 3. 静态方法：invoke 的第一个参数传 null
        Method ping = c.getMethod("ping");
        ping.invoke(null);

        // 4. 目标方法抛出的异常会被包装
        try {
            c.getMethod("add", int.class, int.class).invoke(calc, "x", 2);
        } catch (InvocationTargetException e) {
            System.out.println("真实异常: " + e.getCause());
        } catch (IllegalArgumentException e) {
            System.out.println("参数类型不匹配: " + e.getMessage());
        }
    }
}

import java.lang.reflect.Array;

public class ArrayReflectDemo {
    public static void main(String[] args) {
        // 动态创建 int[5]
        Object arr = Array.newInstance(int.class, 5);
        Array.setInt(arr, 0, 42);
        System.out.println(Array.getInt(arr, 0));        // 42
        System.out.println(Array.getLength(arr));        // 5

        // 动态创建二维数组 String[3][4]：两步构造
        Object matrix = Array.newInstance(String[].class, 3);
        for (int i = 0; i < 3; i++) {
            Object row = Array.newInstance(String.class, 4);
            Array.set(matrix, i, row);
        }
        Array.set(Array.get(matrix, 1), 2, "hello");
        System.out.println(((String[][]) matrix)[1][2]); // hello

        // 通用工具：任意数组转字符串（注意区分基本类型数组与对象数组）
        System.out.println(describe(new int[]{1, 2, 3}));
        System.out.println(describe(new String[]{"a", "b"}));
    }

    static String describe(Object o) {
        Class<?> c = o.getClass();
        if (!c.isArray()) return String.valueOf(o);
        int len = Array.getLength(o);
        StringBuilder sb = new StringBuilder(c.getComponentType().getSimpleName())
                .append('[').append(len).append("]{");
        for (int i = 0; i < len; i++) {
            if (i > 0) sb.append(", ");
            sb.append(Array.get(o, i));
        }
        return sb.append('}').toString();
    }
}

import java.lang.reflect.*;
import java.util.*;

public class GenericDemo {
    static class Repo<T> {
        public Map<String, List<T>> findAll() { return null; }
        public T[] toArray() { return null; }
        public void save(List<? extends Number> nums) {}
    }

    static void printType(Type t, String label) {
        System.out.print(label + " -> " + t.getTypeName() + "  |  ");
        if (t instanceof ParameterizedType) {
            ParameterizedType p = (ParameterizedType) t;
            System.out.println("raw=" + p.getRawType().getSimpleName()
                    + ", actualArgs=" + Arrays.toString(p.getActualTypeArguments())
                    + ", owner=" + p.getOwnerType());
        } else if (t instanceof GenericArrayType) {
            System.out.println("数组元素类型=" + ((GenericArrayType) t).getGenericComponentType());
        } else if (t instanceof TypeVariable) {
            TypeVariable<?> v = (TypeVariable<?>) t;
            System.out.println("类型变量 " + v.getName()
                    + ", 上界=" + Arrays.toString(v.getBounds())
                    + ", 声明者=" + v.getGenericDeclaration());
        } else if (t instanceof WildcardType) {
            WildcardType w = (WildcardType) t;
            System.out.println("通配符 上界=" + Arrays.toString(w.getUpperBounds())
                    + ", 下界=" + Arrays.toString(w.getLowerBounds()));
        } else {
            System.out.println("普通 Class");
        }
    }

    public static void main(String[] args) throws Exception {
        printType(Repo.class.getMethod("findAll").getGenericReturnType(), "findAll 返回值");
        printType(Repo.class.getMethod("toArray").getGenericReturnType(), "toArray 返回值");
        printType(Repo.class.getMethod("save", List.class)
                .getGenericParameterTypes()[0], "save 参数");
        // 父类的真实泛型参数：MyBatis 的 Mapper 解析就靠这一招
        printType(Repo.class.getTypeParameters()[0], "类上的类型变量 T");
    }
}

// 观察膨胀现象：打开 -Dsun.reflect.inflationThreshold=1 与默认值对比
// 也可以用 -verbose:class 观察 GeneratedMethodAccessor 类的生成
import java.lang.reflect.Method;

public class InflationDemo {
    public static class Target { public int echo(int x) { return x; } }

    public static void main(String[] args) throws Exception {
        Method m = Target.class.getMethod("echo", int.class);
        Target t = new Target();

        // 前若干次走 NativeMethodAccessorImpl（JNI，慢）
        for (int i = 0; i < 20; i++) m.invoke(t, i);

        // 超过阈值后走 GeneratedMethodAccessor（字节码，快）
        long s = System.nanoTime();
        for (int i = 0; i < 5_000_000; i++) m.invoke(t, i);
        System.out.printf("预热后 500 万次 invoke 耗时: %.0f ms%n", (System.nanoTime() - s) / 1e6);

        long s2 = System.nanoTime();
        int acc = 0;
        for (int i = 0; i < 5_000_000; i++) acc += t.echo(i);
        System.out.printf("直接调用 500 万次耗时: %.0f ms (acc=%d)%n",
                (System.nanoTime() - s2) / 1e6, acc);
    }
}

import java.lang.invoke.*;

public class MethodHandleDemo {
    public static class User { public String name = "n"; public String getName() { return name; } }

    public static void main(String[] args) throws Throwable {
        // 1. MethodHandle 调用方法：注意它是在 MethodHandles.Lookup 的"权限上下文"里查找
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType mt = MethodType.methodType(String.class);
        MethodHandle getter = lookup.findVirtual(User.class, "getName", mt);
        System.out.println((String) getter.invokeExact(new User()));   // n

        // 2. VarHandle 读写字段，支持 volatile / CAS
        VarHandle vh = lookup.findVarHandle(User.class, "name", String.class);
        User u = new User();
        vh.set(u, "张三");
        System.out.println(vh.get(u));                  // 张三
        System.out.println(vh.compareAndSet(u, "张三", "李四")); // true
        System.out.println(u.name);                     // 李四
    }
}

// 自定义一个注解，反编译后可以看到：
// public interface MyAnno extends java.lang.annotation.Annotation { ... }
public @interface MyAnno {
    String value();          // 元素（element），不是方法
    int count() default 1;   // 带默认值
}

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)   // 运行期可见，反射才能读到
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Inherited
public @interface Payable {
    String channel() default "wechat";
    int timeout() default 30;
    Class<?> fallback() default Object.class;
}

import java.lang.annotation.*;
import java.lang.reflect.*;

public class ReadAnnoDemo {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Metric { String value() default ""; int threshold() default 100; }

    static class Service {
        @Metric(value = "order.create", threshold = 200)
        public void createOrder() {}
        public void cancelOrder() {}
    }

    public static void main(String[] args) {
        for (Method m : Service.class.getDeclaredMethods()) {
            Metric metric = m.getAnnotation(Metric.class);   // 拿不到返回 null
            if (metric != null) {
                System.out.printf("%s -> name=%s, threshold=%d%n",
                        m.getName(), metric.value(), metric.threshold());
            }
            // 参数上的注解：getParameterAnnotations() 返回二维数组
            Annotation[][] pa = m.getParameterAnnotations();
        }
    }
}

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;

// 1. 定义注解：标记字段在 JSON 里的名字，以及是否忽略
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface JsonField {
    String value() default "";   // JSON 中的 key，默认用字段名
    boolean ignore() default false;
}

// 2. 待序列化的对象
class Person {
    @JsonField("user_name") private String name;
    @JsonField private int age;
    @JsonField(ignore = true) private String password;
    private List<String> tags;

    Person(String name, int age, String password, List<String> tags) {
        this.name = name; this.age = age; this.password = password; this.tags = tags;
    }
}

// 3. 迷你序列化器：只处理 String/基本类型/包装/集合/嵌套对象
public class MiniJsonSerializer {
    public static String toJson(Object obj) throws IllegalAccessException {
        if (obj == null) return "null";
        if (obj instanceof String) return "\"" + obj + "\"";
        if (obj instanceof Number || obj instanceof Boolean) return obj.toString();
        if (obj instanceof Collection) {
            StringBuilder sb = new StringBuilder("[");
            for (Iterator<?> it = ((Collection<?>) obj).iterator(); it.hasNext(); ) {
                sb.append(toJson(it.next()));
                if (it.hasNext()) sb.append(",");
            }
            return sb.append("]").toString();
        }

        Map<String, String> kv = new LinkedHashMap<>();
        for (Field f : obj.getClass().getDeclaredFields()) {
            if (Modifier.isStatic(f.getModifiers())) continue;
            JsonField ann = f.getAnnotation(JsonField.class);
            if (ann != null && ann.ignore()) continue;              // 被忽略
            String key = (ann != null && !ann.value().isEmpty())
                    ? ann.value() : f.getName();                    // 默认字段名
            f.setAccessible(true);
            kv.put(key, toJson(f.get(obj)));
        }
        StringBuilder sb = new StringBuilder("{");
        for (Iterator<Map.Entry<String, String>> it = kv.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<String, String> e = it.next();
            sb.append("\"").append(e.getKey()).append("\":").append(e.getValue());
            if (it.hasNext()) sb.append(",");
        }
        return sb.append("}").toString();
    }

    public static void main(String[] args) throws Exception {
        System.out.println(toJson(new Person("张三", 18, "123456", Arrays.asList("vip", "new"))));
        // {"user_name":"张三","age":18,"tags":["vip","new"]}
    }
}

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.Arrays;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Log {
    String value() default "";
    boolean slowOnly() default false;   // 是否只在耗时超阈值时打印
    int thresholdMs() default 0;
}

interface OrderApi { Long create(String sku, int num); }   // JDK 代理要求必须有接口

class OrderService implements OrderApi {
    @Log(value = "创建订单", thresholdMs = 5)
    public Long create(String sku, int num) {
        try { Thread.sleep(12); } catch (InterruptedException ignored) {}
        return 10001L;
    }
}

public class LogAspect {
    /** 用代理包装目标对象：每次方法调用前后插入日志逻辑 */
    @SuppressWarnings("unchecked")
    public static <T> T wrap(T target) {
        Class<?> iface = target.getClass().getInterfaces()[0];
        return (T) Proxy.newProxyInstance(iface.getClassLoader(),
                new Class<?>[]{iface},
                (proxy, method, args) -> {
                    Log log = target.getClass().getMethod(method.getName(),
                            method.getParameterTypes()).getAnnotation(Log.class);
                    boolean needLog = log != null;
                    long start = needLog ? System.nanoTime() : 0;
                    try {
                        Object ret = method.invoke(target, args);   // 反射调用真实对象
                        return ret;
                    } finally {
                        if (needLog) {
                            long ms = (System.nanoTime() - start) / 1_000_000;
                            if (!log.slowOnly() || ms >= log.thresholdMs()) {
                                System.out.printf("[LOG] %s 参数=%s 耗时=%dms%n",
                                        log.value(), Arrays.toString(args), ms);
                            }
                        }
                    }
                });
    }

    public static void main(String[] args) {
        OrderApi svc = wrap(new OrderService());
        System.out.println(svc.create("SKU-1", 2));
        // [LOG] 创建订单 参数=[SKU-1, 2] 耗时=12ms
        // 10001
    }
}

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Component { String value() default ""; }   // value 即 bean 名

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR})
@interface Autowired {}

// ---- 业务类 ----
interface UserRepo { String findById(long id); }

@Component("userRepo")
class JdbcUserRepo implements UserRepo {
    public String findById(long id) { return "user-" + id; }
}

@Component
class UserService {
    @Autowired private UserRepo repo;      // 按类型注入

    public String getUserName(long id) { return repo.findById(id); }
}

// ---- 容器 ----
public class MiniContainer {
    private final Map<String, Object> beans = new ConcurrentHashMap<>();
    private final Map<Class<?>, Object> byType = new ConcurrentHashMap<>();

    public void register(Class<?>... classes) throws Exception {
        // 第一遍：实例化所有 @Component
        for (Class<?> c : classes) {
            Component ann = c.getAnnotation(Component.class);
            if (ann == null) continue;
            String name = ann.value().isEmpty()
                    ? decapitalize(c.getSimpleName()) : ann.value();
            Object instance = c.getDeclaredConstructor().newInstance();
            beans.put(name, instance);
            for (Class<?> itf : c.getInterfaces()) byType.put(itf, instance);
            byType.put(c, instance);
        }
        // 第二遍：字段注入（必须在全部实例化之后，否则可能拿到半成品）
        for (Object bean : beans.values()) inject(bean);
    }

    private void inject(Object bean) throws Exception {
        for (Field f : bean.getClass().getDeclaredFields()) {
            if (!f.isAnnotationPresent(Autowired.class)) continue;
            Object dep = byType.get(f.getType());
            if (dep == null) throw new IllegalStateException("未找到依赖: " + f.getType());
            f.setAccessible(true);
            f.set(bean, dep);
        }
    }

    @SuppressWarnings("unchecked")
    public <T> T getBean(Class<T> type) { return (T) byType.get(type); }

    private static String decapitalize(String s) {
        return Character.toLowerCase(s.charAt(0)) + s.substring(1);
    }

    public static void main(String[] args) throws Exception {
        MiniContainer ctx = new MiniContainer();
        ctx.register(JdbcUserRepo.class, UserService.class);
        System.out.println(ctx.getBean(UserService.class).getUserName(7L));  // user-7
    }
}

import java.lang.reflect.*;
import java.util.Arrays;

interface UserService { String getUserName(long id); void delete(long id); }

class UserServiceImpl implements UserService {
    public String getUserName(long id) { return "user-" + id; }
    public void delete(long id) { System.out.println("删除 " + id); }
}

public class JdkProxyDemo {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();

        // 三个参数：类加载器、要代理的接口列表、调用处理器
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class<?>[]{UserService.class},
                (p, method, params) -> {
                    System.out.println("[前置] " + method.getName()
                            + " 参数=" + Arrays.toString(params));
                    long s = System.nanoTime();
                    try {
                        return method.invoke(target, params);   // 转发给真实对象
                    } finally {
                        System.out.printf("[后置] 耗时 %.3f ms%n",
                                (System.nanoTime() - s) / 1e6);
                    }
                });

        System.out.println(proxy.getUserName(7L));
        proxy.delete(7L);

        // 观察生成的代理类
        System.out.println(proxy.getClass().getName());                   // com.sun.proxy.$Proxy0
        System.out.println(Proxy.isProxyClass(proxy.getClass()));         // true
        System.out.println(Arrays.toString(proxy.getClass().getInterfaces()));
        System.out.println(proxy.getClass().getSuperclass());             // class java.lang.reflect.Proxy
    }
}

// 需要依赖：cglib:cglib:3.3.0（Spring 已内置重打包版本 spring-core 中的 org.springframework.cglib）
import org.springframework.cglib.proxy.*;
import java.lang.reflect.Method;

class OrderService {                      // 注意：没有实现任何接口
    public String pay(long orderId) { return "paid-" + orderId; }
    public final String audit() { return "final 方法，无法被代理"; }
}

public class CglibDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, params, methodProxy) -> {
            System.out.println("[cglib 前置] " + method.getName());
            // methodProxy.invokeSuper 走 FastClass 索引，比 method.invoke 快
            Object ret = methodProxy.invokeSuper(obj, params);
            System.out.println("[cglib 后置] " + ret);
            return ret;
        });
        OrderService proxy = (OrderService) enhancer.create();
        System.out.println(proxy.getClass().getName());   // OrderService$$EnhancerByCGLIB$$xxxx
        System.out.println(proxy.pay(99L));
        System.out.println(proxy.audit());                // 直接走父类，不会被增强
    }
}

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Random;

interface RemoteApi { String query(String keyword); }

public class RpcProxy {
    private static final Random RND = new Random();

    @SuppressWarnings("unchecked")
    public static <T> T create(Class<T> iface) {
        return (T) Proxy.newProxyInstance(iface.getClassLoader(),
                new Class<?>[]{iface},
                (proxy, method, args) -> {
                    // 1. Object 上的方法直接本地处理，避免误当成远程调用
                    if (method.getDeclaringClass() == Object.class) {
                        return switch (method.getName()) {
                            case "toString" -> "RpcProxy@" + iface.getName();
                            case "hashCode" -> System.identityHashCode(proxy);
                            case "equals" -> proxy == args[0];
                            default -> throw new UnsupportedOperationException();
                        };
                    }
                    int maxRetry = 3;
                    for (int i = 1; ; i++) {
                        long s = System.nanoTime();
                        try {
                            System.out.printf("[RPC] %s(%s) 第 %d 次尝试%n",
                                    method.getName(), Arrays.toString(args), i);
                            String r = remoteCall(method.getName(), args);
                            System.out.printf("[RPC] 成功，耗时 %.2f ms%n",
                                    (System.nanoTime() - s) / 1e6);
                            return r;
                        } catch (RuntimeException e) {
                            System.out.printf("[RPC] 失败(%s)，耗时 %.2f ms%n",
                                    e.getMessage(), (System.nanoTime() - s) / 1e6);
                            if (i >= maxRetry) throw e;         // 重试耗尽
                        }
                    }
                });
    }

    private static String remoteCall(String method, Object[] args) {
        if (RND.nextInt(3) == 0) throw new RuntimeException("网络超时"); // 模拟 1/3 失败率
        return method + "-result";
    }

    public static void main(String[] args) {
        RemoteApi api = create(RemoteApi.class);
        System.out.println(api.query("java"));
    }
}

// 假设目标是 JDK 内部类 java.util.ArrayList 的私有字段（java.base 模块未 opens java.util）
import java.lang.reflect.Field;
import java.util.ArrayList;

public class ModuleAccessDemo {
    public static void main(String[] args) throws Exception {
        Field f = ArrayList.class.getDeclaredField("elementData");
        try {
            f.setAccessible(true);
        } catch (RuntimeException e) {
            // JDK 9+：InaccessibleObjectException（RuntimeException 子类）
            // JDK 8：这里会成功
            System.out.println("被模块系统拦截: " + e.getClass().getSimpleName()
                    + " - " + e.getMessage());
        }
    }
}

# JDK 9~16：放宽非法反射访问（JDK 16 起默认 deny）
java --illegal-access=permit -jar app.jar

# 精确开放某个包（推荐，粒度最小）
java --add-opens java.base/java.util=ALL-UNNAMED -jar app.jar
java --add-opens java.base/java.lang=ALL-UNNAMED -jar app.jar