fix: cache ObjectWriter created in switch block of getObjectWriterInternal to prevent Metaspace leak, for issue #7626

Author: Elin-Zhou

core/src/main/java/com/alibaba/fastjson2/writer/ObjectWriterProvider.java

@@ -708,6 +708,16 @@ private ObjectWriter getObjectWriterInternal(Type objectType, Class objectClass,
                 break;
         }
 
+        if (objectWriter != null) {
+            ObjectWriter previous = fieldBased
+                    ? cacheFieldBased.putIfAbsent(objectType, objectWriter)
+                    : cache.putIfAbsent(objectType, objectWriter);
+            if (previous != null) {
+                objectWriter = previous;
+            }
+            return objectWriter;
+        }
+
         if (objectWriter == null
                 && (!fieldBased)
                 && Map.class.isAssignableFrom(objectClass)

core/src/test/java/com/alibaba/fastjson2/writer/GuavaMultimapWriterCacheTest.java

@@ -0,0 +1,136 @@
+package com.alibaba.fastjson2.writer;
+
+import com.alibaba.fastjson2.JSON;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.LinkedListMultimap;
+import com.google.common.collect.TreeMultimap;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.lang.management.ManagementFactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Tag("writer")
+public class GuavaMultimapWriterCacheTest {
+    @Test
+    public void testLinkedListMultimapWriterCached() {
+        ObjectWriterProvider provider = new ObjectWriterProvider();
+        ObjectWriter w1 = provider.getObjectWriter(LinkedListMultimap.class);
+        ObjectWriter w2 = provider.getObjectWriter(LinkedListMultimap.class);
+        assertNotNull(w1);
+        assertSame(w1, w2);
+    }
+
+    @Test
+    public void testArrayListMultimapWriterCached() {
+        ObjectWriterProvider provider = new ObjectWriterProvider();
+        ObjectWriter w1 = provider.getObjectWriter(ArrayListMultimap.class);
+        ObjectWriter w2 = provider.getObjectWriter(ArrayListMultimap.class);
+        assertNotNull(w1);
+        assertSame(w1, w2);
+    }
+
+    @Test
+    public void testHashMultimapWriterCached() {
+        ObjectWriterProvider provider = new ObjectWriterProvider();
+        ObjectWriter w1 = provider.getObjectWriter(HashMultimap.class);
+        ObjectWriter w2 = provider.getObjectWriter(HashMultimap.class);
+        assertNotNull(w1);
+        assertSame(w1, w2);
+    }
+
+    @Test
+    public void testLinkedHashMultimapWriterCached() {
+        ObjectWriterProvider provider = new ObjectWriterProvider();
+        ObjectWriter w1 = provider.getObjectWriter(LinkedHashMultimap.class);
+        ObjectWriter w2 = provider.getObjectWriter(LinkedHashMultimap.class);
+        assertNotNull(w1);
+        assertSame(w1, w2);
+    }
+
+    @Test
+    public void testTreeMultimapWriterCached() {
+        ObjectWriterProvider provider = new ObjectWriterProvider();
+        ObjectWriter w1 = provider.getObjectWriter(TreeMultimap.class);
+        ObjectWriter w2 = provider.getObjectWriter(TreeMultimap.class);
+        assertNotNull(w1);
+        assertSame(w1, w2);
+    }
+
+    @Test
+    public void testLinkedListMultimapSerialize() {
+        LinkedListMultimap<String, String> map = LinkedListMultimap.create();
+        map.put("a", "1");
+        map.put("a", "2");
+        map.put("b", "3");
+        String json = JSON.toJSONString(map);
+        assertEquals("{\"a\":[\"1\",\"2\"],\"b\":[\"3\"]}", json);
+
+        String json2 = JSON.toJSONString(map);
+        assertEquals(json, json2);
+    }
+
+    @Test
+    public void testArrayListMultimapSerialize() {
+        ArrayListMultimap<String, Integer> map = ArrayListMultimap.create();
+        map.put("k1", 1);
+        map.put("k1", 2);
+        String json = JSON.toJSONString(map);
+        assertEquals("{\"k1\":[1,2]}", json);
+
+        String json2 = JSON.toJSONString(map);
+        assertEquals(json, json2);
+    }
+
+    @Test
+    public void testHashMultimapSerialize() {
+        HashMultimap<String, String> map = HashMultimap.create();
+        map.put("k", "v");
+        String json = JSON.toJSONString(map);
+        assertEquals("{\"k\":[\"v\"]}", json);
+    }
+
+    @Test
+    public void testLinkedHashMultimapSerialize() {
+        LinkedHashMultimap<String, String> map = LinkedHashMultimap.create();
+        map.put("a", "1");
+        map.put("a", "2");
+        map.put("b", "3");
+        String json = JSON.toJSONString(map);
+        assertEquals("{\"a\":[\"1\",\"2\"],\"b\":[\"3\"]}", json);
+    }
+
+    @Test
+    public void testTreeMultimapSerialize() {
+        TreeMultimap<String, String> map = TreeMultimap.create();
+        map.put("b", "2");
+        map.put("a", "1");
+        String json = JSON.toJSONString(map);
+        assertEquals("{\"a\":[\"1\"],\"b\":[\"2\"]}", json);
+    }
+
+    @Test
+    public void testNoNewClassesAfterWarmup() {
+        LinkedListMultimap<String, String> map = LinkedListMultimap.create();
+        map.put("k", "v");
+
+        for (int i = 0; i < 10; i++) {
+            JSON.toJSONString(map);
+        }
+
+        long before = ManagementFactory.getClassLoadingMXBean().getTotalLoadedClassCount();
+        for (int i = 0; i < 100; i++) {
+            JSON.toJSONString(map);
+        }
+        long after = ManagementFactory.getClassLoadingMXBean().getTotalLoadedClassCount();
+
+        assertTrue(after - before <= 5,
+                "Should not generate new classes after warmup, but loaded " + (after - before));
+    }
+}