如何在GraphQL-java-8中处理实现接口的动态类型数据绑定？

我来帮你解决这个问题，你遇到的核心问题是：GraphQL 默认的字段获取逻辑是针对 JavaBean 设计的（通过 getter 方法或直接字段访问），但你当前用 Map 作为数据载体，导致子类的专属字段（比如 weight）无法被自动解析，所以返回 null。下面是两种可行的解决方案，还有一些优化建议：

问题根源回顾 #

你的类型解析器已经能正确判断对象对应的 GraphQL 类型，但数据绑定环节缺失：当数据是 Map 时，GraphQL 不知道该如何从 Map 中提取子类的专属字段值，只能返回 null。

方案一：基于 Map 自定义字段 DataFetcher #

如果你想继续用 Map 作为数据对象，可以通过 WiringFactory 为每个子类的专属字段指定自定义的 DataFetcher，明确告诉 GraphQL 如何从 Map 中取值。

修改你的 RuntimeWiring 代码如下：

return RuntimeWiring.newRuntimeWiring()
    .wiringFactory(new WiringFactory() {
        @Override
        public DataFetcher<?> getFieldDataFetcher(FieldWiringEnvironment env) {
            // 处理 Fish 的 weight 字段
            if ("Fish".equals(env.getParentType().getName()) && "weight".equals(env.getFieldDefinition().getName())) {
                return env -> {
                    Map<String, Object> fishMap = env.getSource();
                    return fishMap.get("weight");
                };
            }
            // 处理 Fruit 的 Color 字段
            if ("Fruit".equals(env.getParentType().getName()) && "Color".equals(env.getFieldDefinition().getName())) {
                return env -> {
                    Map<String, Object> fruitMap = env.getSource();
                    return fruitMap.get("Color");
                };
            }
            // 处理 Toy 的 description 字段
            if ("Toy".equals(env.getParentType().getName()) && "description".equals(env.getFieldDefinition().getName())) {
                return env -> {
                    Map<String, Object> toyMap = env.getSource();
                    return toyMap.get("description");
                };
            }
            // 其他字段使用默认 DataFetcher
            return WiringFactory.super.getFieldDataFetcher(env);
        }
    })
    .type(TypeRuntimeWiring.newTypeWiring("ResultOne")
        .typeResolver(env -> {
            if (env.getObject() instanceof Map) {
                Map<?, ?> object = (Map<?, ?>) env.getObject();
                String name = (String) object.get("name");
                // 用 switch 替代多重 if，更简洁
                switch (name) {
                    case "fish":
                        return (GraphQLObjectType) env.getSchema().getType("Fish");
                    case "fruit":
                        return (GraphQLObjectType) env.getSchema().getType("Fruit");
                    case "toy":
                        return (GraphQLObjectType) env.getSchema().getType("Toy");
                    default:
                        return null;
                }
            }
            return null;
        })
    )
    .build();

方案二：转换为 Java 实体类（更推荐） #

如果业务允许，把外部接口返回的 Map 转换成对应的 Java 实体类，这样 GraphQL 可以通过反射自动解析所有字段，不需要自定义 DataFetcher，代码更易维护。

1. 创建对应实体类 #

// 对应 GraphQL 的 ResultOne 接口
public interface ResultOne {
    String getName();
    String getContent();
}

// 对应 Fish 类型
public class Fish implements ResultOne {
    private String name;
    private String content;
    private Float weight;

    // 从 Map 构造实体
    public Fish(Map<String, Object> map) {
        this.name = (String) map.get("name");
        this.content = (String) map.get("content");
        this.weight = (Float) map.get("weight");
    }

    // Getter 方法
    @Override
    public String getName() { return name; }
    @Override
    public String getContent() { return content; }
    public Float getWeight() { return weight; }
}

// 对应 Fruit 类型
public class Fruit implements ResultOne {
    private String name;
    private String content;
    private String color;

    public Fruit(Map<String, Object> map) {
        this.name = (String) map.get("name");
        this.content = (String) map.get("content");
        this.color = (String) map.get("Color");
    }

    @Override
    public String getName() { return name; }
    @Override
    public String getContent() { return content; }
    public String getColor() { return color; }
}

// 对应 Toy 类型
public class Toy implements ResultOne {
    private String name;
    private String content;
    private String description;

    public Toy(Map<String, Object> map) {
        this.name = (String) map.get("name");
        this.content = (String) map.get("content");
        this.description = (String) map.get("description");
    }

    @Override
    public String getName() { return name; }
    @Override
    public String getContent() { return content; }
    public String getDescription() { return description; }
}

2. 转换外部接口数据 #

在你的数据获取逻辑中，把 Map 列表转换成实体类列表：

// 假设 externalService.fetchData() 返回外部接口的原始 Map 数据
List<Map<String, Object>> rawData = externalService.fetchData(name, category);
List<ResultOne> resultList = rawData.stream().map(map -> {
    String type = (String) map.get("name");
    switch (type) {
        case "fish":
            return new Fish(map);
        case "fruit":
            return new Fruit(map);
        case "toy":
            return new Toy(map);
        default:
            return null;
    }
}).collect(Collectors.toList());

3. 简化类型解析器 #

现在对象是具体的 Java 类，类型解析器可以更直观：

.type(TypeRuntimeWiring.newTypeWiring("ResultOne")
    .typeResolver(env -> {
        Object source = env.getObject();
        if (source instanceof Fish) {
            return (GraphQLObjectType) env.getSchema().getType("Fish");
        } else if (source instanceof Fruit) {
            return (GraphQLObjectType) env.getSchema().getType("Fruit");
        } else if (source instanceof Toy) {
            return (GraphQLObjectType) env.getSchema().getType("Toy");
        }
        return null;
    })
)

额外优化：修正查询语法 #

你的示例查询有语法错误，正确的查询应该是：

{
  search(name: "Salmon", category: "food") {
    name
    content
    ... on Fish {
      weight
    }
    ... on Fruit {
      Color
    }
    ... on Toy {
      description
    }
  }
}

不需要在 search 里嵌套 ResultOne，因为 search 返回的就是 [ResultOne] 列表，直接展开字段即可。

内容的提问来源于stack exchange，提问作者Md. Hasan Basri