0

我的目标是遍历一个 graphql Java 文档对象并返回最大深度。

示例：深度 0

{
   name 
}

示例：深度 1

{
   viewer{
     viewerId
   }
}

示例：深度 2

{
   viewer{
     albums{
       albumId
     }
   }
}

示例：深度 2。如您所见，两张专辑/歌曲都在同一个父“查看者”下

{
   viewer{
     albums{
       albumId
     }
     songs{
        songId
     }
   }
}

示例：深度 3

{
   viewer{
     albums{
       tracks{
          trackId
       }
     }
   }
}

我已经编写了基本代码来遍历它，但是我的代码不适用于深度 = 2 的第二个版本。它返回深度 = 3 而不是 2。原因是因为它在同一个父级下计数了两次。本质上的逻辑是这样的：当一个字段有孩子时，深度 = 深度 + 1。

import graphql.language.Document;
import graphql.language.Node;
import graphql.language.OperationDefinition;

public int checkDepthLimit(String query) {
    Document document;
    try {
        document = documentParser.parseDocument(query);
    } catch (Exception e) {}

    Optional<Node> queryNode = document.getChildren().stream()
            .filter(n -> (n.getClass() == OperationDefinition.class))
            .findFirst();

    return checkDepthLimit(queryNode.get());

}

private int checkDepthLimit(Node queryNode) {

    int depth = 0;
    String nodeType = queryNode.getClass().getSimpleName().toUpperCase();

    if (nodeType.equals("FIELD")) {
        if (!queryNode.getChildren().isEmpty()) {
            depth += 1;
        }
    }

    List<Node> nodeChildren = queryNode.getChildren();
    for (int i = 0; i < nodeChildren.size(); i++) {
        depth += checkDepthLimit(nodeChildren.get(i));
    }
    return depth;

}

String query = "{
       viewer{
           viewerId
       }"
QueryComplexity c = new QueryComplexity();
int depth = c.checkDepthLimit(query);

我被困住了，如果有更深入的递归知识的人能够帮助我，我将不胜感激。

4

2 回答 2

5

从 graphql-java v4.0 开始，有一个内置QueryTraversal类可以帮助您检查查询 AST 和用于限制深度的相关工具：MaxQueryDepthInstrumentation

只需像任何其他仪器一样注册它：

GraphQL runtime = GraphQL.newGraphQL(schema)
    .instrumentation(new MaxQueryDepthInstrumentation(MAX_DEPTH))
    .build();

还有MaxQueryComplexityInstrumentation。

graphql-spqr（由我编写）还具有指定字段复杂性的声明性方式：

public static class PetService {

    @GraphQLQuery(name = "pet")
    @GraphQLComplexity("type == 'big' ? 10 : 2") //JavaScript expression calculating the complexity
    public Pet findPet(@GraphQLArgument(name = "type") String type) {
        return db.findPetByType(type);
    }
}

您ComplexityAnalysisInstrumentation可以手动注册，同上：

GraphQL runtime = GraphQL.newGraphQL(schema)
    .instrumentation(new ComplexityAnalysisInstrumentation(new JavaScriptEvaluator(), MAX_DEPTH))
    .build();

或者使用 SPQR 的GraphQLRuntime包装器：

GraphQL runtime = GraphQLRuntime.newGraphQL(schema)
            .maximumQueryComplexity(maxComplexity)
            .build();
于 2017-09-04T09:19:17.977 回答
3

错误是您迭代孩子的地方。正如您已经认识到的（“计数两次”），您将每个孩子的深度添加到当前深度，但您应该只添加最深的一个。

这可以解决问题：

    List<Node> nodeChildren = queryNode.getChildren();
    int maxChildDepth = 0;
    for (int i = 0; i < nodeChildren.size(); i++) {
        final int currentChildDepth = checkDepthLimit(nodeChildren.get(i));
        maxChildDepth = Math.max(maxChildDepth, currentChildDepth);
    }
    depth += maxChildDepth;
    return depth;
于 2017-08-22T23:54:37.390 回答