本节以客户customer和订单order为模型，并且以dao设计模式来实现他们的curd操作。

项目结构

准备数据库和表以及数据

create database gorm_demo;

customers | CREATE TABLE `customers` (
  `id` int unsigned NOT NULL AUTO_INCREMENT,
  `created_at` datetime DEFAULT NULL,
  `updated_at` datetime DEFAULT NULL,
  `deleted_at` datetime DEFAULT NULL,
  `name` varchar(100) NOT NULL,
  `address` varchar(100) NOT NULL,
  `email` varchar(100) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_customers_deleted_at` (`deleted_at`)
);

orders | CREATE TABLE `orders` (
  `id` int unsigned NOT NULL AUTO_INCREMENT,
  `created_at` datetime DEFAULT NULL,
  `updated_at` datetime DEFAULT NULL,
  `deleted_at` datetime DEFAULT NULL,
  `customer_id` int unsigned DEFAULT NULL,
  `product` varchar(255) DEFAULT NULL,
  `price` double DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_orders_deleted_at` (`deleted_at`)
) ;


INSERT INTO customers (name, address, email)
VALUES 
  ('John Doe', '123 Main St', 'john.doe@example.com'),
  ('Jane Doe', '456 Main St', 'jane.doe@example.com'),
  ('Jim Smith', '789 Main St', 'jim.smith@example.com');


INSERT INTO orders (customer_id, product, price)
VALUES
  (1, 'iPhone', 999.99),
  (1, 'Macbook Pro', 1499.99),
  (2, 'iPad', 499.99),
  (3, 'Apple Watch', 399.99);

在上面的代码中：

customers表有5个字段：

id：主键，自动递增。
name：客户姓名，类型为字符串，不能为空。
address：客户地址，类型为字符串，不能为空。
email：客户电子邮件，类型为字符串，不能为空，唯一。
created_at：客户创建时间，类型为时间戳，默认值为当前时间。

orders表有5个字段：

id：主键，自动递增。
customer_id：客户ID，类型为整数，不能为空。
product：产品名称，类型为字符串，不能为空。
price：产品价格，类型为十进制，不能为空。
created_at：订单创建时间，类型为时间戳，默认值为当前

创建并初始化项目

mkdir gorm_demo
cd gorm_demo
code .
go mod init gorm_demo

创建实体

创建一个entity文件夹，里面创建order.go和customer.go 文件内容如下：

order.go

package entity

import "gorm.io/gorm"

type Order struct {
	gorm.Model
	CustomerID uint
	Product    string
	Price      float32
}

customer.go

package entity

import (
	"github.com/jinzhu/gorm"
)

// Customer model
type Customer struct {
	gorm.Model
	Name    string `gorm:"type:varchar(100);not null"`
	Address string `gorm:"type:varchar(100);not null"`
	Email   string `gorm:"type:varchar(100);not null"`
}

创建连接数据库工具类

创建一个util文件夹，在该文件夹中创建db_util.go文件内容如下：

package util

import (
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var db *gorm.DB

func init() {
	var err error
	db, err = gorm.Open("mysql", "root:123456@/gorm_demo?charset=utf8&parseTime=True&loc=Local")
	if err != nil {
		panic("failed to connect database")
	}
}

func GetDB() *gorm.DB {
	return db
}

创建dao接口

创建一个dao文件夹，里面创建order_dao.go、customer_dao.go、order_dao_impl.go、customer_dao_impl.go文件，内容如下：

order_dao.go

package dao

import (
	"gorm_demo/entity"

	"github.com/jinzhu/gorm"
)

type OrderDAO interface {
	FindAllOrders(db *gorm.DB) ([]entity.Order, error)
	FindOrderByID(db *gorm.DB, id int) (entity.Order, error)
	CreateOrder(db *gorm.DB, order entity.Order) error
	UpdateOrder(db *gorm.DB, order entity.Order) error
	DeleteOrder(db *gorm.DB, order entity.Order) error
}

customer_dao.go

package dao

import (
	"gorm_demo/entity"

	"github.com/jinzhu/gorm"
)

// CustomerDAO interface
type CustomerDAO interface {
	CreateCustomer(db *gorm.DB, customer entity.Customer) (entity.Customer, error)
	GetCustomer(db *gorm.DB, id uint) (entity.Customer, error)
	GetAllCustomers(db *gorm.DB) ([]entity.Customer, error)
	UpdateCustomer(db *gorm.DB, customer entity.Customer) (entity.Customer, error)
	DeleteCustomer(db *gorm.DB, customer entity.Customer) error
}

order_dao_impl.go

package dao

import (
	"gorm_demo/entity"

	"github.com/jinzhu/gorm"
)

type OrderDAOImpl struct{}

func (odao *OrderDAOImpl) FindAllOrders(db *gorm.DB) ([]entity.Order, error) {
	var orders []entity.Order
	if err := db.Find(&orders).Error; err != nil {
		return nil, err
	}
	return orders, nil
}

func (odao *OrderDAOImpl) FindOrderByID(db *gorm.DB, id int) (entity.Order, error) {
	var order entity.Order
	if err := db.First(&order, id).Error; err != nil {
		return entity.Order{}, err
	}
	return order, nil
}

func (odao *OrderDAOImpl) CreateOrder(db *gorm.DB, order entity.Order) error {
	if err := db.Create(&order).Error; err != nil {
		return err
	}
	return nil
}

func (odao *OrderDAOImpl) UpdateOrder(db *gorm.DB, order entity.Order) error {
	if err := db.Save(&order).Error; err != nil {
		return err
	}
	return nil
}

func (odao *OrderDAOImpl) DeleteOrder(db *gorm.DB, order entity.Order) error {
	if err := db.Delete(&order).Error; err != nil {
		return err
	}
	return nil
}

customer_dao_impl.go

package dao

import (
	"gorm_demo/entity"

	"github.com/jinzhu/gorm"
)

// CustomerDAOImpl customer data access object implementation
type CustomerDAOImpl struct{}

// CreateCustomer method to create a new customer
func (dao CustomerDAOImpl) CreateCustomer(db *gorm.DB, customer entity.Customer) (entity.Customer, error) {
	err := db.Create(&customer).Error
	return customer, err
}

// GetCustomer method to get a customer by ID
func (dao CustomerDAOImpl) GetCustomer(db *gorm.DB, id uint) (entity.Customer, error) {
	var customer entity.Customer
	err := db.First(&customer, id).Error
	return customer, err
}

// GetAllCustomers method to get all customers
func (dao CustomerDAOImpl) GetAllCustomers(db *gorm.DB) ([]entity.Customer, error) {
	var customers []entity.Customer
	err := db.Find(&customers).Error
	return customers, err
}

// UpdateCustomer method to update a customer
func (dao CustomerDAOImpl) UpdateCustomer(db *gorm.DB, customer entity.Customer) (entity.Customer, error) {
	err := db.Save(&customer).Error
	return customer, err
}

func (dao *CustomerDAOImpl) DeleteCustomer(db *gorm.DB, customer entity.Customer) error {
	if err := db.Delete(&customer).Error; err != nil {
		return err
	}
	return nil
}

测试

package main

import (
	"fmt"
	"gorm_demo/dao"
	"gorm_demo/entity"
	"gorm_demo/util"

	_ "github.com/jinzhu/gorm/dialects/mysql"
)

func main() {

	db := util.GetDB()

	defer db.Close()

	db.AutoMigrate(&entity.Customer{}, &entity.Order{})

	customerDAO := dao.CustomerDAOImpl{}

	// Create a new customer
	newCustomer := entity.Customer{
		Name:    "John Doe",
		Address: "123 Main St",
		Email:   "john.doe@example.com",
	}
	createdCustomer, err := customerDAO.CreateCustomer(db, newCustomer)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Created customer:", createdCustomer)

	// Get a customer by ID
	customer, err := customerDAO.GetCustomer(db, createdCustomer.ID)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Retrieved customer:", customer)

	// Get all customers
	customers, err := customerDAO.GetAllCustomers(db)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Retrieved customers:", customers)

	// Update a customer
	customer.Name = "Jane Doe"
	updatedCustomer, err := customerDAO.UpdateCustomer(db, customer)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Updated customer:", updatedCustomer)

	// Delete a customer
	err = customerDAO.DeleteCustomer(db, customer)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Deleted customer:", customer)
}