Add better feedback when using abstract classes in serialization (#1179)

* Add better feedback when using abstract class in serialization

* Add one more check for abstract class

* Add check for primitive

* Add check for array class

* fix: Remove abstract class check from hot path, add a new test for abstract class serialization and add more informative error message in defaultInstantiatorStrategy

* remove dev logs

* Add more tests regarding abstract classes and add more feedback for InstantionError

* Clean up the Tests and move creation of exceptions into its own method

* remove unnecessary import

* Apply formatter and add license header to DefaultInstantiatorStrategyTest

Author: pvlov

src/com/esotericsoftware/kryo/util/DefaultInstantiatorStrategy.java

@@ -1,15 +1,15 @@
 /* Copyright (c) 2008-2023, Nathan Sweet
  * All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
  * conditions are met:
- * 
+ *
  * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
  * disclaimer in the documentation and/or other materials provided with the distribution.
  * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
  * from this software without specific prior written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
@@ -49,6 +49,7 @@ public InstantiatorStrategy getFallbackInstantiatorStrategy () {
 	}
 
 	public ObjectInstantiator newInstantiatorOf (final Class type) {
+
 		if (!Util.isAndroid) {
 			// Use ReflectASM if the class is not a non-static member class.
 			Class enclosingType = type.getEnclosingClass();
@@ -61,8 +62,8 @@ public ObjectInstantiator newInstantiatorOf (final Class type) {
 						public Object newInstance () {
 							try {
 								return access.newInstance();
-							} catch (Exception ex) {
-								throw new KryoException("Error constructing instance of class: " + className(type), ex);
+							} catch (Exception | InstantiationError ex) {
+								throw createInstantiationError(type, ex);
 							}
 						}
 					};
@@ -86,17 +87,17 @@ public Object newInstance () {
 					try {
 						return constructor.newInstance();
 					} catch (Exception ex) {
-						throw new KryoException("Error constructing instance of class: " + className(type), ex);
+						throw createInstantiationError(type, ex);
 					}
 				}
 			};
 		} catch (Exception ignored) {
 		}
 
 		if (fallbackStrategy == null) {
-			if (type.isMemberClass() && !Modifier.isStatic(type.getModifiers()))
+			if (type.isMemberClass() && !Modifier.isStatic(type.getModifiers())) {
 				throw new KryoException("Class cannot be created (non-static member class): " + className(type));
-			else {
+			} else {
 				StringBuilder message = new StringBuilder("Class cannot be created (missing no-arg constructor): " + className(type));
 				if (type.getSimpleName().equals("")) {
 					message
@@ -108,10 +109,29 @@ public Object newInstance () {
 						.append("2. Register a FieldSerializer for the containing class and call FieldSerializer\n")
 						.append("setIgnoreSyntheticFields(false) on it. This is not safe but may be sufficient temporarily.");
 				}
+
+				if (type.isInterface()) {
+					message.append(
+						"\nNote: The type you are trying to serialize into is abstract (interface). Kryo will not be able to create an instance of it. Possible solutions:\n")
+						.append(
+							"You can either use a class that implements the interface or use a custom ObjectInstantiator to create an instance.");
+				}
+
 				throw new KryoException(message.toString());
 			}
 		}
 		// InstantiatorStrategy.
 		return fallbackStrategy.newInstantiatorOf(type);
 	}
+
+	private KryoException createInstantiationError (Class type, Throwable throwable) {
+		StringBuilder message = new StringBuilder("Error constructing instance of class: " + className(type));
+		// Note: For Array and Primitive types the abstract bit is always set.
+		if (!type.isArray() && !type.isPrimitive() && Modifier.isAbstract(type.getModifiers())) {
+			message.append(
+				"\nNote: The type you are trying to serialize into is abstract. Kryo will not be able to create an instance of it. Possible solutions:\n")
+				.append("You can either use a concrete subclass or use a custom ObjectInstantiator to create an instance.");
+		}
+		return new KryoException(message.toString(), throwable);
+	}
 }

test/com/esotericsoftware/kryo/DefaultInstantiatorStrategyTest.java

@@ -0,0 +1,68 @@
+/* Copyright (c) 2025, Daniel Pavlov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the distribution.
+ * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+package com.esotericsoftware.kryo;
+
+import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+public class DefaultInstantiatorStrategyTest {
+
+    DefaultInstantiatorStrategy instantiatorStrategy = new DefaultInstantiatorStrategy();
+
+    @Test
+    public void testAbstractStaticMemberClassCannotBeInstantiated() {
+        KryoException thrown = assertThrows(KryoException.class, () -> tryInstantiate(AbstractStaticMemberClass.class));
+        assertTrue(thrown.getMessage().contains("The type you are trying to serialize into is abstract."));
+    }
+
+    @Test
+    public void testInterfaceMemberClassCannotBeInstantiated() {
+        KryoException thrown = assertThrows(KryoException.class, () -> tryInstantiate(MemberInterface.class));
+        assertTrue(thrown.getMessage().contains("The type you are trying to serialize into is abstract (interface)."));
+    }
+
+    @Test
+    public void testAbstractClassCannotBeInstantiated() {
+        KryoException thrown = assertThrows(KryoException.class, () -> tryInstantiate(AbstracClass.class));
+        assertTrue(thrown.getMessage().contains("The type you are trying to serialize into is abstract."));
+    }
+
+    @Test
+    public void testInterfaceClassCannotBeInstantiated() {
+        KryoException thrown = assertThrows(KryoException.class, () -> tryInstantiate(InterfaceClass.class));
+        assertTrue(thrown.getMessage().contains("The type you are trying to serialize into is abstract (interface)."));
+    }
+
+    public void tryInstantiate(Class type) {
+        instantiatorStrategy.newInstantiatorOf(type).newInstance();
+    }
+
+    private static abstract class AbstractStaticMemberClass {}
+
+    private interface MemberInterface {}
+}
+
+abstract class AbstracClass {}
+
+interface InterfaceClass {}