//main.go

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
)

type Student struct {
	Id   int32
	Name string
	Age  int
}

// pool 连接池模式
func ConnectToDB(uri, name string, timeout time.Duration, num uint64) (*mongo.Database, error) {
	// 设置连接超时时间
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	// 通过传进来的uri连接相关的配置
	o := options.Client().ApplyURI(uri)
	// 设置最大连接数 - 默认是100 ，不设置就是最大 max 64
	o.SetMaxPoolSize(num)
	// 发起链接
	client, err := mongo.Connect(ctx, o)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	// 判断服务是不是可用
	if err = client.Ping(context.Background(), readpref.Primary()); err != nil {
		log.Fatal(err)
		return nil, err
	}
	// 返回 client
	return client.Database(name), nil
}

func main() {

	toDB, err := ConnectToDB("mongodb://admin:123456@localhost:27017", "admin", time.Duration(2), 50)
	fmt.Println(err)
	if err != nil {
		fmt.Println(err)
		fmt.Println(toDB)
		return
	}
	fmt.Println("sussces")
	doc := Student{Name: "刘刘", Age: 18, Id: 1}

	coll := toDB.Collection("users")
	objId, err := coll.InsertOne(context.TODO(), doc)
	fmt.Println(objId)
	if err != nil {
		return
	}
	fmt.Println("新增成功")
	var one Student
	filter := bson.D{{"id", 1}}
	var ctx context.Context
	var cancel func()
	ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	err = coll.FindOne(ctx, filter).Decode(&one)
	if err == mongo.ErrNoDocuments {
		// Do something when no record was found
		fmt.Println("record does not exist")
	} else if err != nil {
		log.Fatal(err)
	}
	fmt.Println(one)

}

PS E:\proj\gowork\studyMongoDb> go run .\main.go
<nil>
sussces
&{ObjectID("64ae992a5063fc95642035ed")}
新增成功
{1 刘刘 18}
PS E:\proj\gowork\studyMongoDb> 

package dbs

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
)

var (
	Client     *mongo.Client     // database 话柄
	Collection *mongo.Collection // collection 话柄
)

// pool 连接池模式
func ConnectToDB(uri, name string) {

	cb := context.Background()
	// 设置连接超时时间
	ctx1, cancel := context.WithTimeout(cb, time.Duration(2))
	defer cancel()
	// 通过传进来的uri连接相关的配置
	o := options.Client().ApplyURI(uri)
	// 设置最大连接数 - 默认是100 ，不设置就是最大 max 64
	o.SetMaxPoolSize(50)
	// 发起链接
	client, err := mongo.Connect(ctx1, o)
	if err != nil {
		fmt.Println(err)
		return
	}
	// 判断服务是不是可用
	if err = client.Ping(cb, readpref.Primary()); err != nil {
		log.Fatal(err)
		return
	}
	// 默认连接的数据库
	_db := client.Database(name)

	Client = client
	// 默认连接集合为users
	Collection = _db.Collection("users")
}

package models

import (
	"context"
	"fmt"
	"log"

	"example.com/studyMongoDb/dbs"
	"go.mongodb.org/mongo-driver/bson"
)

type User struct {
	Key      string `json:"key"`
	Name     string `json:"name"`
	Password string `json:"password"`
	Id       int    `json:"id"`
}


func (u *User) GetList(ctx context.Context) (users []User, err1 error) {
	cur, err := dbs.Collection.Find(ctx, bson.D{})
	if err != nil {
		log.Fatal(err)
		return
	}
	if err := cur.Err(); err != nil {
		log.Fatal(err)
		return
	}
	err = cur.All(ctx, &users)
	if err != nil {
		log.Fatal(err)
		return
	}
	cur.Close(ctx)
	return

}

func (u *User) Query() (user []User, err1 error) {
	cb := context.Background()
	fil := bson.M{"key": u.Key}
	// 模糊查询
	// bson.M{"Name": primitive.Regex{Pattern: u.name}}
	cur, err := dbs.Collection.Find(cb, fil)
	// dbs.Collection.FindOne(cb, fil).Decode(&user)
	if err != nil {
		log.Fatal(err)
		return
	}
	if err := cur.Err(); err != nil {
		log.Fatal(err)
		return
	}
	err = cur.All(cb, &user)
	if err != nil {
		log.Fatal(err)
		return
	}
	cur.Close(cb)
	return

}

func (u *User) Add() (err error) {
	objId, err1 := dbs.Collection.InsertOne(context.TODO(), &u)
	if err1 != nil {
		fmt.Println("insert into error:", err)

	}
	fmt.Println("录入数据成功,", objId)
	return
}
func (u *User) EditOne() (err1 error) {
	fil := bson.M{"key": u.Key}
	update := bson.M{"$set": u}
	// .update({条件},{修改后的数据})
	updateResult, err := dbs.Collection.UpdateOne(context.Background(), fil, update)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("collection.UpdateOne:", updateResult)
	return
}

func (u *User) Delete() (err1 error) {
	fil := bson.M{"key": u.Key}
	deleteResult, err := dbs.Collection.DeleteOne(context.Background(), fil)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("collection.DeleteOne:", deleteResult)
	return
}

package api

import (
	"context"
	"fmt"
	"net/http"

	"example.com/studyMongoDb/models"
	"github.com/gin-gonic/gin"
)

func UserAdd(c *gin.Context) {
	var user models.User
	if c.Bind(&user) == nil { //把客户端格式传过来的数据绑定到结构体user中去
		fmt.Println("data=", user)
		err := user.Add() // 调用model层的对应方法
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "新增失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "新增成功",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserList(c *gin.Context) {
	var user models.User
	if c.Bind(&user) == nil { //把客户端格式传过来的数据绑定到结构体user中去
		users, err := user.GetList(context.Background()) // 调用model层的对应方法
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "获取列表失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":   "获取列表成功",
				"code":  1,
				"users": users,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserEditOne(c *gin.Context) {
	var user models.User
	if c.Bind(&user) == nil {
		err := user.EditOne()
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "编辑失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "编辑成功",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserDelete(c *gin.Context) {
	var user models.User
	if c.Bind(&user) == nil {
		err := user.Delete()
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "删除失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "删除成功",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}
func UserQuery(c *gin.Context, key string) {
	user := models.User{
		Key: key,
	}
	if c.Bind(&user) == nil {
		user, err := user.Query()
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "查询失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "查询成功",
				"code": 1,
				"user": user,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

package routers

import (
	"example.com/studyMongoDb/api"
	"github.com/gin-gonic/gin"
)

func InitRouter() *gin.Engine {

	router := gin.Default()
	router.POST("/UserAdd", api.UserAdd)
	router.GET("/UserList", api.UserList)
	router.POST("/UserEditOne", api.UserEditOne)
	router.POST("/UserDelete", api.UserDelete)
	router.GET("/UserQuery/:key", func(c *gin.Context) {
		key := c.Param("key")
		api.UserQuery(c, key)
	})

	return router
}

package main

import (
	"context"

	"example.com/studyMongoDb/dbs"
	"example.com/studyMongoDb/routers"
)

func main() {

	dbs.ConnectToDB("mongodb://admin:123456@localhost:27017", "admin")
	router := routers.InitRouter()
	router.Run(":8000")
	// 优雅关闭连接
	defer dbs.Client.Disconnect(context.TODO())

}

PS E:\proj\gowork\studyMongoDb> go run .\main.go
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] POST   /UserAdd                  --> example.com/studyMongoDb/api.UserAdd (3 handlers) 
[GIN-debug] GET    /UserList                 --> example.com/studyMongoDb/api.UserList (3 handlers)
[GIN-debug] POST   /UserEditOne              --> example.com/studyMongoDb/api.UserEditOne (3 handlers)
[GIN-debug] POST   /UserDelete               --> example.com/studyMongoDb/api.UserDelete (3 handlers)
[GIN-debug] GET    /UserQuery/:key           --> example.com/studyMongoDb/routers.InitRouter.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on :8000

package db

import (
	"context"
	"fmt"

	"github.com/redis/go-redis/v9"
)

var Rdbs *redis.Client

func InitRedis(ctx context.Context) {
	rd := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	Rdbs = rd
	//清空当前数据库中的所有key，只要加了这个每次重新启动服务器，所有数据被清空
	// Rdbs.FlushDB(ctx)
	_, err := Rdbs.Ping(ctx).Result() // PING, <nil>
	if err != nil {
		fmt.Println("connect redis failed:", err)
		return
	}

}
func Close() {
	Rdbs.Close()
}

package models

import (
	"context"
	"encoding/json"
	"fmt"

	"example.com/goRedis/db"
)

type User struct {
	Key      string `json:"key"`
	Name     string `json:"name"`
	Password string `json:"password"`
	Id       int    `json:"id"`
}

// 存储和读取redis时，不能直接存入结构体，必须进行序列号和反序列化

// 序列化
func (u *User) MarshalBinary() (data []byte, err error) {
	return json.Marshal(u)
}

// 反序列化
func (u *User) UnmarshalBinary(data []byte) (err error) {
	return json.Unmarshal(data, u)
}

// 新增数据
func (u *User) Add(ctx *context.Context) (err error) {

	// HMSet 批量设置 map[string]interface{}{"name": "张", "password": "11111", "id": 123}

	fmt.Println("json.=", u)
	// 必须转为[]byte, redis不支持直接存结构体

	// 0 表示key永不过期
	_, err = db.Rdbs.Set(*ctx, u.Key, u, 0).Result()
	if err != nil {
		fmt.Println("db.Rdbs.Set,", err)
		return
	}
	return
}

// 根据key 获取到数据
func (u *User) GetUser(ctx *context.Context) (user1 User, err error) {

	err = db.Rdbs.Get(*ctx, u.Key).Scan(u)
	if err != nil {
		fmt.Println("GetUser error", err)
		return
	}
	user1 = *u
	return
}

// 查询所有
func (u *User) QueryAll(ctx *context.Context) (user1 []User, er error) {
	// keys, err := db.Rdbs.Keys(*ctx, "[1-9]*")).Result()
	keys, err := db.Rdbs.Keys(*ctx, "*").Result()
	fmt.Println("key=", keys)
	if err != nil {
		fmt.Println("db.Rdbs.Keys error:", err)
		return
	}
	for _, key := range keys {
		err = db.Rdbs.Get(*ctx, key).Scan(u)
		if err != nil {
			fmt.Print("Rdbs.Get error", err)
			fmt.Println("key=", key)
			return
		}
		fmt.Println("query=", *u)
		user1 = append(user1, *u)

	}
	return
}

// 删除
func (u *User) DeleteUser(ctx *context.Context) (err bool) {
	// 先判断key是否存在
	if db.Rdbs.Exists(*ctx, u.Key).Val() == 1 {
		_, er := db.Rdbs.Del(*ctx, u.Key).Result()
		if er != nil {
			fmt.Println("DeleteUser error: ", err)
			return false
		}
		return true
	}
	return false
}

// 修改
func (u *User) UpdateUser(ctx *context.Context) (err error) {
	// 先判断key是否存在
	if db.Rdbs.Exists(*ctx, u.Key).Val() == 1 {
		// 必须转为[]byte, redis不支持直接存结构体
		u1, _ := json.Marshal(u)
		_, err = db.Rdbs.Set(*ctx, u.Key, u1, 0).Result()
		if err != nil {
			fmt.Println("UpdateUser error:", err)
			return
		}
	}
	return
}

package api

import (
	"context"
	"fmt"
	"net/http"

	"example.com/goRedis/models"
	"github.com/gin-gonic/gin"
)

func UserAdd(c *gin.Context, ctx *context.Context) {
	fmt.Println("add=", c)
	var user models.User
	if c.Bind(&user) == nil { //把客户端格式传过来的数据绑定到结构体user中去
		fmt.Println("data=", user)
		err := user.Add(ctx) // 调用model层的对应方法
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "新增失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "新增成功",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserGet(c *gin.Context, ctx *context.Context, key string) {
	// 接受key
	users := models.User{
		Key: key,
	}
	if c.Bind(&users) == nil {
		users, err := users.GetUser(ctx)
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "获取失败",
				"code": -1,
				"user": users,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "获取成功",
				"code": 1,
				"user": users,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserAll(c *gin.Context, ctx *context.Context) {
	var user models.User
	if c.Bind(&user) == nil {
		users, err := user.QueryAll(ctx)
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "获取失败",
				"code": -1,
				"user": users,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "获取成功",
				"code": 1,
				"user": users,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserDel(c *gin.Context, ctx *context.Context) {
	var user models.User
	if c.Bind(&user) == nil {
		err := user.DeleteUser(ctx)
		fmt.Println("del=", err)
		if !err {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "删除失败1",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "删除成功1",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

func UserUpdate(c *gin.Context, ctx *context.Context) {
	var user models.User
	if c.Bind(&user) == nil {
		err := user.UpdateUser(ctx)
		if err != nil {

			c.JSON(http.StatusOK, gin.H{
				"msg":  "修改失败",
				"code": -1,
			})

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "修改成功",
				"code": 1,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}
}

package main

import (
	"context"

	"example.com/goRedis/api"
	"example.com/goRedis/db"
	"github.com/gin-gonic/gin"
)

func main() {
	ctx := context.Background()
	db.InitRedis(ctx)
	defer db.Close()
	r := gin.Default()
	r.POST("/userAdd", func(c *gin.Context) {
		api.UserAdd(c, &ctx)
	})
	r.GET("/userAll", func(c *gin.Context) {
		api.UserAll(c, &ctx)
	})
	r.GET("/userGet/:key", func(c *gin.Context) {
		key := c.Param("key")

		api.UserGet(c, &ctx, key)
	})
	r.POST("/userUpdate", func(c *gin.Context) {
		api.UserUpdate(c, &ctx)
	})
	r.POST("/userDel", func(c *gin.Context) {
		api.UserDel(c, &ctx)
	})
	r.Run(":8000")
}

E:\proj\gowork\studyGin> go get -u github.com/gin-gonic/gin

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	// 1.创建路由
	r := gin.Default()
	// 2.绑定路由规则，执行的函数
	// gin.Context，封装了request和response
	r.GET("/", func(c *gin.Context) {
		c.String(http.StatusOK, "hello World!")
	})
	// 3.监听端口，默认在8080
	// Run("里面不指定端口号默认为8080")
	r.Run(":8000")
}

│  go.mod
│  go.sum
│  main.go
│
├─apis # 存放具体的业务逻辑，比如users.go中放的增删改查的逻辑
├─database # 存放数据库的相关配置
├─middleware # 存放中间件的内容
│  ├─jwt
│  └─middleware
├─models # 存放结构体的文件
└─routers # 存放路由，比如get,post等对应关系

package database

//安装gorm
//go get gorm.io/gorm
// 安装mysql驱动
//go get gorm.io/driver/mysql
import (
	"fmt"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var Db *gorm.DB

func InitDb() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
	database, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println("open mysql error:", err)
	}
	Db = database

}
func Close() {
	sqlDB, _ := Db.DB()
	sqlDB.Close()
}

package models

import (
	"fmt"

	"example.com/myGin/database"
)

type User struct {
	Name     string `form:"name",json:"name",bingding:"required",gorm:"unique;not null"`
	Password string `form:"password",json:"password",bingding:"required"gorm:"NOT NULL"`
	Id       int    `form:"id",gorm:"PRIMARY_KEY"`
}

// 登录
func (u *User) Login() (user1 User, err error) {
	obj := database.Db.Where("name=? and password=?", u.Name, u.Password).First(&user1)
	if err = obj.Error; err != nil {
		fmt.Printf("这是登陆错误  %v 和 %T", err, err)
		return
	}
	fmt.Println(user1)
	return

}

// 获取用户列表
func (u *User) UserList() (users []User, err error) {
	if err = database.Db.Find(&users).Error; err != nil {
		return
	}
	return

}

package apis

import (
	"net/http"

	"example.com/myGin/models"
	"github.com/gin-gonic/gin"
)


func UserLogin(c *gin.Context) {
	var user models.User
	// c.ShouldBindJSON
	if c.Bind(&user) == nil { //把客户端格式传过来的数据绑定到结构体user中去
		msg, err := user.Login() // 调用model层的对应方法
		if err != nil {
			if err.Error() == "record not found" {
				c.JSON(http.StatusOK, gin.H{
					"msg":  "用户不存在",
					"user": nil,
				})
			} else {
				c.JSON(http.StatusOK, gin.H{
					"msg":  "登陆错误",
					"user": nil,
				})

			}

		} else {
			c.JSON(http.StatusOK, gin.H{
				"msg":  "登陆成功",
				"user": msg,
			})
		}
	} else {
		c.JSON(400, gin.H{"JSON=== status": "binding JSON error!"})
	}

}

// 获取用户列表
func GetUserList(c *gin.Context) {
	var user models.User
	users, err := user.UserList()
	if err != nil {
		fmt.Println("get user list error:", err)
	}
	c.JSON(http.StatusOK, gin.H{
		"msg": users,
	})
}