使用SPQR从Cayenne生成类生成GraphQL Schema遇阻求助

首先得说清楚你遇到的错误根源：SPQR默认是基于JavaBean规范（标准getter/setter）或者字段注解来识别类属性的，但Apache Cayenne的实体类用的是动态属性访问（readProperty/writeProperty），那些静态的Property常量SPQR也没法自动识别，导致它无法正确生成对应的GraphQL类型，最终抛出那个根字段格式错误的异常。

下面给你两个无需修改Cayenne实体类的解决方案，你可以根据自己的场景选择：

方案一：自定义SPQR类型解析器（TypeResolver） #

这个方案适合实体类较多、不想写大量重复DTO的场景，核心是告诉SPQR怎么解析Cayenne实体的属性。

步骤1：实现自定义TypeResolver #

我们可以通过Cayenne的元数据API获取实体的属性信息，手动构建GraphQL类型：

import graphql.schema.*;
import org.apache.cayenne.Persistent;
import org.apache.cayenne.map.ObjAttribute;
import org.apache.cayenne.map.ObjEntity;
import org.apache.cayenne.map.ObjRelationship;
import org.apache.cayenne.server.ServerRuntime;
import io.leangen.graphql.spqr.spring.util.TypeResolver;

public class CayenneEntityTypeResolver implements TypeResolver {

    @Override
    public GraphQLObjectType resolve(TypeResolutionEnvironment env) {
        Class<?> targetType = env.getType();
        
        // 只处理Cayenne的持久化实体类
        if (!Persistent.class.isAssignableFrom(targetType)) {
            return null; // 交给SPQR默认逻辑处理
        }

        // 获取Cayenne的实体元数据
        ObjEntity objEntity = ServerRuntime.getRuntime()
                .getChannel()
                .getEntityResolver()
                .lookupObjEntity(targetType);

        // 构建GraphQL对象类型
        GraphQLObjectType.Builder typeBuilder = GraphQLObjectType.newObject()
                .name(targetType.getSimpleName());

        // 映射所有基本属性
        for (ObjAttribute attribute : objEntity.getAttributes()) {
            String propName = attribute.getName();
            Class<?> javaType = attribute.getType();
            GraphQLScalarType scalarType = Scalars.valueFor(javaType);

            typeBuilder.field(field -> field
                    .name(propName)
                    .type(scalarType)
                    .dataFetcher(dataEnv -> {
                        Persistent entity = (Persistent) dataEnv.getSource();
                        return entity.readProperty(propName);
                    }));
        }

        // 可选：处理关联关系（一对一、一对多等）
        for (ObjRelationship relationship : objEntity.getRelationships()) {
            // 这里简化处理，你可以根据关联类型调整为对象类型或列表类型
            Class<?> relType = relationship.getTargetEntity().getJavaClass();
            GraphQLType graphQLRelType = env.getTypeRegistry().resolve(relType);
            
            typeBuilder.field(field -> field
                    .name(relationship.getName())
                    .type(graphQLRelType)
                    .dataFetcher(dataEnv -> {
                        Persistent entity = (Persistent) dataEnv.getSource();
                        return entity.readProperty(relationship.getName());
                    }));
        }

        return typeBuilder.build();
    }
}

步骤2：注册解析器到SPQR #

修改你的buildSchema方法，把自定义解析器加进去：

private static GraphQLSchema buildSchema() {
    return new GraphQLSchemaGenerator()
            .withTypeResolvers(new CayenneEntityTypeResolver()) // 注册自定义类型解析器
            .withOperationsFromSingletons(myRepository)
            .generate();
}

方案二：使用DTO作为中间层 #

这个方案更简单直观，适合实体类不多的场景，核心是把Cayenne实体转换成符合JavaBean规范的DTO，让SPQR可以自动识别。

步骤1：创建对应DTO类 #

public class MyCayenneClassDTO {
    private Integer aProperty;
    private String anotherProperty;

    // 从Cayenne实体转换的静态方法
    public static MyCayenneClassDTO fromEntity(MyCayenneClass entity) {
        MyCayenneClassDTO dto = new MyCayenneClassDTO();
        dto.setAProperty(entity.getAProperty());
        dto.setAnotherProperty(entity.getAnotherProperty());
        return dto;
    }

    // 标准getter/setter
    public Integer getAProperty() {
        return aProperty;
    }

    public void setAProperty(Integer aProperty) {
        this.aProperty = aProperty;
    }

    public String getAnotherProperty() {
        return anotherProperty;
    }

    public void setAnotherProperty(String anotherProperty) {
        this.anotherProperty = anotherProperty;
    }
}

步骤2：修改Repository方法返回DTO #

调整你的MyRepository，让方法返回DTO而不是Cayenne实体：

public class MyRepository {
    public MyCayenneClassDTO getEntityById(Integer id) {
        // 原来获取Cayenne实体的逻辑
        MyCayenneClass entity = ...;
        // 转换为DTO返回
        return MyCayenneClassDTO.fromEntity(entity);
    }
}

这样SPQR就能正常识别DTO的属性，自动生成GraphQL Schema了。

方案对比与选择 #

• 自定义TypeResolver：优点是避免重复编写DTO，适合实体多、属性经常变动的场景；缺点是需要处理Cayenne元数据和关联关系，代码复杂度稍高。
• DTO中间层：优点是实现简单，不用深入SPQR的扩展逻辑，出错概率低；缺点是实体多的时候需要编写大量DTO和转换代码，维护成本高。

我个人如果实体数量少的话会选DTO方案，省心；如果实体多就用TypeResolver方案，一劳永逸。

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