Medical_ERP/common/redis/redis.go

package redis

import (
	"Medical_ERP/utils"
	"encoding/json"
	"errors"
	"github.com/beego/beego/v2/server/web"
	"github.com/go-redis/redis/v7"
	"log"
	"time"

	"github.com/beego/beego/v2/core/logs"
)

var redisCache *redis.Client

// 创建 redis 客户端
func createClient(redisHost string, password string, dataBase int) *redis.Client {
	log.Println("连接redis...")
	client := redis.NewClient(&redis.Options{
		Addr:         redisHost,
		Password:     password,
		DB:           dataBase,
		ReadTimeout:  2 * time.Minute,
		WriteTimeout: 1 * time.Minute,
		PoolTimeout:  2 * time.Minute,
		IdleTimeout:  10 * time.Minute,
		PoolSize:     1000,
	})

	// 通过 cient.Ping() 来检查是否成功连接到了 redis 服务器
	_, err := client.Ping().Result()
	if err != nil {
		logs.Error("连接redis连接失败,", err)
	} else {
		log.Println("连接redis成完成...")
	}

	return client
}

func init() {

	Redis_address, _ := web.AppConfig.String("Redis_address")
	Redis_password, _ := web.AppConfig.String("Redis_password")
	Redis_dbNum, _ := web.AppConfig.Int("Redis_dbNum")
	redisCache = createClient(Redis_address, Redis_password, Redis_dbNum)
}

func SetJson(key string, data interface{}, timeout time.Duration) error {

	//json序列化
	str, err := json.Marshal(data)
	if err != nil {
		logs.Error(err)
		return err
	}
	err = redisCache.Set(key, str, timeout).Err()
	if err != nil {
		logs.Error(err)
		return err
	}
	return nil

}

func GetJson(key string, data interface{}) error {
	if existed, err := redisCache.Exists(key).Result(); err != nil || existed == 0 {
		return errors.New("redis nil")
	}

	v, err := redisCache.Get(key).Result()
	if err != nil {
		logs.Error(err)
		return err
	}

	err = json.Unmarshal([]byte(v), &data)
	if err != nil {
		logs.Error(err)
		return err
	}

	return nil

}

func SetStr(key, value string, time time.Duration) (err error) {
	err = redisCache.Set(key, value, time).Err()
	if err != nil {
		logs.Error("set key:", utils.ReplaceUserInput(key), ",value:", utils.ReplaceUserInput(value), err)
	}
	return
}

func GetStr(key string) (value string) {
	v, _ := redisCache.Get(key).Result()
	return v
}

func DelKey(key string) (err error) {
	err = redisCache.Del(key).Err()
	return
}

// SetNX 尝试获取锁
func SetNX(key, value string, expiration time.Duration) (ok bool, err error) {
	ok, err = redisCache.SetNX(key, value, expiration).Result()
	return
}

// SetNX 释放锁
func DelNX(key string) (err error) {
	err = redisCache.Del(key).Err()
	return
}