# go学习资料

**Repository Path**: sadu_tqx/go-learning-materials

## Basic Information

- **Project Name**: go学习资料
- **Description**: golang的学习笔记和相关的资料
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-06-20
- **Last Updated**: 2023-08-31

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Gin+Gorm实现简单备忘录

## 1 连接数据库

### 1.1 编写配置文件("\conf\config.ini")

```ini
[service]
AppMode = debug
HttpPort = :3000

[mysql]
Db = mysql
DBHost = 127.0.0.1
DbPort = 3306
DbUser = root
DbPassWord = 123456
DbName = gin_gorm
```

### 1.2 加载配置文件("\conf\conf.go")

```go
// go get gopkg.in/ini.v1 安装依赖
package conf

import (
	"fmt"
	"gin_gorm/model"
	"strings"

	"gopkg.in/ini.v1"
)

var (
	AppMode    string
	HttpPort   string
	Db         string
	DbHost     string
	DbPort     string
	DbUser     string
	DbPassWord string
	DbName     string
)

func Init() {
	file, err := ini.Load("./conf/config.ini")
	if err != nil {
		fmt.Println("配置文件读取错误，请检查文件路径")
	}
	LoadServer(file) // 加载服务器配置
	LoadMysql(file)  // 加载数据库配置
	path := strings.Join([]string{DbUser, ":", DbPassWord, "@tcp(", DbHost, ":", DbPort, ")/", DbName, "?charset=utf8mb4&parseTime=true"}, "")
	model.Database(path) // 连接数据库
}

func LoadServer(file *ini.File) {
	AppMode = file.Section("service").Key("AppMode").String()
	HttpPort = file.Section("service").Key("HttpPort").String()
}

func LoadMysql(file *ini.File) {
	Db = file.Section("mysql").Key("Db").String()
	DbHost = file.Section("mysql").Key("DbHost").String()
	DbPort = file.Section("mysql").Key("DbPort").String()
	DbUser = file.Section("mysql").Key("DbUser").String()
	DbPassWord = file.Section("mysql").Key("DbPassWord").String()
	DbName = file.Section("mysql").Key("DbName").String()
}
```

### 1.3  连接数据库("\model\init.go")

```python 
package model

import (
	"fmt"
	"log"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB

// 连接数据库
func Database(connstring string) {
	fmt.Println(connstring)
	db, err := gorm.Open("mysql", connstring)
	if err != nil {
		log.Panic("mysql数据库连接错误")
	}
	fmt.Println("数据库连接成功")
	db.LogMode(true)
	// go get github.com/gin-gonic/gin
	if gin.Mode() == "release" {
		db.LogMode(false) // 发行版不用输出日志
	}
	db.SingularTable(true)                       // 表明不加S
	db.DB().SetMaxIdleConns(20)                  // 设置连接池
	db.DB().SetMaxOpenConns(100)                 // 设置最大连接数
	db.DB().SetConnMaxLifetime(time.Second * 30) // 超时时间
	DB = db
}
```

### 1.4  连接("/main.go")

```go
package main

import "gin_gorm/conf"

func main() {
	conf.Init()
}
```

##  2  数据库建表

### 2.1 建立用户表("\model\user.go")

```go
package model

import "github.com/jinzhu/gorm"

type User struct {
	gorm.Model
	UserName       string `gorm:"unique"`
	PasswordDigest string // 存储密文，也就是加密后的密码
}
```

### 2.2 建立备忘录表("model\task.go")

```go
package model

import "github.com/jinzhu/gorm"

type Task struct {
	gorm.Model
	User      User   `gorm:"ForeiKey:Uid"`
	Uid       uint   `gorm:"not null"`
	Title     string `gorm:"index;not null"`
	Status    int    `gorm:"default:'0'"` // 0 未完成 1 已完成
	Content   string `gorm:"type:longtext"`
	StartTime int64  // 备忘录开始时间
	EndTime   int64  // 备忘录完成时间
}
```

### 2.3 自动迁移("model\migrate.go")

```go
package model

func migration() {
	// 自动迁移模式
	DB.Set("gorm:gin_gorm", "charset=utf8mb4").
		AutoMigrate(&User{}).AutoMigrate(&Task{})
	DB.Model(&Task{}).AddForeignKey("uid", "User(id)", "CASCADE", "CASCADE") // 增加外键
}
```

### 2.4 执行迁移("model\init.go")

```go
package model

import (
	"fmt"
	"log"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB

// 连接数据库
func Database(connstring string) {
	fmt.Println(connstring)
	db, err := gorm.Open("mysql", connstring)
	if err != nil {
		log.Panic("mysql数据库连接错误")
	}
	fmt.Println("数据库连接成功")
	db.LogMode(true)
	// go get github.com/gin-gonic/gin
	if gin.Mode() == "release" {
		db.LogMode(false) // 发行版不用输出日志
	}
	db.SingularTable(true)                       // 表明不加S
	db.DB().SetMaxIdleConns(20)                  // 设置连接池
	db.DB().SetMaxOpenConns(100)                 // 设置最大连接数
	db.DB().SetConnMaxLifetime(time.Second * 30) // 超时时间
	DB = db
	migration() // 数据库迁移
}
```

## 3 用户注册与登录

### 3.1 配置注册路由("routers\routes.go")

```go
package routers

import (
	"gin_gorm/api"

	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
	//go get github.com/gin-contrib/sessions
)

func NewRouter() *gin.Engine {
	r := gin.Default()
	store := cookie.NewStore([]byte("something-very-secret"))
	r.Use(sessions.Sessions("mysession", store))
	v1 := r.Group("api/v1")
	{
		// 用户操作
		v1.POST("user/register", api.UserRegister)
	}
	return r
}
```

### 3.2 定义注册操作("api\user.go")

```go
package api

import (
	"gin_gorm/service"
	"net/http"

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

func UserRegister(ctx *gin.Context) {
	var userRegister service.UserService // 声明user服务对象，绑定获取数据
	if err := ctx.ShouldBind(&userRegister); err == nil {
		res := userRegister.Register() // 执行注册方法
		ctx.JSON(http.StatusOK, res)
	} else {
		ctx.JSON(400, err)
	}
}
```

### 3.3 注册接口及方法("service\user.go")

```go
package service

import (
	"gin_gorm/model"
	"gin_gorm/serializer"
	"net/http"
)

type UserService struct {
	UserName string `form:"user_name" json:"user_name" binding:"required,min=3,max=15" example:"tangshao"`
	Password string `form:"password" json:"password" binding:"required,min=5,max=16" example:"tangshao"`
}

func (service *UserService) Register() serializer.Response {
	var user model.User
	var count int
	model.DB.Model(&model.User{}).Where("user_name=?", service.UserName).First(&user).Count(&count)
	if count != 0 {
		return serializer.Response{
			Status: http.StatusBadGateway,
			Msg:    "用户已经存在",
		}
	}
	user.UserName = service.UserName
	// 加密
	if err := user.SetPassword(service.Password); err != nil {
		return serializer.Response{
			Status: http.StatusBadGateway,
			Msg:    err.Error(),
		}
	}
	// 创建用户
	if err := model.DB.Create(&user).Error; err != nil {
		return serializer.Response{
			Status: 500,
			Msg:    "数据库操作错误",
		}
	}
	return serializer.Response{
		Status: http.StatusOK,
		Msg:    "用户注册成功",
	}
}
```

### 3.4 数据序列化接口("serializer\common.go")

```go
package serializer

// 基础的序列化器
type Response struct {
	Status int         `json:"status"`
	Data   interface{} `json:"data"`
	Msg    string      `json:"msg"`
	Error  string      `json:"error"`
}
```

### 3.5  启动服务("main.go")

```go
package main

import (
	"gin_gorm/conf"
	"gin_gorm/routers"
)

func main() {
	conf.Init()
	r := routers.NewRouter()
	r.Run(conf.HttpPort)
}
```