REST作为一种现代网络应用非常流行的软件架构风格受到广大WEB开发者的喜爱，在目前软件架构设计模式中随处可见REST的身影，但是随着REST的流行与发展，它的一个最大的缺点开始暴露出来：

在很多时候客户端需要的数据往往在不同的地方具有相似性，但却又不尽相同。

如同样的用户信息，在有的场景下前端只需要用户的简要信息(名称、头像)，在其他场景下又需要用户的详细信息。当这样的相似但又不同的地方多的时候，就需要开发更多的接口来满足前端的需要。

随着这样的场景越来越多，接口越来越多，文档越来越臃肿，前后端沟通成本呈指数增加。

基于上面的场景，我们迫切需要有一种解决方案或框架，可以使得在使用同一个领域模型(DO、DTO)的数据接口时可以由前端指定需要的接口字段，而后端根据前端的需求自动适配并返回对应的字段。

这就是我们今天的主角GraphQL。

创建一个SpringBoot项目

通过IDEA创建一个SpringBoot项目，并引入对应的jar

1. <dependencies> 
2.  <dependency> 
3.   <groupId>org.springframework.boot</groupId> 
4.   <artifactId>spring-boot-starter</artifactId> 
5.  </dependency> 
6.  
7.  <dependency> 
8.   <groupId>org.springframework.boot</groupId> 
9.   <artifactId>spring-boot-starter-web</artifactId> 
10.  </dependency> 
11.  
12.  <!–graphql start–> 
13.  <dependency> 
14.   <groupId>com.graphql-java</groupId> 
15.   <artifactId>graphql-spring-boot-starter</artifactId> 
16.   <version>5.0.2</version> 
17.  </dependency> 
18.  <dependency> 
19.   <groupId>com.graphql-java</groupId> 
20.   <artifactId>graphql-java-tools</artifactId> 
21.   <version>5.2.4</version> 
22.  </dependency> 
23.  <!–graphql end–> 
24.  
25.  <dependency> 
26.   <groupId>org.projectlombok</groupId> 
27.   <artifactId>lombok</artifactId> 
28.  </dependency> 
29. </dependencies> 

这里主要需要引入 graphql-spring-boot-starter和 graphql-java-tools。

建立Java实体类

User

1. @Data 
2. public class User { 
3.     private int userId; 
4.     private String userName; 
5.     private String realName; 
6.     private String email; 
7.     private List<Post> posts; 
8.  
9.     public User() { 
10.     } 
11.  
12.     public User(int userId, String userName, String realName, String email) { 
13.         this.userId = userId; 
14.         this.userName = userName; 
15.         this.realName = realName; 
16.         this.email = email; 
17.     } 
18. } 

Post

1. @Data 
2. public class Post { 
3.     private int postId; 
4.     private String title ; 
5.     private String text; 
6.     private String  category; 
7.     private User user; 
8.  
9.     public Post() { 
10.  
11.     } 
12.  
13.     public Post(int postId, String title, String text, String category) { 
14.         this.postId = postId; 
15.         this.title = title; 
16.         this.text = text; 
17.         this.category = category; 
18.     } 
19.  
20. } 

定义了两个JAVA实体：Post，User。

编写Schema文件

在resources/schema目录下创建GraphQL Schema文件

1. schema { 
2.     query: Query, 
3. } 
4.  
5. type Query { 
6.     # 获取具体的用户 
7.     getUserById(id:Int) : User 
8.     # 获取具体的博客 
9.     getPostById(id:Int) : Post 
10. } 
11.  
12. type User { 
13.     userId : ID!, 
14.     userName : String, 
15.     realName : String, 
16.     email : String, 
17.     posts : [Post], 
18. } 
19.  
20. type Post { 
21.     postId : ID!, 
22.     title : String!, 
23.     text : String, 
24.     category: String 
25.     user: User, 
26. } 

如上，我们通过 type关键字定义了两个对象，User与Post。在属性后面添加!表明这是一个非空属性，通过[Post]表明这是一个Post集合，类似于Java对象中List。

通过Query关键字定义了两个查询对象，getUserById，getPostById，分别返回User对象和Post对象。

关于schema的语法大家可以参考链接：https://graphql.org/learn/schema

编写业务逻辑

PostService

1. @Service 
2. public class PostService implements GraphQLQueryResolver { 
3.     /** 
4.      * 为了测试，只查询id为1的结果 
5.      */ 
6.     public Post getPostById(int id){ 
7.         if(id == 1){ 
8.             User user = new User(1,"javadaily","JAVA日知录","zhangsan@qq.com"); 
9.             Post post = new Post(1,"Hello,Graphql","Graphql初体验","日记"); 
10.             post.setUser(user); 
11.             return post; 
12.         }else{ 
13.             return null; 
14.         } 
15.  
16.     } 
17. } 

UserService

1. @Service 
2. public class UserService implements GraphQLQueryResolver { 
3.     List<User> userList = Lists.newArrayList(); 
4.  
5.     public User getUserById(int id){ 
6.         return userList.stream().filter(item -> item.getUserId() == id).findAny().orElse(null); 
7.     } 
8.  
9.  
10.     @PostConstruct 
11.     public void  initUsers(){ 
12.         Post post1 = new Post(1,"Hello,Graphql1","Graphql初体验1","日记"); 
13.         Post post2 = new Post(2,"Hello,Graphql2","Graphql初体验2","日记"); 
14.         Post post3 = new Post(3,"Hello,Graphql3","Graphql初体验3","日记"); 
15.         List<Post> posts = Lists.newArrayList(post1,post2,post3); 
16.  
17.         User user1 = new User(1,"zhangsan","张三","zhangsan@qq.com"); 
18.         User user2 = new User(2,"lisi","李四","lisi@qq.com"); 
19.  
20.         user1.setPosts(posts); 
21.         user2.setPosts(posts); 
22.  
23.  
24.         userList.add(user1); 
25.         userList.add(user2); 
26.  
27.     } 
28.  
29. } 

基于Graphql的查询需要实现 GraphQLQueryResolver接口，由于为了便于演示我们并没有引入数据层，请大家知悉。

配置Graphql 端点

1. server.port = 8080 
2. graphql.servlet.corsEnabled=true 
3. # 配置端点 
4. graphql.servlet.mapping=/graphql 
5. graphql.servlet.enabled=true 

配置完端口和端点后我们就可以对我们编写的Graphql接口进行测试了。

接口地址为：localhost:8080/graphql

测试

这里我使用的是Chrome浏览器的 Altair Graphal Client插件，当然你还可以使用其他的客户端工具，如：graphql-playground。