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

NobleBeer · NobleBeer · commit 188498be76e9 · 2025-10-10T18:29:28.000+03:00
diff --git a/src/main/java/org/example/GenerateExample.java b/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);
diff --git a/src/main/java/org/example/classes/BinaryTreeNode.java b/src/main/java/org/example/classes/BinaryTreeNode.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public class BinaryTreeNode {
     private Integer data;
     private BinaryTreeNode left;
diff --git a/src/main/java/org/example/classes/Cart.java b/src/main/java/org/example/classes/Cart.java
@@ -1,10 +1,10 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
 import java.util.List;
 
-@CustomClassGenerator
+@Generatable
 public class Cart {
     private List<Product> items;
 
diff --git a/src/main/java/org/example/classes/Example.java b/src/main/java/org/example/classes/Example.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public class Example {
     int i;
 
diff --git a/src/main/java/org/example/classes/Product.java b/src/main/java/org/example/classes/Product.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public class Product {
     private String name;
     private double price;
diff --git a/src/main/java/org/example/classes/Rectangle.java b/src/main/java/org/example/classes/Rectangle.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public class Rectangle implements Shape {
     private double length;
     private double width;
diff --git a/src/main/java/org/example/classes/Shape.java b/src/main/java/org/example/classes/Shape.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public interface Shape {
     double getArea();
     double getPerimeter();
diff --git a/src/main/java/org/example/classes/Triangle.java b/src/main/java/org/example/classes/Triangle.java
@@ -1,8 +1,8 @@
 package org.example.classes;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
-@CustomClassGenerator
+@Generatable
 public class Triangle implements Shape {
     private double sideA;
     private double sideB;
diff --git a/src/main/java/org/example/generator/ClassPathScanner.java b/src/main/java/org/example/generator/ClassPathScanner.java
@@ -1,6 +1,6 @@
 package org.example.generator;
 
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
 import java.io.File;
 import java.util.Arrays;
@@ -49,7 +49,7 @@ private static Set<Class<?>> scanDirectory(File dir, String targetPackage) {
     private static Optional<Class<?>> tryAddClass(String className) {
         try {
             var name = Class.forName(className);
-            if (name.isAnnotationPresent(CustomClassGenerator.class)) {
+            if (name.isAnnotationPresent(Generatable.class)) {
                 return Optional.of(name);
             }
         } catch (Throwable ignored) {}
diff --git a/src/main/java/org/example/generator/ImplementationIndex.java b/src/main/java/org/example/generator/ImplementationIndex.java
@@ -1,7 +1,7 @@
 package org.example.generator;
 
 import org.example.common.RandomProvider;
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -31,7 +31,7 @@ public Optional<Class<?>> randomImplementationFor(Class<?> currentInterface) {
     private void buildIndex() {
         annotatedTypes.stream()
                 .flatMap(currentClass -> {
-                    CustomClassGenerator annotation = currentClass.getAnnotation(CustomClassGenerator.class);
+                    Generatable annotation = currentClass.getAnnotation(Generatable.class);
 
                     if (annotation != null && annotation.implementsFor().length > 0) {
                         return Arrays.stream(annotation.implementsFor())
diff --git a/src/main/java/org/example/generator/InstanceGenerator.java b/src/main/java/org/example/generator/InstanceGenerator.java
@@ -1,7 +1,7 @@
 package org.example.generator;
 
 import org.example.common.RandomProvider;
-import org.example.generator.annotation.CustomClassGenerator;
+import org.example.generator.annotation.Generatable;
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
@@ -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(Generatable.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;
     }
-}
+}
diff --git a/src/main/java/org/example/generator/annotation/Generatable.java b/src/main/java/org/example/generator/annotation/Generatable.java
@@ -3,8 +3,8 @@
 import java.lang.annotation.*;
 
 @Inherited
-@Target(value= ElementType.TYPE)
-@Retention(value= RetentionPolicy.RUNTIME)
-public @interface CustomClassGenerator {
+@Target(value = ElementType.TYPE)
+@Retention(value = RetentionPolicy.RUNTIME)
+public @interface Generatable {
     Class<?>[] implementsFor() default {};
 }
