go语言web开发系列之十六:gin框架中通过gorm使用事务

package controller
 
import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/liuhongdi/digv16/global"
	"github.com/liuhongdi/digv16/service"
)
 
type OrderController struct{}
 
//result:= global.NewResult(c)
 
func NewOrderController() OrderController {
	return OrderController{}
}
 
//新加一个订单
func (o *OrderController) AddOne(c *gin.Context) {
	result := global.NewResult(c)
 
	goodsId:=1;
	buyNum:=11;
 
	orderOne,err := service.AddOneOrder(int64(goodsId),buyNum);
	if err != nil {
		result.Error(404,"数据处理错误")
	} else {
		result.Success(&orderOne);
	}
	return
}
 
 
//新加一个订单,使用tx
func (o *OrderController) AddOneTx(c *gin.Context) {
	result := global.NewResult(c)
	goodsId:=1;
	buyNum:=11;
 
	orderOne,err := service.AddOneOrderTx(int64(goodsId),buyNum);
 
	fmt.Println("orderOne:");
	fmt.Println(orderOne);
	fmt.Println(":end:");
	//if ()
	if (orderOne == nil || err != nil) {
		result.Error(20001,"数据处理错误")
	} else {
		result.Success(&orderOne);
	}
	return
}

package service
 
import (
	"github.com/liuhongdi/digv16/dao"
	"github.com/liuhongdi/digv16/model"
)
 
//新加一个订单
func AddOneOrder(goodsId int64,buyNum int) (*model.Order, error) {
	return dao.AddOneOrder(goodsId,buyNum)
}
 
//新加一个订单,使用tx
func AddOneOrderTx(goodsId int64,buyNum int) (*model.Order, error) {
	return dao.AddOneOrderTx(goodsId,buyNum)
}

package dao
 
import (
	"errors"
	"fmt"
	"github.com/liuhongdi/digv16/global"
	"github.com/liuhongdi/digv16/model"
	"gorm.io/gorm"
)
 
//添加一个订单
func AddOneOrder(goodsId int64,buyNum int) (*model.Order, error) {
	//添加order
	order := model.Order{UserId: 1, SalePrice: "20.00"}
	resultCO := global.DBLink.Create(&order) // 通过数据的指针来创建
	if (resultCO.Error != nil) {
		return nil,resultCO.Error
	}
    //减库存
	result := global.DBLink.Debug().Table("m_goods").Where("goodsId = ? and stock >= ?", goodsId,buyNum).Update("stock", gorm.Expr("stock - ?", buyNum))
	if (result.Error != nil) {
		return nil,result.Error
	}
	if (result.RowsAffected <= 0){
		return nil,errors.New("减库存失败")
	}
    //添加订单商品
	orderId := order.OrderId;
	orderGoods := model.OrderGoods{OrderId:orderId,GoodsId:goodsId,BuyNum:buyNum}
	resultCOG := global.DBLink.Create(&orderGoods) // 通过数据的指针来创建
	if (resultCOG.Error != nil) {
		return nil,resultCOG.Error
	}
	//return
	return &order,nil
}
 
 
//添加一个订单
func AddOneOrderTx(goodsId int64,buyNum int) (*model.Order, error) {
	// 事务开始后，需要使用 tx 处理数据
	tx := global.DBLink.Begin()
 
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("this is in defer recover")
			tx.Rollback()
		}
	}()
 
	if err := tx.Error; err != nil {
		return nil,err
	}
 
	//添加order
	order := model.Order{UserId: 1, SalePrice: "20.00"}
	resultCO := tx.Debug().Create(&order) // 通过数据的指针来创建
	if (resultCO.Error != nil) {
		tx.Rollback()
		return nil,resultCO.Error
	}
 
	/*
	var z int = 0
	var i int = 100 / z
	fmt.Println("i:%i",i)
    */
	//减库存
	result := tx.Debug().Table("m_goods").Where("goodsId = ? and stock >= ?", goodsId,buyNum).Update("stock", gorm.Expr("stock - ?", buyNum))
	if (result.Error != nil) {
		tx.Rollback()
		return nil,result.Error
	}
	if (result.RowsAffected <= 0){
		tx.Rollback()
		fmt.Println("减库存失败")
		return nil,errors.New("减库存失败")
	}
	//添加订单商品
	orderId := order.OrderId;
	orderGoods := model.OrderGoods{OrderId:orderId,GoodsId:goodsId,BuyNum:buyNum}
	resultCOG := tx.Debug().Create(&orderGoods) // 通过数据的指针来创建
	if (resultCOG.Error != nil) {
		tx.Rollback()
		return nil,resultCOG.Error
	}
    //commit
    fmt.Println("begin commit")
	errCM := tx.Commit().Error
	if (errCM != nil) {
		fmt.Println("begin return1")
		tx.Rollback()
		return nil,errCM
	}else {
		fmt.Println("begin return2")
		return &order,nil
	}
}

package model
 
type Goods struct {
	GoodsId	int64  `gorm:"column:goodsId",json:"goodsId"` // 自增
	GoodsName	string  `gorm:"column:goodsName",json:"goodsName"`    // 用户id
	Stock int  `gorm:"column:stock",json:"stock"`  // 售价
}
 
func (Goods) TableName() string {
	return "m_goods"
}

package model
 
type Order struct {
	OrderId	int64  `gorm:"primaryKey;autoIncrement;column:orderId",json:"orderid"` // 自增
	UserId	int64  `gorm:"column:userId",json:"userid"`    // 用户id
	SalePrice string  `gorm:"column:salePrice",json:"saleprice"`  // 售价
}
 
func (Order) TableName() string {
	return "m_order"
}

package router
 
import (
	"github.com/gin-gonic/gin"
	"github.com/liuhongdi/digv16/controller"
	"github.com/liuhongdi/digv16/global"
	"log"
	"runtime/debug"
)
 
func Router() *gin.Engine {
	router := gin.Default()
	//处理异常
	router.NoRoute(HandleNotFound)
	router.NoMethod(HandleNotFound)
	router.Use(Recover)
 
	// 路径映射
	goodsc:=controller.NewGoodsController()
	router.GET("/goods/getone/:id", goodsc.GetOne);
	//router.GET("/article/list", articlec.GetList);
 
	orderc:=controller.NewOrderController()
	router.GET("/order/addone", orderc.AddOne);
	router.GET("/order/addonetx", orderc.AddOneTx);
 
	return router
}
 
func HandleNotFound(c *gin.Context) {
	global.NewResult(c).Error(404,"资源未找到")
	return
}
 
func Recover(c *gin.Context) {
	defer func() {
		if r := recover(); r != nil {
			//打印错误堆栈信息
			log.Printf("panic: %v\n", r)
			debug.PrintStack()
			global.NewResult(c).Error(500,"服务器内部错误")
		}
	}()
	//加载完 defer recover，继续后续接口调用
	c.Next()
}

/*
var z int = 0
var i int = 100 / z
fmt.Println("i:%i",i)
*/