golang beego 使用一个接口redis存储响应数据另一个接口读取redis响应数据给前端

1. 首先安装redis包

go get github.com/gomodule/redigo/redis

2. 在beego项目中创建redis相关的配置文件和连接池

conf/app.conf

redis_host = 127.0.0.1
redis_port = 6379
redis_password =
redis_db = 0
redis_max_idle = 10
redis_max_active = 100
redis_idle_timeout = 240s

controllers/redis.go

package controllers

import (
    "github.com/astaxie/beego"
    "github.com/gomodule/redigo/redis"
)

var (
    redisPool *redis.Pool
)

func init() {
    redis_host := beego.AppConfig.String("redis_host")
    redis_port := beego.AppConfig.String("redis_port")
    redis_password := beego.AppConfig.String("redis_password")
    redis_db := beego.AppConfig.String("redis_db")
    redis_max_idle, _ := beego.AppConfig.Int("redis_max_idle")
    redis_max_active, _ := beego.AppConfig.Int("redis_max_active")
    redis_idle_timeout := beego.AppConfig.String("redis_idle_timeout")

    redisPool = &redis.Pool{
        MaxIdle:     redis_max_idle,
        MaxActive:   redis_max_active,
        IdleTimeout: redis_idle_timeout,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", redis_host+":"+redis_port)
            if err != nil {
                return nil, err
            }
            if redis_password != "" {
                if _, err := c.Do("AUTH", redis_password); err != nil {
                    c.Close()
                    return nil, err
                }
            }
            if _, err := c.Do("SELECT", redis_db); err != nil {
                c.Close()
                return nil, err
            }
            return c, nil
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            if time.Since(t) < time.Minute {
                return nil
            }
            _, err := c.Do("PING")
            return err
        },
    }
}

3. 写入redis

controllers/write.go

package controllers

import (
    "encoding/json"
    "github.com/astaxie/beego"
    "github.com/gomodule/redigo/redis"
)

type ResponseData struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

type WriteController struct {
    beego.Controller
}

func (c *WriteController) Post() {
    data := &ResponseData{
        Name: "Tom",
        Age:  18,
    }
    dataJson, _ := json.Marshal(data)
    conn := redisPool.Get()
    defer conn.Close()
    _, err := conn.Do("SET", "response_data", dataJson)
    if err != nil {
        c.Data["json"] = map[string]interface{}{
            "code": 500,
            "msg":  "写入redis失败",
        }
        c.ServeJSON()
        return
    }
    c.Data["json"] = map[string]interface{}{
        "code": 200,
        "msg":  "写入redis成功",
    }
    c.ServeJSON()
}

4. 读取redis

controllers/read.go

package controllers

import (
    "encoding/json"
    "github.com/astaxie/beego"
    "github.com/gomodule/redigo/redis"
)

type ReadController struct {
    beego.Controller
}

func (c *ReadController) Get() {
    conn := redisPool.Get()
    defer conn.Close()
    dataJson, err := redis.Bytes(conn.Do("GET", "response_data"))
    if err != nil {
        c.Data["json"] = map[string]interface{}{
            "code": 500,
            "msg":  "读取redis失败",
        }
        c.ServeJSON()
        return
    }
    data := &ResponseData{}
    json.Unmarshal(dataJson, data)
    c.Data["json"] = map[string]interface{}{
        "code": 200,
        "msg":  "读取redis成功",
        "data": data,
    }
    c.ServeJSON()
}

5. 在路由中注册接口

routers/router.go

package routers

import (
    "github.com/astaxie/beego"
    "myproject/controllers"
)

func init() {
    beego.Router("/write", &controllers.WriteController{})
    beego.Router("/read", &controllers.ReadController{})
}

6. 启动beego服务

bee run

7. 使用curl测试

写入数据

curl -X POST http://localhost:8080/write

读取数据

curl http://localhost:8080/read
``