Fix raw uses of parameterized classes

Replace raw types with properly parameterized generics:
- ConcurrentHashMap<Class, CachedConstructor> → ConcurrentHashMap<Class<?>, CachedConstructor<?>>
- CacheKey → CacheKey<?>
- Map t → Map<String, Object> t

Add type-safe helper method getCachedConstructor() to encapsulate necessary
unchecked cast with clear documentation of safety invariant.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: oschwald

sample/Benchmark.java

@@ -45,7 +45,7 @@ private static void bench(Reader r, int count, int seed) throws IOException {
         for (int i = 0; i < count; i++) {
             random.nextBytes(address);
             InetAddress ip = InetAddress.getByAddress(address);
-            Map t = r.get(ip, Map.class);
+            Map<String, Object> t = r.get(ip, Map.class);
             if (TRACE) {
                 if (i % 50000 == 0) {
                     System.out.println(i + " " + ip);

src/main/java/com/maxmind/db/CHMCache.java

@@ -13,7 +13,7 @@ public class CHMCache implements NodeCache {
     private static final int DEFAULT_CAPACITY = 4096;
 
     private final int capacity;
-    private final ConcurrentHashMap<CacheKey, DecodedValue> cache;
+    private final ConcurrentHashMap<CacheKey<?>, DecodedValue> cache;
     private boolean cacheFull = false;
 
     /**
@@ -36,7 +36,7 @@ public CHMCache(int capacity) {
     }
 
     @Override
-    public DecodedValue get(CacheKey key, Loader loader) throws IOException {
+    public DecodedValue get(CacheKey<?> key, Loader loader) throws IOException {
         DecodedValue value = cache.get(key);
         if (value == null) {
             value = loader.load(key);

src/main/java/com/maxmind/db/Decoder.java

@@ -36,7 +36,7 @@ class Decoder {
 
     private final ByteBuffer buffer;
 
-    private final ConcurrentHashMap<Class, CachedConstructor> constructors;
+    private final ConcurrentHashMap<Class<?>, CachedConstructor<?>> constructors;
 
     Decoder(NodeCache cache, ByteBuffer buffer, long pointerBase) {
         this(
@@ -51,7 +51,7 @@ class Decoder {
         NodeCache cache,
         ByteBuffer buffer,
         long pointerBase,
-        ConcurrentHashMap<Class, CachedConstructor> constructors
+        ConcurrentHashMap<Class<?>, CachedConstructor<?>> constructors
     ) {
         this.cache = cache;
         this.pointerBase = pointerBase;
@@ -135,7 +135,7 @@ DecodedValue decodePointer(long pointer, Class<?> cls, java.lang.reflect.Type ge
         int targetOffset = (int) pointer;
         int position = buffer.position();
 
-        CacheKey key = new CacheKey(targetOffset, cls, genericType);
+        CacheKey<?> key = new CacheKey<>(targetOffset, cls, genericType);
         DecodedValue o = cache.get(key, cacheLoader);
 
         buffer.position(position);
@@ -371,7 +371,7 @@ private <T, V> Map<String, V> decodeMapIntoMap(
 
     private <T> Object decodeMapIntoObject(int size, Class<T> cls)
         throws IOException {
-        CachedConstructor<T> cachedConstructor = this.constructors.get(cls);
+        CachedConstructor<T> cachedConstructor = getCachedConstructor(cls);
         Constructor<T> constructor;
         Class<?>[] parameterTypes;
         java.lang.reflect.Type[] parameterGenericTypes;
@@ -392,7 +392,7 @@ private <T> Object decodeMapIntoObject(int size, Class<T> cls)
 
             this.constructors.put(
                 cls,
-                new CachedConstructor(
+                new CachedConstructor<>(
                     constructor,
                     parameterTypes,
                     parameterGenericTypes,
@@ -445,6 +445,13 @@ private <T> Object decodeMapIntoObject(int size, Class<T> cls)
         }
     }
 
+    private <T> CachedConstructor<T> getCachedConstructor(Class<T> cls) {
+        // This cast is safe because we only put CachedConstructor<T> for Class<T> as the key
+        @SuppressWarnings("unchecked")
+        CachedConstructor<T> result = (CachedConstructor<T>) this.constructors.get(cls);
+        return result;
+    }
+
     private static <T> Constructor<T> findConstructor(Class<T> cls)
         throws ConstructorNotFoundException {
         Constructor<?>[] constructors = cls.getConstructors();

src/main/java/com/maxmind/db/NoCache.java

@@ -13,7 +13,7 @@ private NoCache() {
     }
 
     @Override
-    public DecodedValue get(CacheKey key, Loader loader) throws IOException {
+    public DecodedValue get(CacheKey<?> key, Loader loader) throws IOException {
         return loader.load(key);
     }
 

src/main/java/com/maxmind/db/NodeCache.java

@@ -18,7 +18,7 @@ interface Loader {
          * @throws IOException
          *             if there is an error loading the value
          */
-        DecodedValue load(CacheKey key) throws IOException;
+        DecodedValue load(CacheKey<?> key) throws IOException;
     }
 
     /**
@@ -33,6 +33,6 @@ interface Loader {
      * @throws IOException
      *             if there is an error loading the value
      */
-    DecodedValue get(CacheKey key, Loader loader) throws IOException;
+    DecodedValue get(CacheKey<?> key, Loader loader) throws IOException;
 
 }

src/main/java/com/maxmind/db/Reader.java

@@ -26,7 +26,7 @@ public final class Reader implements Closeable {
     private final Metadata metadata;
     private final AtomicReference<BufferHolder> bufferHolderReference;
     private final NodeCache cache;
-    private final ConcurrentHashMap<Class, CachedConstructor> constructors;
+    private final ConcurrentHashMap<Class<?>, CachedConstructor<?>> constructors;
 
     /**
      * The file mode to use when opening a MaxMind DB.

src/test/java/com/maxmind/db/RealisticPerformanceBenchmark.java

@@ -0,0 +1,106 @@
+package com.maxmind.db;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * Realistic benchmark comparing MethodHandle vs Reflection performance
+ * using actual MaxMind DB deserialization patterns with caching.
+ */
+public class RealisticPerformanceBenchmark {
+    
+    public static class GeoRecord {
+        private final String country;
+        private final String city;
+        private final Double latitude;
+        private final Double longitude;
+        
+        @MaxMindDbConstructor
+        public GeoRecord(
+                @MaxMindDbParameter(name = "country") String country,
+                @MaxMindDbParameter(name = "city") String city,
+                @MaxMindDbParameter(name = "latitude") Double latitude,
+                @MaxMindDbParameter(name = "longitude") Double longitude) {
+            this.country = country;
+            this.city = city;
+            this.latitude = latitude;
+            this.longitude = longitude;
+        }
+        
+        public String getCountry() { return country; }
+        public String getCity() { return city; }
+        public Double getLatitude() { return latitude; }
+        public Double getLongitude() { return longitude; }
+    }
+    
+    public static void main(String[] args) throws Throwable {
+        int warmupIterations = 100_000;
+        int benchmarkIterations = 1_000_000;
+        
+        // Simulate realistic parameters with varied data
+        Object[][] parameterSets = generateTestParameters(benchmarkIterations);
+        Class<?>[] parameterTypes = {String.class, String.class, Double.class, Double.class};
+        
+        // Cached constructor and MethodHandle (realistic usage)
+        Constructor<GeoRecord> constructor = GeoRecord.class.getDeclaredConstructor(parameterTypes);
+        MethodHandle methodHandle = MethodHandles.lookup().unreflectConstructor(constructor);
+        
+        // Warmup
+        runReflectionBenchmark(constructor, parameterSets, warmupIterations);
+        runMethodHandleBenchmark(methodHandle, parameterSets, warmupIterations);
+        
+        System.out.println("Realistic MaxMind DB deserialization benchmark:");
+        System.out.println("Iterations: " + benchmarkIterations);
+        System.out.println("Pattern: Cached constructor/MethodHandle with varied parameters");
+        System.out.println();
+        
+        // Benchmark with cached instances (realistic usage)
+        long reflectionTime = runReflectionBenchmark(constructor, parameterSets, benchmarkIterations);
+        System.out.println("Cached Reflection time: " + reflectionTime + "ms");
+        
+        long methodHandleTime = runMethodHandleBenchmark(methodHandle, parameterSets, benchmarkIterations);
+        System.out.println("Cached MethodHandle time: " + methodHandleTime + "ms");
+        
+        double improvement = ((double) reflectionTime / methodHandleTime - 1) * 100;
+        System.out.printf("MethodHandle improvement: %.1f%%\n", improvement);
+    }
+    
+    private static Object[][] generateTestParameters(int count) {
+        Object[][] parameters = new Object[count][];
+        String[] countries = {"US", "CA", "GB", "DE", "FR", "JP", "AU", "BR"};
+        String[] cities = {"New York", "London", "Tokyo", "Paris", "Sydney", "Toronto"};
+        
+        for (int i = 0; i < count; i++) {
+            ThreadLocalRandom random = ThreadLocalRandom.current();
+            parameters[i] = new Object[]{
+                countries[random.nextInt(countries.length)],
+                cities[random.nextInt(cities.length)],
+                random.nextDouble(-90, 90), // latitude
+                random.nextDouble(-180, 180) // longitude
+            };
+        }
+        return parameters;
+    }
+    
+    private static long runReflectionBenchmark(Constructor<GeoRecord> constructor, 
+                                               Object[][] parameterSets, int iterations) throws Exception {
+        long start = System.currentTimeMillis();
+        for (int i = 0; i < iterations; i++) {
+            constructor.newInstance(parameterSets[i % parameterSets.length]);
+        }
+        long end = System.currentTimeMillis();
+        return end - start;
+    }
+    
+    private static long runMethodHandleBenchmark(MethodHandle methodHandle,
+                                                 Object[][] parameterSets, int iterations) throws Throwable {
+        long start = System.currentTimeMillis();
+        for (int i = 0; i < iterations; i++) {
+            methodHandle.invokeWithArguments(parameterSets[i % parameterSets.length]);
+        }
+        long end = System.currentTimeMillis();
+        return end - start;
+    }
+}