Golang 整合Mysql、Redis、MongoDb, 最新教程，细到极致

  Hello，各位小伙伴，已经大半个月没有更新了，趁着下午摸鱼的时间，咱们使用Go来整合第三方存储

   闲话少说，让我们继续学习

mysql

1、首先是老大哥Mysql,新建一个数据库，go-test

2、新建一张表 tb_user

CREATE TABLE tb_user (
id int NOT NULL AUTO_INCREMENT,
username varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
password varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

INSERT INTO tb_user VALUES (1, ‘Jessica’, ‘123456’);
INSERT INTO tb_user VALUES (2, ‘tom’, ‘123’);
INSERT INTO tb_user VALUES (3, ‘jack’, ‘456’);

3、然后我们搜一下mysql 依赖，https://pkg.go.dev/

3A、如果不成功的话，需要执行 go mod init +项目名，然后 go mod tidy 间接导入依赖

PS D:\Project\Go_Project\goproject1> go get -u github.com/go-sql-driver/mysql

5、Mysql 初始化连接 和 CRUD

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"time"
)

type User struct {
	id                 int
	username, password string
}

func initDB() (err error, db *sql.DB) {
	dsn := "root:root@tcp(127.0.0.1:3306)/go-test?charset=utf8mb4&parseTime=True"
	db, err = sql.Open("mysql", dsn)

	//最大连接时长
	db.SetConnMaxLifetime(time.Minute * 3)
	//最大连接数
	db.SetMaxOpenConns(10)
	//空闲连接数
	db.SetMaxIdleConns(10)

	err = db.Ping()
	if err != nil {
		return err, db
	}

	return nil, db
}

func InsertData(dbs *sql.DB) {
	sqlStr := "INSERT INTO `tb_user` VALUES (?,?,?);"
	r, err := dbs.Exec(sqlStr, nil, "jerry", "123456")
	if err != nil {
		fmt.Println(err)
		return
	} else {
		//获取刚刚插入的ID
		id, _ := r.LastInsertId()
		fmt.Println(id)
	}
}

func queryOneRow(dbs *sql.DB) User {
	sqlStr := "select * from `tb_user` where id = ?"

	var user User
	err := dbs.QueryRow(sqlStr, 2).Scan(&user.id, &user.username, &user.password)

	if err != nil {
		fmt.Println(err)
	}
	return user
}

func queryListRow(dbs *sql.DB) []User {
	sqlStr := "select * from `tb_user`"
	r, err := dbs.Query(sqlStr)

	if err != nil {
		fmt.Println(err)
	} else {
		//这里一次只能查询10条，如果需要动态变化，需要修改代码 2022-08-31 Jessica
		var userData = make([]User, 10)
		for i := 0; i < len(userData); i++ {
			//1、r.next() 表示还有下一条数据，不用做其他的非空判断
			if r.Next() {
				var u User
				err := r.Scan(&u.id, &u.username, &u.password)
				userData[i] = u

				if err != nil {
					log.Print(err)
				}
			} else {
				break
			}
		}
		return userData

	}

	err = r.Close()
	if err != nil {
		return nil
	}

	return nil
}

func updateData(dbs *sql.DB) {
	sql := "update `tb_user` set username=?,password=? where id=?"

	result, err := dbs.Exec(sql, "Jessica1", "20", 1)

	//更新了多少条数据
	updated, err := result.RowsAffected()

	fmt.Println("更新了", updated, "条数据")

	if err != nil {
		fmt.Println(err)
	}
}

func deleteData(dbs *sql.DB) {
	sql := "delete from tb_user where id = ?"

	result, err := dbs.Exec(sql, 5)

	if err != nil {
		fmt.Println(err)
	} else {
		//删除了多少条数据
		affected, _ := result.RowsAffected()
		fmt.Println(affected)
	}
}

func main() {
	err, dbs := initDB()
	if err != nil {
		return
	} else {
		log.Println("数据库初始化 success...")
	}

	//1、新增
	//InsertData(dbs)

	//2.1、查询单条数据
	//UserData := queryOneRow(dbs)
	//fmt.Println(UserData)

	//2.2、查询多条数据
	UserArrData := queryListRow(dbs)
	for _, value := range UserArrData {
		if value != (User{}) {
			fmt.Println(value)
		}
	}

	//3、修改
	//updateData(dbs)

	//3A、删除
	//deleteData(dbs)

}

redis

6、接着是内存老六，Linux没有装Redis的，Redis安装教程，本地开启Redis服务，然后搜索redis,https://pkg.go.dev/search?q=redis

PS D:\Project\Go_Project\goproject1> go get github.com/go-redis/redis/v8

7、然后我们用 go代码连接 redis

package main

import (
	"context"
	"fmt"
	"github.com/go-redis/redis/v8" //redis6版本用V8, redis7版本用V9
)

var ctx = context.Background()

var client *redis.Client

func init() {
	client = redis.NewClient(&redis.Options{
		Addr:     "your server ip:6379",
		Password: "your password",
		DB:       0,
	})

}

func main() {
	testSet()
}

func testSet() {
	err := client.Set(ctx, "name", "Jessica", 0 ).Err()
	if err != nil {
		return
	}

	value , _ := client.Get(ctx, "name").Result()
	fmt.Println(value)
	
}

mongodb

8、最后一个，mongodb 中间件,Mogodb6.0安装教程

9、导入包

PS D:\Project\Go_Project\goproject1> go get go.mongodb.org/mongo-driver/mongo

10、Navicat 新建一个集合，student

11、然后 我们用 go 操作 MongoDb，实现CRUD

package main

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

type Student struct {
	Name string
	Age  int
}

var clientMongoDb *mongo.Client

func init() {
	clientOptions := options.Client().ApplyURI("mongodb://101.35.245.191:27017")

	var err error
	clientMongoDb, err = mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	errs := clientMongoDb.Ping(context.TODO(), nil)

	if errs != nil {
		log.Fatal(errs)
	} else {
		fmt.Println("Connected to mongodb")
	}
}

func main() {
	//insertOne()

	//insertMany()

	find()

	//update()

	//delete()

}

//插入一条数据
func insertOne() {
	stu := Student{
		Name: "tom",
		Age:  10,
	}

	collection := clientMongoDb.Database("test").Collection("student")
	insertOne, err := collection.InsertOne(context.TODO(), stu)

	if err != nil {
		fmt.Println(err)
	}

	id := insertOne.InsertedID
	fmt.Println("插入的数据id为: ", id)

}

//插入多条数据
func insertMany() {
	stu1 := Student{
		Name: "jerry",
		Age:  10,
	}

	stu2 := Student{
		Name: "lucy",
		Age:  10,
	}

	collection := clientMongoDb.Database("test").Collection("student")

	insertMany, err := collection.InsertMany(context.TODO(), []interface{}{stu1, stu2})

	if err != nil {
		fmt.Println(err)
	}

	ids := insertMany.InsertedIDs
	fmt.Println("插入的数据ids为: ", ids)

}

//查询一条或者多条
func find() {
	//查询结束之后，关闭连接
	defer clientMongoDb.Disconnect(context.TODO())

	collection := clientMongoDb.Database("test").Collection("student")

	//查一条，过滤
	//cur, err := collection.Find(context.TODO(), bson.D{{"name", "tom"}})

	//查多条数据，不过滤
	cur, err := collection.Find(context.TODO(), bson.D{})
	if err != nil {
		fmt.Println(err)
	}

	var result bson.D

	for cur.Next(context.TODO()) {
		//将cur的参数，全部解析到 bson格式里面，bson是json的加强版
		cur.Decode(&result)
		fmt.Println(result.Map())
	}

}

//更新一条或者多条
func update() {
	//查询结束之后，关闭连接
	defer clientMongoDb.Disconnect(context.TODO())

	collection := clientMongoDb.Database("test").Collection("student")

	updateValue := bson.D{{"$set", bson.D{{"name", "Jessica"}, {"age", 25}}}}

	//第二个是更新前的数据，第三个是更新后的数据
	updateId, err := collection.UpdateMany(context.TODO(), bson.D{{"name", "Big jerry"}}, updateValue)

	if err != nil {
		fmt.Println(err)
	}
	count := updateId.ModifiedCount
	fmt.Println("一共更新了", count, "条")

}

//删除一条或者多条
func delete() {
	//查询结束之后，关闭连接
	defer clientMongoDb.Disconnect(context.TODO())

	collection := clientMongoDb.Database("test").Collection("student")

	//把年龄为10的 tom和 lucy删掉
	deleteID, err := collection.DeleteMany(context.TODO(), bson.D{{"age", 10}})
	if err != nil {
		fmt.Println(err)
	}

	count := deleteID.DeletedCount
	fmt.Println("一共删除了", count, "条")
}

12、至此，go连接常用的存储中间件讲到这里结束，基本上可以覆盖go开发80%的需求，希望能够得到大家喜欢。另外，这也算是完成了老哥八月底写完一篇文章的小目标，好开森

13、最后，各位小伙伴，麻烦给老哥一个点赞、关注、收藏三连好吗，你的支持是老哥更新最大的动力，谢谢！