您现在的位置是：首页 > Java

当前栏目

Graphql-Java实践(三)-工具类graphql-java-tools

工具对象

2023-03-02 11:48:21 时间

开门尖山，放上github地址，大家可自行查阅使用，我这边只是尝试一下  
[HomePage][]  
**注：graphql-java-tools已经不更新了，内部引用的GraphQL-java版本为6.0但最新GraphQL已经更新到8.0，去除了一些6.0中的Class，所以不能另外引用最新的GraphQL-java**  
首先Maven：新版本有冲突，需要注释

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
</code></pre> </td> 
   <td> <pre><code>&lt;dependency&gt;
    &lt;groupId&gt;com.graphql-java&lt;/groupId&gt;
    &lt;artifactId&gt;graphql-java-tools&lt;/artifactId&gt;
    &lt;version&gt;4.3.0&lt;/version&gt;
&lt;/dependency&gt;

&lt;!--&lt;dependency&gt;--&gt;
    &lt;!--&lt;groupId&gt;com.graphql-java&lt;/groupId&gt;--&gt;
    &lt;!--&lt;artifactId&gt;graphql-java&lt;/artifactId&gt;--&gt;
    &lt;!--&lt;version&gt;8.0&lt;/version&gt;--&gt;
&lt;!--&lt;/dependency&gt;--&gt;
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

schema：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
</code></pre> </td> 
   <td> <pre><code># 省略schema，使用默认Query,Mutation
type Query {
    # 获取所有用户列表
    user: [ToolUser]
    # 根据id获取狗嘻嘻
    dog(userId:String):[ToolDog]
}
type Mutation{
    createUser(addUser:[InputToolUser]):[ToolUser]
}

input InputToolUser{
    id: String!
    age: Int
    userName: String!
    dogs:[InputToolDog]
}
input InputToolDog {
    id: String!
    dogName: String!
}

type ToolUser {
    id: String!
    age: Int
    userName: String!
    dogs:[ToolDog]
}
type ToolDog {
    id: String!
    dogName: String!
}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

当你申明完了Schema文件，只需在代码中定义与IDL中一样的类名与属性名，工具类会帮助你进行自动映射绑定，在执行查询时帮助我们获取数据，关于绑定映射，有以下两种情况：  
标量类型：变量名字一致自动绑定  
复杂/引用类型（标量类型也可以使用来设置除getXXX之外的新的返回值）：需要定义对应的Resolvers与其绑定，**GraphQLResolver**

同时，针对外部API，有特定的RootResolver **GraphQLQueryResolver** ，**GraphQLMutationResolver**，**GraphQLSubscriptionResolver**，对应着查询、变更、订阅。

无论是自定义类型或者Resolver，工具类制定了一套方法名和Schema中Field字段的对应规则，通过这些接口的实现类，可以帮助我们简化DataFetcher和Field的绑定关系。  
具体可查询Github：  
Field Mapping Priority（字段映射优先级）  
The field mapping is done by name against public/protected methods and public/protected/private fields, with the following priority:

First on the resolver or root resolver (note that dataClassInstance doesn’t apply for root resolvers):

method (dataClassInstance, *fieldArgs \[, DataFetchingEnvironment\])  
method is(dataClassInstance, *fieldArgs \[, DataFetchingEnvironment\]), only if the field returns a Boolean  
method get(dataClassInstance, *fieldArgs \[, DataFetchingEnvironment\])  
method getField(dataClassInstance, *fieldArgs \[, DataFetchingEnvironment\])  
Then on the data class:

method (*fieldArgs \[, DataFetchingEnvironment\])  
method is(*fieldArgs \[, DataFetchingEnvironment\]), only if the field returns a Boolean  
method get(*fieldArgs \[, DataFetchingEnvironment\])  
method getField(*fieldArgs \[, DataFetchingEnvironment\])  
field

**自己测试了一下，针对DataClass，定义的method好像在执行时不会进行调用，所以暂时还是通过Resolver来获取想要的数据，无论是标量类型还是复杂类型**

这是种实现, 当提供了resolver时优先使用（在pojo是A类型，而IDL是B类型时很有用，Date类型也是）, 其次是 class this.get方法。  
自定义Resolver中多了一个对象实例的参数，这个对象是当前正在处理的Field字段所在的对象实例，可以帮助我们获取对象中的属性值，在一些需要根据对象内部字段判断的场景内很有用。比如User类内部有List属性，那么getDogs方法的第一个参数就可以是user实例。  
换一个角度思考，GraphQL对于Field的获取是冒泡向下获取的，直到遇到标量类型。GraphQL-java基础包中也说明了针对所有非标量类型，都可以定义一个DataFetcher，而不是使用默认的PropertyDataFetcher。这样一来，Resolver的作用也就不言而喻了。

简单来说，只要实现类中的公有方法有与Schema中Field名称满足上述规则，针对Resolver，方法的参数依次为（当前数据对象–**RootResolver没有该属性**、参数、环境上下文–可选）；针对单纯的自定义类型，方法参数依次为（参数，环境上下文–可选），Resolver多了一个当前处理的对象信息。可以看出，对于自定义类型，其实就是默认的get/set方法，和官方基础包中的PropertyDataFetcher功能一致。

至此，继续例子代码：  
自定义类型：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
</code></pre> </td> 
   <td> <pre><code>@Data
@AllArgsConstructor
public class ToolUser implements Serializable{
    private static final long serialVersionUID = -3272807693514763753L;

private String id;
    private String userName;
    private int age;
    private List&lt;ToolDog&gt; dogs;

}
@Data
@AllArgsConstructor
public class ToolDog implements Serializable{
    private static final long serialVersionUID = -3272807693514763753L;
    private String id;
    private String dogName;
}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

自定义Resolver（解决user中的非标量类型dogs的数据获取）：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
</code></pre> </td> 
   <td> <pre><code>public class ToolUserResolver implements GraphQLResolver&lt;ToolUser&gt; {

//根据userId获取dogs
    public List&lt;ToolDog&gt; getDogs(ToolUser user){
        String userId = user.getId();
        System.out.println("UserResolver , userId = " +userId);
        return DemoRepository.dogs.get(userId);
    }
}
//标量类型，在ToolDog中定义使用无效
public class ToolDogResolver implements GraphQLResolver&lt;ToolDog&gt; {

//根据userId获取dogs
    public String getId(ToolDog dog,DataFetchingEnvironment env){
        String dogId = dog.getId();
        System.out.println("ToolDogResolver , dogId = " +dogId);
        return "resolver - " + dogId;
    }
}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

RootResolvers-Query：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
</code></pre> </td> 
   <td> <pre><code>public class ToolQuery implements GraphQLQueryResolver {

//schema user
    public List&lt;ToolUser&gt; user(DataFetchingEnvironment env){
        return DemoRepository.users.values().stream().collect(Collectors.toList());
    }

//schema dogs
    public List&lt;ToolDog&gt; dog(String userId){
        return DemoRepository.dogs.get(userId);
    }
}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

RootResolvers-Mutation：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
</code></pre> </td> 
   <td> <pre><code>public class ToolMutation implements GraphQLMutationResolver {

//schema user
    public List&lt;ToolUser&gt; createUser(List&lt;InputToolUser&gt; toolUsers){
        System.out.println("createUser - " + toolUsers);
        return DemoRepository.users.values().stream().collect(Collectors.toList());
    }

}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

这里说一来，对于Mutation，由于是根据字段名及类名进行的自动绑定，故需要编写对应的input 自定义类型，其实蛮傻的，相当于一个类型定义了两次，官方因为只能通过map获取入参，反而没有这方面的困扰：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
</code></pre> </td> 
   <td> <pre><code>@Data
@AllArgsConstructor
public class InputToolUser implements Serializable{
    private static final long serialVersionUID = -3272807693514763753L;

private String id;
    private String userName;
    private int age;
    private List&lt;InputToolDog&gt; dogs;
}
public class InputToolDog implements Serializable,Cloneable{
    private static final long serialVersionUID = -3272807693514763753L;

private String id;
    private String dogName;
    public InputToolDog(){}

@Override
    protected InputToolDog clone()  {
        InputToolDog clone = null;
        try{
            clone = (InputToolDog) super.clone();

}catch(CloneNotSupportedException e){
            throw new RuntimeException(e); // won't happen
        }

return clone;
    }

}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

这边有一点要注意的是，前面几篇文章中也提到过，到遇到复杂对象的Variable时，GraphQL引擎只会接受Map类型的数据结构。细心的你可能已经发现，这次Mutation操作的入参是一个List，所以这次的数据结构应该是List，大家在用Json作数据转换的时候需要注意了。  
在这里，工具类又帮我们完成了一件事，基础包版本中，复杂类型的入参只能通过getArgument获得，而且返回值是一个Map<String,Object>，而不是这边已经帮我们转换过的对象List toolUsers。

Main函数：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
</code></pre> </td> 
   <td> <pre><code>public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        new DemoRepository();
        GraphQLSchema schema = SchemaParser.newParser()
                .file("graphql/tool.graphqls").resolvers(new ToolQuery(),
                new ToolUserResolver(),new ToolDogResolver(),new ToolMutation()).build().makeExecutableSchema();

GraphQL graphQL = GraphQL.newGraphQL(schema).build();
        Map&lt;String,Object&gt; variable = Maps.newHashMap();
       variable.put("addUser", MutationVariableHandler.getListVariablesMapFromString(JSON.toJSONString(DemoRepository.inputUsers.values().stream().
               collect(Collectors.toList()), SerializerFeature.DisableCircularReferenceDetect)));
//        ExecutionInput executionInput = ExecutionInput.newExecutionInput().variables(variable).
//                query("query Query{user{id,userName,age,dogs{id,dogName}}}").build();
//        ExecutionInput executionInput = ExecutionInput.newExecutionInput().variables(variable).
//                query("query Query($userId:String){dog(userId:$userId){id,dogName}}").build();

ExecutionInput executionInput = ExecutionInput.newExecutionInput().variables(variable).
                query("mutation Mutation($addUser:[InputToolUser])" +
                        "{createUser(addUser:$addUser){id,userName,age,dogs{id,dogName}}}").build();

ExecutionResult result = graphQL.execute(executionInput);
        Map&lt;String, Object&gt; data = result.getData();
        List errors = result.getErrors();
        System.out.println(data);
        System.out.println("errors = "+errors);
    }
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

Console（查询执行的结果大家可以变换注释自己执行）：  
createUser - \[InputToolUser(id=input-user-3, userName=uc, age=30, dogs=\[InputToolDog(id=dog-2, dogName=db), InputToolDog(id=dog-3, dogName=dc)\]), InputToolUser(id=input-user-2, userName=ub, age=20, dogs=\[InputToolDog(id=dog-2, dogName=db)\]), InputToolUser(id=input-user-1, userName=ua, age=10, dogs=\[InputToolDog(id=dog-1, dogName=da), InputToolDog(id=dog-2, dogName=db)\])\]  
UserResolver , userId = user-1  
ToolDogResolver , dogId = dog-1  
ToolDogResolver , dogId = dog-2  
UserResolver , userId = user-3  
ToolDogResolver , dogId = dog-2  
ToolDogResolver , dogId = dog-3  
UserResolver , userId = user-2  
ToolDogResolver , dogId = dog-2  
\{createUser=\[\{id=user-1, userName=ua, age=10, dogs=\[\{id=resolver - dog-1, dogName=da\}, \{id=resolver - dog-2, dogName=db\}\]\}, \{id=user-3, userName=uc, age=30, dogs=\[\{id=resolver - dog-2, dogName=db\}, \{id=resolver - dog-3, dogName=dc\}\]\}, \{id=user-2, userName=ub, age=20, dogs=\[\{id=resolver - dog-2, dogName=db\}\]\}\]\}  
errors = \[\]

备注：  
DemoRepository：只是Mock了一些数据而已，随便写的。其实这边在运行时还碰到了一个小问题，由于构建的dog对象实例在不同的user对象中都使用了，导致触发了alibaba fastJson的循环调用监测，生成的json中会多一个$ref字段，可以设置SerializerFeature.DisableCircularReferenceDetect来禁止循环引用检测。后面其实稍微改了一下，增加了clone方法，确保实例不同

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
</code></pre> </td> 
   <td> <pre><code>public class DemoRepository {
    //userId ,users
    public static Map&lt;String, ToolUser&gt; users = Maps.newHashMap();
    //userId ,dogs
    public static Map&lt;String, List&lt;ToolDog&gt;&gt; dogs = Maps.newHashMap();
    //input user
    public static Map&lt;String, InputToolUser&gt; inputUsers = Maps.newHashMap();

public DemoRepository() throws InstantiationException, IllegalAccessException {

ToolDog da = new ToolDog("dog-1","da");
        ToolDog db = new ToolDog("dog-2","db");
        ToolDog dc = new ToolDog("dog-3","dc");
        List&lt;ToolDog&gt; dogList = Lists.newArrayList(da,db,dc);

ToolUser ua = new ToolUser("user-1","ua",10,Arrays.asList(da,db));
        ToolUser ub = new ToolUser("user-2","ub",20,Arrays.asList(db));
        ToolUser uc = new ToolUser("user-3","uc",30,Arrays.asList(db,dc));

//dogs = dogList.stream().collect(Collectors.toMap(ToolDog::getId, Function.identity()));
        users = Stream.of(ua,ub,uc).collect(Collectors.toMap(ToolUser::getId, Function.identity()));
        dogs = Stream.of(ua,ub,uc).collect(Collectors.toMap(ToolUser::getId, ToolUser::getDogs));

List&lt;InputToolDog&gt; inputToolDogs = convert(InputToolDog.class,dogList.toArray(new ToolDog[3]));
        InputToolUser iua = new InputToolUser("input-user-1","ua",10,Arrays.asList(inputToolDogs.get(0).clone(),inputToolDogs.get(1).clone()));
        InputToolUser iub = new InputToolUser("input-user-2","ub",20,Arrays.asList(inputToolDogs.get(1).clone()));
        InputToolUser iuc = new InputToolUser("input-user-3","uc",30,Arrays.asList(inputToolDogs.get(1).clone(),inputToolDogs.get(2).clone()));

//dogs = dogList.stream().collect(Collectors.toMap(ToolDog::getId, Function.identity()));
        inputUsers = Stream.of(iua,iub,iuc).collect(Collectors.toMap(InputToolUser::getId, Function.identity()));
    }

public static &lt;T,R&gt; List&lt;R&gt; convert(Class&lt;R&gt; clazz,T... source) throws IllegalAccessException, InstantiationException {
        List&lt;R&gt; result = Lists.newArrayList();
        if(source != null &amp;&amp; source.length &gt; 0){
            for(T a : source){
                R r = clazz.newInstance();
                BeanUtils.copyProperties(a, r);
                result.add(r);
            }
        }
        return result;
    }

}
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

MutationVariableHandler.getListVariablesMapFromString：由于这次是List的入参，所以对应的Jackson的Reference也做了相应的变化：

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>1
2
3
4
5
6
7
8
9
</code></pre> </td> 
   <td> <pre><code>private static TypeReference&lt;List&lt;HashMap&lt;String, Object&gt;&gt;&gt; typeRefReadJsonList = new TypeReference&lt;List&lt;HashMap&lt;String, Object&gt;&gt;&gt;() {
    };
public static List&lt;HashMap&lt;String, Object&gt;&gt; getListVariablesMapFromString(String variablesFromRequest) {
        try {
            return jacksonObjectMapper.readValue(variablesFromRequest, typeRefReadJsonList);
        } catch (IOException exception) {
            throw new GraphQLException("Cannot parse variables", exception);
        }
    }
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

总结：怎么说呢，工具类有不少优势，把整体的项目结构与Schema的关系梳理的更加清晰，用实现类的方式把我们从为Field定义DataFetcher解脱了出来，只用根据名称就可以进行互绑；但另一方面，因为GraphQL-java还在不断升级迭代，版本已经远远超过了工具包中自带的基础jar包版本，所以还是慎用吧。。。。，不然以后的迁移和兼容也有的搞了

[HomePage]: https://github.com/graphql-java/graphql-java-tools

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Graphql-Java实践(三)-工具类graphql-java-tools

相关文章