Fix(core): Prevent redundant schema resolution by fixing AnnotatedType equality

Signed-off-by: potato <[email protected]>

Author: juntae6942

modules/swagger-core/src/main/java/io/swagger/v3/core/converter/AnnotatedType.java

@@ -243,47 +243,28 @@ public AnnotatedType propertyName(String propertyName) {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (!(o instanceof AnnotatedType)) {
-            return false;
-        }
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
         AnnotatedType that = (AnnotatedType) o;
-
-        if ((type == null && that.type != null) || (type != null && that.type == null)) {
-            return false;
-        }
-
-        if (type != null && that.type != null && !type.equals(that.type)) {
-            return false;
-        }
-        return Arrays.equals(this.ctxAnnotations, that.ctxAnnotations);
+        return skipOverride == that.skipOverride &&
+                schemaProperty == that.schemaProperty &&
+                resolveAsRef == that.resolveAsRef &&
+                resolveEnumAsRef == that.resolveEnumAsRef &&
+                includePropertiesWithoutJSONView == that.includePropertiesWithoutJSONView &&
+                skipSchemaName == that.skipSchemaName &&
+                skipJsonIdentity == that.skipJsonIdentity &&
+                Objects.equals(type, that.type) &&
+                Objects.equals(name, that.name) &&
+                Arrays.equals(ctxAnnotations, that.ctxAnnotations) &&
+                Objects.equals(jsonViewAnnotation, that.jsonViewAnnotation);
     }
 
-
     @Override
     public int hashCode() {
-        if (ctxAnnotations == null || ctxAnnotations.length == 0) {
-            return Objects.hash(type, "fixed");
-        }
-        List<Annotation> meaningfulAnnotations = new ArrayList<>();
-
-        boolean hasDifference = false;
-        for (Annotation a: ctxAnnotations) {
-            if(!a.annotationType().getName().startsWith("sun") && !a.annotationType().getName().startsWith("jdk")) {
-                meaningfulAnnotations.add(a);
-            } else {
-                hasDifference = true;
-            }
-        }
-        int result = 1;
-        result = 31 * result + (type == null ? 0 : Objects.hash(type, "fixed"));
-        if (hasDifference) {
-            result = 31 * result + meaningfulAnnotations.hashCode();
-        } else {
-            result = 31 * result + Arrays.hashCode(ctxAnnotations);
-        }
+        int result = Objects.hash(type, name, skipOverride, schemaProperty, resolveAsRef,
+                resolveEnumAsRef, jsonViewAnnotation, includePropertiesWithoutJSONView, skipSchemaName,
+                skipJsonIdentity);
+        result = 31 * result + Arrays.hashCode(ctxAnnotations);
         return result;
     }
 }

modules/swagger-core/src/test/java/io/swagger/v3/core/converting/AnnotatedTypeCachingTest.java

@@ -0,0 +1,72 @@
+package io.swagger.v3.core.converting;
+
+import io.swagger.v3.core.converter.AnnotatedType;
+import io.swagger.v3.core.converter.ModelConverter;
+import io.swagger.v3.core.converter.ModelConverterContext;
+import io.swagger.v3.core.converter.ModelConverterContextImpl;
+import io.swagger.v3.oas.models.media.Schema;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.Set;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+
+public class AnnotatedTypeCachingTest {
+
+    @Test
+    public void testAnnotatedTypeEqualityIgnoresContextualFields() {
+        AnnotatedType type1 = new AnnotatedType(String.class)
+                .propertyName("userStatus");
+        AnnotatedType type2 = new AnnotatedType(String.class)
+                .propertyName("city");
+        assertEquals(type1, type2, "AnnotatedType objects with different contextual fields (e.g., propertyName) should be equal.");
+        assertEquals(type1.hashCode(), type2.hashCode(), "The hash codes of equal AnnotatedType objects must be the same.");
+    }
+
+    static class User {
+        public String username;
+        public String email;
+        public Address address;
+    }
+
+    static class Address {
+        public String street;
+        public String city;
+    }
+
+    private static class DummyModelConverter implements ModelConverter {
+        @Override
+        public Schema resolve(AnnotatedType type, ModelConverterContext context, Iterator<ModelConverter> chain) {
+            if (type.getType().equals(User.class)) {
+                context.resolve(new AnnotatedType(String.class).propertyName("username"));
+                context.resolve(new AnnotatedType(String.class).propertyName("email"));
+                context.resolve(new AnnotatedType(Address.class).propertyName("address"));
+                return new Schema();
+            }
+            if (type.getType().equals(Address.class)) {
+                context.resolve(new AnnotatedType(String.class).propertyName("street"));
+                context.resolve(new AnnotatedType(String.class).propertyName("city"));
+                return new Schema();
+            }
+            return new Schema();
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testCacheHitsForRepeatedStringTypeWithCorrectedEquals() throws Exception {
+        ModelConverterContextImpl context = new ModelConverterContextImpl(new DummyModelConverter());
+        Schema userSchema = context.resolve(new AnnotatedType(User.class));
+        assertNotNull(userSchema);
+        Field processedTypesField = ModelConverterContextImpl.class.getDeclaredField("processedTypes");
+        processedTypesField.setAccessible(true);
+        Set<AnnotatedType> processedTypes = (Set<AnnotatedType>) processedTypesField.get(context);
+        long stringTypeCount = processedTypes.stream()
+                .filter(annotatedType -> annotatedType.getType().equals(String.class))
+                .count();
+        assertEquals(stringTypeCount, 1, "With the correct equals/hashCode, String type should be added to the cache only once.");
+    }
+}