go基于echo、gorm实现增删改查,从请求到落库

go就不多介绍了直接上菜了.

一.项目解构

conf // 配置相关

dao // 数据库

log // 日志

router // 路由相关,相当于java springMVC中controller

app.go // main函数入口,启动类

conf.tomf // 配置文件

二、部分代码说明

app.go主函数

package main

import (
	"fmt"
	"github.com/labstack/echo"
	"go-learning/conf"
	"go-learning/log"
	"go-learning/router"
	"go-learning/router/response"
	"net/http"
)

func main() {
	e := echo.New()
	e.HTTPErrorHandler = customHTTPErrorHandler
	router.RouterInit(e)
	e.Logger.Info(e.Start(conf.Conf.Server.Port))
}

//路由错误页面配置
func customHTTPErrorHandler(err error, c echo.Context) {
	var (
		code = http.StatusInternalServerError
		msg  interface{}
	)

	if he, ok := err.(*echo.HTTPError); ok {
		code = he.Code
		msg = he.Message
		if he.Internal != nil {
			msg = fmt.Sprintf("%v, %v", err, he.Internal)
		}
	} else if c.Echo().Debug {
		msg = err.Error()
	} else {
		msg = fmt.Sprintf("%s : %v", http.StatusText(code), err)
	}
	if _, ok := msg.(string); ok {
		msg = c.JSON(http.StatusInternalServerError, response.Error(&response.GlobalErrorCode{ErrorCode: code, Error: fmt.Sprint(msg)}))
	}
	// Send response
	if !c.Response().Committed {
		// Issue #608
		if c.Request().Method == "HEAD" {
			err = c.NoContent(code)
		} else {
			err = c.JSON(code, msg)
		}
		if err != nil {
			log.Error(err)
		}
	}
}

主函数启动之后加载配置的路由:

主函数中router.RouterInit(e) ->init.go中方法RouterInit->api_router.go中ApiRouters(e *echo.Echo)最终加载路由:

package packet

import (
	"github.com/labstack/echo"
)

// 路由器
func ProductRouter(e *echo.Echo) {
	// 增
	e.POST("/v1/go/learn/add", Add)
	// 删
	e.POST("/v1/go/learn/del", Del)
	// 改
	e.POST("/v1/go/learn/update", Update)
	// 查
	e.GET("/v1/go/learn/get/list", GetList)
}

三、实现一个具体的请求

从上述的路由中加载路由,例如:e.POST("/v1/go/learn/add", Add)

Add是指定的实现方法,如下:

packet_product_handler.go中

// 新增商品
func Add(c echo.Context) (err error) {
	product := new(service.ProductBO)
	if  err = c.Bind(product); err != nil{
		return c.JSONBlob(http.StatusBadRequest, nil)
	}
	// 保存
	service.Save(product)
	return c.JSON(http.StatusOK, response.OK())
}

 

packet_product_handler.go中的service.Save(product)是调用service方法这个是模拟java分层来写的如下:

product_service.go中

func Save(bo *ProductBO) {
	do := new(mapper.T_product)
	do.Product_name = bo.ProductName
	do.Product_url = bo.ProductUrl
	do.Created_at = time.Now().Format("2006-01-02 15:04:05")
	do.Created_by = "sys"
	do.Updated_at = time.Now().Format("2006-01-02 15:04:05")
	mapper.Save(do)
}

其中ProductBO是一个结构体,如下:

// 成员变量首字母要大写
type (
	ProductBO struct {
		Id  int `json:"id"`
		ProductName string  `json:"productName"`
		ProductUrl string `json:"productUrl"`
	}
)

最后调用dao与数据库做交互,这里自然是落库了,如下:

product_mapper.go中Save方法:

func Save(product *T_product) {
	db = dao.GetDb()
	db.Create(product)
}

其中数据库的连接信息是通过db.go的方法获取,如下:

func dbConn(MyUser, Password, Host, Db string, Port int) *gorm.DB {
	connArgs := fmt.Sprintf("%s:%s@(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", MyUser,Password, Host, Port, Db )
	db, err := gorm.Open("mysql", connArgs)
	if err != nil {
		log.Fatal(err)
	}
	db.SingularTable(true)
	return db
}

func GetDb() *gorm.DB {
	return dbConn("root", "root", "127.0.0.1", "spring_jpa", 3306);
}

以上是一个大致的请求接口到落库的过程.

具体的代码可以参考github实现:

https://github.com/15902124763/go-learning

或者掘金,后续会继续更新,算是一个成长的记录,