Study golang「1」 - Zsm's blog

study golang / demo1#

作为一个初学者，跟着佬的步伐写五个小demo玩玩，熟悉一下整个的开发方式和流程

项目架构#

1
.
2
├── main.go
3
└── static
4
    ├── form.html
5
    └── index.html

最初级的东西了，这里不用gin练练代码，静态文件就不写了，自由发挥了bro

整体代码#

先初始化一下，这里就一个go文件，所以随便了go mod init zsm

main.go

1
package main
2

3
import (
4
  "fmt"
5
  "log"
6
  "net/http"
7
)
8

9
func formHandler(w http.ResponseWriter, r *http.Request) {
10
  // w 为 http.ResponseWriter 的实例，用于向客户端返回响应。
11
  // r 为 http.Request 的实例，包含了客户端的请求信息。
12
  err := r.ParseForm()
13
  if err != nil {
14
    fmt.Println(w, "ParseForm() err:%v", err)
15
    return
16
  }
17
  fmt.Fprintln(w, "POST request successful")
18

19
  name := r.FormValue("name")
20
  address := r.FormValue("address")
21
  fmt.Fprintf(w, "Name=%s\n", name)
22
  fmt.Fprintf(w, "address=%s\n", address)
23

24
}
25

26
func helloHandler(w http.ResponseWriter, r *http.Request) {
27
  //请求路径
28
  if r.URL.Path != "/hello" {
29
    http.Error(w, "404 not found", http.StatusNotFound)
30
    return
31
  }
32
  //请求方法
33
  if r.Method != "GET" {
34
    http.Error(w, "method is not supported", http.StatusNotFound)
35
    return
36
  }
37
  fmt.Fprintf(w, "Hello")
38
}
39

40
func main() {
41
  fileServer := http.FileServer(http.Dir("./static")) //挂载静态文件
42
  http.Handle("/", fileServer)                        //挂载到根目录
43

44
  //路径绑定函数
45
  http.HandleFunc("/form", formHandler)
46
  http.HandleFunc("/hello", helloHandler)
47

48
  fmt.Println("server is running on 8080")
49

50
  err := http.ListenAndServe(":8080", nil)
51
  if err != nil {
52
    log.Fatal(err)
53
  }
54

55
}

原生http模块比较麻烦算是，练练熟练度就行了

关于指针传递#

比较好玩的是在go里面*是用来声明以及操作指针的，而&是一个运算符，它用于获取（或查找）变量的地址。比如

1
func handleRequest(r *http.Request) {
2

3
}

这里r赋值为后面的指针，那我要访问后再说解析的时候，就可以直接在上面进行操作了，比如

1
func modifyHeader(r *http.Request) {
2
    r.Header.Set("X-Custom-Header", "Value") // 修改请求头
3
}

这样的好处是如果http.Request是一个大结构体，传指针可以减少内存使用还有复制开销，也避免了将整个结构体复制到函数调用栈，有效提高性能

那我怎么获取实际对象呢，直接解引用就行了，即*r

这样的好处不仅仅在性能优化上，也为开发者提供了一种一致的编程模式，在一定程度上有利于规范化

study golang / demo2#

为降低难度，本项目未使用 DATEBASE ，仅使用本地 json 文件存储数据。

项目架构#

1
.
2
└─src
3
    ├─go-basic-server
4
    ├─go-code
5
    ├─go-keword-scraper
6
    ├─go-movies-curd
7
    │      go.mod
8
    │      go.sum
9
    │      main.go
10
    │
11
    ├─go-rest
12
    ├─go-server
13
    └─go-todo

这里没有用数据库，用简单的方法先模拟一下xd

整体代码#

先写结构体，方便后面的定义全局变量

1
//电影
2
type Movie struct {
3
  ID       string    `json:"id"`
4
  Isbn     string    `json:"isbn"`
5
  Title    string    `json:"title"`
6
  Director *Director `json:"director"`
7
}
8

9
//导演
10
type Director struct {
11
  FirstName string `json:"firstname"`
12
  LastName  string `json:"lastname"`
13
}
14

15
var movies []Movie

接下来创建路由还有插入几个真数据

1
func main() {
2
  //router
3
  r := mux.NewRouter()
4

5
  movies = append(movies, Movie{ID: "1", Isbn: "438227", Title: "Movie One", Director: &Director{FirstName: "John", LastName: "Doe"}})
6
  movies = append(movies, Movie{ID: "2", Isbn: "45455", Title: "Movie Two", Director: &Director{FirstName: "Steve", LastName: "Smith"}})
7

8
  r.HandleFunc("/movies", getMovies).Methods("GET")
9
  r.HandleFunc("/movies/{id}", getMovie).Methods("GET")
10
  r.HandleFunc("/movies", createMovie).Methods("POST")
11
  r.HandleFunc("/movies/{id}", updateMovie).Methods("POST")
12
  r.HandleFunc("/movies{id}", deleteMovie).Methods("DELETE")
13

14
  fmt.Println("server is running on 8080")
15
  log.Fatal(http.ListenAndServe(":8080", r))
16
}

这里写五个api接口，依次写上去

1
// 拿全部的电影
2
func getMovies(w http.ResponseWriter, r *http.Request) {
3
    w.Header().Set("Content-Type", "application/json")
4
    json.NewEncoder(w).Encode(movies)
5
}
6

7
// 删除指定电影
8
func deleteMovie(w http.ResponseWriter, r *http.Request) {
9
    w.Header().Set("Content-Type", "application/json")
10
    // 从 HTTP 请求 r 中提取路径参数，并将它们以 map[string]string 的形式返回
11
    params := mux.Vars(r)
12
    // index 是当前元素的索引（即位置），它是一个整数值; item 是当前索引位置上的元素本身
13
    for index, item := range movies {
14

15
        if item.ID == params["id"] {
16
            // append(movies[:index], movies[index+1:]...) 实际上创建了一个新的切片，其中包含了删除指定元素后的所有元素。
17
            movies = append(movies[:index], movies[index+1:]...)
18
            // break 语句用于退出 for 循环
19
            break
20
        }
21
    }
22
    json.NewEncoder(w).Encode(movies)
23
}
24

25
// 拿一个电影
26
func getMovie(w http.ResponseWriter, r *http.Request) {
27
    w.Header().Set("Content-Type","application/json")
28
    params := mux.Vars(r)
29
    for _, item := range movies {
30

31
        if item.ID == params["id"] {
32
            json.NewEncoder(w).Encode(item)
33
            return
34
        }
35
    }
36
}
37

38
// 增加一个电影
39
func createMovie(w http.ResponseWriter, r *http.Request) {
40
    w.Header().Set("Content-Type", "application/json")
41
    var movie Movie
42
    // Decode(&movie)：传入 movie 的指针，以便解码器可以直接修改 movie 变量的内容。
43
    // _ 表示我们忽略 Decode 方法的返回值。如果解码过程发生错误，通常会记录错误信息而不是简单地忽略。
44
    _ = json.NewDecoder(r.Body).Decode(&movie)
45
    // rand.Intn(100000000)：生成一个随机整数，范围是 0 到 99999999（不包括 100000000）。
46
    movie.ID = strconv.Itoa(rand.Intn(100000000))
47
    // 将 movie 添加到 movies 切片的末尾。append 函数会创建一个新的切片（如果原切片空间不足），并将原切片和新元素合并到一起。
48
    movies = append(movies, movie)
49
    json.NewEncoder(w).Encode(movie)
50
}
51

52
// 更新单个电影
53
func updateMovie(w http.ResponseWriter, r *http.Request) {
54

55
    // 设定响应头 Content-Type 为 application/json
56
    w.Header().Set("Content-Type", "application/json")
57
    params := mux.Vars(r)
58

59
    for index, item := range movies {
60
        if item.ID == params["id"] {
61
            // 删除原有电影
62
            movies = append(movies[:index], movies[index+1:]...)
63
            // 创建新电影
64
            var movie Movie
65
            // 创建一个 JSON 解码器，并从 HTTP 请求的主体中解码 JSON 数据到 `movie` 变量。
66
            _ = json.NewDecoder(r.Body).Decode(&movie)
67
            movie.ID = params["id"]
68
            movies = append(movies, movie)
69
            json.NewEncoder(w).Encode(movies)
70
            return
71
        }
72
    }
73

74
}

关于测试接口#

很多人都喜欢用POSTMAN这个软件，其实vsc里面是有这个插件的，可以使用，或者是用REST Client这个插件，手写GET/POST包发过去即可，前者比较轮椅

关于结构体标签#

结构体里面定义的时候，一般后面都会加上json这个东西，主要的用途就是编码和解码、数据库字段映射、表单解析和 XML 编码和解码，如

1
//结构体标签最常见的用途是与 JSON 编码和解码相关。通过指定 JSON 标签，可以控制 JSON 数据中的字段名称和行为。
2
type Person struct {
3
 Name  string `json:"name"`
4
 Age   int    `json:"age"`
5
 Email string `json:"email"`
6
}
7
// 当你使用 encoding/json 包对这个结构体进行编码时，json:"name" 标签指定了在 JSON 数据中应该使用 "name" 作为字段名。这使得 JSON 数据与 Go 结构体字段之间能够正确映射。
8
import (
9
 "encoding/json"
10
 "fmt"
11
)
12

13
func main() {
14
 p := Person{Name: "Alice", Age: 30, Email: "alice@example.com"}
15
 jsonData, _ := json.Marshal(p)
16
 fmt.Println(string(jsonData)) // 输出: {"name":"Alice","age":30,>>"email":"alice@example.com"}
17
}
18

19
//------------------//
20

21
// 结构体标签也可以用于数据库操作，通过标签指定字段名与数据库表中的列名之间的映射。
22
// 这里，gorm:"column:user_name" 标签指定了结构体字段 Name 对应数据库表中的 user_name 列。
23
type User struct {
24
 ID    int    `gorm:"primary_key"`
25
 Name  string `gorm:"column:user_name"`
26
 Email string `gorm:"column:user_email"`
27
}
28

29
//------------------//
30

31
// 在 Web 开发中，结构体标签可以用于表单解析，指定表单字段的名称与结构体字段之间的映射关系。例如，使用 gin 框架处理表单数据：
32
// 在这个例子中，form:"username" 标签表示表单字段 username 将被映射到结构体字段 Username。
33
type LoginForm struct {
34
 Username string `form:"username"`
35
 Password string `form:"password"`
36
}
37

38
//------------------//
39

40
// 除了 JSON，结构体标签也可以用于 XML 编码和解码。例如，使用 encoding/xml 包：
41
// 这里，xml:"title" 标签指定了 XML 数据中字段名为 title，这在 XML 编码和解码时起作用。
42
type Book struct {
43
 Title  string `xml:"title"`
44
 Author string `xml:"author"`
45
}

a ctfer on the load

study golang / demo1#

项目架构#

整体代码#

关于指针传递#

study golang / demo2#

项目架构#

整体代码#

关于测试接口#

关于结构体标签#