Golang-Gorm-快速上手

Gorm文档

GORM文档地址

安装依赖

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

连接数据库

默认连接方式

func main() {// 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}

想要正确的处理 time.Time ，需要带上 parseTime 参数， charset=utf8mb4可以支持表情

自定义配置连接数据库

	dsn := "root:root@tcp(127.0.0.1:3306)/learn_gorm?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.New(mysql.Config{DSN:                       dsn,   // DSN data source nameDefaultStringSize:         256,   // string 类型字段的默认长度 如果该字段是字符串并作为主键会造成索引超长DisableDatetimePrecision:  true,  // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持DontSupportRenameIndex:    true,  // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引DontSupportRenameColumn:   true,  // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置}), &gorm.Config{ //连接的配置SkipDefaultTransaction: false, // 默认false，增删改都是事务操作来保证数据一致性，能提升一点性能NamingStrategy: schema.NamingStrategy{TablePrefix:         "",    // 如果设置了会给每个表名加前缀SingularTable:       false, // 单数表名，如果false会在表明后加sNameReplacer:        nil,   // 字符转转换器，转换字段名NoLowerCase:         false, //当设置为true时，NoLowerCase选项将禁用表名和列名的蛇形命名转换。保持表名和列名的原始大小写形式。IdentifierMaxLength: 0,     //不限制数据库标识符（如表名、列名）的最大长度。},Logger:                                   nil,  // 可以自定义日志DisableForeignKeyConstraintWhenMigrating: true, //true时，建表将不会建立物理外键，代码中我们采用逻辑外键提升数据库操作效率})

数据库连接池配置

sqlDB, err := db.DB()
// 设置最大连接数量
sqlDB.SetMaxIdleConns(10)// 连接池最多可容纳的连接数量
sqlDB.SetMaxOpenConns(100)// 连接池中连接最常生命周期
sqlDB.SetConnMaxLifetime(time.Hour)

数据库logger日志

Gorm 有一个 默认 logger 实现，默认情况下，它会打印慢 SQL 和错误， 我们可以定义自己的 logger，Logger 需要实现以下接口，它接受 context，所以可以用它来追踪日志

type Interface interface {LogMode(LogLevel) InterfaceInfo(context.Context, string, ...interface{})Warn(context.Context, string, ...interface{})Error(context.Context, string, ...interface{})Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

_default := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), logger.Config{SlowThreshold: 200 * time.Millisecond,LogLevel:      logger.Warn,Colorful:      true,})

模型

Gorm认为约定优于配置，即通过一些默认约定来简化配置和操作数据库。它提供了许多默认行为和命名约定。
GORM中默认采用ID作为主键，结构体名的蛇形复数作为表名，字段名的蛇形作为列名字，并使用CreatedAt,UpdateAt字段追踪创建、更新时间。
例如：

type User struct {ID        uintFirstName stringLastName  stringEmail     stringCreatedAt time.TimeUpdatedAt time.Time
}
/*
据GORM的默认约定，上述结构体将映射到以下表结构：表名: users（结构体名User的蛇形复数）
列名: id（自动生成的主键列名）
列名: first_name（结构体字段FirstName的蛇形命名）
列名: last_name（结构体字段LastName的蛇形命名）
列名: email（结构体字段Email的蛇形命名）
列名: created_at（结构体字段CreatedAt的蛇形命名）
列名: updated_at（结构体字段UpdatedAt的蛇形命名）
*/

创建模型

创建模型文档地址

package modelsimport ("gorm.io/gorm"
)type User struct {gorm.ModelAvatar   string `json:"headerImg" gorm:"default:https://qmplusimg.henrongyi.top/gva_header.jpg;comment:用户头像"` // 用户头像Username string `json:"userName" gorm:"index;comment:用户登录名"`                                                  // 用户登录名Password string `json:"-"  gorm:"comment:用户登录密码"`                                                             // 用户登录密码NickName string `json:"nickName" gorm:"default:系统用户;comment:用户昵称"`                                            // 用户昵称Phone    string `json:"phone"  gorm:"comment:用户手机号"`                                                          // 用户手机号Email    string `json:"email"  gorm:"comment:用户邮箱"`                                                           // 用户邮箱Enable   int    `json:"enable" gorm:"default:1;comment:用户是否被冻结 1正常 2冻结"`                                      //用户是否被冻结 1正常 2冻结Roles    []Role `json:"Role" gorm:"many2many:user_role;"`
}
// 表名
func (User) TableName() string {return "users"
}

模型常用标签

声明 model 时，tag 是可选的，GORM 支持以下 tag： tag 名大小写不敏感，但建议使用 camelCase 风格

主键

type User struct {Username string `gorm:"primaryKey"`                                                  
}

指定列明

默认情况以蛇形结构体字段名作为列明，但我们也可以通过tag指定

type User struct {Username string `gorm:"column：name"`                                                  
}

唯一约束

不可重复字段。

type User struct {Username string `gorm:"unique"`

列数据类型

推荐使用兼容性好的通用类型，例如：所有数据库都支持 bool、int、uint、float、string、time、bytes 并且可以和其他标签一起使用，例如：not null、size, autoIncrement… 像 varbinary(8) 这样指定数据库数据类型也是支持的。在使用指定数据库数据类型时，它需要是完整的数据库数据类型，如：MEDIUMINT UNSIGNED not NULL AUTO_INCREMENT

type User struct {ID   uint   `gorm:"type:int(11)"`Name string `gorm:"type:varchar(255)"`Age  int    `gorm:"type:tinyint"`
}

默认值

type User struct {Role string `gorm:"default:user"`
}

当结构体的字段默认值是零值的时候比如 0, ‘’, false，这些字段值将不会被保存到数据库中，你可以使用指针类型或者Scanner/Valuer来避免这种情况。例如：

type User struct {gorm.ModelName stringAge  *int           `gorm:"default:18"`Active sql.NullBool `gorm:"default:true"`
}

指定字段数据类型长度大小

type User struct {Username string `gorm:"size:50"`
}

数据序列化或反序列化

type User struct {Settings map[string]interface{} `gorm:"serializer:json"`
}

serializer标签指定将Settings字段中的数据以JSON格式进行序列化和反序列化。

不能为空

type User struct {Settings map[string]interface{} `gorm:"not null"`
}

自增长

type User struct {ID uint `gorm:"primaryKey;autoIncrement"`
}

创建索引

type User struct {Email string `gorm:"index:idx_email"`Age   int    `gorm:"uniqueIndex:idx_age_country"`
}

在上述示例中，index标签创建名为idx_email的索引，uniqueIndex标签创建名为idx_age_country的唯一索引。

添加注释

type User struct {FirstName string `gorm:"comment:用户的名字"`
}

忽略字段

-标签表示忽略SecretField字段，即不进行数据库迁移和读写操作。

type User struct {SecretField string `gorm:"-"`
}

字段读写权限

<-:create表示只允许在创建时写入PasswordHash字段，->:false表示禁止读取PasswordHash字段。

type User struct {PasswordHash string `gorm:"<-:create;->:false"`
}

嵌入字段和嵌入字段列明前缀

type Address struct {City  stringState string
}type User struct {ID      uintAddress Address `gorm:"embedded;embeddedPrefix:user_"`
}

embedded标签用于指定Address字段作为嵌套字段，embeddedPrefix标签用于指定嵌入字段的列名前缀为user_。相当于如下

type User struct {ID      uintCity  stringState string
}
//建表后字段名为ID  user_city user_state

关联标签

GORM中的关联标签通常用于指定如何处理模型之间的关联。 这些标签定义了一些关系细节，比如外键，引用和约束。

标签描述
foreignKey指定连接表中用作外键的当前模型的列名。
references指示连接表的外键映射到的引用表中的列名
polymorphic定义多态类型，通常是模型名称。
polymorphicValue如果没有另行指定，则设置多态值，通常为表名。
many2many命名多对多关系中使用的连接表。
joinForeignKey标识连接表中映射回当前模型表的外键列。
joinReferences指向链接到参考模型表的连接表中的外键列
constraint为关联指定关系约束，如OnUpdate， OnDelete .

外键foreignKey

指定在关联表中使用的当前模型的列名作为外键。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字，对于如下的外键默认就是post_id

type User struct {ID       uintPostId int//foreignKey标签指定了在Post模型中使用UserID作为关联表的外键。Posts    []Post `gorm:"foreignKey:PostId"`
}type Post struct {ID     uint
}
重写外键

默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字。也就是company+id
例如：

type User struct {gorm.ModelName      stringCompanyId intCompany Company `gorm:"foreignKey:CompanyId"`
}
type Company struct {Name stringCode int `gorm:"primaryKey"`
}
// 我们创建数据
func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: 111,}u := model.User{Name:    "张三",Company: c,}u.CreateUser()
}

结果如图所示：在这里插入图片描述
我们可以将外键名字company_id名字改了，通过如下方式

type User struct {gorm.ModelName      stringCompany_FK intCompany Company `gorm:"foreignKey:Company_FK "`
}
type Company struct {Name stringCode int `gorm:"primaryKey"`
}

在这里插入图片描述

引用references

指定在关联表中外键对应的引用表的列名。

type User struct {ID       uint//references标签指定了Post模型中UserID外键对应的引用表的列名为ID。Posts    []Post `gorm:"foreignKey:UserID;references:ID"`
}type Post struct {ID     uintUserID uint
}
重写引用

GORM 通常使用数据库表，主表（拥有者）的主键值作为外键参考。 正如上面的例子，我们使用主表Company中的主键字段ID作为外键的参考值。
但我们可以通过使用标签 references 来更改它。

type User struct {gorm.ModelName      stringCompanyId intCompany   Company `gorm:"foreignKey:CompanyId;references:Code"`
}type Company struct {gorm.ModelName stringCode int
}
// 我们创建数据
func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: 111,}u := model.User{Name:    "张三",Company: c,}u.CreateUser()
}

可以看结果引用不再是以公司主键ID作为外键值了。在这里插入图片描述

多对多many2many

指定在多对多关系中使用的关联表。

type User struct {ID    uint//many2many标签指定了在User和Role之间使用的关联表为user_roles。Roles []Role `gorm:"many2many:user_roles;"`
}type Role struct {ID   uintName string
}

标识外键列joinForeignKey

标识在关联表中映射回当前模型的表的外键列。

type User struct {ID       uint//joinForeignKey标签指定了在关联表中映射回User模型的表的外键列为UserID。Posts    []Post `gorm:"many2many:user_posts;joinForeignKey:UserID;"`
}type Post struct {ID     uintUserID uint
}

数据库相关操作

创建表CreateTable/AutoMigrate

一般我们使用AutoMigrate去创建
方式一

	err := db.AutoMigrate(models.Permission{},models.User{},models.Role{},)

方式二

	m := db.Migrator()m.CreateTable([]interface{}{&models.Permission{},&models.User{},&models.Role{},})

两种方式没太大差别

查询表HasTable

m := db.Migrator()
//传参结构体引用
m.HasTable(&models.User{})// 返回bool值
//传参字符串，这种硬编码方式不推荐
m.HasTable("user")// 返回bool值

删除表DropTable

	m := db.Migrator()exist_table := m.HasTable(&models.User{})if exist_table {m.CreateTable(&models.User{})}else{m.DropTable(&models.User{})}

修改表名

m := db.Migrator()
err := m.RenameTable(&models.User{},"yu_user")

关联关系

一对一

在 GORM 中，“Belongs To” 和 “Has One” 是两种不同的关联关系类型，用于定义数据库表之间的关系。它们之间的区别主要在于关联关系的方向和外键的存储位置。
在 Belongs To 关系中，外键通常存储在被关联模型（子模型）中。
在 Has One 关系中，外键通常存储在拥有模型（父模型）中。

属于关系Belongs To

属于关系是一方依赖于另一方，无法独立存在。
例如，假设我们有两个模型：Author（作者）和 Book（书籍）。一个 Book 属于一个 Author，因此我们可以在 Book 模型中定义一个 author_id 字段作为外键，用于存储与其关联的 Author 的主键。
下面省略建表步骤，只关注模型

package modelimport "gorm.io/gorm"// `User` 属于 `Company`，`CompanyID` 是外键 该外键存放在被关联的模型User中。
type User struct {gorm.ModelName      stringCompanyID intCompany   Company //如果设置了User实体属于Company实体，那么GORM会自动把Company中的ID属性保存到User的CompanyID属性中。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字
}type Company struct {ID   intName stringCode string
}
func (this *User) CreateUser() {global.GVA_DB.Create(this)
}
func (this *Company) CreateCompany() {global.GVA_DB.Create(this)
}

在这里插入图片描述
然后我们创建数据

package mainimport ("fmt""relation/global""relation/initialize""relation/model"
)func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: "AAA",}u := model.User{Name:    "张三",Company: c,}u.CreateUser()fmt.Println("数据库初始化成功")
}

观察表
在这里插入图片描述
我们并没有创建公司的数据，但是通过GORM自动关联我们可以看到公司这个表自动被创建了。

拥有Has One

拥有关系是一方包含另一方，可以独立存在。
拥有Has One表明一个模型的每个实例都包含或拥有另一个模型的一个实例。如果我们假设一个 User拥有一个 CreditCard （个人资料），我们可以在 User 模型中定义一个 CreditCard 字段作为外键，用于存储与其关联的 CreditCard 的主键。

// User 有一张 CreditCard，UserID 是外键
type User struct {gorm.ModelCreditCard CreditCard
}type CreditCard struct {gorm.ModelNumber stringUserID uint
}

一对多

不同于 has one，拥有者可以有零或多个关联模型。例如，每个 user 可以有多张 credit card。多的一方把另一方的主键作为外键。少的一方声明多的一方的数组切片类型。
一对多在多的一方存放外键

// User 有多张 CreditCard，UserID 是外键
type User struct {gorm.ModelCreditCards []CreditCard
}type CreditCard struct {gorm.ModelNumber stringUserID uint
}

自引用

自己引用自己就是自引用，例如待办事项中，每个待办事项可以拥有子待办事项。什么意思？举个实际例子，创建待办事项明天9点开会，然后9点开会有个子待办事项，准备ppt ，开会技术分享等等这些都是开会中要做的。
明白后怎么建表呢？

package modelimport ("gorm.io/gorm"
)type Backlog struct {gorm.ModelBacklogContent  string    `json:"backlogContent" gorm:"comment:代办事项内容"`Completed       bool      `json:"completed" gorm:"comment:是否完成;default:false"`UserId          uint      `json:"user_id"`ParentId        *uint     `json:"parent_id"`ChildrenBacklog []Backlog `gorm:"foreignkey:ParentId;"`
}func (receiver Backlog) TableName() string {return "backlog"
}type User struct {gorm.ModelUsername   string    `json:"userName" gorm:"comment:用户名"`NickName   string    `json:"nickName" gorm:"comment:昵称"`Password   string    `json:"password" gorm:"comment:密码"`Identity   string    `json:"身份" gorm:"comment:用户身份"`Email      string    `json:"email" gorm:"comment:用户邮箱"`UUID       uuid.UUID `json:"uuid" gorm:"index;comment:用户UUID"`Avatar     string    `json:"avatar" gorm:"comment:用户头像;default:https://fancyfish.top/hero.jpg"`ThemeColor string    `json:"themeColor" gorm:"comment:用户主题颜色"`Backlog    Backlog
}func (receiver User) TableName() string {return "user"
}

创建数据

	backlog1 := model.Backlog{BacklogContent: "golang-swagger",Completed:      false,ChildrenBacklog: []model.Backlog{model.Backlog{BacklogContent: "golang-swagger-init",Completed:      false,},},}u := model.User{Username:   "fancy_fish",NickName:   "张三",Password:   "123",Email:      "1074121761@qq.com",UUID:       util.BasicUtils.GenerateUUID(),ThemeColor: "#fff",Backlog:    backlog1,}global.GVA_DB.Create(&u)

看结果
在这里插入图片描述

查询

// 检索用户列表并预加载信用卡
func GetAll(db *gorm.DB) ([]User, error) {var users []Usererr := db.Model(&User{}).Preload("CreditCards").Find(&users).Errorreturn users, err
}

自引用

自己引用自己

type User struct {gorm.ModelName      stringManagerID *uintTeam      []User `gorm:"foreignkey:ManagerID"`
}

多对多

多对多需要中间表，在gorm中需要用关联标签，展示出关系。

// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName string
}

在这里插入图片描述
我们创建几个数据

	global.GVA_DB.Create([]model.User{model.User{Name: "张三",Languages: []model.Language{model.Language{Name: "英语",},model.Language{Name: "汉语",},},},model.User{Name: "李四",Languages: []model.Language{model.Language{Name: "德语",},model.Language{Name: "俄语",},},},})

观察表，在这里插入图片描述

反向引用

在上面创建表插入数据后，我们查询语言，看结果

var l []model.Language
global.GVA_DB.Select("name").Find(&l)
fmt.Println(l)

在这里插入图片描述
如果我们想查询语言关联的用户呢？

// 检索 Language 列表并预加载 User
func GetAllLanguages() ([]model.Language, error) {var languages []model.Languageerr := global.GVA_DB.Model(&model.Language{}).Preload("Users").Find(&languages).Errorreturn languages, err
}

此时会报错。
这时候我们需要反向引用，才能够在查询语言时预加载用户。那怎么反向引用呢？我们需要给Language表加上用户的引用，如下

type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName stringUsers []*User `gorm:"many2many:user_languages;"`
}

此时再执行上面的查询操作GetAllLanguages
在这里插入图片描述
就可以成功拿到结果了。
总结一下：选择哪种方式取决于具体的业务需求，如果需要在查询Language模型时方便地访问与之关联的User模型的数据，可以选择第二种方式。否则，如果只需要在查询User模型时访问与之关联的Language模型的数据，第一种方式已经足够。

重写外键

对于 many2many 关系，连接表会同时拥有两个模型的外键，例如：

type User struct {gorm.ModelLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName string
}// 连接表：user_languages
//   foreign key: user_id, reference: users.id
//   foreign key: language_id, reference: languages.id

重写外键

type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_language;foreignKey:Refer;References:LRefer;joinForeignKey:u_id;joinReferences:p_id"`Refer     uint
}type Language struct {gorm.ModelName   stringLRefer uint
}

foreignKey:Refer：指定连接表中指向User模型的外键字段名为Refer的字段，且外键名字改为user_refer,默认是user_id(表名+主键字段名)。
joinForeignKey:UserReferID：改本表外键名。
References:UserRefer：指定连接表中指向Profile模型的外键字段名为LRefer的字段，且外键名改为language_l_refer(表名+主键字段名)。
joinReferences:ProfileRefer：改连接表外键名。
在这里插入图片描述

自定义中间表

type Person struct {ID        intName      stringAddresses []Address `gorm:"many2many:person_addresses;"`
}type Address struct {ID   uintName string
}type PersonAddress struct {PersonID  int `gorm:"primaryKey"`AddressID int `gorm:"primaryKey"`CreatedAt time.TimeDeletedAt gorm.DeletedAt
}func (PersonAddress) BeforeCreate(db *gorm.DB) error {// ...
}// 修改 Person 的 Addresses 字段的连接表为 PersonAddress
// PersonAddress 必须定义好所需的外键，否则会报错
err := db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})

表相关操作

排除和指定字段

通过select指定字段，如下是创建指定字段数据

	u := model.User{Name: "张三",Age:  18,}global.GVA_DB.Select("Age").Create(&u)

通过omit排除指定字段

var h model.Human
global.GVA_DB.Omit("name").Find(&h)

这样就得到了除了name字段以外的值。

增

type User struct {gorm.ModelName stringAge intBirthday time.Time
}
user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}result := db.Create(&user) // 通过数据的指针来创建user.ID             // 返回插入数据的主键
result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

新增多条记录

方式一

users := []User{User{Name: "Jinzhu", Age: 18, Birthday: time.Now()},User{Name: "Jackson", Age: 19, Birthday: time.Now()},
}result := db.Create(&users) // 传递切片以插入多行数据u1 := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,Company:  c,}u2 := model.User{Name:     "李四",Age:      27,Birthday: time.Now(),UserInfo: ui,Company:  c,}global.GVA_DB.Create([]*model.User{&u1, &u2})result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

方式二CreateBatchSize
使用CreateBatchSize 选项初始化GORM实例后，此后进行创建& 关联操作时所有的INSERT行为都会遵循初始化时的配置。

var users = []model.User{{Name: "jinzhu_1", Birthday: time.Now()}, {Name: "jinzhu_2", Birthday: time.Now()}, {Name: "jinzhu_10000", Birthday: time.Now()}}
global.GVA_DB.CreateInBatches(users, len(users))

在这里插入图片描述

sqlite批量插入不支持默认值

SQLite 不支持批量插入的时候使用默认值。解决方案：通过BeforeCreate钩子设置

func (p *Pet) BeforeCreate(tx *gorm.DB) (err error) {if p.Name == "" {p.Name = "cat"}
}

在这里插入图片描述

创建的声明周期钩子

GROM允许用户通过实现这些接口 BeforeSave, BeforeCreate, AfterSave, AfterCreate来自定义钩子。 这些钩子方法会在创建一条记录时被调用，关于钩子的生命周期请参阅Hooks。

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {u.UUID = uuid.New()if u.Role == "admin" {return errors.New("invalid role")}return
}

如果想跳过Hooks方法，可以使用SkipHooks会话模式，例子如下

DB.Session(&gorm.Session{SkipHooks: true}).Create(&user)DB.Session(&gorm.Session{SkipHooks: true}).Create(&users)DB.Session(&gorm.Session{SkipHooks: true}).CreateInBatches(users, 100)

根据Map创建

创建记录不仅只有结构体的方式还能通过map创建，但不用的是**当使用map来创建时，钩子方法不会执行，关联不会被保存且不会回写主键。**因此最好使用结构体创记录。

db.Model(&User{}).Create([]map[string]interface{}{{"Name": "jinzhu_1", "Age": 18},{"Name": "jinzhu_2", "Age": 20},
})

关联创建

创建关联数据时，如果关联值非零，这些关联会被更新插入，并且它们的Hooks方法也会被调用。

type UserInfo struct {gorm.ModelAddress stringEmail   stringIPhone  stringUserId  uint
}
type User struct {gorm.ModelName     stringAge      int8Birthday time.TimeUserInfo  UserInfo
}ui := model.UserInfo{Address: "中国",Email:   "xxx@qq.com",IPhone:  "1234567",}u := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,}global.GVA_DB.Create(&u)

在这里插入图片描述

跳过关联更新

可以通过Select, Omit方法来跳过关联更新，示例如下：

db.Omit("UserInfo").Create(&user)// skip all associations
db.Omit(clause.Associations).Create(&user)

在这里插入图片描述

删除

改

查

preload预加载查询

模型

type UserInfo struct {gorm.ModelAddress stringEmail   stringIPhone  stringUserId  uint
}
type User struct {gorm.ModelName      stringAge       int8Birthday  time.TimeCompanyId intCompany   Company `gorm:"foreignKey:CompanyId;references:Code"`UserInfo  UserInfo
}
type Company struct {gorm.ModelName stringCode int
}

创建数据

	c := model.Company{Name: "A公司",Code: 111,}ui := model.UserInfo{Address: "中国",Email:   "xxx@qq.com",IPhone:  "1234567",}u1 := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,Company:  c,}u2 := model.User{Name:     "李四",Age:      27,Birthday: time.Now(),UserInfo: ui,Company:  c,}global.GVA_DB.Create([]*model.User{&u1, &u2})

查询

	var u model.Userglobal.GVA_DB.Select("name", "age").First(&u)fmt.Println(u)//此时查询结果

在这里插入图片描述

此时查询结果并没有关联表信息，如果需要查询关联表信息需要preload
preload查询

	var u model.Userglobal.GVA_DB.Preload("UserInfo").Preload("Company").First(&u)fmt.Println(u)

在这里插入图片描述

preload后面除了预加载的表还可以跟查询条件

	var u model.Userglobal.GVA_DB.Preload("UserInfo"，"address=中国").Preload("Company").First(&u)fmt.Println(u)//高级查询global.GVA_DB.Preload("UserInfo"，func(db *gorm.DB)*gorm.DB{return db.Joins("XXX").Where("xxx")}).Preload("Company").First(&u)

单个记录查询

GORM 提供了 First、Take、Last 方法，以便从数据库中检索单个对象。当查询数据库时它添加了 LIMIT 1 条件，且没有找到记录时，它会返回 ErrRecordNotFound 错误

// 获取第一条记录（主键升序）
db.First(&user)
// SELECT * FROM users ORDER BY id LIMIT 1;// 获取一条记录，没有指定排序字段
db.Take(&user)
// SELECT * FROM users LIMIT 1;// 获取最后一条记录（主键降序）
db.Last(&user)
// SELECT * FROM users ORDER BY id DESC LIMIT 1;result := db.First(&user)
result.RowsAffected // 返回找到的记录数
result.Error        // returns error or nil// 检查 ErrRecordNotFound 错误
errors.Is(result.Error, gorm.ErrRecordNotFound)

如果你想避免ErrRecordNotFound错误，你可以使用Find，比如db.Limit(1).Find(&user).对单个对象使用Find而不带limit，db.Find(&user)将会查询整个表并且只返回第一个对象，这是性能不高并且不确定的。

查询全部记录

var users_res []model.User
global.GVA_DB.Debug().Find(&users_res)
fmt.Println(users_res)
// SELECT * FROM `user` WHERE `user`.`deleted_at` IS NULLresult.RowsAffected // returns found records count, equals `len(users)`
result.Error        // returns error

条件查询

根据主键查询。

（使用字符串时，需要额外的注意来避免SQL注入）

db.First(&user, 10)
// SELECT * FROM users WHERE id = 10;
db.Find(&users, []int{1,2,3})
// SELECT * FROM users WHERE id IN (1,2,3);
字符串条件
db.Where("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
查找name != jinzhu的
db.Where("name <> ?", "jinzhu").Find(&users)
// SELECT * FROM users WHERE name <> 'jinzhu';// IN  查询名字==下面切片内容的
db.Where("name IN ?", []string{"jinzhu", "jinzhu 2"}).Find(&users)
// SELECT * FROM users WHERE name IN ('jinzhu','jinzhu 2');// LIKE 模糊匹配
db.Where("name LIKE ?", "%jin%").Find(&users)
// SELECT * FROM users WHERE name LIKE '%jin%';// AND 条件并列
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;// Time 
db.Where("updated_at > ?", lastWeek).Find(&users)
// SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
结构体、Map和切片条件查询
// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20;// Slice of primary keys
db.Where([]int64{20, 21, 22}).Find(&users)
// SELECT * FROM users WHERE id IN (20, 21, 22);

当使用结构体查询Gorm只会查询非零值字段（0,‘’,fasle），

db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu";

如果查询条件中包含零值就使用Map查询

db.Where(map[string]interface{}{"Name": "jinzhu", "Age": 0}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 0;
find内联查询
// Get by primary key if it were a non-integer type
db.First(&user, "id = ?", "string_primary_key")
// SELECT * FROM users WHERE id = 'string_primary_key';
// ===如下
db.Where("id=?","string_primary_key").find(&user)// Plain SQL
db.Find(&user, "name = ?", "jinzhu")
// SELECT * FROM users WHERE name = "jinzhu";
// ===如下
db.Where("name=?","jinzhu").find(&user)db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
// SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;
// ===如下
db.Where("name <> ? AND age > ?","jinzhu", 20).find(&user)// Struct
db.Find(&users, User{Age: 20})
// SELECT * FROM users WHERE age = 20;
// ===如下
db.Where("age=?, 20).find(&user)// Map
db.Find(&users, map[string]interface{}{"age": 20})
// SELECT * FROM users WHERE age = 20;
Not查询DB.Not( )
db.Not("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;// Not In
db.Not(map[string]interface{}{"name": []string{"jinzhu", "jinzhu 2"}}).Find(&users)
// SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");// Struct
db.Not(User{Name: "jinzhu", Age: 18}).First(&user)
// SELECT * FROM users WHERE name <> "jinzhu" AND age <> 18 ORDER BY id LIMIT 1;// Not In slice of primary keys
db.Not([]int64{1,2,3}).First(&user)
// SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;
Or查询
db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
// SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';// Struct
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2", Age: 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2", "age": 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

查询记录的特定字段

db.Select("name", "age").Find(&users)
// SELECT name, age FROM users;db.Select([]string{"name", "age"}).Find(&users)
// SELECT name, age FROM users;db.Table("users").Select("COALESCE(age,?)", 42).Rows()
// SELECT COALESCE(age,'42') FROM users;

排序查询DB.Order( )

db.Order("age desc, name").Find(&users)
// SELECT * FROM users ORDER BY age desc, name;// Multiple orders
db.Order("age desc").Order("name").Find(&users)
// SELECT * FROM users ORDER BY age desc, name;db.Clauses(clause.OrderBy{Expression: clause.Expr{SQL: "FIELD(id,?)", Vars: []interface{}{[]int{1, 2, 3}}, WithoutParentheses: true},
}).Find(&User{})
// SELECT * FROM users ORDER BY FIELD(id,1,2,3)

偏移量limit 和offset

limit指定要检索的最大记录数 Offset指定在开始返回记录之前要跳过的记录数

db.Limit(10).Offset(5).Find(&users)
// SELECT * FROM users OFFSET 5 LIMIT 10;

去重Distinct

db.Distinct("name", "age").Order("name, age desc").Find(&results)

joins查询

type result struct {Name  stringEmail string
}db.Model(&User{}).Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})
// SELECT users.name, emails.email FROM `users` left join emails on emails.user_id = users.idrows, err := db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Rows()
for rows.Next() {...
}db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)// multiple joins with parameter
db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Joins("JOIN credit_cards ON credit_cards.user_id = users.id").Where("credit_cards.number = ?", "411111111111").Find(&user)

多态

在GORM中为一对多和多对多关系提供了多态支持。
什么是多态呢？同一类型不同表现形态。具体一点举个场景例子，有一个Human表和Animal表，还有一个tool工具表。我们想在Human和Tool表之间建立一对多或多对多关系以及Animal和tool表之间同样建立一对一或一对多关系。假设一对多，我不总不能在tool表中建立HumanId外键和AnimalId外键吧？那如果后面又加一个Alia的表需要和tool建立关系，难道要再加一个AliaId字段吗？
综上所述，我们可以在主表中添加如下关联标签

type Human struct {ID   intName stringTool []Tool`gorm:"polymorphic:Owner;"`
}
type Tool struct {ID        intName      stringOwnerID   intOwnerType string
}

然后执行下面语句添加点数据

db.Create(&Human {Name: "Human1", Tool: []Tool{{Name: "Tool1"}, {Name: "Tool2"}}})
db.Create(&model.Animal{Name: "Animal1", Tool: []model.Tool{{Name: "Tool1"}, {Name: "Tool2"}}})

观察数据库Tool
在这里插入图片描述

多态的关联标签

`gorm:"polymorphic:Owner;polymorphicValue:master"`

polymorphic：根据上面我们能看出来polymorphic字段其实就是指定多态字段的名字的。还用上面例子，我们把tool的polymorphic修改成PolymorphicOwner，并在tool中添加多态字段，看结果

type Human struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}
type Tool struct {ID                   intName                 stringPolymorphicOwnerID   intPolymorphicOwnerType string
}
type Animal struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}

在这里插入图片描述
polymorphicValue就是更改多态字段的值，我们添加如下标签看结果。

type Human struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}
type Tool struct {ID                   intName                 stringPolymorphicOwnerID   intPolymorphicOwnerType string
}
type Animal struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}

在这里插入图片描述

利用Error.is判断错误

我们可以利用Error.is判断gorm报错信息，根据这个信息执行相应操作，例如

if !errors.Is(db.Where("username = ?", u.Username).First(&user).Error, gorm.ErrRecordNotFound) { // 判断用户名是否注册return userInter, errors.New("用户名已注册")
}assignErr := global.GVA_DB.Where("user_id = ? AND authority_authority_id = ?", id, authorityId).First(&system.SysUserAuthority{}).Errorif errors.Is(assignErr, gorm.ErrRecordNotFound) {return errors.New("该用户无此角色")}

事务

事务就是要么成功要么全部回滚。

开启事务

db.Transaction(func(tx *gorm.DB) error {if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {// 返回任何错误都会回滚事务return err}if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {return err}// 返回 nil 提交事务return nil
})

嵌套事务

凡是调用db.Transaction的返回Error的事务内部全部回滚。

db.Transaction(func(tx *gorm.DB) error {tx.Create(&user1)tx.Transaction(func(tx2 *gorm.DB) error {tx2.Create(&user2)return errors.New("rollback user2") // Rollback user2})tx.Transaction(func(tx3 *gorm.DB) error {tx3.Create(&user3)return nil})return nil
})// Commit user1, user3

手动执行事务

db, _ := GLOV_DB.DB()
// 开始事务
tx := db.Begin()// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
tx.Create(...)// ...// 遇到错误时回滚事务
tx.Rollback()// 否则，提交事务
tx.Commit()

示例

func CreateAnimals(db *gorm.DB) error {//事务一旦开始，使用 tx 处理数据tx := db.Begin()defer func() {if r := recover(); r != nil {tx.Rollback()}}()if err := tx.Error; err != nil {return err}if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {tx.Rollback()return err}if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {tx.Rollback()return err}return tx.Commit().Error
}

事务保存点

有时候我们希望事务失败回滚时，不要回滚全部任务，从我们指定位置回滚，就可以使用保存点，然后回滚至保存点。
示例：

func CreateAnimals(db *gorm.DB) error {tx := db.Begin()defer func() {if r := recover(); r != nil {tx.RollbackTo("sp1")}}()if err := tx.Error; err != nil {return err}tx.Create(&user1)tx.SavePoint("sp1")tx.Create(&user2)return tx.Commit().Error
}

自定义数据类型

什么是自定义数据类型？有些类型的数据，无法直接存到数据库，例如结构体，map，这些数据不向string int等可以直接存，那怎么办呢？这就需要自定义数据类型。
自定义的数据类型必须实现 Scanner 和 Valuer 接口，以便让 GORM 知道如何将该类型接收、保存到数据库，Valuer让GORM知道如何存数据，Scanner让GORM知道如何取出来数据。
示例：

type user_info struct {Name stringAge  int
}
type User struct {gorm.ModelInfo user_info
}
db.AutoMigrate(&model.User{})

在这里插入图片描述
自定义数据类型：

type User_info struct {Name stringAge  int
}
type User struct {gorm.ModelInfo User_info
}func (this User_info) Value() (driver.Value, error) {str, err := json.Marshal(this)if err != nil {return nil, err}return string(str), nil
}
func (this *User_info) Scan(value interface{}) error {obj, ok := value.([]byte)if !ok {return errors.New("不匹配")}json.Unmarshal(obj, this)return nil
}global.GVA_DB.AutoMigrate(&model.User{})global.GVA_DB.Create(&model.User{Info: model.User_info{Name: "info_name", Age: 18},})

在这里插入图片描述
查询一下

	var u model.Userglobal.GVA_DB.Find(&u)fmt.Println(u)

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/292741.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【C++第五课-C/C++内存管理】C/C++的内存分布、new/delete、new和delete的实现原理

【C++第五课-C/C++内存管理】C/C++的内存分布、new/delete、new和delete的实现原理

目录 C/C的内存分布new/deletenew内置类型使用new自定义类型使用newnew失败 delete内置类型使用delete自定义类型使用delete new和delete的实现原理new[] 和delete[]的补充知识 定位new&#xff08;了解&#xff09;常见面试题 C/C的内存分布 频繁的new/delete堆容易产生内存碎…
阅读更多...
算法学习——LeetCode力扣动态规划篇10（583. 两个字符串的删除操作、72. 编辑距离、647. 回文子串、516. 最长回文子序列）

算法学习——LeetCode力扣动态规划篇10（583. 两个字符串的删除操作、72. 编辑距离、647. 回文子串、516. 最长回文子序列）

算法学习——LeetCode力扣动态规划篇10 583. 两个字符串的删除操作 583. 两个字符串的删除操作 - 力扣&#xff08;LeetCode&#xff09; 描述 给定两个单词 word1 和 word2 &#xff0c;返回使得 word1 和 word2 相同所需的最小步数。 每步 可以删除任意一个字符串中的一个…
阅读更多...
2023年第十四届蓝桥杯大赛软件类省赛C/C++研究生组真题(代码完整题解)

2023年第十四届蓝桥杯大赛软件类省赛C/C++研究生组真题(代码完整题解)

C题-翻转⭐ 标签：贪心 简述：如果 S 中存在子串 101 或者 010，就可以将其分别变为 111 和 000，操作可以无限重复。最少翻转多少次可以把 S 变成和 T 一样。 链接： 翻转 思路：要求步骤最少->S每个位置最多修改一次->从头开始遍历不匹配就翻转->翻转不了就-1 …
阅读更多...
汇编语言——用INT 21H 的A号功能，输入一个字符串存放在内存，倒序输出

汇编语言——用INT 21H 的A号功能，输入一个字符串存放在内存，倒序输出

用INT 21H 的A号功能&#xff0c;输入一个字符串“Hello, world!”&#xff0c;存放在内存&#xff0c;然 后倒序输出。 在DOS中断中&#xff0c;INT 21H是一个常用的系统功能调用中断&#xff0c;它提供了多种功能&#xff0c;其中A号功能用于字符串的输入。 在使用这个功能时…
阅读更多...
康耐视visionpro-CogAcqFifoTool工具详细说明

康耐视visionpro-CogAcqFifoTool工具详细说明

CogAcqFifoTool操作说明&#xff1a; ① 打开工具栏&#xff0c;双击或点击鼠标拖拽 添加CogAcqFifoTool ②.从图片采集设备/图像采集卡列表里选择对应的相机&#xff0c;视频格式选择图像格式。 Mono表示黑白图像&#xff0c;RGB表示彩色相机。点击初始化取相初始化相机。 ③…
阅读更多...
灵动翻译音频文件字幕提取及翻译；剪映视频添加字幕

灵动翻译音频文件字幕提取及翻译；剪映视频添加字幕

参考&#xff1a;视频音频下载工具 https://tuberipper.com/21/save/mp3 1、灵动翻译音频文件字幕提取及翻译 灵动翻译可以直接chorme浏览器插件安装&#xff1a; 点击使用&#xff0c;可以上传音频文件 上传后自动翻译&#xff0c;然后点击译文即可翻译成中文&#xff0c;…
阅读更多...
排序——非基于比较的排序

排序——非基于比较的排序

本专栏和大家分享关于排序的算法,其中有插入排&#xff08;直接插入排序和希尔排序&#xff09;、选择排序&#xff08;直接选择排序和堆排&#xff09;、交换排序&#xff08;冒泡排序和快速排序&#xff09;、归并排序以及其他非基于比较的排序 本文与大家分享非基于比较的排…
阅读更多...
MySQL学习之连接查询

MySQL学习之连接查询

笛卡尔乘积现象 在表的连接查询方面有一种现象被称为&#xff1a;笛卡尔积现象。 笛卡尔积现象&#xff1a; 当两张表进行连接查询的时候&#xff0c;没有任何条件进行限制&#xff0c;最终的查询结果条数是两张表记录条数的乘积。 select ename,dname from emp,dept; 避免…
阅读更多...
算法系列--动态规划--特殊的状态表示--分析重复子问题

算法系列--动态规划--特殊的状态表示--分析重复子问题

&#x1f495;"轻舟已过万重山!"&#x1f495; 作者&#xff1a;Lvzi 文章主要内容&#xff1a;算法系列–算法系列–动态规划–特殊的状态表示–分析重复子问题 大家好,今天为大家带来的是算法系列--动态规划--特殊的状态表示--分析重复子问题 一.组合总数IV 链接…
阅读更多...
实现富文本的三部曲

实现富文本的三部曲

1、引入 ueditor.config.js ueditor.all.min.js lang/zh-cn/zh-cn.js 2、编辑器显示处 id"content" <textarea id"content" name"content"></textarea> 3、底部 <script type"text/javascript"> //实例化编辑器 …
阅读更多...
搜索与图论——Floyd算法求最短路

搜索与图论——Floyd算法求最短路

floyd算法用来求多源汇最短路 用邻接矩阵来存所有的边 时间复杂度O(n^3) #include<iostream> #include<cstring> #include<algorithm>using namespace std;const int N 20010,INF 1e9;int n,m,k; int g[N][N];void floyd(){for(int k 1;k < n;k ){f…
阅读更多...
网络基础（二）——序列化与反序列化

网络基础（二）——序列化与反序列化

目录 1、应用层 2、再谈“协议” 3、网络版计算器 Socket.hpp TcpServer.hpp ServerCal.hpp ServerCal.cc Protocol.hpp ClientCal.cc Log.hpp Makefile 1、应用层 我们程序员写的一个个解决我们实际问题&#xff0c;满足我们日常需求的网络程序&#xff0c;都是在…
阅读更多...
QT+Opencv+yolov5实现监测

QT+Opencv+yolov5实现监测

功能说明&#xff1a;使用QTOpencvyolov5实现监测 仓库链接&#xff1a;https://gitee.com/wangyoujie11/qt_yolov5.git git本仓库到本地 一、环境配置 1.opencv配置 将OpenCV-MinGW-Build-OpenCV-4.5.2-x64文件夹放在自己的一个目录下&#xff0c;如我的路径&#xff1a; …
阅读更多...
appium辅助自动化工具-- Appium studio

appium辅助自动化工具-- Appium studio

这里我要给大家介绍一款appium辅助自动化测试工具appium studio&#xff0c;你没看错&#xff0c;不是android studio&#xff0c;也不是appium android studio&#xff0c;就是appium studio&#xff01; 下载地址&#xff1a; Appium Studio | Digital.ai Continuous Test…
阅读更多...
智慧公厕的技术融合策略

智慧公厕的技术融合策略

智慧公厕是迎合现代城市发展需要的一项重要基础设施&#xff0c;其设计的技术融合策略在实现公共厕所泛在感知、互通互联、协同构筑智慧城市等方面起到了关键作用。本文将以智慧公厕源头实力厂家广州中期科技有限公司&#xff0c;大量精品案例现场实景实图实例&#xff0c;从物…
阅读更多...
Makefile：动态库的编译链接与使用（六）

Makefile：动态库的编译链接与使用（六）

1、动态链接库 动态链接库&#xff1a;不会把代码编译到二进制文件中&#xff0c;而是运行时才去加载&#xff0c;所以只需要维护一个地址 动态&#xff1a;运行时才去加载&#xff0c;即所谓的动态加载连接&#xff1a;指库文件和二进制程序分离&#xff0c;用某种特殊的手段…
阅读更多...
MySQL - 高阶语句（一）

MySQL - 高阶语句（一）

先准备一张表 create table class1 (id int,name varchar(10) primary key not null ,score decimal(5,2),address varchar(20),hobbid int(5));insert into class1 values(1,liuyi,80,beijing,2); insert into class1 values(2,wangwu,90,shengzheng,2); insert into class1 …
阅读更多...
图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

电动两轮车不仅为当今生活提供了便利&#xff0c;更是一种健康和绿色的出行方式。想象一下&#xff0c;在经过一整晚的充分休息&#xff0c;骑上爱车&#xff0c;满血复活的准备开始新的一天。您会愿意带着如何给心爱的两轮车充电的担心开始这一天吗&#xff1f; 随着越来越…
阅读更多...
第1章.提示词:开启AI智慧之门的钥匙

第1章.提示词:开启AI智慧之门的钥匙

什么是提示词&#xff1f; 提示词&#xff0c;是引导语言模型的指令&#xff0c;让用户能够驾驭模型的输出&#xff0c;确保生成的文本符合需求。 ChatGPT&#xff0c;这位文字界的艺术大师&#xff0c;以transformer架构为基石&#xff0c;能轻松驾驭海量数据&#xff0c;编织…
阅读更多...
JUC并发编程（七）

JUC并发编程（七）

1、不可变对象 1.1、概念 不可变类是指一旦创建对象实例后&#xff0c;就不能修改该实例的状态。这意味着不可变类的对象是不可修改的&#xff0c;其内部状态在对象创建后不能被更改。不可变类通常具有以下特征&#xff1a; 实例状态不可改变&#xff1a;一旦不可变类的对象被…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023