go 配置redis

go 整合Redis

添加redis依赖

go get github.com/redis/go-redis/v9

文件结构

│ config.yaml
│ main.go
├─config
│      config.go
│      conf_redis.go
├─database
│      redis.go

在config文件夹下编写个个组件的配置代码，而config.go是将所有组件的配置合在一起。

1. config.yaml

redis:
  host: "127.0.0.1"
  port: 6379
  password: "" # 如果没有密码留空
  db: 0 # 默认数据库索引
  pool_size: 20 # 连接池大小
  min_idle_conns: 5 # 最小空闲连接数
  max_retries: 3 # 最大重试次数
  dial_timeout: 5 # 连接超时(秒)
  read_timeout: 3 # 读取超时(秒)
  write_timeout: 3 # 写入超时(秒)

2. config_redis.go

package config

import (
	"fmt"
	"time"
	"github.com/redis/go-redis/v9"
)

type REDIS struct {
	Host         string `json:"host" yaml:"host"`
	Port         int    `json:"port" yaml:"port"`
	Password     string `json:"password" yaml:"password"`
	DB           int    `json:"db" yaml:"db"`
	PoolSize     int    `json:"pool_size" yaml:"pool_size"`
	MinIdleConns int    `json:"min_idle_conns" yaml:"min_idle_conns"`
	MaxRetries   int    `json:"max_retries" yaml:"max_retries"`
	DialTimeout  int    `json:"dial_timeout" yaml:"dial_timeout"`
	ReadTimeout  int    `json:"read_timeout" yaml:"read_timeout"`
	WriteTimeout int    `json:"write_timeout" yaml:"write_timeout"`
}

func (r *REDIS) Addr() string {
	return fmt.Sprintf("%s:%d", r.Host, r.Port)
}

// Options 返回Redis连接选项
func (r *REDIS) Options() *redis.Options {
	return &redis.Options{
		Addr:         r.Addr(),
		Password:     r.Password,
		DB:           r.DB,
		PoolSize:     r.PoolSize,
		MinIdleConns: r.MinIdleConns,
		MaxRetries:   r.MaxRetries,
		DialTimeout:  time.Duration(r.DialTimeout) * time.Second,
		ReadTimeout:  time.Duration(r.ReadTimeout) * time.Second,
		WriteTimeout: time.Duration(r.WriteTimeout) * time.Second,
	}
}

3. config.go

package config

import (
	"fmt"
	"os"
	"gopkg.in/yaml.v2"
)

type Config struct {
	Redis REDIS `yaml:"redis"`
}

// LoadConfig 从YAML文件加载配置
func LoadConfig(path string) (*Config, error) {
	config := &Config{}
	
	file, err := os.Open(path)
	if err != nil {
		return nil, fmt.Errorf("failed to open config file: %w", err)
	}
	defer file.Close()
	
	decoder := yaml.NewDecoder(file)
	if err := decoder.Decode(config); err != nil {
		return nil, fmt.Errorf("failed to decode config: %w", err)
	}
	
	return config, nil
}

4. database/redis.go

package database

import (
	"context"
	"fmt"
	"library-system/config"
	"log"
	"time"

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

var RedisClient *redis.Client

func InitRedis(cfg *config.REDIS) error{
	RedisClient = redis.NewClient(cfg.Options())
	ctx,cancel := context.WithTimeout(context.Background(),5*time.Second)
	defer cancel()

	// 测试连接是否成功
	if _ , err := RedisClient.Ping(ctx).Result() ; err != nil {
		return fmt.Errorf("redis连接失败: %w",err)
	}
	log.Println("redis连接已建立")
	return nil 
}

// CloseRedis 关闭Redis连接
func CloseRedis() error {
	if RedisClient != nil {
		return RedisClient.Close()
	}
	return nil
}

5. 主程序main.go

package main

import (
	"library-system/config"
	"library-system/database"
	"log"

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

func main() {
	// ------------------------------------ 加载配置 -----------------------------------//


	cfg,err := config.LoadConfig("config.yaml")
	if err != nil {
		log.Fatalf("加载配置失败: %v",err)
	}

	// redis
	// 初始化Redis
	if err := database.InitRedis(&cfg.Redis); err != nil {
		log.Fatalf("Failed to initialize Redis: %v", err)
	}
	defer database.CloseRedis()

	// ------------------------------------ 加载配置 -----------------------------------//
	
	r := gin.Default()

	// 设置信任的代理
	r.SetTrustedProxies([]string{"127.0.0.1"})

	r.GET("/hello",func (context *gin.Context)  {
		context.JSON(200,gin.H{"msg": "hello"})
	})

	r.GET("/user",func (c *gin.Context){
		username := c.Query("username")
		password := c.Query("password")
		c.JSON(200,gin.H{
			"username": username,
			"password": password,
		})
	})

	//启动服务
	r.Run(":8082")
}