一.GORM概述

1.学习方法

3w1h指What、Why、Where、How。

学技术也有方法可言，比如学习一个新的技术gorm:
    - 新手期:
        先到百度搜索几篇基本的用法案例，粘贴过来测试一下，测试通了说明你对grom有一个基础的了解。
    - 筑基期:
        到官方系统的整理，最好整理成博客，以便于以后用的时候方便查询，但这只是学会了基础语法。
    - 结丹期:
        如何将学到的东西融入到项目中，最好给自己找几个需求，然后练习实现，从而不断让自己的技术沉淀。
        如果没有案例的话，可以在GitHub或者gitee上找一些开源项目模仿跑通。
        如果你真的能做到这个阶段，保守估计，想必你的薪资应该不会低于: 35K+
    - 化神期：
        读源码和实现原理，参加过大厂面试的小伙伴应该都知道，他们很喜欢为什么问底层原理，其实了解底层原理有助于咱们做故障排查。
        比如公司要实现一个CMDB系统，你如果了解类似相关产品的实现方案的底层原理，想必你动手写应该不会毫无头绪。

2.orm是一种术语而不是软件

- orm英文全称object relational mapping,就是 对象映射关系 程序

- 简单来说类似python这种面向对象的程序来说一切皆对象，但是我们使用的数据库却都是关系型的

- 为了保证一致的使用习惯，通过orm将编程语言的对象模型和数据库的关系模型建立映射关系

- 这样我们直接使用编程语言的对象模型进行操作数据库就可以了，而不用直接使用sql语言

3.什么是grom

gorm是一个使用Go语言编写的ORM框架。它文档齐全，对开发者友好，支持主流数据库。

gorm官方中文文档：https://gorm.io/zh_CN/docs/

二.GORM基本使用

1.安装gorm

go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite
go get -u gorm.io/driver/mysql

2.创建数据库

    1.创建数据库和表信息
CREATE DATABASE yinzhengjie CHARSET utf8mb4;
USE yinzhengjie;
CREATE TABLE users(
    id BIGINT(20) PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
    username VARCHAR(255) NOT NULL COMMENT '用户名',
    password VARCHAR(255) NOT NULL COMMENT '密码',
    status ENUM('active', 'inactive', 'deleted') NOT NULL DEFAULT 'active' COMMENT '用户状态'
);


    2.查看表结构信息
mysql> DESC users;
+----------+-------------------------------------+------+-----+---------+----------------+
| Field    | Type                                | Null | Key | Default | Extra          |
+----------+-------------------------------------+------+-----+---------+----------------+
| id       | bigint                              | NO   | PRI | NULL    | auto_increment |
| username | varchar(255)                        | NO   |     | NULL    |                |
| password | varchar(255)                        | NO   |     | NULL    |                |
| status   | enum('active','inactive','deleted') | NO   |     | active  |                |
+----------+-------------------------------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

mysql> 


    3.配置远程用户授权访问
CREATE USER IF NOT EXISTS admin IDENTIFIED WITH mysql_native_password BY 'yinzhengjie';
GRANT ALL ON yinzhengjie.* TO admin;




    4.查看权限验证
mysql> SHOW GRANTS FOR 'admin';
+--------------------------------------------------------+
| Grants for admin@%                                     |
+--------------------------------------------------------+
| GRANT USAGE ON *.* TO `admin`@`%`                      |
| GRANT ALL PRIVILEGES ON `yinzhengjie`.* TO `admin`@`%` |
+--------------------------------------------------------+
2 rows in set (0.00 sec)

mysql> 


    5.访问测试
[root@yinzhengjie ~]# mysql -uadmin -pyinzhengjie -h 10.0.0.20 -e 'SHOW DATABASES;'
mysql: [Warning] Using a password on the command line interface can be insecure.
+--------------------+
| Database           |
+--------------------+
| information_schema |
| yinzhengjie        |
+--------------------+
[root@yinzhengjie ~]#

3.连接数据库创建表

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type UserInfo struct {
    /**
    json:"id"
        在json格式解析时字段名称为id。
    grom:"primary_key"
        对于grom框架而言，声明该字段为主键。

    */
    Id       int64 `json:"id" grom:"primary_key"`
    Username string
    Password string
}

func main() {
    // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        fmt.Printf("连接数据库出错: %v\n", err)
        panic(err) // 如果连接出错，就直接抛出异常!
    }

    fmt.Printf("数据库连接成功: %v\n", db)

    /**
    使用AutoMigrate自动创建表结构.

    参考连接:
        https://gorm.io/zh_CN/docs/migration.html

    这个语句慎用，因为其创建的表的数据类型可能比我们预期要给的大:
        mysql> desc user_infos;
        +----------+----------+------+-----+---------+----------------+
        | Field    | Type     | Null | Key | Default | Extra          |
        +----------+----------+------+-----+---------+----------------+
        | id       | bigint   | NO   | PRI | NULL    | auto_increment |
        | username | longtext | YES  |     | NULL    |                |
        | password | longtext | YES  |     | NULL    |                |
        +----------+----------+------+-----+---------+----------------+
        3 rows in set (0.00 sec)

        mysql>
    */
    err = db.AutoMigrate(UserInfo{})
    if err != nil {
        panic(fmt.Sprintf("表创建失败,%v\n", err))
    }
    fmt.Println("数据表创建成功!")

}

4.单表的增删改查

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type UserInfo struct {
    Id       int64 `json:"id" grom:"primary_key"`
    Username string
    Password string
}

func main() {
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        fmt.Printf("连接数据库出错: %v\n", err)
        panic(err) // 如果连接出错，就直接抛出异常!
    }

    err = db.AutoMigrate(UserInfo{})

    // 1.向数据库添加数据，注意多次执行会创建多个用户哟，而且会自动基于ID自增，小心造成数据的重复创建哟!
    db.Create(&UserInfo{
        Username: "JasonYin",
        Password: "yinzhengjie",
    })

    db.Create(&UserInfo{
        Username: "root",
        Password: "yinzhengjie",
    })

    db.Create(&UserInfo{
        Username: "root",
        Password: "123",
    })

    // 2.修改表中的某一个字段
    db.Model(UserInfo{
        Id: 1,
    }).Update("password", "123")

    // 4. 过滤查询数据单条数据
    u1 := UserInfo{Username: "root"}
    db.Where("username= ?", u1.Username).First(&u1)
    fmt.Printf("u1 ---> %#v\n", u1)

    // 5. 过滤查询数据多条数据
    u2 := UserInfo{Username: "root"}
    u2_all_user := []UserInfo{}
    db.Where("username= ?", u2.Username).Find(&u2_all_user)
    fmt.Printf("u2---> %#v\n", u2_all_user)

    // 6.查看所有数据
    users := []UserInfo{} // 定义一个UserInfo结构体切片来接收数据
    db.Find(&users)
    fmt.Printf("all ---> %#v\n", users)

    // 7.删除数据
    // 7.1 基于主键id删除，比如删除id为1的数据
    db.Delete(&UserInfo{Id: 1})
    // 7.2 基于条件删除，比如基于username为root的数据进行删除
    db.Where("username =?", "root").Delete(&UserInfo{})
}

5.数据库的模型定义

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
)

type User struct {
    /**
    声明 model时，tag是可选的，GORM支持以下tag。
        column:
            指定db列名
        type:
            列数据类型，推荐使用兼容性好的通用类型，
            例如：所有数据库都支持 bool、int、uint、float、string、time、bytes 并且可以和其他标签一起使用，
            例如：not null、size, autoIncrement… 像 varbinary(8) 这样指定数据库数据类型也是支持的。
            在使用指定数据库数据类型时，它需要是完整的数据库数据类型，如：MEDIUMINT UNSIGNED not NULL AUTO_INCREMENT
        serializer:
            指定将数据序列化或反序列化到数据库中的序列化器, 例如: serializer:json/gob/unixtime
        size:
            定义列数据类型的大小或长度，例如 size: 256
        primaryKey:
            将列定义为主键
        unique:
            将列定义为唯一键
        default:
            定义列的默认值
        precision:
            指定列的精度
        scale:
            指定列大小
        not null:
            指定列为NOT NULL
        autoIncrement:
            指定列为自动增长
        autoIncrementIncrement:
            自动步长，控制连续记录之间的间隔
        embedded:
            嵌套字段
        embeddedPrefix:
            嵌入字段的列名前缀
        autoCreateTime:
            创建时追踪当前时间，对于 int 字段，它会追踪时间戳秒数，您可以使用 nano/milli 来追踪纳秒、毫秒时间戳，例如：autoCreateTime:nano
        autoUpdateTime:
            创建/更新时追踪当前时间，对于 int 字段，它会追踪时间戳秒数，您可以使用 nano/milli 来追踪纳秒、毫秒时间戳，例如：autoUpdateTime:milli
        index:
            根据参数创建索引，多个字段使用相同的名称则创建复合索引，查看 索引 获取详情
        uniqueIndex:
            与 index 相同，但创建的是唯一索引
        check:
            创建检查约束，例如 check:age > 13，查看 约束 获取详情
        <-:
            设置字段写入的权限， <-:create 只创建、<-:update 只更新、<-:false 无写入权限、<- 创建和更新权限
        ->:
            设置字段读的权限，->:false 无读权限
        -:
            忽略该字段，- 表示无读写，-:migration 表示无迁移权限，-:all 表示无读写迁移权限
        comment:
            迁移时为字段添加注释

    tag名大小写不敏感，但建议使用camelCase风格。

    更多资料请参考官网:
        https://gorm.io/zh_CN/docs/models.html
    */
    Id           int64      `gorm:"primary_key" json:"id"`
    Name         string     // 默认字符串对应的是数据库的longtext文本类型
    CreatedAt    *time.Time `json:"createdAt" gorm:"column:create_at"`
    Email        string     `gorm:"type:varchar(255);unique_index"` // 使用type字段定义类型，并设置为唯一索引
    Role         string     `gorm:"size:255"`                       // 设置字段的大小为255个字节
    MemberNumber *string    `gorm:"unique;not null"`                // 设置memberNumber 字段唯一且不为空
    Num          int        `gorm:"AUTO_INCREMENT"`                 // 设置 Num字段自增
    Address      string     `gorm:"index:addr"`                     // 给Address 创建一个名字是 `addr`的索引
    IgnoreMe     int        `gorm:"-"`                              // 忽略这个字段
}

func main() {
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    // 创建表
    err := db.AutoMigrate(User{})
    if err != nil {
        panic(err)
    }
}

三.一对多关联查询

1.has many 一对多概述

has many关联就是创建一个和另一个模型的一对多关系。

例如: 每一个用户都有多张信用卡，这样就是生活中一个简单的一对多关系。


定义关系:
type User struct {
    // gorm.Model是gorm内置的模块，已经定义好了相关的结构体咱们可以直接引用
    gorm.Model
    CreditCard []CreditCard
}

type CreditCard struct {
    gorm.Model
    Number string
    // 默认会在CreditCard表中生成UserID字段作为User表关联的外键ID
    UserID uint
}



推荐阅读:
    https://gorm.io/zh_CN/docs/has_many.html

2.外键

- 为了定义一对多关系， 外键是必须存在的，默认外键的名字是 所有者类型的名字加上它的主键

- 就像上面的例子，为了定义一个属于User的模型，外键就应该为UserID 。

- 使用其他的字段名作为外键， 你可以通过"foreignkey"来定制它，


举个例子:
type User struct {
    gorm.Model
    CreditCard []CreditCard `gorm:"foreignkey:UserRef"`
}

type CreditCard struct {
    gorm.Model
    Number  string
    UserRef uint
}

3.外键关联

- GORM通常使用拥有者的主键作为外键的值。 对于上面的例子，它是User的ID字段。
- 为user添加creditcard 时，GORM 会将user的ID字段保存到creditcard的UserID 字段。
- 同样的，您也可以使用标签 references 来更改它。


举个例子:
type User struct {
    gorm.Model
    MemberNumber string
    CreditCards  []CreditCard `gorm:"foreignKey:UserNumber;references:MemberNumber"`
}

type CreditCard struct {
    gorm.Model
    Number     string
    UserNumber string
}

4.外键约束

你可以通过为标签 constraint 配置 OnUpdate、OnDelete 实现外键约束，在使用 GORM 进行迁移时它会被创建.

举个例子：
type User struct {
  gorm.Model
  CreditCards []CreditCard `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}

5.一对多案例

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// 2.建立一对多关系
type User struct {
    gorm.Model
    Username string `json:"username gorm:"column:username"`
    // 添加外键关联，只要该字段是一个CreditCard的切片，会自动和CreditCard模型建立外键关联。
    CreditCards []CreditCard
}

type CreditCard struct {
    gorm.Model
    Number string
    // 这个就是User表关联的外键，表示基于User表的ID主键(primary key)字段进行关联。这个是gorm的规定【结构体 + 主键】
    UserID uint
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    fmt.Println(db)

    // 3.创建表结构
    //db.AutoMigrate(User{}, CreditCard{})

    /**
    4.创建一对多

    创建后记得查看数据库信息:
    mysql> SHOW TABLES;
    +-----------------------+
    | Tables_in_yinzhengjie |
    +-----------------------+
    | credit_cards          |
    | users                 |
    +-----------------------+
    2 rows in set (0.00 sec)

    mysql>
    mysql> SELECT * FROM users;
    +----+-------------------------+-------------------------+------------+-----------+
    | id | created_at              | updated_at              | deleted_at | username  |
    +----+-------------------------+-------------------------+------------+-----------+
    |  1 | 2023-11-20 23:48:17.561 | 2023-11-20 23:48:17.561 | NULL       | Jason Yin |
    +----+-------------------------+-------------------------+------------+-----------+
    1 row in set (0.01 sec)

    mysql>
    mysql> SELECT * FROM credit_cards;
    +----+-------------------------+-------------------------+------------+--------+---------+
    | id | created_at              | updated_at              | deleted_at | number | user_id |
    +----+-------------------------+-------------------------+------------+--------+---------+
    |  1 | 2023-11-20 23:48:17.574 | 2023-11-20 23:48:17.574 | NULL       | 1001   |       1 |
    |  2 | 2023-11-20 23:48:17.574 | 2023-11-20 23:48:17.574 | NULL       | 1002   |       1 |
    +----+-------------------------+-------------------------+------------+--------+---------+
    2 rows in set (0.00 sec)

    mysql>

    */
    //user := User{
    //    Username: "Jason Yin",
    //    CreditCards: []CreditCard{
    //        {Number: "1001"},
    //        {Number: "1002"},
    //    },
    //}
    //
    //db.Create(&user)

    // 5.为已存在的用户添加信用卡
    u := User{
        Username: "Jason Yin",
    }
    db.First(&u) // 查找返回的第一条记录

    // 使用Association方法基于指定"CreditCards"关联外键字段找到关联关系，并使用Append方法追加信息。
    db.Model(&u).Association("CreditCards").Append([]CreditCard{
        {Number: "1003"},
        {Number: "1004"},
    })

    /**
        添加成功后，再次查看表信息


        mysql> SHOW TABLES;
        +-----------------------+
        | Tables_in_yinzhengjie |
        +-----------------------+
        | credit_cards          |
        | users                 |
        +-----------------------+
        2 rows in set (0.00 sec)

        mysql>
        mysql> SELECT * FROM users;
        +----+-------------------------+-------------------------+------------+-----------+
        | id | created_at              | updated_at              | deleted_at | username  |
        +----+-------------------------+-------------------------+------------+-----------+
        |  1 | 2023-11-20 23:48:17.561 | 2023-11-21 00:00:12.988 | NULL       | Jason Yin |
        +----+-------------------------+-------------------------+------------+-----------+
        1 row in set (0.00 sec)

        mysql>
        mysql> SELECT * FROM credit_cards;
        +----+-------------------------+-------------------------+------------+--------+---------+
        | id | created_at              | updated_at              | deleted_at | number | user_id |
        +----+-------------------------+-------------------------+------------+--------+---------+
        |  1 | 2023-11-20 23:48:17.574 | 2023-11-20 23:48:17.574 | NULL       | 1001   |       1 |
        |  2 | 2023-11-20 23:48:17.574 | 2023-11-20 23:48:17.574 | NULL       | 1002   |       1 |
        |  3 | 2023-11-21 00:00:12.991 | 2023-11-21 00:00:12.991 | NULL       | 1003   |       1 |
        |  4 | 2023-11-21 00:00:12.991 | 2023-11-21 00:00:12.991 | NULL       | 1004   |       1 |
        +----+-------------------------+-------------------------+------------+--------+---------+
        4 rows in set (0.00 sec)

        mysql>

    */
}

6.一对多Association关联查询【不推荐】

package main

import (
    "encoding/json"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// 2.建立一对多关系
type User struct {
    gorm.Model
    Username string `json:"username gorm:"column:username"`
    // 添加外键关联，只要该字段是一个CreditCard的切片，会自动和CreditCard模型建立外键关联。
    CreditCards []CreditCard
}

type CreditCard struct {
    gorm.Model
    Number string
    // 这个就是User表关联的外键，表示基于User表的ID主键(primary key)字段进行关联。
    UserID uint
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    fmt.Println(db)

    /**
    3.查询关联表数据

    使用Association方法:
        1)需要把User查询好;
        2)然后根据User定义中指定的AssociationForeignKey去查找CreditCard;

    这种查询方式需要使用2次回表查询，效率会很低，慎用!!!

    官方链接:
        https://gorm.io/zh_CN/docs/associations.html#%E6%9F%A5%E6%89%BE%E5%85%B3%E8%81%94
    */

    // 3.1 先查询User表数据
    u := User{Username: "Jason Yin"}
    db.First(&u)
    //fmt.Printf("%v\n", u.Username)

    // 3.2 基于AssociationForeignKey外键字段"CreditCards"进行查找
    err := db.Model(&u).Association("CreditCards").Find(&u.CreditCards)
    if err != nil {
        panic(fmt.Sprintf("err ---> %v\n", err))
    }

    // 将其转换为json格式显示
    bytes, _ := json.Marshal(&u)
    fmt.Println(string(bytes))
}

7.一对多Preload预加载关联查询【推荐】

package main

import (
    "encoding/json"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// 2.建立一对多关系
type User struct {
    gorm.Model
    Username string `json:"username gorm:"column:username"`
    // 添加外键关联，只要该字段是一个CreditCard的切片，会自动和CreditCard模型建立外键关联。
    CreditCards []CreditCard
}

type CreditCard struct {
    gorm.Model
    Number string
    // 这个就是User表关联的外键，表示基于User表的ID主键(primary key)字段进行关联。
    UserID uint
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    fmt.Println(db)

    /**
    3.使用Preload预加载方法:
        在查询User时先去获取CreditCard的记录

    很明显，这种效率会更高，一次性把数据查询出来，不会去回表查询两次。

    推荐阅读:
        https://gorm.io/zh_CN/docs/preload.html
    */
    users := []User{}
    db.Preload("CreditCards").Find(&users)

    bytesUser, _ := json.Marshal(&users)
    fmt.Println(string(bytesUser))
}

四.多对多关联查询

1.对多对关系描述

Many to Many会在两个model中添加一张连接表。

举个例子:
    一个学生可以选择多个课程，一个课程又包含多个学生，这是双向对对多的关系。

推荐阅读:
    https://gorm.io/zh_CN/docs/many_to_many.html

2.多对多表结构创建

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// 2.定义多对多关联表
type User struct {
    gorm.Model
    /**
    gorm:"many2many:user_languages;"
        指定了User表和Language表是多对多的关系，且"user_languages"是第三张连接表。
    */
    Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
    gorm.Model
    Name string
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    /**
    3.创建多对多表结构

    创建成功后记得去数据库验证多对多表结构创建信息:
    mysql> SHOW TABLES;
    +-----------------------+
    | Tables_in_yinzhengjie |
    +-----------------------+
    | languages             |
    | user_languages        |
    | users                 |
    +-----------------------+
    3 rows in set (0.00 sec)

    mysql>
    mysql> DESC users;
    +------------+-----------------+------+-----+---------+----------------+
    | Field      | Type            | Null | Key | Default | Extra          |
    +------------+-----------------+------+-----+---------+----------------+
    | id         | bigint unsigned | NO   | PRI | NULL    | auto_increment |
    | created_at | datetime(3)     | YES  |     | NULL    |                |
    | updated_at | datetime(3)     | YES  |     | NULL    |                |
    | deleted_at | datetime(3)     | YES  | MUL | NULL    |                |
    +------------+-----------------+------+-----+---------+----------------+
    4 rows in set (0.01 sec)

    mysql>
    mysql> DESC languages;
    +------------+-----------------+------+-----+---------+----------------+
    | Field      | Type            | Null | Key | Default | Extra          |
    +------------+-----------------+------+-----+---------+----------------+
    | id         | bigint unsigned | NO   | PRI | NULL    | auto_increment |
    | created_at | datetime(3)     | YES  |     | NULL    |                |
    | updated_at | datetime(3)     | YES  |     | NULL    |                |
    | deleted_at | datetime(3)     | YES  | MUL | NULL    |                |
    | name       | longtext        | YES  |     | NULL    |                |
    +------------+-----------------+------+-----+---------+----------------+
    5 rows in set (0.00 sec)

    mysql>
    mysql> DESC user_languages;
    +-------------+-----------------+------+-----+---------+-------+
    | Field       | Type            | Null | Key | Default | Extra |
    +-------------+-----------------+------+-----+---------+-------+
    | user_id     | bigint unsigned | NO   | PRI | NULL    |       |
    | language_id | bigint unsigned | NO   | PRI | NULL    |       |
    +-------------+-----------------+------+-----+---------+-------+
    2 rows in set (0.00 sec)

    mysql>
    */
    db.AutoMigrate(User{}, Language{})
}

3.多对多表结构自定义连接表

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
)

// 2.定义多对多关联表
type Person struct {
    ID   int
    Name string
    // 声明对对多关系，让Person和Address表进行关联
    Addresses []Address `gorm:"many2many:person_addresses;"`
}

type Address struct {
    ID   uint
    Name string
}

// 自定义第三张表时我们除了可以关联两个表的关联字段外，还可以添加一些我们需要的字段，比如"CreatedAt",”DeletedAt“等。
type PersonAddresses struct {
    // 对应Person表的主见
    PersonID int `gorm:"primaryKey"`
    // 对应Address表的主见
    AddressID int `gorm:"primaryKey"`
    CreatedAt time.Time
    DeletedAt gorm.DeletedAt
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    // 3.创建第三张表
    db.AutoMigrate(Person{}, Address{}, PersonAddresses{})

    /**
    4.添加数据

    进入数据库终端查询结构如下:
    mysql> SHOW TABLES;
    +-----------------------+
    | Tables_in_yinzhengjie |
    +-----------------------+
    | addresses             |
    | people                |
    | person_addresses      |
    +-----------------------+
    3 rows in set (0.00 sec)

    mysql> SELECT * FROM people;
    +----+-----------+
    | id | name      |
    +----+-----------+
    |  1 | Jason Yin |
    |  2 | 尹正杰    |
    +----+-----------+
    2 rows in set (0.00 sec)

    mysql> SELECT * FROM addresses;
    +----+-----------+
    | id | name      |
    +----+-----------+
    |  1 | 北京      |
    |  2 | 上海      |
    |  3 | 深圳      |
    |  4 | 陕西      |
    |  5 | 河北      |
    |  6 | 山东      |
    |  7 | 黑龙江    |
    +----+-----------+
    7 rows in set (0.00 sec)

    mysql> SELECT * FROM person_addresses;
    +-----------+------------+------------+------------+
    | person_id | address_id | created_at | deleted_at |
    +-----------+------------+------------+------------+
    |         1 |          1 | NULL       | NULL       |
    |         1 |          2 | NULL       | NULL       |
    |         1 |          3 | NULL       | NULL       |
    |         2 |          4 | NULL       | NULL       |
    |         2 |          5 | NULL       | NULL       |
    |         2 |          6 | NULL       | NULL       |
    |         2 |          7 | NULL       | NULL       |
    +-----------+------------+------------+------------+
    7 rows in set (0.00 sec)

    mysql>

    */
    p1 := Person{
        ID:   1,
        Name: "Jason Yin",
        Addresses: []Address{
            {ID: 1, Name: "北京"},
            {ID: 2, Name: "上海"},
            {ID: 3, Name: "深圳"},
        },
    }

    p2 := Person{
        ID:   2,
        Name: "尹正杰",
        Addresses: []Address{
            {ID: 4, Name: "陕西"},
            {ID: 5, Name: "河北"},
            {ID: 6, Name: "山东"},
            {ID: 7, Name: "黑龙江"},
        },
    }
    db.Create(&p1)
    db.Create(&p2)

}

4.多对多Preload预加载

package main

import (
    "encoding/json"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
)

// 定义多对多关系
type Person struct {
    ID        int
    Name      string
    Addresses []Address `gorm:"many2many:person_addresses;"`
}
type Address struct {
    ID   uint
    Name string
}
type PersonAddress struct {
    PersonID  int `gorm:"primaryKey"`
    AddressID int `gorm:"primaryKey"`
    CreatedAt time.Time
    DeletedAt gorm.DeletedAt
}

func main() {
    // 1.创建gorm的链接
    dsn := "admin:yinzhengjie@tcp(10.0.0.20:3306)/yinzhengjie?charset=utf8mb4&parseTime=True&loc=Local"
    db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})

    // 1.获取所有用户的地址
    persons := []Person{}
    db.Preload("Addresses").Find(&persons)
    allData, _ := json.Marshal(&persons)
    fmt.Println(string(allData))

    // 2.获取 name="Jason Yin" 用户的地址
    person := Person{Name: "Jason Yin"}
    db.Preload("Addresses").Find(&person)
    oneData, _ := json.Marshal(&person)
    fmt.Println(string(oneData))

}