Golang切片的结构体或新手在构建REST时遇到的问题

huangapple
go评论118阅读模式
英文:

Golang slices of struct or newbie trouble building REST

问题

我需要你的帮助。
我想构建一个简单的API，但遇到了一些问题。
我选择了gint和postgres驱动的database/sql。

  1. package main
  3. import (
  4. 	"database/sql"
  5. 	"fmt"
  7. 	"github.com/gin-gonic/gin"
  9. 	_ "github.com/lib/pq"
  10. )
  12. func main() {
  14. 	router := gin.Default()
  15. 	router.GET("/search/:text", SearchWord)
  16. 	router.Run(":8080")
  18. }
  20. func checkErr(err error) {
  21. 	if err != nil {
  22. 		panic(err)
  23. 	}
  24. }
  26. type Message struct {
  27. 	ticket_id int    `json:"ticket_id"`
  28. 	event     string `json:"event"`
  29. }
  31. func SearchWord(c *gin.Context) {
  32. 	word := c.Params.ByName("text")
  33. 	db, err := sql.Open("postgres", "host=8.8.8.8 user= password= dbname=sample")
  34. 	defer db.Close()
  35. 	checkErr(err)
  36. 	rows, err2 := db.Query("SELECT ticket_id,event FROM ....$1", word)
  37. 	checkErr(err)
  38. 	for rows.Next() {
  39. 		var ticket_id int
  40. 		var event string
  41. 		err = rows.Scan(&ticket_id, &event)
  42. 		checkErr(err)
  43. 		fmt.Printf("%d | %s \n\n", ticket_id, event)
  44. 	}
  46. }

这段代码运行良好，但当我需要生成JSON时。
我需要创建一个行的结构体

  1. type Message struct {
  2. 	ticket_id int    `json:"ticket_id"`
  3. 	event     string `json:"event"`
  4. }

然后我需要创建一个切片，并在每个rows.Next()循环中追加，然后用JSON回复浏览器...

  1. c.JSON(200, messages)

但是如何做到这一点...不知道 Golang切片的结构体或新手在构建REST时遇到的问题

英文:

and need your help.
Wanted to build simple api and stuck with some problem.
I've choose gin and database/sql with postgres driver

  1. package main
  3. import (
  4. 	"database/sql"
  5. 	"fmt"
  7. 	"github.com/gin-gonic/gin"
  9. 	_ "github.com/lib/pq"
  10. )
  12. func main() {
  14. 	router := gin.Default()
  15. 	router.GET("/search/:text", SearchWord)
  16. 	router.Run(":8080")
  18. }

I need to make query to DB and make json out of this request.

  1. func checkErr(err error) {
  2. 	if err != nil {
  3. 		panic(err)
  4. 	}
  5. }
  7. type Message struct {
  8. 	ticket_id int    `json:"ticket_id"`
  9. 	event     string `json:"event"`
  10. }
  12. func SearchWord(c *gin.Context) {
  13.     word := c.Params.ByName("text")
  14. 	db, err := sql.Open("postgres", "host=8.8.8.8 user= password= dbname=sample")
  15. 	defer db.Close()
  16. 	checkErr(err)
  17. 	rows, err2 := db.Query("SELECT ticket_id,event FROM ....$1, word)
  18. 	checkErr(err)
  19. 	for rows.Next() {
  20. 		var ticket_id int
  21. 		var event string
  22. 		err = rows.Scan(&ticket_id, &event)
  23. 		checkErr(err)
  24. 		fmt.Printf("%d | %s \n\n", ticket_id, event)
  25. 	}
  27. }

This coda working nice, but when i need to make json.
I need to make struct of a row

  1. type Message struct {
  2. 	ticket_id int    `json:"ticket_id"`
  3. 	event     string `json:"event"`
  4. }

an then i need to create slice , and append every rows.Next() loop an than answer to browser with Json...

  1. c.JSON(200, messages)

But how to do that...don't know Golang切片的结构体或新手在构建REST时遇到的问题

答案1

得分: 1

免责声明：我对Go语言还不太熟悉。

由于你已经使用Scan将列数据扫描到变量中，你应该能够使用它们的值初始化一个结构体：

m := &Message{ticket_id: ticket_id, event: event}

你可以使用以下方式初始化一个切片：

s := make([]*Message, 0)

然后在实例化后，将每个消息结构体追加到切片中：

s = append(s, m)

由于我对Go语言不太熟悉，有几个问题我不太确定：

  • 在使用rows.Scan将数据从查询复制到变量后，初始化Message结构体是否按预期复制了当前迭代的值？

  • 如果有一种方法可以从查询中获取总行数，初始化一个静态长度的数组可能会更高效，而不是使用切片？

  • 我认为@inf删除的关于将Message转换为JSON的答案可能需要解决，并且Message字段可能需要大写。

从@inf复制过来的内容：

> 结构体成员的名称需要大写，这样它们才能被导出并访问。
>
> type Message struct {
> Ticket_id int json:"ticket_id"
> Event string json:"event" }

英文:

disclaimer: I am brand new to go

Since you Scanned your column data into your variables, you should be able to initialize a structure with their values:

m := &Message{ticket_id: ticket_id, event: event}

You could initialize a slice with

s := make([]*Message, 0)

And then append each of your message structs after instantiation:

s = append(s, m)

Because I'm not too familiar with go there are a couple things i'm not sure about:

  • after copying data from query to your vars using rows.Scan does initializing the Message struct copy the current iterations values as expected??

  • If there is a way to get the total number of rows from your query it might be slighlty more performant to initialize a static length array, instead of a slice?

  • I think @inf deleted answer about marshalling your Message to json down the line might need to be addressed, and Message field's might need to be capitalized

copied from @inf:

> The names of the members of your struct need be capitalized so that
> they get exported and can be accessed.
>
> type Message struct {
> Ticket_id int json:"ticket_id"
> Event string json:"event" }

答案2

得分: 0

我稍微作弊一下，顺便修复一些问题：

首先，在程序启动时只需打开一次数据库连接池（而不是在每个请求中都打开）。

其次，我们将使用 sqlx 来更轻松地将数据库行转换为结构体。

  1. package main
  3. import (
  4. 	"log"
  5. 	"net/http"
  7. 	"github.com/gin-gonic/gin"
  8. 	"github.com/jmoiron/sqlx"
  9. )
  11. var db *sqlx.DB
  13. func main() {
  14. 	var err error
  15. 	// sqlx.Connect 也会检查连接是否正常工作。
  16. 	// sql.Open 只是“建立”一个连接池，但不会 ping 数据库。
  17. 	db, err = sqlx.Connect("postgres", "postgres:///...")
  18. 	if err != nil {
  19. 		log.Fatal(err)
  20. 	}
  22. 	router := gin.Default()
  23. 	router.GET("/search/:text", SearchWord)
  24. 	router.Run(":8080")
  25. }
  27. // in_another_file.go
  29. type Message struct {
  30. 	TicketID int    `json:"ticket_id" db:"ticket_id"`
  31. 	Event    string `json:"event" db:"event"`
  32. }
  34. func SearchWord(c *gin.Context) {
  35. 	word := c.Params.ByName("text")
  36. 	// 我们创建一个结构体切片来将行转换为结构体
  37. 	var messages []*Message
  38. 	// 从这里开始，我们可以并发安全地使用数据库连接池
  39. 	err := db.Select(&messages, "SELECT ticket_id, event FROM ... WHERE ... = $1", word)
  40. 	if err != nil {
  41. 		http.Error(c.Writer, err.Error(), 500)
  42. 		return
  43. 	}
  45. 	// 使用 gin-gonic 的 JSON writer 输出结果
  46. 	c.JSON(200, messages)
  47. }

希望这样清楚了。sqlx 还会为您调用 rows.Close()，否则连接会保持挂起状态。

英文:

I'm going to cheat a little here and fix a few things along the way:

First: open your database connection pool once at program start-up (and not on every request).

Second: we'll use sqlx to make it easier to marshal our database rows into our struct.

<!-- language: lang-go -->

  1. package main
  3. var db *sqlx.DB
  5. func main() {
  6.     var err error
  7.     // sqlx.Connect also checks that the connection works.
  8.     // sql.Open only &quot;establishes&quot; a pool, but doesn&#39;t ping the DB.
  9.     db, err = sqlx.Connect(&quot;postgres&quot;, &quot;postgres:///...&quot;)
  10.     if err != nil {
  11.         log.Fatal(err)
  12.     }
  14.     router := gin.Default()
  15.     router.GET(&quot;/search/:text&quot;, SearchWord)
  16.     router.Run(&quot;:8080&quot;)
  18. }
  20. // in_another_file.go
  22. type Message struct {
  23.     TicketID int    `json:&quot;ticket_id&quot; db:&quot;ticket_id&quot;`
  24.     Event     string `json:&quot;event&quot; db:&quot;event&quot;`
  25. }
  27. func SearchWord(c *gin.Context) {
  28.     word := c.Params.ByName(&quot;text&quot;)
  29.     // We create a slice of structs to marshal our rows into
  30.     var messages []*Message{}
  31.     // Our DB connection pool is safe to use concurrently from here
  32.     err := db.Select(&amp;messages, &quot;SELECT ticket_id,event FROM ....$1, word)
  33.     if err != nil {
  34.         http.Error(c.Writer, err.Error(), 500)
  35.         return
  36.     }
  37.     
  38.     // Write it out using gin-gonic&#39;s JSON writer.
  39.     c.JSON(200, messages)
  40. }

I hope that's clear. sqlx also takes care of calling rows.Close() for you, which will otherwise leave connections hanging.

huangapple
  • 本文由 发表于 2015年7月6日 00:10:15
  • 转载请务必保留本文链接：https://go.coder-hub.com/31232316.html
  • go
  • go-gin
  • json
  • postgresql
  • rest
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定