Java Reflection — setAccessible Fails on JDK 9+

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

public class ClassMetadataInspector {

    // A realistic domain class — imagine this came from a third-party JAR
    static class PaymentProcessor {
        private double transactionFeePercent = 2.5;
        public String processorName;
        protected int retryLimit = 3;

        public PaymentProcessor(String processorName) {
            this.processorName = processorName;
        }

        public String chargeCard(String cardToken, double amount) {
            return "Charged " + amount + " via " + processorName;
        }

        private void auditLog(String event) {
            System.out.println("[AUDIT] " + event);
        }
    }

    public static void main(String[] args) {
        // Step 1: Grab the Class object — the JVM already has this in Metaspace
        Class<?> processorClass = PaymentProcessor.class;

        System.out.println("=== Class Metadata ===");
        System.out.println("Simple Name : " + processorClass.getSimpleName());
        System.out.println("Full Name   : " + processorClass.getName());
        System.out.println("Superclass  : " + processorClass.getSuperclass().getSimpleName());
        System.out.println("Is Interface: " + processorClass.isInterface());

        System.out.println("\n=== All Declared Fields (including private) ===");
        // getDeclaredFields() returns ALL fields in THIS class — including private ones
        // getFields() only returns PUBLIC fields, including inherited ones
        for (Field field : processorClass.getDeclaredFields()) {
            String visibility = Modifier.toString(field.getModifiers());
            System.out.printf("  [%-12s] %s : %s%n",
                visibility,
                field.getType().getSimpleName(),
                field.getName());
        }

        System.out.println("\n=== All Declared Methods ===");
        for (Method method : processorClass.getDeclaredMethods()) {
            String visibility = Modifier.toString(method.getModifiers());
            System.out.printf("  [%-12s] %s %s()%n",
                visibility,
                method.getReturnType().getSimpleName(),
                method.getName());
        }
    }
}

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

public class ReflectiveInvoker {

    static class DatabaseConnection {
        // Private field — no public setter by design
        private int maxPoolSize = 10;
        private boolean sslEnabled = false;

        // Private method — internal lifecycle hook
        private void reconnect(String reason) {
            System.out.println("Reconnecting pool. Reason: " + reason);
        }

        public int getMaxPoolSize() {
            return maxPoolSize;
        }

        @Override
        public String toString() {
            return "DatabaseConnection{maxPoolSize=" + maxPoolSize +
                   ", sslEnabled=" + sslEnabled + "}";
        }
    }

    public static void main(String[] args) throws Exception {
        DatabaseConnection dbConn = new DatabaseConnection();
        System.out.println("Before reflection: " + dbConn);

        // --- Mutating a private field ---
        Field poolSizeField = DatabaseConnection.class
                .getDeclaredField("maxPoolSize");  // exact field name required

        // Without this line, the next call throws IllegalAccessException
        poolSizeField.setAccessible(true);

        // Write directly to the private field — no setter runs
        poolSizeField.set(dbConn, 50);
        System.out.println("After pool size mutation: " + dbConn);

        // --- Mutating a private boolean field ---
        Field sslField = DatabaseConnection.class.getDeclaredField("sslEnabled");
        sslField.setAccessible(true);
        sslField.set(dbConn, true);
        System.out.println("After SSL flag mutation: " + dbConn);

        // --- Invoking a private method ---
        Method reconnectMethod = DatabaseConnection.class
                .getDeclaredMethod("reconnect", String.class); // must match param types exactly
        reconnectMethod.setAccessible(true);

        // First arg is the instance, remaining args are the method parameters
        reconnectMethod.invoke(dbConn, "Pool size config changed");

        // --- Handling exceptions from invoked methods ---
        // Checked exceptions from the invoked method are wrapped in InvocationTargetException
        try {
            reconnectMethod.invoke(dbConn, "test");
        } catch (InvocationTargetException ite) {
            // Unwrap to get the real cause
            System.out.println("Actual cause: " + ite.getCause());
        }
    }
}

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

public class DynamicInstantiationAndGenerics {

    // Simulate a plugin or user-defined class loaded by name
    static class ReportGenerator {
        private String reportFormat;
        private int pageLimit;

        // Reflection requires this constructor to be accessible
        public ReportGenerator(String reportFormat, int pageLimit) {
            this.reportFormat = reportFormat;
            this.pageLimit = pageLimit;
        }

        public void generate() {
            System.out.println("Generating " + reportFormat +
                               " report, max " + pageLimit + " pages.");
        }
    }

    // Class with a generic field — type info IS preserved in bytecode signatures
    static class DataPipeline {
        private List<String> stages = new ArrayList<>();
        private List<Integer> priorities = new ArrayList<>();
    }

    public static void main(String[] args) throws Exception {

        // --- Dynamic instantiation ---
        // In a real plugin system, this string comes from a config file or database
        String className = DynamicInstantiationAndGenerics.class.getName()
                          + "$ReportGenerator";

        Class<?> reportClass = Class.forName(className);

        // Fetch the constructor that takes (String, int) — must match exactly
        Constructor<?> twoArgConstructor = reportClass
                .getDeclaredConstructor(String.class, int.class);

        // Use Constructor.newInstance() — NOT the deprecated Class.newInstance()
        Object reportInstance = twoArgConstructor.newInstance("PDF", 100);

        // Invoke generate() reflectively
        Method generateMethod = reportClass.getDeclaredMethod("generate");
        generateMethod.invoke(reportInstance);

        // --- Generic type recovery via field signatures ---
        System.out.println("\n=== Generic Field Type Info ===");
        Class<?> pipelineClass = DataPipeline.class;

        for (Field field : pipelineClass.getDeclaredFields()) {
            Type genericType = field.getGenericType(); // gets the full parameterized type

            if (genericType instanceof ParameterizedType paramType) {
                // The raw type (e.g., List)
                Type rawType = paramType.getRawType();
                // The actual type arguments (e.g., String or Integer)
                Type[] typeArgs = paramType.getActualTypeArguments();

                System.out.printf("Field '%s': raw=%s, typeArg=%s%n",
                    field.getName(),
                    ((Class<?>) rawType).getSimpleName(),
                    typeArgs[0].getTypeName());
            }
        }

        // --- Demonstrate type erasure at runtime ---
        System.out.println("\n=== Type Erasure Demo ===");
        List<String> stringList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();

        // At runtime, these are identical — type parameters are GONE
        System.out.println("Same class? " +
            (stringList.getClass() == integerList.getClass())); // true!
    }
}

import java.lang.reflect.Method;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class ReflectionPerformanceBenchmark {

    static class PricingEngine {
        public double calculateDiscount(double originalPrice, double discountRate) {
            return originalPrice * (1.0 - discountRate);
        }
    }

    // Cache your reflection objects — never look them up in a loop
    private static final Method CACHED_METHOD;
    private static final MethodHandle CACHED_METHOD_HANDLE;

    static {
        try {
            // Lookup ONCE at class initialization — not on every call
            CACHED_METHOD = PricingEngine.class
                    .getDeclaredMethod("calculateDiscount", double.class, double.class);
            CACHED_METHOD.setAccessible(true); // also set once

            // MethodHandle lookup — JVM can inline this unlike Method.invoke()
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            CACHED_METHOD_HANDLE = lookup.findVirtual(
                    PricingEngine.class,
                    "calculateDiscount",
                    MethodType.methodType(double.class, double.class, double.class)
            );
        } catch (NoSuchMethodException | IllegalAccessException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    public static void main(String[] args) throws Throwable {
        PricingEngine engine = new PricingEngine();
        int iterations = 1_000_000;
        long start, end;

        // --- Direct call baseline ---
        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            engine.calculateDiscount(100.0, 0.15);
        }
        end = System.nanoTime();
        System.out.printf("Direct call      : %,d ns total%n", (end - start));

        // --- Uncached reflection (worst case — simulate naive usage) ---
        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            // BAD: getDeclaredMethod called every iteration — never do this
            Method freshMethod = PricingEngine.class
                    .getDeclaredMethod("calculateDiscount", double.class, double.class);
            freshMethod.setAccessible(true);
            freshMethod.invoke(engine, 100.0, 0.15);
        }
        end = System.nanoTime();
        System.out.printf("Uncached reflect  : %,d ns total%n", (end - start));

        // --- Cached Method.invoke() ---
        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            CACHED_METHOD.invoke(engine, 100.0, 0.15);
        }
        end = System.nanoTime();
        System.out.printf("Cached reflect    : %,d ns total%n", (end - start));

        // --- MethodHandle (best reflection alternative for hot paths) ---
        start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            // invokeExact is the fastest — types must match perfectly
            CACHED_METHOD_HANDLE.invoke(engine, 100.0, 0.15);
        }
        end = System.nanoTime();
        System.out.printf("MethodHandle      : %,d ns total%n", (end - start));
    }
}

import java.lang.reflect.Field;
import java.lang.reflect.InaccessibleObjectException;

public class ModuleReflectionDemo {

    public static void main(String[] args) {
        // Trying to access private field of a JDK class — will throw on Java 9+
        try {
            // Obtain Field object for System.out — it's a static PrintStream
            Field outField = System.class.getDeclaredField("out");
            outField.setAccessible(true);  // This line throws InaccessibleObjectException

            PrintStream originalOut = (PrintStream) outField.get(null);
            System.out.println("Original out: " + originalOut);
        } catch (InaccessibleObjectException e) {
            System.err.println("Reflection blocked by module system: " + e.getMessage());
            System.err.println("Fix: add JVM flag --add-opens java.base/java.lang=ALL-UNNAMED");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // Safe alternative: use SecurityManager (deprecated) or high-level API
        // System.out is accessible via System.out directly — no reflection needed.
        System.out.println("This is the safe, direct way.");
    }
}

// io.thecodeforge — java tutorial

import java.lang.reflect.Constructor;

public class PluginLoader {
    public static Plugin load(String className) throws Exception {
        // Load a plugin class we've never compiled against
        Class<?> clazz = Class.forName(className);
        Constructor<?> ctor = clazz.getDeclaredConstructor();
        return (Plugin) ctor.newInstance();
    }
}

// Usage: Plugin p = PluginLoader.load("com.badass.RedisCachePlugin");

// io.thecodeforge — java tutorial

import java.lang.reflect.Field;

public class ReflectionBurn {
    public static void main(String[] args) throws Exception {
        User user = new User("admin", "s3cret!");
        
        // This compiles. This runs. Then someone renames 'password' to 'hashedPassword'
        // Good luck debugging at 2am.
        Field passwordField = User.class.getDeclaredField("password");
        passwordField.setAccessible(true);
        passwordField.set(user, "pwned");
        
        System.out.println(user.getPassword()); // pwned
    }
}

class User {
    private String username;
    private String password;
    
    User(String username, String password) {
        this.username = username;
        this.password = password;
    }
    
    String getPassword() { return password; }
}

// io.thecodeforge — java tutorial

import java.lang.reflect.*;

public class ReflectionLeak {
    private String secret = "production-db-password";

    public static void main(String[] args) throws Exception {
        Field f = ReflectionLeak.class.getDeclaredField("secret");
        f.setAccessible(true);
        ReflectionLeak obj = new ReflectionLeak();
        System.out.println(f.get(obj));
        // Rename field? Boom at 3 AM: NoSuchFieldException
    }
}

// io.thecodeforge — java tutorial

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

public class CachedReflection {
    private static final ConcurrentHashMap<Class<?>, Method> cache = new ConcurrentHashMap<>();

    public static String fastInvoke(Class<?> clazz) throws Exception {
        Method m = cache.computeIfAbsent(clazz, c -> {
            try { return c.getMethod("getName"); } catch (NoSuchMethodException e) { throw new RuntimeException(e); }
        });
        return (String) m.invoke(clazz.getDeclaredConstructor().newInstance());
    }

    public static void main(String[] args) throws Exception {
        System.out.println(fastInvoke(String.class));
    }
}

// io.thecodeforge — java tutorial
public class ReflectionIntro {
    public static void main(String[] args) throws Exception {
        String className = "java.util.ArrayList";
        Class<?> clazz = Class.forName(className);
        System.out.println("Class: " + clazz.getName());
        System.out.println("Methods: " + clazz.getMethods().length);
        // Creates instance without compile-time reference
        Object list = clazz.getDeclaredConstructor().newInstance();
        System.out.println("Instance type: " + list.getClass());
    }
}

// io.thecodeforge — java tutorial
import java.lang.reflect.Method;

public class ReflectConclusion {
    public static void main(String[] args) throws Exception {
        // Cached for performance
        Method m = String.class.getMethod("toUpperCase");
        // Single call, not repeated reflection
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            m.invoke("hello");
        }
        long end = System.nanoTime();
        System.out.println("Avg ns/call: " + (end - start) / 1000);
    }
}