什么是数据库？

数据库（Database）是按照数据结构来组织、存储和管理数据的仓库。
每个数据库都有一个或多个不同的 API 用于创建，访问，管理，搜索和复制所保存的数据。
我们也可以将数据存储在文件中，但是在文件中读写数据速度相对较慢。
所以，现在我们使用关系型数据库管理系统（RDBMS）来存储和管理大数据量。所谓的关系型数据库，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。
RDBMS 即关系数据库管理系统(Relational Database Management System)的特点：

  • 1.数据以表格的形式出现
  • 2.每行为各种记录名称
  • 3.每列为记录名称所对应的数据域
  • 4.许多的行和列组成一张表单

  • 5.若干的表单组成databa

    RDBMS 术语

    在我们开始学习MySQL 数据库前，让我们先了解下RDBMS的一些术语：

  • 数据库: 数据库是一些关联表的集合。

  • 数据表: 表是数据的矩阵。在一个数据库中的表看起来像一个简单的电子表格。
  • 列: 一列(数据元素) 包含了相同类型的数据, 例如邮政编码的数据。
  • 行：一行（=元组，或记录）是一组相关的数据，例如一条用户订阅的数据。
  • 冗余：存储两倍数据，冗余降低了性能，但提高了数据的安全性。
  • 主键：主键是唯一的。一个数据表中只能包含一个主键。你可以使用主键来查询数据。
  • 外键：外键用于关联两个表。
  • 复合键：复合键（组合键）将多个列作为一个索引键，一般用于复合索引。
  • 索引：使用索引可快速访问数据库表中的特定信息。索引是对数据库表中一列或多列的值进行排序的一种结构。类似于书籍的目录。

  • 参照完整性: 参照的完整性要求关系中不允许引用不存在的实体。与实体完整性是关系模型必须满足的完整性约束条件，目的是保证数据的一致性。

    gorm概览

  • 全特性 ORM (几乎包含所有特性)

  • 模型关联 (一对一， 一对多，一对多（反向）， 多对多， 多态关联)
  • 钩子 (Before/After Create/Save/Update/Delete/Find)
  • 预加载
  • 事务
  • 复合主键
  • SQL 构造器
  • 自动迁移
  • 日志
  • 基于GORM回调编写可扩展插件
  • 全特性测试覆盖
  • 开发者友好

开始使用

首先使用gorm还是老规矩，先将要使用的gorm拉下来，gorm的包有很多，我们使用

  1. go get -u github.com/jinzhu/gorm

将gorm拉下来之后 我们要连接数据库，那么首先就需要连接到数据库，那么这里我们可以下一个连接的方法在程序运行的时候进行一个mysql连接初始化。

  1. ├─middleware        应用目录
  2. │  ├─DB          数据库连接
  3. │  ├─tools      小工具
  4. │  │  ├─config.go   读取配置
  5. │  ├─...        集成的一些小工具。第三方adk，api等
  6. │  │

这里的话创建一个DB文件夹，在中间创建一个mysql.go用来写mysql的连接

  1. func ConnectDB() *gorm.DB {
  2.     username := tools.Conf.Get("mysql", "username") // mysql用户名
  3.     port := tools.Conf.Get("mysql", "port") // 端口
  4.     password := tools.Conf.Get("mysql", "password") // 密码
  5.     host := tools.Conf.Get("mysql", "host") // 地址
  6.     dbName := tools.Conf.Get("mysql", "db_name") // 数据库名
  7.     dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&loc=%s&parseTime=true",
  8.         username,
  9.         password,
  10.         host,
  11.         port,
  12.         dbName,
  13.         url.QueryEscape("Asia/Shanghai")) // 字符串替换
  15.     // var err error
  16.     DB, err := gorm.Open("mysql", dsn) // 打开mysql连接
  17.     if err != nil {
  18.         fmt.Println("database connect error:", err)
  19.         os.Exit(0)
  20.     }
  22.     DB.SingularTable(true) 
  23.     DB.DB().SetMaxOpenConns(100) 
  24.     DB.DB().SetMaxIdleConns(20)
  25.     DB.DB().SetConnMaxLifetime(time.Minute)
  26.     if tools.Conf.Get("server", "debug") == "true" {
  27.         DB = DB.Debug() // 是否开启debug，开启后控制台会输出数据库的查询语句 报错信息等
  28.     }
  30.     fmt.Println("database connect success")
  31.     return DB // 将初始化的mysql连接返回
  32. }

在main函数中执行一个DB.Init让程序启动的时候初始化数据库
image.png
image.png
这样连接数据库后赋值给定义的全局变量DB就可以在其他文件中调用了

使用mysql查询数据那么首先得定义一个struct对应的数据库中的表，正常的话是一个个手动敲 这样就比较麻烦，这里可以用到https://github.com/idoubi/sql2struct 安装一个谷歌浏览器扩展，复制数据库中的表结构，可以自动转成struct，这样就省了很多的时间

image.png

这里是用的user表，那么在model文件夹中创建一个user.go
image.png

  1. package model
  3. import (
  4.     "errors"
  5.     "github.com/jinzhu/gorm"
  6. )
  8. type ExUser struct {
  9.     ID         int64  `gorm:"column:id" json:"id" form:"id"`
  10.     Username   string `gorm:"column:username" json:"username" form:"username"`
  11.     Avatar     string `gorm:"column:avatar" json:"avatar" form:"avatar"`
  12.     Password   string `gorm:"column:password" json:"password" form:"password"`
  13.     CreateTime int64  `gorm:"column:create_time" json:"create_time" form:"create_time"`
  14.     LoginTime  int64  `gorm:"column:login_time" json:"login_time" form:"login_time"`
  15.     Token      string `gorm:"column:token" json:"token" form:"token"`
  16.     Status     int64  `gorm:"column:status" json:"status" form:"status"`
  17.     Email      string `gorm:"column:email" json:"email" form:"email"`
  18.     Desc       string `gorm:"column:desc" json:"desc" form:"desc"`
  19. }
  21. func (h *ExUser) Tablename() string {
  22.     return "ex_user"
  23. }
  24. func (h *ExUser) GetUserByUsername(DB *gorm.DB) error {
  25.     if len(h.Username) == 0 {
  26.         return errors.New("用户名不能为空")
  27.     }
  29.     if err := DB.Table(h.Tablename()).Where("username = ?", h.Username).First(&h).Error; err != nil {
  30.         return err
  31.     }
  33.     return nil
  34. }

这里将转化的struct复制到文件中，并且创建了一个返回数据库表名的Tablename方法，并且建了一个GetUserByUsername
这个方法核心的就是DB.Table(h.Tablename()).Where("username = ?", h.Username).First(&h).Error这一句
对应的就是SELECT * FROMex_userWHEREusername= "username" LIMIT 1
这个就是查询的语句了，

image.png

接下来在login方法中接收到前端POST传过来的username和password，判断后初始化model.ExUser将用户名传入，使用User.GetUserByUsername(DB.DB)查询用户名等于提交的用户名，在判断密码是否正确，是否被禁用 ，那么一个简单的查询数据库就完成了。
除了查询之外 与之对应的还有Delete Create Updates 使用的方法也差不多

  2. // 通过用户ID删除用户
  3. func (h *ExUser) DeleteUserById(DB *gorm.DB) error {
  4.     return DB.Table(h.Tablename()).Where("id = ?", h.ID).Delete(&h).Error
  5. }
  7. // 创建用户
  8. func (h *ExUser) CreateUser(DB *gorm.DB) error {
  9.     return DB.Table(h.Tablename()).Create(&h).Error
  10. }
  12. // 修改用户
  13. func (h *ExUser) UpdateUser(DB *gorm.DB) error {
  14.     return DB.Table(h.Tablename()).Updates(&h).Error
  15. }

对应的使用方法

  1. user := model.ExUser{
  2.         Username: "test",
  3.     }
  4.     //    创建
  5.     if err := user.CreateUser(DB.DB); err != nil {
  6.         return
  7.     }
  9.     user = model.ExUser{
  10.         ID: 1,
  11.     }
  12.     // 删除
  13.     if err := user.DeleteUserById(DB.DB); err != nil {
  14.         return 
  15.     }
  17.     user = model.ExUser{
  18.         ID: 1,
  19.         Username: "test2",
  20.     }
  21.     // 修改
  22.     if err := user.UpdateUser(DB.DB); err != nil {
  23.         return 
  24.     }

这里就是一个简单的增删改查就完毕了

gorm文档

http://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/gorm/%E5%85%A5%E9%97%A8%E6%8C%87%E5%8D%97/%E6%A6%82%E8%A7%88.html