基于GraphQL、SPQR与Spring Boot实现动态查询及API性能优化

核心思路 #

利用SPQR提供的ResolutionEnvironment解析用户请求的字段结构，然后根据这些字段动态构建SQL/JPQL查询，只获取需要的数据，避免查询全量字段造成的资源浪费。

第一步：解析GraphQL请求的字段 #

先从ResolutionEnvironment中提取用户实际请求的层级化字段路径（如id、aluno.id、serie.tipoSerie.nome），可以写一个递归工具方法来遍历字段结构：

private Set<String> extractRequestedFields(ResolutionEnvironment env) {
    Set<String> fields = new HashSet<>();
    DataFetchingFieldSelectionSet selectionSet = env.getDataFetchingEnvironment().getSelectionSet();
    
    selectionSet.getFields().forEach(field -> {
        String fieldName = field.getName();
        // 处理嵌套对象的子字段
        if (field.getSelectionSet() != null && !field.getSelectionSet().getFields().isEmpty()) {
            Set<String> subFields = extractRequestedFields(new ResolutionEnvironment(env.getDataFetchingEnvironment().getSelectionSet(fieldName), env.getGraphQlContext(), env.getLocale()));
            subFields.forEach(sub -> fields.add(fieldName + "." + sub));
        } else {
            fields.add(fieldName);
        }
    });
    return fields;
}

第二步：动态构建SQL查询（三种实现方式） #

方式1：使用Spring Data JPA Criteria API（推荐，安全无注入风险）

Criteria API可以动态构建查询，完美适配字段的动态选择。修改你的AlunoSerieService方法：

@GraphQLQuery(name = "findAllAlunosSerie")
@Transactional(readOnly = true)
public List<AlunoSerieOutput> findAll(@GraphQLEnvironment ResolutionEnvironment environment) {
    Set<String> requestedFields = extractRequestedFields(environment);
    
    // 初始化Criteria查询
    CriteriaBuilder cb = alunoSerieRepository.getEntityManager().getCriteriaBuilder();
    CriteriaQuery<Object[]> query = cb.createQuery(Object[].class);
    Root<AlunoSerie> root = query.from(AlunoSerie.class);
    
    // 构建SELECT子句，只包含请求的字段
    List<Selection<?>> selections = new ArrayList<>();
    for (String field : requestedFields) {
        Path<?> path = root;
        // 拆分嵌套字段路径，如aluno.id -> root.get("aluno").get("id")
        String[] fieldParts = field.split("\\.");
        for (String part : fieldParts) {
            path = path.get(part);
        }
        selections.add(path);
    }
    query.select(cb.array(selections.toArray(new Selection[0])));
    
    // 执行查询并映射结果
    List<Object[]> results = alunoSerieRepository.getEntityManager().createQuery(query).getResultList();
    return mapResultsToOutput(results, requestedFields);
}

// 自定义结果映射逻辑，适配嵌套字段赋值
private List<AlunoSerieOutput> mapResultsToOutput(List<Object[]> results, Set<String> requestedFields) {
    List<AlunoSerieOutput> outputs = new ArrayList<>();
    for (Object[] resultRow : results) {
        AlunoSerieOutput output = new AlunoSerieOutput();
        int index = 0;
        for (String field : requestedFields) {
            String[] fieldParts = field.split("\\.");
            Object targetObj = output;
            // 遍历嵌套层级，创建空对象避免空指针
            for (int i = 0; i < fieldParts.length - 1; i++) {
                String part = fieldParts[i];
                try {
                    Field fieldRef = targetObj.getClass().getDeclaredField(part);
                    fieldRef.setAccessible(true);
                    Object subObj = fieldRef.get(targetObj);
                    if (subObj == null) {
                        subObj = fieldRef.getType().getDeclaredConstructor().newInstance();
                        fieldRef.set(targetObj, subObj);
                    }
                    targetObj = subObj;
                } catch (Exception e) {
                    throw new RuntimeException("嵌套字段映射失败", e);
                }
            }
            // 给最终字段赋值
            try {
                Field finalField = targetObj.getClass().getDeclaredField(fieldParts[fieldParts.length - 1]);
                finalField.setAccessible(true);
                finalField.set(targetObj, resultRow[index]);
            } catch (Exception e) {
                throw new RuntimeException("字段赋值失败", e);
            }
            index++;
        }
        outputs.add(output);
    }
    return outputs;
}

方式2：使用动态JPQL查询（需注意注入风险）

如果熟悉JPQL，可以直接拼接SELECT语句：

@GraphQLQuery(name = "findAllAlunosSerie")
@Transactional(readOnly = true)
public List<AlunoSerieOutput> findAll(@GraphQLEnvironment ResolutionEnvironment environment) {
    Set<String> requestedFields = extractRequestedFields(environment);
    
    // 构建JPQL的SELECT子句
    String selectClause = String.join(", ", requestedFields.stream()
            .map(f -> "a." + f) // a为AlunoSerie实体的别名
            .collect(Collectors.toList()));
    String jpql = "SELECT " + selectClause + " FROM AlunoSerie a";
    
    // 执行查询并映射结果
    List<Object[]> results = alunoSerieRepository.getEntityManager().createQuery(jpql).getResultList();
    return mapResultsToOutput(results, requestedFields);
}

注意：需确保字段名来自GraphQL的合法定义，而非用户自由输入，避免SQL注入风险。

方式3：使用Spring Data JPA Projection（适合固定字段组合场景）

定义Projection接口来匹配常用的字段组合，在Repository中添加支持动态Projection的方法：

首先定义Projection接口：

public interface AlunoSerieBasicProjection {
    Long getId();
    AlunoProjection getAluno();
    
    interface AlunoProjection {
        Long getId();
        String getNome();
    }
}

Repository添加方法：

public interface AlunoSerieRepository extends JpaRepository<AlunoSerie, Long> {
    <T> List<T> findAll(Class<T> projectionType);
}

Service中根据请求字段选择对应Projection：

@GraphQLQuery(name = "findAllAlunosSerie")
@Transactional(readOnly = true)
public List<?> findAll(@GraphQLEnvironment ResolutionEnvironment environment) {
    Set<String> requestedFields = extractRequestedFields(environment);
    
    // 根据字段组合判断使用的Projection
    if (requestedFields.contains("id") && requestedFields.contains("aluno.id") && requestedFields.contains("aluno.nome")) {
        return alunoSerieRepository.findAll(AlunoSerieBasicProjection.class);
    }
    // 其他Projection分支...
    
    // 默认返回全量字段
    return alunoSerieMapper.modelToOutput(alunoSerieRepository.findAll());
}

关键注意事项 #

• 嵌套字段处理：必须递归解析GraphQL选择集，确保嵌套对象的字段被正确提取和查询。
• 结果映射：动态查询返回Object数组，需手动或借助工具（如ModelMapper）完成DTO映射。
• 性能收益：仅查询所需字段可减少数据库IO和网络传输，有效降低API负载。

内容的提问来源于stack exchange，提问作者Diego Macario