Go+Redis零基础到用户管理系统API实战_20240730 课程笔记

Python私教2024-08-01 14:09

概述

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

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

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

视频课程

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

视频已经录制完成，完整目录截图如下：

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

课程目录

  • 01 概述
  • 02 建立Redis连接对象
  • 03 edis的打开和关闭方法
  • 04 通过Do执行get和set命令
  • 05 通过String自动转换字符串
  • 06 通过Do实现mset和mget的操作
  • 07 通过Do实现hset和hget的操作
  • 08 通过Do实现lpush和lpop以及llen的操作
  • 09 Redis的连接池介绍
  • 10 Redis连接池的创建和使用
  • 11 Redis的管道操作
  • 12 Redis的事务操作
  • 13 实现redigo的本地化
  • 14 对zdpgo_redis的包结构进行调整
  • 15 发布zdpgo_redisv1.1.0版本
  • 16 新增用户
  • 17 修改用户
  • 18 删除用户
  • 19 查询所有用户
  • 20 实现查询所有用户的接口并进行测试
  • 21 实现新增用户的接口并进行测试
  • 22 解决ID唯一性的问题
  • 23 实现修改用户的接口并进行测试
  • 24 实现删除用户的接口并进行测试
  • 25 实现根据ID查询用户的接口并进行测试
  • 26 总结

完整代码

01 概述

02 建立Redis连接对象

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

func main() {
	r, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer r.Close()
}

03 edis的打开和关闭方法

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	fmt.Println("主程序的操作。。。")
}

04 通过Do执行get和set命令

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	// set 操作
	_, err = r.Do("SET", "name", "张三")
	if err != nil {
		fmt.Println(err)
		return
	}

	// get 操作
	var reply interface{}
	reply, err = r.Do("GET", "name")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(reply.([]byte)))
}

05 通过String自动转换字符串

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	// set 操作
	_, err = r.Do("SET", "name", "张三")
	if err != nil {
		fmt.Println(err)
		return
	}

	// get 操作
	var reply string
	reply, err = redis.String(r.Do("GET", "name"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(reply)
}

06 通过Do实现mset和mget的操作

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	// set 操作
	// 也一定要注意，是：key1,value1,key2,value2... 的格式
	_, err = r.Do("MSET", "name", "张三", "age", 22, "gender", "男")
	if err != nil {
		fmt.Println(err)
		return
	}

	// get 操作
	// 这个传递的是想要哪些key
	var reply []string
	reply, err = redis.Strings(r.Do("MGET", "name", "age", "gender"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(reply)
}

07 通过Do实现hset和hget的操作

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	_, err = r.Do("HSET", "user", "name", "张三")
	if err != nil {
		fmt.Println(err)
		return
	}

	var reply string
	reply, err = redis.String(r.Do("HGET", "user", "name"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(reply)
}

08 通过Do实现lpush和lpop以及llen的操作

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	r   redis.Conn
	err error
)

func InitRedis() {
	r, err = redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Println(err)
		return
	}
}

func CloseRedis() {
	r.Close()
}

func main() {
	InitRedis()
	defer CloseRedis()

	_, err = r.Do("LPUSH", "arr", "张三", "李四", "王五")
	if err != nil {
		fmt.Println(err)
		return
	}

	var reply string
	reply, err = redis.String(r.Do("LPOP", "arr"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(reply)

	var length int
	length, err = redis.Int(r.Do("LLEN", "arr"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(length)

}

09 Redis的连接池介绍

10 Redis连接池的创建和使用

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	pool *redis.Pool
	err  error
)

func InitRedis() {
	pool = &redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	_, err = r.Do("LPUSH", "arr", "张三", "李四", "王五")
	if err != nil {
		fmt.Println(err)
		return
	}

	var reply string
	reply, err = redis.String(r.Do("LPOP", "arr"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(reply)

	var length int
	length, err = redis.Int(r.Do("LLEN", "arr"))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(length)

}

11 Redis的管道操作

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	pool *redis.Pool
	err  error
)

func InitRedis() {
	pool = &redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	// 写入缓冲
	r.Send("SET", "name1", "张三")
	r.Send("SET", "name2", "李四")

	// 清空缓冲，写入服务端（Redis）
	r.Flush()

	// 读取：先进先出
	receive, err := r.Receive()
	fmt.Printf("receive:%#v, err:%v\n", receive, err)

	receive, err = r.Receive()
	fmt.Printf("receive:%#v, err:%v\n", receive, err)

	// 因为没有数据了，所以会一直处于等待状态
	receive, err = r.Receive()
	fmt.Printf("receive:%#v, err:%v\n", receive, err)
}

12 Redis的事务操作

go 复制代码 
package main

import (
	"fmt"
	"github.com/gomodule/redigo/redis"
)

var (
	pool *redis.Pool
	err  error
)

func InitRedis() {
	pool = &redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	r.Send("MULTI") // 开启事务

	// 事务过程中的一些业务操作
	r.Send("INCR", "num1")
	r.Send("INCR", "num2")

	reply, err := r.Do("EXEC") // 执行事务
	fmt.Printf("%#v err:%v\n", reply, err)
}

13 实现redigo的本地化

14 对zdpgo_redis的包结构进行调整

15 发布zdpgo_redisv1.1.0版本

16 新增用户

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_redis"
)

var (
	pool *zdpgo_redis.Pool
	err  error
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

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

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	// string  hash  list
	// string  hash users:{1:{id:1,xxx},2:xxx}
	// string 代码会更简单
	zs := User{2, "李四", 23}

	key := fmt.Sprintf("user/%d", zs.Id)
	zsBytes, _ := json.Marshal(zs)
	value := string(zsBytes)

	r.Do("SET", key, value)
	value2, _ := zdpgo_redis.String(r.Do("GET", key))
	fmt.Println(value2)
}

17 修改用户

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_redis"
)

var (
	pool *zdpgo_redis.Pool
	err  error
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

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

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	id := 1
	name := "李四"

	// 查询
	key := fmt.Sprintf("user/%d", id)
	value2, _ := zdpgo_redis.String(r.Do("GET", key))
	fmt.Println(value2)

	// 解析
	var user User
	json.Unmarshal([]byte(value2), &user)
	fmt.Println(user)

	// 修改
	user.Name = name

	// 重新存储
	jsonBytes, _ := json.Marshal(user)
	fmt.Println(string(jsonBytes))

	r.Do("SET", key, string(jsonBytes))
}

18 删除用户

go 复制代码 
package main

import (
	"fmt"
	"github.com/zhangdapeng520/zdpgo_redis"
)

var (
	pool *zdpgo_redis.Pool
	err  error
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

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

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	id := 1

	// 查询
	key := fmt.Sprintf("user/%d", id)
	value2, _ := zdpgo_redis.String(r.Do("GET", key))
	fmt.Println(value2)

	// 删除
	r.Do("DEL", key)

	// 再查询
	value2, _ = zdpgo_redis.String(r.Do("GET", key))
	fmt.Println(value2)
}

19 查询所有用户

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_redis"
)

var (
	pool *zdpgo_redis.Pool
	err  error
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

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

func main() {
	InitRedis()

	r := pool.Get()
	defer r.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(r.Do("KEYS", "user/*"))
	fmt.Println(userKeys)

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(r.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}
	fmt.Println(users)
}

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

go 复制代码 
package main

import (
	"encoding/json"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func main() {
	InitRedis()

	router := zdpgo_httprouter.New()
	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()
}
go 复制代码 
package main

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

func main() {
	resp, err := http.Get("http://localhost:8888/user")
	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))
}

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

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	zdpgo_httprouter.GetJson(r, &user)

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

	// 新增
	key := fmt.Sprintf("user/%d", user.Id)
	zsBytes, _ := json.Marshal(user)
	value := string(zsBytes)
	rdb.Do("SET", key, value)

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

func main() {
	InitRedis()

	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()
}
go 复制代码 
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))
}

22 解决ID唯一性的问题

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	zdpgo_httprouter.GetJson(r, &user)

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

	// 新增
	key := fmt.Sprintf("user/%d", user.Id)
	zsBytes, _ := json.Marshal(user)
	value := string(zsBytes)
	rdb.Do("SET", key, value)

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

func main() {
	InitRedis()

	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()
}
go 复制代码 
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))
}

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

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	zdpgo_httprouter.GetJson(r, &user)

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

	// 新增
	key := fmt.Sprintf("user/%d", user.Id)
	zsBytes, _ := json.Marshal(user)
	value := string(zsBytes)
	rdb.Do("SET", key, value)

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

func RouterUpdateUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	var idStr = ps.ByName("id")
	zdpgo_httprouter.GetJson(r, &user)

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	userJson, _ := zdpgo_redis.String(rdb.Do("GET", key))

	// 解析
	var dbUser User
	json.Unmarshal([]byte(userJson), &dbUser)

	// 修改
	dbUser.Name = user.Name
	dbUser.Age = user.Age

	// 重新存储
	jsonBytes, _ := json.Marshal(dbUser)
	rdb.Do("SET", key, string(jsonBytes))

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

func main() {
	InitRedis()

	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()
}
go 复制代码 
package main

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

func main() {
	targetUrl := "http://localhost:8888/user/108534300"
	data := map[string]interface{}{
		"name": "王六",
		"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))
}

24 实现删除用户的接口并进行测试

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	zdpgo_httprouter.GetJson(r, &user)

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

	// 新增
	key := fmt.Sprintf("user/%d", user.Id)
	zsBytes, _ := json.Marshal(user)
	value := string(zsBytes)
	rdb.Do("SET", key, value)

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

func RouterUpdateUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	var idStr = ps.ByName("id")
	zdpgo_httprouter.GetJson(r, &user)

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	userJson, _ := zdpgo_redis.String(rdb.Do("GET", key))

	// 解析
	var dbUser User
	json.Unmarshal([]byte(userJson), &dbUser)

	// 修改
	dbUser.Name = user.Name
	dbUser.Age = user.Age

	// 重新存储
	jsonBytes, _ := json.Marshal(dbUser)
	rdb.Do("SET", key, string(jsonBytes))

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

func RouterDeleteUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var idStr = ps.ByName("id")

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	rdb.Do("DEL", key)

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

func main() {
	InitRedis()

	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()
}
go 复制代码 
package main

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

func main() {
	targetUrl := "http://localhost:8888/user/53"
	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))
}

25 实现根据ID查询用户的接口并进行测试

go 复制代码 
package main

import (
	"encoding/json"
	"fmt"
	"github.com/zhangdapeng520/zdpgo_httprouter"
	"github.com/zhangdapeng520/zdpgo_redis"
	"net/http"
	"time"
)

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

var (
	pool *zdpgo_redis.Pool
)

func InitRedis() {
	pool = &zdpgo_redis.Pool{
		MaxIdle:     16,
		MaxActive:   1024,
		IdleTimeout: 300,
		Dial: func() (zdpgo_redis.Conn, error) {
			return zdpgo_redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func RouterGetUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	// 获取所有的key
	userKeys, _ := zdpgo_redis.Strings(rdb.Do("KEYS", "user/*"))

	// 查询
	var users []User
	for _, key := range userKeys {
		var user User
		userStr, _ := zdpgo_redis.String(rdb.Do("GET", key))
		json.Unmarshal([]byte(userStr), &user)
		users = append(users, user)
	}

	zdpgo_httprouter.ResponseSuccess(w, users)
}

func RouterAddUser(w http.ResponseWriter, r *http.Request, _ zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	zdpgo_httprouter.GetJson(r, &user)

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

	// 新增
	key := fmt.Sprintf("user/%d", user.Id)
	zsBytes, _ := json.Marshal(user)
	value := string(zsBytes)
	rdb.Do("SET", key, value)

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

func RouterUpdateUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var user User
	var idStr = ps.ByName("id")
	zdpgo_httprouter.GetJson(r, &user)

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	userJson, _ := zdpgo_redis.String(rdb.Do("GET", key))

	// 解析
	var dbUser User
	json.Unmarshal([]byte(userJson), &dbUser)

	// 修改
	dbUser.Name = user.Name
	dbUser.Age = user.Age

	// 重新存储
	jsonBytes, _ := json.Marshal(dbUser)
	rdb.Do("SET", key, string(jsonBytes))

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

func RouterDeleteUser(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var idStr = ps.ByName("id")

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	rdb.Do("DEL", key)

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

func RouterGetUserId(w http.ResponseWriter, r *http.Request, ps zdpgo_httprouter.Params) {
	rdb := pool.Get()
	defer rdb.Close()

	var idStr = ps.ByName("id")

	// 查询
	key := fmt.Sprintf("user/%s", idStr)
	userJson, _ := zdpgo_redis.String(rdb.Do("GET", key))

	var dbUser User
	json.Unmarshal([]byte(userJson), &dbUser)

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

func main() {
	InitRedis()

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

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

	server.ListenAndServe()
}
go 复制代码 
package main

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

func main() {
	resp, err := http.Get("http://localhost:8888/user/1")
	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语言操作Redis基础知识，然后还讲解了管道，连接池，事务等高级用户。借助用户管理这个业务为中心，详细讲解了如何使用Go语言加Redis实现用户的增删改查操作，之后有结合httprouter的用法，开发用户管理的增删改查API接口。

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

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

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

相关推荐
UQI-LIUWJ12 小时前
unsloth笔记：运行&微调 gemma
人工智能·笔记·深度学习
googleccsdn12 小时前
ESNP LAB 笔记：配置MPLS（Part4）
网络·笔记·网络协议
楚肽生物小敏12 小时前
Cy5-Tyramide, Cyanine 5 Tyramide；1431148-26-3
笔记
speop13 小时前
llm的一点学习笔记
笔记·学习
运维小雅13 小时前
哪些因素会直观地影响到产品销量？
经验分享·笔记·媒体
抓饼先生13 小时前
Linux control group笔记
linux·笔记·bash
boonya13 小时前
Redis核心原理与面试问题解析
数据库·redis·面试
搞一搞汽车电子13 小时前
S32K3平台eMIOS 应用说明
开发语言·驱动开发·笔记·单片机·嵌入式硬件·汽车
上官浩仁13 小时前
springboot redisson 缓存入门与实战
spring boot·redis·缓存
没有bug.的程序员14 小时前
Redis Stream：轻量级消息队列深度解析
java·数据库·chrome·redis·消息队列
热门推荐
01UV安装并设置国内源022025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！032025年数学建模国赛C题超详细解题思路04A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程05不再让Windows更新！&Edge游戏助手卸载及关闭自动更新06KGG转MP3工具|非KGM文件|解密音频07UV 工具安装与国内镜像源配置指南08突破百度网盘的下载限速，两种方法教会你【超详细】09Linux下V2Ray安装配置指南10教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员