Facebook:如何在Golang中搭建GraphQL?

开发 前端
本文将重点介绍GraphQL的主要功能,以及就API而言它存在的优缺点。文末将展示一个使用Golang的简单程序(已搭建GraphQL)。

本文转载自公众号“读芯术”(ID:AI_Discovery)。

多年来,人们一直在使用REST API来满足开发需求,但得完成大量不必要的调用后,开发者才能灵活使用。例如,如果Web和移动设备所需的数据不同,我们还须针对Web和移动设备创建两个不同的端点。

因此,Facebook创建了一种查询语言——GraphQL,该语言可以准确地给出开发者查询的内容,干净利落,也让 API 更容易地随着时间推移而演进,还能用于构建强大的开发者工具。

本文将重点介绍GraphQL的主要功能,以及就API而言它存在的优缺点。文末将展示一个使用Golang的简单程序(已搭建GraphQL)。

什么是GraphQL?

GraphQL是用于API的查询语言,它是服务器端运行时,通过为数据定义的类型系统执行查询。

GraphQL是一种查询语言,适用许多领域,但通常用来在客户端和服务器应用程序之间搭桥。无所谓使用的是哪个网络层,所以可以在客户端和服务器应用程序之间读取和写入数据。(RobinWieruch《GraphQL指南》)

虽然GraphQL是查询语言,但它与数据库没有直接关系,也就是GraphQL不限于任意SQL或是NoSQL的数据库。GraphQL位于客户端和服务器端,通过API连接/访问。开发这种查询语言的目的之一是通过提供所需的数据来促进后端、前端或移动应用程序之间的数据通信。

Facebook:如何在Golang中搭建GraphQL?

GraphQL的操作

1. 查询(Query)

查询用于读取或获取值。无论哪种情况,操作都是一个简单的字符串,GraphQL服务器可以解析该字符串并以特定格式的数据进行响应。

你可以使用查询操作从API请求数据。查询描述需要从GraphQL服务器获取的数据,发送查询其实是按字段要求提取数据。(Eve Porcello、Alex Banks著《学习GraphQL》)

Facebook:如何在Golang中搭建GraphQL?

2. 模式(Schema)

GraphQL使用Schema描述数据图的形状。这样的Schema定义类型的层次结构,依托的是从后端数据存储区填充的字段,也准确表示客户端可以对数据图执行哪些查询和突变。

3. 分解器(Resolver)

分解器是负责为Schema单一字段填充数据的功能。它可以用你定义的任何方式填充该数据,例如从后端数据库或第三方API提取数据。

4. 突变(Mutation)

修改数据存储中的数据并返回一个值,它可用于插入、更新或删除数据。

突变与查询原理相同:它具有字段和对象、参数和变量、片段和操作名称,以及返回结果的指令和嵌套对象。(Robin Wieruch著《GraphQL之路》)

Facebook:如何在Golang中搭建GraphQL?

5. 订阅(Subscription)

将数据从服务器推送到客户端的方法是选择侦听来自服务器的实时消息。

GraphQL的订阅来自Facebook的真实用例。开发团队希望找到一种方法,不刷新页面就能实时显示发文获得的有效点赞(Live Likes)。(Eve Porcello、Alex Banks著《学习GraphQL》)

Facebook:如何在Golang中搭建GraphQL?

GraphQL的优势与劣势

Facebook:如何在Golang中搭建GraphQL?

1. 优势

(1) 开发迅速

来看一个案例:如何得到图书借阅者的数据。在视图中,首先我要显示书籍列表,书籍列表菜单显示中出现一个借阅者的列表。在REST API中,需要创建新的端点以返回图书清单,再创建一个新的端点以返回每本书的借阅人。

Facebook:如何在Golang中搭建GraphQL?

与REST API不同,GraphQL中仅使用一个端点就可以返回书籍列表和借阅者列表了。

Facebook:如何在Golang中搭建GraphQL?

使用以下示例GraphQL查询:

Facebook:如何在Golang中搭建GraphQL?

(2) 灵活性

来看一个案例:如何获取书籍详细信息。在网络视图上,我想展示书籍详细信息,例如名称、价格和介绍。在REST API中需要创建一个新的端点以返回名称、价格、介绍等的书籍详细信息。

Facebook:如何在Golang中搭建GraphQL?

如果在移动端查看时,只想展示图书详细信息中的名称和价格怎么办?如果使用与Web视图相同的端点,则会浪费介绍的数据。所以需要更改该端点内部的现有逻辑,或创建一个新的端点。

Facebook:如何在Golang中搭建GraphQL?

与REST API不同,GraphQL中仅使用一个端点即可按照Web或移动设备的需求返回书籍详细信息。在GraphQL中,只需更改查询。

(3) 维护简单,易于使用

  • Rest API:如果客户端需要其他数据,通常需要添加一个新端点或更改一个现有端点。
  • GraphQL:客户只需要更改查询。

2. 缺点

  • 处理文件上传:GraphQL规范中没有关于文件上传的内容,并且突变不接受参数中的文件。
  • 简单的API:如果你的API非常简单,那GraphQL只会使其复杂,所以使用REST API可能会更好。

代码实现

实现过程使用了Golang编程语言,这里是项目架构:

Facebook:如何在Golang中搭建GraphQL?

在依赖版本和依赖管理功能上使用的是go模块。用graphql-go来支持查询、突变和订阅;用graphql-go-handler来支持处理器。此时,我将创建一个简单的程序,这里使用GraphQL为详细书目创建CRUD。步骤如下:

先新建一个环境文件夹,然后新建一个名为connection.yml的文件:

  1. app: 
  2. name: "GraphQL Test" 
  3. debug: true 
  4. port: "8080" 
  5. host: "localhost" 
  6. service: "http" 
  7. context: 
  8. timeout: 2 
  9. databases: 
  10. mongodb: 
  11. name: "local_db" 
  12. connection: "mongodb://root:root@localhost:27017" 

然后创建一个架构文件夹,创建名为databaseConfiguration.go、environmentConfiguration.go和model.go的文件。这个文件夹用来配置数据库并从connection.yml读取数据。

(1) databaseConfiguration.go

  1. package infrastructureimport( 
  2.    "context" 
  3.   "go.mongodb.org/mongo-driver/mongo" 
  4.   "go.mongodb.org/mongo-driver/mongo/options" 
  5.    "log" 
  6. )var Mongodb *mongo.Databasefunc(e *Environment) InitMongoDB()(db *mongo.Database, err error) { 
  7. clientOptions :=options.Client().ApplyURI(e.Databases["mongodb"].Connection) 
  8.    client, err :mongo.Connect(context.TODO(),clientOptions) 
  9.    err = client.Ping(context.TODO(), nil) 
  10. if err != nil { 
  11. return db, err 
  12.    } 
  13. Mongodb = client.Database(e.Databases["mongodb"].Name) 
  14. log.Println("Mongodb Ready!!!") 
  15. return db, err 

(2) environmentConfiguration.go

  1. package infrastructureimport( 
  2.    "io/ioutil" 
  3.    "log" 
  4.    "os" 
  5.    "path" 
  6.   "runtime""gopkg.in/yaml.v2" 
  7. )func(env *Environment) SetEnvironment() { 
  8.    _, filename, _, _ :runtime.Caller(1) 
  9. env.path = path.Join(path.Dir(filename),"environment/Connection.yml") 
  10.    _, err :os.Stat(env.path) 
  11. if err != nil { 
  12.       panic(err) 
  13. return 
  14. }func(env *Environment) LoadConfig() { 
  15.    content, err :=ioutil.ReadFile(env.path) 
  16. if err != nil { 
  17. log.Println(err) 
  18.       panic(err) 
  19.    } 
  20.    err =yaml.Unmarshal([]byte(string(content)), env) 
  21. if err != nil { 
  22. log.Println(err) 
  23.       panic(err) 
  24.    } 
  25. if env.App.Debug == false { 
  26. log.SetOutput(ioutil.Discard) 
  27.    } 
  28. log.Println("Config load successfully!") 
  29. return 

(3) model.go

  1. package infrastructuretypeapp struct{ 
  2. Appname     string `yaml:"name"` 
  3.    Debug       bool  `yaml:"debug"` 
  4.    Port        string `yaml:"port"` 
  5.    Service     string `yaml:"service"` 
  6.    Host        string `yaml:"host"` 
  7. }type database struct { 
  8.    Name       string `yaml:"name"` 
  9.    Connection string`yaml:"connection"` 
  10. }type Environment struct { 
  11.    App       app                 `yaml:"app"` 
  12.    Databases map[string]database`yaml:"databases"` 
  13.    path      string 

第三,创建一个书目文件夹,创建如下文件:

Facebook:如何在Golang中搭建GraphQL?

model.go:

  1. package 
  2. package booktypeBook struct { 
  3.    Name        string 
  4.    Price       string 
  5.    Description string 
  6. } booktypeBook struct {   Name        string   Price       string   Description string} 

resolver.go:

  1. package bookimport( 
  2.   "context""github.com/graphql-go/graphql" 
  3. )var productType = graphql.NewObject( 
  4. graphql.ObjectConfig{ 
  5.       Name: "Book", 
  6.       Fields: graphql.Fields{ 
  7.          "name": &graphql.Field{ 
  8.             Type: graphql.String, 
  9.          }, 
  10.          "price":&graphql.Field{ 
  11.             Type: graphql.String, 
  12.          }, 
  13.          "description":&graphql.Field{ 
  14.             Type: graphql.String, 
  15.          }, 
  16.       }, 
  17.    }, 
  18. )var queryType = graphql.NewObject( 
  19. graphql.ObjectConfig{ 
  20.       Name: "Query", 
  21.       Fields: graphql.Fields{ 
  22.          "book":&graphql.Field{ 
  23.             Type:        productType, 
  24.             Description: "Get bookby name", 
  25. Args: graphql.FieldConfigArgument{ 
  26.                "name":&graphql.ArgumentConfig{ 
  27.                   Type: graphql.String, 
  28.                }, 
  29.             }, 
  30.             Resolve: func(pgraphql.ResolveParams) (interface{}, error) { 
  31. var result interface{} 
  32.                name, ok :=p.Args["name"].(string) 
  33. if ok { 
  34.                   // Find product 
  35.                   result =GetBookByName(context.Background(), name) 
  36.                } 
  37. return result, nil 
  38.             }, 
  39.          }, 
  40.          "list":&graphql.Field{ 
  41.             Type:        graphql.NewList(productType), 
  42.             Description: "Get booklist", 
  43. Args: graphql.FieldConfigArgument{ 
  44.                "limit":&graphql.ArgumentConfig{ 
  45.                   Type: graphql.Int, 
  46.                }, 
  47.             }, 
  48.             Resolve: func(paramsgraphql.ResolveParams) (interface{}, error) { 
  49. var result interface{} 
  50.                limit, _ :=params.Args["limit"].(int) 
  51.                result =GetBookList(context.Background(), limit) 
  52. return result, nil 
  53.             }, 
  54.          }, 
  55.       }, 
  56.    })var mutationType =graphql.NewObject(graphql.ObjectConfig{ 
  57.    Name: "Mutation", 
  58.    Fields: graphql.Fields{ 
  59.       "create":&graphql.Field{ 
  60.          Type:        productType, 
  61.          Description: "Create newbook", 
  62. Args: graphql.FieldConfigArgument{ 
  63.             "name":&graphql.ArgumentConfig{ 
  64.                Type:graphql.NewNonNull(graphql.String), 
  65.             }, 
  66.             "price":&graphql.ArgumentConfig{ 
  67.                Type:graphql.NewNonNull(graphql.String), 
  68.             }, 
  69.             "description":&graphql.ArgumentConfig{ 
  70.                Type:graphql.NewNonNull(graphql.String), 
  71.             }, 
  72.          }, 
  73.          Resolve: func(paramsgraphql.ResolveParams) (interface{}, error) { 
  74.             book :Book
  75.                Name:        params.Args["name"].(string), 
  76.                Price:       params.Args["price"].(string), 
  77.                Description:params.Args["description"].(string), 
  78.             } 
  79. if err :InsertBook(context.Background(), book); err != nil { 
  80. return nil, err 
  81.             }return book, nil 
  82.          }, 
  83.       },"update":&graphql.Field{ 
  84.          Type:        productType, 
  85.          Description: "Update bookby name", 
  86. Args: graphql.FieldConfigArgument{ 
  87.             "name":&graphql.ArgumentConfig{ 
  88.                Type:graphql.NewNonNull(graphql.String), 
  89.             }, 
  90.             "price":&graphql.ArgumentConfig{ 
  91.                Type: graphql.String, 
  92.             }, 
  93.             "description":&graphql.ArgumentConfig{ 
  94.                Type: graphql.String, 
  95.             }, 
  96.          }, 
  97.          Resolve: func(paramsgraphql.ResolveParams) (interface{}, error) { 
  98.             book :Book{} 
  99. if name, nameOk :params.Args["name"].(string); nameOk { 
  100. book.Name = name 
  101.             } 
  102. if price, priceOk :params.Args["price"].(string); priceOk { 
  103. book.Price = price 
  104.             } 
  105. if description, descriptionOk :=params.Args["description"].(string); descriptionOk { 
  106. book.Description = description 
  107.             }if err :=UpdateBook(context.Background(), book); err != nil { 
  108. return nil, err 
  109.             } 
  110. return book, nil 
  111.          }, 
  112.       },"delete": &graphql.Field{ 
  113.          Type:        productType, 
  114.          Description: "Delete bookby name", 
  115. Args: graphql.FieldConfigArgument{ 
  116.             "name":&graphql.ArgumentConfig{ 
  117.                Type:graphql.NewNonNull(graphql.String), 
  118.             }, 
  119.          }, 
  120.          Resolve: func(paramsgraphql.ResolveParams) (interface{}, error) { 
  121.             name, _ :=params.Args["name"].(string) 
  122. if err :DeleteBook(context.Background(), name); err != nil { 
  123. return nil, err 
  124.             } 
  125. return name, nil 
  126.          }, 
  127.       }, 
  128.    }, 
  129. })// schema 
  130. var Schema, _ = graphql.NewSchema( 
  131. graphql.SchemaConfig{ 
  132.       Query:    queryType, 
  133.       Mutation: mutationType, 
  134.    }, 

repository.go:

  1. package bookimport( 
  2.    "context" 
  3.    "log""graphql/infrastructure""go.mongodb.org/mongo-driver/bson" 
  4.   "go.mongodb.org/mongo-driver/mongo/options" 
  5. )funcGetBookByName(ctxcontext.Context, name string) (result interface{}){ 
  6. var book Book 
  7.    data :=infrastructure.Mongodb.Collection("booklist").FindOne(ctx,bson.M{"name": name}) 
  8. data.Decode(&book) 
  9. return book 
  10. }funcGetBookList(ctxcontext.Context, limit int) (result interface{}){ 
  11. var book Book 
  12. var books []Bookoption :options.Find().SetLimit(int64(limit))cur, err:infrastructure.Mongodb.Collection("booklist").Find(ctx, bson.M{},option) 
  13. defer cur.Close(ctx) 
  14. if err != nil { 
  15. log.Println(err) 
  16. return nil 
  17.    } 
  18. for cur.Next(ctx) { 
  19. cur.Decode(&book) 
  20.       books = append(books, book) 
  21.    } 
  22. return books 
  23. }funcInsertBook(ctxcontext.Context, book Book) error { 
  24.    _, err :=infrastructure.Mongodb.Collection("booklist").InsertOne(ctx, book) 
  25. return err 
  26. }funcUpdateBook(ctxcontext.Context, book Book) error { 
  27.    filter :bson.M{"name":book.Name} 
  28.    update :bson.M{"$set":book} 
  29. upsertBool :true 
  30. updateOption :options.UpdateOptions{ 
  31. Upsert: &upsertBool, 
  32.    } 
  33.    _, err :=infrastructure.Mongodb.Collection("booklist").UpdateOne(ctx, filter,update, &updateOption) 
  34. return err 
  35. }funcDeleteBook(ctxcontext.Context, name string) error { 
  36.    _, err :=infrastructure.Mongodb.Collection("booklist").DeleteOne(ctx,bson.M{"name": name}) 
  37. return err 

response.go:

  1. package bookimport( 
  2.    "encoding/json" 
  3.    "net/http" 
  4.    "time" 
  5. )type SetResponsestruct { 
  6.    Status     string     `json:"status"` 
  7.    Data       interface{} `json:"data,omitempty"` 
  8. AccessTime string     `json:"accessTime"` 
  9. }funcHttpResponseSuccess(w http.ResponseWriter, r *http.Request, data interface{}){ 
  10. setResponse :SetResponse
  11.       Status:     http.StatusText(200), 
  12. AccessTime: time.Now().Format("02-01-2006 15:04:05"), 
  13.       Data:       data} 
  14.    response, _ :=json.Marshal(setResponse) 
  15. w.Header().Set("Content-Type", "Application/json") 
  16. w.WriteHeader(200) 
  17. w.Write(response) 
  18. }funcHttpResponseError(w http.ResponseWriter, r *http.Request, data interface{},code int) { 
  19. setResponse :SetResponse
  20.       Status:     http.StatusText(code), 
  21. AccessTime: time.Now().Format("02-01-2006 15:04:05"), 
  22.       Data:       data} 
  23.    response, _ :=json.Marshal(setResponse) 
  24. w.Header().Set("Content-Type", "Application/json") 
  25. w.WriteHeader(code) 
  26. w.Write(response) 

routes.go:

  1. package bookimport( 
  2.    "github.com/go-chi/chi" 
  3.   "github.com/go-chi/chi/middleware" 
  4.   "github.com/graphql-go/handler" 
  5. )funcRegisterRoutes(r *chi.Mux) *chi.Mux { 
  6.    /* GraphQL */ 
  7. graphQL :handler.New(&handler.Config{ 
  8.       Schema:   &Schema, 
  9.       Pretty:   true, 
  10. GraphiQL: true, 
  11.    }) 
  12. r.Use(middleware.Logger) 
  13. r.Handle("/query", graphQL) 
  14. return r 

最后,创建名为 main.go的文件。

main.go:

  1. package mainimport( 
  2.    "github.com/go-chi/chi" 
  3.    "graphql/book" 
  4.    "graphql/infrastructure" 
  5.    "log" 
  6.    "net/http" 
  7.    "net/url" 
  8. )funcmain() { 
  9.    routes :chi.NewRouter() 
  10.    r :book.RegisterRoutes(routes) 
  11. log.Println("Server ready at 8080") 
  12. log.Fatal(http.ListenAndServe(":8080", r)) 
  13. }funcinit() { 
  14. val :url.Values{} 
  15. val.Add("parseTime", "1") 
  16. val.Add("loc", "Asia/Jakarta") 
  17.    env :infrastructure.Environment{} 
  18. env.SetEnvironment() 
  19. env.LoadConfig() 
  20. env.InitMongoDB() 

运行程序的结果如下:

 

Facebook:如何在Golang中搭建GraphQL?

 

 

创建书目详情示例

 

GraphQL有很多优点,但事实证明,与REST API相比,GraphQL处理文件上传和简单API的性能表现有所不足。因此,我们必须首先了解要构建的系统,是否适合将GraphQL用作应用程序的设计架构。

 

责任编辑:赵宁宁 来源: 今日头条
相关推荐

2022-01-21 10:58:39

JavaScriptGolangPython

2024-11-12 08:00:00

LSM树GolangMemTable

2021-05-07 09:06:55

GraphQLAPI 以太坊

2022-10-08 11:39:56

断路器Golang项目

2015-05-25 09:13:31

NTP网络时间协议NTP服务器

2022-03-28 08:00:00

数据库GraphQL公共云

2022-01-05 18:19:30

容器镜像Golang

2018-11-08 09:00:31

树莓派WordPressLinux

2016-07-26 13:58:52

Ubuntulinux网桥

2020-01-18 14:55:03

架构运维技术

2015-11-09 11:23:09

FacebookFOOMs

2023-11-09 09:13:48

GraphQLAPI 架构

2015-06-03 15:12:07

云端TFS微软代码管理环境

2019-05-09 09:00:00

WindowsKafka

2014-04-15 15:14:49

UbuntuGhost博客平台

2018-07-03 09:48:30

Facebook 开发Python

2020-06-24 07:00:00

GraphQL API监控

2022-03-30 18:18:33

GolangTiDB数据库

2020-11-24 13:55:20

FedoraVirtualBoxLinux

2021-04-19 16:31:33

Stratis加密Linux
点赞
收藏

51CTO技术栈公众号