ArchUnit中的AnyOf-谓词

Question

我想测试所有Hibernate关联注释(@manytoone、@onetomany、@onetoone、@manytomany)是否使用fetch=fetchtype.lazy。这是有效的：

private static final Set<Class<? extends Annotation>> associations =
         Set.of(ManyToOne.class, OneToMany.class, OneToOne.class, ManyToMany.class);

@ArchTest
public static final ArchRule allEntityRelationsShouldBeLazy = fields().that()
      .areDeclaredInClassesThat().areAnnotatedWith(Entity.class)
      .and()
      .areAnnotatedWith(ManyToOne.class)
      .or().areAnnotatedWith(OneToMany.class)
      .or().areAnnotatedWith(OneToOne.class)
      .or().areAnnotatedWith(ManyToMany.class)
      // what I'd like: .areAnnotatedWith(Any.of(associations))
      .should()
      .notBeAnnotatedWith(new DescribedPredicate<>("FetchType.EAGER or undefined FetchType") {
         @Override
         public boolean apply(JavaAnnotation<?> input) {
            JavaClass rawType = input.getRawType();
            if (!rawType.isEquivalentTo(OneToOne.class)
            // what I'd like: if (!Any.of(associations).apply(input)) {
                  && !rawType.isEquivalentTo(OneToMany.class)
                  && !rawType.isEquivalentTo(ManyToOne.class)
                  && !rawType.isEquivalentTo(ManyToMany.class)) {
               // Filter again, because a field can contain multiple annotations.
               return false;
            }
            return input.get("fetch")
                  .transform(JavaEnumConstant.class::cast)
                  .transform(fetchType -> !FetchType.LAZY.name().equals(fetchType.name()))
                  .or(true);
         }
      });

我必须过滤两次，因为一个字段可以有几个注释，如下所示：

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "otherEntity", referencedColumnName = "id")
private OtherEntity otherEntity;

Answer 1

您想要的可以用Java流操作构建：

import static com.tngtech.archunit.base.DescribedPredicate.describe;
import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.fields;

@ArchTest
ArchRule allEntityRelationsShouldBeLazy = fields().that()
    .areDeclaredInClassesThat().areAnnotatedWith(Entity.class)
    .and(are(annotatedWithAnyOf(associations)))
    .should().notBeAnnotatedWith(describe("FetchType.EAGER or undefined FetchType",
        input -> associations.stream().anyMatch(input.getRawType()::isEquivalentTo)
                 && input.get("fetch")
                     .transform(JavaEnumConstant.class::cast)
                     .transform(enumConst -> !FetchType.LAZY.name().equals(enumConst.name()))
                     .get()  // associations have a default fetch type
    ));
    
DescribedPredicate<CanBeAnnotated> annotatedWithAnyOf(Collection<Class<? extends Annotation>> annotations) {
    return annotations.stream()
            .map(CanBeAnnotated.Predicates::annotatedWith)
            .reduce(DescribedPredicate::or)
            .get();  // annotations must not be empty
}