gorm增删查改json_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

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