java - 降低函数的圈复杂度

Question

我有一个函数，它使用 JPA Criteria API 根据我传递给它的一些参数从数据库检索数据。使用对象 gridParams 传递参数，如下所示:

public List<MyObjectDTO> find(final GridParamsDTO gridParams) {

        final CriteriaBuilder builder = getCriteriaBuilder();
        final List<Predicate> predicates = new ArrayList<>();

        final CriteriaQuery<MyObjectDTO> criteriaQuery = builder.createQuery(MyObjectDTO.class);

        final Root<MyObject> from = criteriaQuery.from(MyObject.class);

        Join<MyObject, AnotherObject> join = from.join(MyObject_.anotherObject, JoinType.LEFT);

        if ((gridParams.getFilter() != null) && (gridParams.getFilter().length > 0)) {

            for (final GridFilterDTO filter : gridParams.getFilter()) {
                if ("fieldX".equals(filter.getField())) {
                    final List<Predicate> sqPredicates = new ArrayList<>();
                    Subquery<Long> sq = criteriaQuery.subquery(Long.class);
                    Root<ObjectX> sqFrom = sq.from(ObjectX.class);
                    sqPredicates
                            .add(builder.equal(sqFrom.get(ObjectX_.organismeIDE), filter.getFilterSingleValue()));
                    sq.select(sqFrom.get(ObjectX_.referentielID).get(MyObject_.objectX));
                    sq.where(builder.and(sqPredicates.toArray(new Predicate[sqPredicates.size()])));
                    predicates.add(builder.in(from.get(MyObject_.objectX)).value(sq));
                }
                if ("fieldA".equals(filter.getField()) || "fieldB".equals(filter.getField())) {
                    final GridFilterOperatorEnum gridFilterEnumValues = GridFilterOperatorEnum.values()[filter.getOperator().ordinal()];
                    switch (gridFilterEnumValues) {
                    case TEXT_CONTAINS:
                        predicates.add(builder.like(builder.upper(from.get(filter.getField())), "%" + filter.getFilterSingleValue().toUpperCase() + "%"));
                        break;
                    case TEXT_START_WITH:
                        predicates.add(builder.like(builder.upper(from.get(filter.getField())), filter.getFilterSingleValue().toUpperCase() + "%"));
                        break;
                    case TEXT_DIFFERENT:
                        predicates.add(builder.notEqual(from.get(filter.getField()), filter.getFilterSingleValue()));
                        break;
                    case TEXT_END_WITH:
                        predicates.add(builder.like(builder.upper(from.get(filter.getField())), "%" + filter.getFilterSingleValue().toUpperCase()));
                        break;
                    case TEXT_EQUALS:
                        predicates.add(builder.equal(builder.upper(from.get(filter.getField())), filter.getFilterSingleValue().toUpperCase()));
                        break;
                    default:
                        break;
                    }
                }
                if ("dateField1".equals(filter.getField()) || "dateField2".equals(filter.getField())) {
                    final GridFilterOperatorEnum gridFilterEnumValues = GridFilterOperatorEnum.values()[filter.getOperator().ordinal()];
                    switch (gridFilterEnumValues) {
                    case DATE_EQUALS:
                        predicates.add(builder.equal(from.<LocalDate> get(filter.getField()), LocalDate.parse(filter.getFilterSingleValue())));
                        break;
                    case DATE_BEFORE:
                        predicates.add(builder.lessThan(from.<LocalDate> get(filter.getField()), LocalDate.parse(filter.getFilterSingleValue())));
                        break;
                    case DATE_AFTER:
                        predicates.add(builder.greaterThan(from.<LocalDate> get(filter.getField()), LocalDate.parse(filter.getFilterSingleValue())));
                        break;
                    case DATE_BETWEEN:
                        predicates.add(
                                builder.between(from.<LocalDate> get(filter.getField()), LocalDate.parse(filter.getFilterSetValues()[0]),
                                        LocalDate.parse(filter.getFilterSetValues()[1])));
                        break;
                    default:
                        break;
                    }
                }
                if ("anotherField".equals(filter.getField())) {
                    if (filter.getFilterSetValues().length > 0) {
                        predicates
                                .add(builder.isTrue(join.get(AnotherObject_.lib).in((Object[]) filter.getFilterSetValues())));
                    } else {
                        predicates.add(join.get(AnotherObject_.lib).isNull());
                    }

                }
            }

        }

        if (gridParams.hasSort()) {
            List<Order> orderList = new ArrayList<>();
            for (IGridSort gridSort : gridParams.getSort()) {
                if (ArrayUtils.contains(new String[] { "fieldA", "dateField1", "dateField2", "fieldB" }, gridSort.getField())) {
                    if (gridSort.getSort().equalsIgnoreCase(GridSortDTO.ASC)) {
                        orderList.add(builder.asc(from.get(gridSort.getField())));
                    } else if (gridSort.getSort().equalsIgnoreCase(GridSortDTO.DESC)) {
                        orderList.add(builder.desc(from.get(gridSort.getField())));
                    }
                }
                if (gridSort.getField().equalsIgnoreCase("anotherField")) {
                    if (gridSort.getSort().equalsIgnoreCase(GridSortDTO.ASC)) {
                        orderList.add(builder.asc(join.get(AnotherObject_.lib)));
                    } else if (gridSort.getSort().equalsIgnoreCase(GridSortDTO.DESC)) {
                        orderList.add(builder.desc(join.get(AnotherObject_.lib)));
                    }
                }
            }
            if (!orderList.isEmpty()) {
                criteriaQuery.orderBy(orderList);
            }
        }

        predicates.add(builder.between(builder.literal(LocalDate.now()), from.get(MyObject_.dateDebut),
                from.get(MyObject_.dateFin)));

        criteriaQuery.multiselect(from.get(MyObject_.objectX), from.get(MyObject_.dateDebut), from.get(MyObject_.dateFin),
                from.get(MyObject_.lib), from.get(MyObject_.coleur), join,
                from.get(MyObject_.refExterne));
        criteriaQuery.where(builder.and(predicates.toArray(new Predicate[predicates.size()])));
        criteriaQuery.distinct(true);

        final TypedQuery<MyObjectDTO> typedQuery = getEntityManager().createQuery(criteriaQuery);

        if (gridParams.hasStart()) {
            typedQuery.setFirstResult(gridParams.getStartRow());
        }
        if (gridParams.hasEnd()) {
            typedQuery.setMaxResults(gridParams.getEndRow() - Math.max(0, gridParams.getStartRow()));
        }

        return typedQuery.getResultList();
    }
}

问题是 SonarQube 提示这个方法“find”的循环复杂度是 31，大于授权的 30，我做了一些研究，发现我必须重构我的函数以降低循环复杂度。

在此函数中，我必须测试 gridParams 是否定义了 4 个字段:(开始、结束、排序和过滤器)，排序和过滤器是对象数组，因此我必须迭代它们。

最终我需要检查很多字段，但我不知道如何在没有大量检查的情况下完成此操作:/

我该如何解决这个问题？

Answer 1

您可能想首先查看 Refactoring Catalog 中的一些重构。 .

如果你看看你的方法，你会发现有很多部分:

• 编译谓词列表的部分
• 编译订单列表的部分
• 创建查询的部分
• 运行查询的部分

这些是使用提取方法重构重构为单独方法的良好候选者。一旦这些部分被提取到新的方法中，就可以在每种方法上重复该过程，直到您认为您已经完成了尽可能多的操作。然后，您可以查看您创建的新方法并识别那些操作相同数据的方法。他们可能希望转移到单独的类，例如查询类。

switch 语句看起来也很适合用多态性重构替换条件。

如果有疑问，请从小处开始，一次进行一个简单的重构。