在ArchUnit中，泛型的循环依赖是无法被自动检测到的。这是因为ArchUnit的静态分析是基于Java字节码而不是运行时实例的。

要解决这个问题，可以使用一些手动的方法来检测泛型的循环依赖。

以下是一个示例代码，演示了如何手动检测泛型的循环依赖：

import com.tngtech.archunit.lang.ArchRule;
import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
import com.tngtech.archunit.library.dependencies.SlicesRuleDefinition;
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;

@AnalyzeClasses(packages = "your.package.name")
public class ArchUnitTest {

    @ArchTest
    public static final ArchRule noCircularDependencies = ArchRuleDefinition.classes()
            .should(SlicesRuleDefinition.slices().matching("..your.package.name.(**)..").should().beFreeOfCycles());

    @ArchTest
    public static final ArchRule noGenericCircularDependencies = ArchRuleDefinition.classes()
            .should(ArchUnitHelper::checkNoGenericCircularDependencies);

    private static boolean checkNoGenericCircularDependencies(JavaClasses classes) {
        // 获取所有的泛型类
        Set> genericClasses = classes.stream()
                .filter(clazz -> clazz.getGenericSuperclass() instanceof ParameterizedType)
                .map(clazz -> (ParameterizedType) clazz.getGenericSuperclass())
                .map(ParameterizedType::getRawType)
                .collect(Collectors.toSet());

        // 检查泛型类之间的依赖关系
        for (Class clazz : genericClasses) {
            Set> dependencies = findDependencies(clazz);

            if (dependencies.contains(clazz)) {
                System.out.println("Circular dependency detected: " + clazz.getName());
                return false;
            }
        }
        return true;
    }

    private static Set> findDependencies(Class clazz) {
        Set> dependencies = new HashSet<>();

        // 获取泛型类的参数类型
        Type[] typeArguments = ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments();

        for (Type typeArgument : typeArguments) {
            if (typeArgument instanceof Class) {
                dependencies.add((Class) typeArgument);
            } else if (typeArgument instanceof ParameterizedType) {
                dependencies.add((Class) ((ParameterizedType) typeArgument).getRawType());
            } else if (typeArgument instanceof TypeVariable) {
                dependencies.add((Class) ((TypeVariable) typeArgument).getBounds()[0]);
            }
        }

        return dependencies;
    }
}

在上面的示例代码中，使用了ArchUnit的API来创建两个Arch规则。

noCircularDependencies规则使用了SlicesRuleDefinition.slices().should().beFreeOfCycles()方法来检测包之间的循环依赖。

noGenericCircularDependencies规则使用了自定义的checkNoGenericCircularDependencies方法来检测泛型类之间的循环依赖。这个方法首先获取所有的泛型类，然后检查每个泛型类的依赖关系。如果发现循环依赖，就会输出错误信息。

在测试中，你可以使用@AnalyzeClasses注解来指定要分析的包，然后运行这个测试类来检测代码中的循环依赖问题。

需要注意的是，这种手动的检测方法可能会有一些限制和局限性，因为它仅仅是在静态分析阶段进行检查，无法获取运行时实例的信息。因此，建议在开发过程中使用这种方法来辅助检查循环依赖问题，但不应该完全依赖这个方法来解决所有的循环依赖。最佳实践是在编码过程中避免出现循环依赖问题，以确保代码的健壮性和可维护性。