LAB-2 Реализация защиты от зацикливания при генерации параметров того же типа в кейсе с циклическими/перекрестными зависимостями

Author: NobleBeer

src/main/java/org/example/GenerateExample.java

@@ -11,7 +11,7 @@
 
 public class GenerateExample {
     public static void main(String[] args) {
-        InstanceGenerator instanceGenerator = new InstanceGenerator();
+        var instanceGenerator = new InstanceGenerator();
         try {
             var generated1 = instanceGenerator.generateValueOf(Example.class);
             System.out.println(generated1);

src/main/java/org/example/generator/InstanceGenerator.java

@@ -11,60 +11,96 @@
 import java.lang.reflect.Type;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Deque;
+import java.util.ArrayDeque;
+import java.util.Objects;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class InstanceGenerator {
+
     private final ImplementationIndex implementationIndex;
+    private final ThreadLocal<Deque<Class<?>>> constructing = ThreadLocal.withInitial(ArrayDeque::new);
 
     public InstanceGenerator() {
         var discovered = ClassPathScanner.scanForAnnotatedClasses();
         this.implementationIndex = new ImplementationIndex(discovered);
     }
 
     public Object generateValueOf(Class<?> type) {
+        return generateValueOf(type, -1);
+    }
+
+    private Object generateValueOf(Class<?> type, int depth) {
         var primitive = PrimitiveValueGenerator.getGenerator(type);
-        if (primitive.isPresent()) return primitive.get().get();
+        if (primitive.isPresent()) {
+            return primitive.get().get();
+        }
 
         if (type.isInterface()) {
             var impl = implementationIndex.randomImplementationFor(type);
-            if (impl.isEmpty()) throw new IllegalArgumentException("Не найдены реализации интерфейса: " + type.getName());
-            return generateSafely(impl.get());
+            if (impl.isEmpty())
+                throw new IllegalArgumentException("Не найдены реализации интерфейса: " + type.getName());
+            return generateSafely(impl.get(), depth);
         }
 
         if (Modifier.isAbstract(type.getModifiers())) {
             throw new IllegalArgumentException("Класс " + type.getName() + " является абстрактным, не удаётся создать экземпляр");
         }
 
-        if (!type.isAnnotationPresent(CustomClassGenerator.class)) {
-            throw new IllegalArgumentException("Класс " + type.getName() + " нельзя сгенерировать. Требуется аннотация @CustomClassGenerator");
+        if (depth == 0) {
+            return null;
         }
 
-        var constructors = type.getDeclaredConstructors();
-        if (constructors.length == 0) throw new IllegalArgumentException("Класс " + type.getName() + " не имеет конструкторов");
-
+        var stack = constructing.get();
+        if (stack.contains(type) && !Objects.equals(stack.peek(), type)) {
+            return null;
+        }
 
-        Constructor<?> constructor = constructors[RandomProvider.RANDOM.nextInt(constructors.length)];
-        var args = buildArgsForConstructor(constructor);
+        stack.push(type);
         try {
-            constructor.setAccessible(true);
-            return type.cast(constructor.newInstance(args));
-        } catch (Throwable e) {
-            throw new RuntimeException("Не удалось создать экземпляр " + type.getName(), e);
+            if (!type.isAnnotationPresent(CustomClassGenerator.class)) {
+                throw new IllegalArgumentException("Класс " + type.getName() + " нельзя сгенерировать. Требуется аннотация @CustomClassGenerator");
+            }
+
+            var constructors = type.getDeclaredConstructors();
+            if (constructors.length == 0) throw new IllegalArgumentException("Класс " + type.getName() + " не имеет конструкторов");
+
+            Constructor<?> constructor = constructors[RandomProvider.RANDOM.nextInt(constructors.length)];
+
+            int allowedForChildren = depth > 0 ? depth - 1 : -1;
+            var args = buildArgsForConstructor(constructor, allowedForChildren);
+            try {
+                return type.cast(constructor.newInstance(args));
+            } catch (Throwable e) {
+                throw new RuntimeException("Не удалось создать экземпляр " + type.getName(), e);
+            }
+        } finally {
+            stack.pop();
+            if (stack.isEmpty()) constructing.remove();
         }
     }
 
-    private Object generateSafely(Class<?> currentClass) {
+    private Object generateSafely(Class<?> currentClass, int depth) {
         try {
-            return generateValueOf(currentClass);
+            return generateValueOf(currentClass, depth);
         } catch (Exception e) {
             throw new RuntimeException("Не удается создать значение для " + currentClass.getName(), e);
         }
     }
 
-    private Object[] buildArgsForConstructor(Constructor<?> constructor) {
+    private Object generateSafely(Class<?> currentClass) {
+        return generateSafely(currentClass, -1);
+    }
+
+    private Object[] buildArgsForConstructor(Constructor<?> constructor, int allowedSelfDepthForChildren) {
         var parameters = constructor.getParameters();
         var args = new Object[parameters.length];
+        Class<?> declaringClass = constructor.getDeclaringClass();
+
+        final Integer[] perConstructorSelfDepth = new Integer[] {
+                allowedSelfDepthForChildren >= 0 ? allowedSelfDepthForChildren : null
+        };
 
         IntStream.range(0, parameters.length).forEach(i -> {
             var parameter = parameters[i];
@@ -119,6 +155,15 @@ private Object[] buildArgsForConstructor(Constructor<?> constructor) {
                 return;
             }
 
+            if (parameterType.equals(declaringClass)) {
+                if (perConstructorSelfDepth[0] == null) {
+                    perConstructorSelfDepth[0] = 1 + RandomProvider.RANDOM.nextInt(3);
+                }
+                int depthToPass = perConstructorSelfDepth[0];
+                args[i] = generateSafely(parameterType, depthToPass);
+                return;
+            }
+
             args[i] = generateSafely(parameterType);
         });
 
@@ -141,4 +186,4 @@ private Class<?> resolveClassFromType(Type type) {
 
         return null;
     }
-}
+}