go+gorm+mysql

1. 使用gin
2. 新建gorm
3. 编写配置文件
4. 启动gin框架

项目地址

gitee项目地址
https://gitee.com/heibaizi2000/todo.git

项目目录层次

config   配置文件
	- config.go
	- config.yaml
controller	接口地址
	- foodcontroller.go 
database 数据库实体类
	-db.go 初始化数据库
model 表的实体类
route  		编写路由
	-router.go 
main.go

config下的config.go文件

package config

import (
	"fmt"
	"github.com/spf13/viper"
)

//export config
type Config struct {
	Dsn           string
	SecretKey     string
	RedisHost     string
	RedisPassword string
	RedisDB       int
}

var Cfg *Config

// Init
func Init() {
	//file location
	viper.SetConfigFile("config/config.yaml")

	//if can't read it
	if err := viper.ReadInConfig(); err != nil {
		panic(fmt.Errorf("failed to read config %ss", err))
	}

	host := viper.GetString("mysql.host")
	port := viper.GetString("mysql.port")
	username := viper.GetString("mysql.username")
	password := viper.GetString("mysql.password")
	dbName := viper.GetString("mysql.db_name")

	redishost := viper.GetString("redis.Addr")
	redisPassword := viper.GetString("redis.Password")
	redisDB := viper.GetInt("redis.DB")

	dsn := username + ":" + password + "@tcp(" + host + ":" + port + ")/" + dbName + "?charset=utf8mb4&parseTime=True&loc=Local"
	Cfg = &Config{
		Dsn:           dsn,
		SecretKey:     viper.GetString("SecretKey"),
		RedisHost:     redishost,
		RedisPassword: redisPassword,
		RedisDB:       redisDB,
	}
}

config.yaml

mysql:
  host: localhost
  port: 3306
  username: food
  password: linyu0512
  db_name: food

redis:
  Addr: localhost
  Password: 123456
  DB: 0

SecretKey: "abcd1234"

controller

foodcontroller.go文件

package controller

import (
	"context"
	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis/v8"
	_ "github.com/go-redis/redis/v8"
	"gorm.io/gorm"
	"log"
	"net/http"
	"order/model"
)

type Handlers struct {
	DB    *gorm.DB
	REDIS *redis.Client
}

var ctx = context.Background()

func (h *Handlers) GetTodos(c *gin.Context) {
	//先到redis中查询有无category
	result, err := h.REDIS.Get(ctx, "category").Result()
	if err != nil {
		//如果找到了 就从redis返回
		log.Println("redis没有")
	} else {
		c.JSON(http.StatusOK, result)
		//var foods []model.Food
		//h.DB.Where("category = ?", "酒").Find(&foods)
		//set := h.REDIS.LPush(ctx, "category", foods)
		//if set != nil {
		//	log.Println("可以")
		//}
	}
	//没有到数据库中查询
	//然后存到redis中

	var foods []model.Food
	//查询userid有多少待办事项
	//h.DB.Where("category = ?", c.GetString("category")).Find(&foods)
	h.DB.Where("category = ?", "酒").Find(&foods)
	//
	set := h.REDIS.Set(ctx, "category", 122, 0)

	if set != nil {
		log.Println("出错了")
	}
	c.JSON(http.StatusOK, foods)

}



func (h *Handlers) GetHello(c *gin.Context) {
	//var foods []model.Food
	查询userid有多少待办事项
	h.DB.Where("category = ?", c.GetString("category")).Find(&foods)
	//h.DB.Where("category = ?", "酒").Find(&foods)
	c.JSON(http.StatusOK, "foods")

}

database 下的db.go

package database

import (
	"github.com/go-redis/redis"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"order/config"
)

// 初始化mysql
func InitMysql() (*gorm.DB, error) {
	config.Init()

	db, err := gorm.Open(mysql.Open(config.Cfg.Dsn), &gorm.Config{
		// table add s
		NamingStrategy: schema.NamingStrategy{SingularTable: true},
	})

	if err != nil {
		panic("fail connect")
	}
	//建表
	//err = db.AutoMigrate(&model.User{}, &model.Todo{})
	//if err != nil {
	//	return nil, err
	//}

	return db, nil
}

// init redis
func InitRedis() (rdb *redis.Client, err error) {
	rdb = redis.NewClient(&redis.Options{
		Addr:     config.Cfg.RedisHost,
		Password: config.Cfg.RedisPassword, // no password set
		DB:       config.Cfg.RedisDB,       // use default DB
	})

	_, err = rdb.Ping().Result()
	if err != nil {
		return nil, err
	}
	return rdb, nil
}

redisHelp.go

package database

import (
	"github.com/go-redis/redis/v8"
	"sync"
	"time"
)

type RedisHelper struct {
	*redis.Client
}

var redisHelper *RedisHelper

var redisOnce sync.Once

func GetRedisHelper() *RedisHelper {
	return redisHelper
}

func NewRedisHelper() *redis.Client {
	rdb := redis.NewClient(&redis.Options{
		Addr:         "162.14.107.118:6379",
		Password:     "heibaizi2000+-*2023",
		DB:           0,
		DialTimeout:  10 * time.Second,
		ReadTimeout:  30 * time.Second,
		WriteTimeout: 30 * time.Second,
		PoolSize:     10,
		PoolTimeout:  30 * time.Second,
	})

	redisOnce.Do(func() {
		rdh := new(RedisHelper)
		rdh.Client = rdb
		redisHelper = rdh
	})

	return rdb
}

model实体类中间层

package model

type Food struct {
	ID       int    `json:"id" gorm:"primaryKey"`
	Category string `json:"category"`
	Name     string `json:"name"`
	Price    int    `json:"price"`
	image    int    `json:"image"`
}

router目录下的路由文件

package routes

import (
	"context"
	"github.com/gin-gonic/gin"
	"log"
	"order/controller"
	"order/database"
)

type Server interface {
	Run(addr ...string) (err error)
}

func setupRouter() *gin.Engine {
	//link mysql
	db, err := database.InitMysql()
	if err != nil {
		log.Println(err)
	}
	var (
		ctx = context.Background()
	)
	redisHelper := database.NewRedisHelper()
	if _, err := redisHelper.Ping(ctx).Result(); err != nil {
		log.Fatal(err.Error())
		return nil
	}

	h := controller.Handlers{DB: db, REDIS: redisHelper}
	r := gin.Default()
	r.GET("/todos", h.GetTodos)
	return r
}
func NewServer() Server {
	return setupRouter()
}

main.go 启动文件

package main

import "order/routes"

func main() {
	server := routes.NewServer()
	server.Run()
}