Go语言+Vue3零基础入门全栈班09 Go语言+MongoDB开发用户管理系统API实战_20240730 课程笔记

于 2024-07-31 10:22:35 发布
阅读量718 收藏 9
点赞数 10
分类专栏： Golang MongoDB 文章标签： golang mongodb 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37703224/article/details/140815772
版权
Golang 同时被 2 个专栏收录
165 篇文章 5 订阅
订阅专栏
MongoDB
18 篇文章 0 订阅
订阅专栏

概述

如果您没有Golang的基础，应该学习如下前置课程。

  • Golang零基础入门
  • Golang面向对象编程
  • Go Web 基础
  • Go语言开发REST API接口_20240728
  • Go语言操作MySQL开发用户管理系统API教程_20240729
  • Redis零基础快速入门_20231227
  • Go+Redis开发用户管理系统API实战_20240730
  • MongoDB快速入门_20240411

基础不好的同学每节课的代码最好配合视频进行阅读和学习，如果基础比较扎实，则阅读本教程巩固一下相关知识点即可，遇到不会的知识点再看视频。

课程特色

本教程录制于2024年7月31日，使用Go1.22版本，基于Goland2024进行开发，采用的技术栈比较新。

每节课控制在十分钟以内，课时精简，每节课都是一个独立的知识点，如果有遗忘，完全可以当做字典来查询，绝不浪费大家的时间。

整个课程从如何连接MongoDB数据库讲起，然后如何创建数据库和表，如何做增删改查，如何讲增删改查的代码改造为REST API接口，层层递进，学习路径平缓。

对于基础较好的同学，本课程还特意讲解了MongoDB官方驱动库的本地化和httprouter的进阶封装使用，基础好的同学也能够从本套课程中学到干货。

Golang是当前国内越来越多的企业正在全面转的一门系统级别的高性能的编程语言，比C语言写法更加的简单，比Python性能更加的好，是新时代的C语言，建议每个程序员都掌握！

视频课程

最近发现越来越多的公司在用Golang了，所以精心整理了一套视频教程给大家，这个是其中的第9部，后续还会有很多。

视频已经录制完成，完整目录截图如下：
在这里插入图片描述

本套课程的特色是每节课都是一个核心知识点，每个视频控制在十分钟左右，精简不废话，拒绝浪费大家的时间。

课程目录

  • 01 概述
  • 02 连接MongoDB
  • 03 创建数据库和表
  • 04 新增数据
  • 05 批量新增数据
  • 06 根据ID查询数据
  • 07 将查询结果解析到结构体列表
  • 08 使用bson.M进行查询
  • 09 使用bson.D实现in查询
  • 10 使用Pipeline和Aggregate实现聚合查询
  • 11 使用UpdateMany修改数据
  • 12 使用DeleteMany删除数据
  • 13 将MongoDB官方驱动库进行本地化
  • 14 实现新增用户的接口并进行测试
  • 15 实现查询所有用户的接口并进行测试
  • 16 封装404错误信息统一返回
  • 17 使用统一返回的404错误信息
  • 18 实现修改用户的接口并进行测试
  • 19 优化统一返回值类型
  • 20 实现根据ID删除用户的接口并进行测试
  • 21 总结

完整代码

01 概述

02 连接MongoDB

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

func main() {
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(mongoDb)
}

03 创建数据库和表

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")
	fmt.Println(usersCollection)
}

04 新增数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 新增数据
	zs := User{1, "张三", 23}
	result, err := usersCollection.InsertOne(context.Background(), zs)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 取出ID
	objectID := result.InsertedID.(primitive.ObjectID)
	fmt.Println(objectID)
}

05 批量新增数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 新增数据
	data := []interface{}{
		User{1, "张三", 23},
		User{2, "李四", 23},
	}
	result, err := usersCollection.InsertMany(context.Background(), data)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 取出ID
	for _, u := range result.InsertedIDs {
		objectID := u.(primitive.ObjectID)
		fmt.Println(objectID)
	}
}

06 根据ID查询数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 查询数据
	query := map[string]int{"id": 1}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(10),
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	for cur.Next(context.Background()) {
		var user User
		if cur.Decode(&user) != nil {
			fmt.Println(err)
			return
		}
		fmt.Println(user)
	}
}

07 将查询结果解析到结构体列表

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 查询数据
	query := map[string]int{"id": 1}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(10),
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		return
	}

	for _, user := range users {
		fmt.Println(user)
	}
}

08 使用bson.M进行查询

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 查询数据
	query := bson.M{"id": 1}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(10),
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		return
	}

	for _, user := range users {
		fmt.Println(user)
	}
}

09 使用bson.D实现in查询

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 查询数据
	query := bson.D{{
		"name",
		bson.D{{ // D表示Document 文档
			"$in",
			bson.A{"张三", "李四"}, // A 表示Array 数组
		}},
	}}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(10),
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		return
	}

	for _, user := range users {
		fmt.Println(user)
	}
}

10 使用Pipeline和Aggregate实现聚合查询

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 查询数据
	groupStage := mongo.Pipeline{bson.D{
		{"$group", bson.D{
			{"_id", "$name"},
			{"count", bson.D{
				{"$sum", 1},
			}},
		}},
	}}
	cur, err := usersCollection.Aggregate(
		context.TODO(),
		groupStage,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []bson.M
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		return
	}
	for _, user := range users {
		fmt.Println(user)
	}
}

11 使用UpdateMany修改数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 更新数据
	query := bson.M{"id": 1}
	update := bson.M{"$set": bson.M{"age": 33}}
	result, err := usersCollection.UpdateMany(
		context.TODO(),
		query,
		update,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(result.ModifiedCount)
}

12 使用DeleteMany删除数据

package main

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

type User struct {
	Id   int    `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func main() {
	// 建立连接
	mongoUrl := "mongodb://localhost:27017"
	mongoDb, err := mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 创建或者选择数据
	db := mongoDb.Database("user_manager")

	// 创建表
	usersCollection := db.Collection("users")

	// 删除数据
	query := bson.M{"id": 1}
	result, err := usersCollection.DeleteMany(
		context.TODO(),
		query,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(result.DeletedCount)
}

13 将MongoDB官方驱动库进行本地化

14 实现新增用户的接口并进行测试

服务端代码：

package main

import (
	"context"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo/options"
	"net/http"
	"time"
)

var (
	// 建立连接
	mongoUrl   = "mongodb://localhost:27017"
	mongoDb, _ = mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	// 创建或者选择数据
	db = mongoDb.Database("user_manager")
	// 创建表
	usersCollection = db.Collection("users")
)

type User struct {
	Id   int64  `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	var user User
	zdpgo_httprouter.GetJson(r, &user)

	id := time.Now().UnixNano()
	user.Id = id

	// 新增
	_, err := usersCollection.InsertOne(context.Background(), user)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, user)
}

func main() {
	router := zdpgo_httprouter.New()
	router.POST("/user", RouterAddUser)

	server := &http.Server{
		Addr:         "0.0.0.0:8888",
		Handler:      router,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 5 * time.Second,
	}

	server.ListenAndServe()
}

客户端代码：

package main

import (
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"io"
)

func main() {
	targetUrl := "http://localhost:8888/user"
	data := map[string]interface{}{
		"name": "王五",
		"age":  35,
	}
	resp, err := zdpgo_httprouter.SendJson("POST", targetUrl, data)
	if err != nil {
		fmt.Println(err)
		return
	}

	body := resp.Body
	bodyBytes, err := io.ReadAll(body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(bodyBytes))
}

15 实现查询所有用户的接口并进行测试

服务端代码：

package main

import (
	"context"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_mongo/bson"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo/options"
	"net/http"
	"time"
)

var (
	// 建立连接
	mongoUrl   = "mongodb://localhost:27017"
	mongoDb, _ = mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	// 创建或者选择数据
	db = mongoDb.Database("user_manager")
	// 创建表
	usersCollection = db.Collection("users")
)

type User struct {
	Id   int64  `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	var user User
	zdpgo_httprouter.GetJson(r, &user)

	id := time.Now().UnixNano()
	user.Id = id

	// 新增
	_, err := usersCollection.InsertOne(context.Background(), user)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, user)
}
func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	// 查询数据
	query := bson.M{}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(20),
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseSuccess(w, nil)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseSuccess(w, nil)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, users)
}

func main() {
	router := zdpgo_httprouter.New()
	router.POST("/user", RouterAddUser)
	router.GET("/user", RouterGetUser)

	server := &http.Server{
		Addr:         "0.0.0.0:8888",
		Handler:      router,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 5 * time.Second,
	}

	server.ListenAndServe()
}

客户端代码：

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	targetUrl := "http://localhost:8888/user"
	resp, err := http.Get(targetUrl)
	if err != nil {
		fmt.Println(err)
		return
	}

	body := resp.Body
	bodyBytes, err := io.ReadAll(body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(bodyBytes))
}

16 封装404错误信息统一返回

17 使用统一返回的404错误信息

18 实现修改用户的接口并进行测试

服务端代码：

package main

import (
	"context"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_mongo/bson"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo/options"
	"net/http"
	"strconv"
	"time"
)

var (
	// 建立连接
	mongoUrl   = "mongodb://localhost:27017"
	mongoDb, _ = mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	// 创建或者选择数据
	db = mongoDb.Database("user_manager")
	// 创建表
	usersCollection = db.Collection("users")
)

type User struct {
	Id   int64  `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	var user User
	zdpgo_httprouter.GetJson(r, &user)

	id := time.Now().UnixNano()
	user.Id = id

	// 新增
	_, err := usersCollection.InsertOne(context.Background(), user)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, user)
}
func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	// 查询数据
	query := bson.M{}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(20),
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseError404(w, nil)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseError404(w, nil)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, users)
}
func RouterUpdateUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	id := ps.ByName("id")
	idInt, _ := strconv.ParseInt(id, 10, 64)

	var user User
	zdpgo_httprouter.GetJson(r, &user)
	user.Id = idInt

	// 更新数据
	query := bson.M{"id": idInt}
	update := bson.M{"$set": bson.M{"name": user.Name, "age": user.Age}}
	result, err := usersCollection.UpdateMany(
		context.TODO(),
		query,
		update,
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseSuccess(w, nil)
		return
	}

	// 返回
	data := map[string]interface{}{
		"modifiedCount": result.ModifiedCount,
		"user":          user,
	}
	zdpgo_httprouter.ResponseSuccess(
		w,
		data,
	)
}

func main() {
	router := zdpgo_httprouter.New()
	router.POST("/user", RouterAddUser)
	router.GET("/user", RouterGetUser)
	router.PUT("/user/:id", RouterUpdateUser)

	server := &http.Server{
		Addr:         "0.0.0.0:8888",
		Handler:      router,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 5 * time.Second,
	}

	server.ListenAndServe()
}

客户端代码：

package main

import (
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"io"
)

func main() {
	targetUrl := "http://localhost:8888/user/2"
	data := map[string]interface{}{
		"name": "李四333",
		"age":  35,
	}
	resp, err := zdpgo_httprouter.SendJson("PUT", targetUrl, data)
	if err != nil {
		fmt.Println(err)
		return
	}

	body := resp.Body
	bodyBytes, err := io.ReadAll(body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(bodyBytes))
}

19 优化统一返回值类型

20 实现根据ID删除用户的接口并进行测试

服务端代码：

package main

import (
	"context"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_mongo/bson"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo"
	"github.com/zhangdapeng520/zdpgo_mongo/mongo/options"
	"net/http"
	"strconv"
	"time"
)

var (
	// 建立连接
	mongoUrl   = "mongodb://localhost:27017"
	mongoDb, _ = mongo.Connect(
		context.TODO(),
		options.Client().ApplyURI(mongoUrl).SetConnectTimeout(5*time.Second),
	)
	// 创建或者选择数据
	db = mongoDb.Database("user_manager")
	// 创建表
	usersCollection = db.Collection("users")
)

type User struct {
	Id   int64  `bson:"id" json:"id"`
	Name string `bson:"name" json:"name"`
	Age  int    `bson:"age" json:"age"`
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	var user User
	zdpgo_httprouter.GetJson(r, &user)

	id := time.Now().UnixNano()
	user.Id = id

	// 新增
	_, err := usersCollection.InsertOne(context.Background(), user)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, user)
}
func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	// 查询数据
	query := bson.M{}
	cur, err := usersCollection.Find(
		context.TODO(),
		query,
		options.Find().SetSkip(0),
		options.Find().SetLimit(20),
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseError404(w, nil)
		return
	}
	defer cur.Close(context.Background())

	// 反序列化
	var users []User
	err = cur.All(context.Background(), &users)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseError404(w, nil)
		return
	}

	// 返回
	zdpgo_httprouter.ResponseSuccess(w, users)
}
func RouterUpdateUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	id := ps.ByName("id")
	idInt, _ := strconv.ParseInt(id, 10, 64)

	var user User
	zdpgo_httprouter.GetJson(r, &user)
	user.Id = idInt

	// 更新数据
	query := bson.M{"id": idInt}
	update := bson.M{"$set": bson.M{"name": user.Name, "age": user.Age}}
	result, err := usersCollection.UpdateMany(
		context.TODO(),
		query,
		update,
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseSuccess(w, nil)
		return
	}

	// 返回
	data := map[string]interface{}{
		"modifiedCount": result.ModifiedCount,
		"user":          user,
	}
	zdpgo_httprouter.ResponseSuccess(
		w,
		data,
	)
}
func RouterDeleteUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	id := ps.ByName("id")
	idInt, _ := strconv.ParseInt(id, 10, 64)

	// 删除数据
	query := bson.M{"id": idInt}
	result, err := usersCollection.DeleteMany(
		context.TODO(),
		query,
	)
	if err != nil {
		fmt.Println(err)
		zdpgo_httprouter.ResponseError500(w, nil)
		return
	}

	// 返回
	data := map[string]interface{}{
		"deletedCount": result.DeletedCount,
		"id":           id,
	}
	zdpgo_httprouter.ResponseSuccess(
		w,
		data,
	)
}

func main() {
	router := zdpgo_httprouter.New()
	router.POST("/user", RouterAddUser)
	router.GET("/user", RouterGetUser)
	router.PUT("/user/:id", RouterUpdateUser)
	router.DELETE("/user/:id", RouterDeleteUser)

	server := &http.Server{
		Addr:         "0.0.0.0:8888",
		Handler:      router,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 5 * time.Second,
	}

	server.ListenAndServe()
}

客户端代码：

package main

import (
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"io"
)

func main() {
	targetUrl := "http://localhost:8888/user/965490400"
	data := map[string]interface{}{}
	resp, err := zdpgo_httprouter.SendJson("DELETE", targetUrl, data)
	if err != nil {
		fmt.Println(err)
		return
	}

	body := resp.Body
	bodyBytes, err := io.ReadAll(body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(bodyBytes))
}

总结

本套教程主要讲解Go语言操作MongoDB的基础知识，从零到一的层层递进，从怎么连接MongoDB讲起，然后讲解如何做增删改查，如何讲增删改查的代码改造为REST API接口。

通过本套课程，能帮你入门Go语言操作MongoDB的技术。

如果您需要完整的源码，打赏20元即可。

人生苦短，我用PyGo，我是您身边的Python私教~

Python私教
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Python私教

创业不易，请打赏支持我一点吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值