[golang gin框架] 1.Gin环境搭建,程序的热加载,路由GET,POST,PUT,DELETE

置顶 已于 2024-01-12 14:23:59 修改
阅读量3.1k 收藏 19
点赞数 1
分类专栏： golang # gin框架开发 文章标签： golang 开发语言
于 2023-02-12 16:27:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoupenghui168/article/details/128995199
版权

一.Gin 介绍

Gin 是一个 Go (Golang) 编写的轻量级 http web 框架，运行速度非常快，如果你是性能和高效的追求者，推荐你使用 Gin 框架.
Gin 最擅长的就是 Api 接口的高并发，如果项目的规模不大，业务相对简单，这个时候
也推荐使用 Gin.
当某个接口的性能遭到较大挑战的时候，这个还是可以考虑使用 Gin 重写接口.
Gin 也是一个流行的 golang Web 框架，Github Strat 量已经超过了 50k.
Gin 的官网： Gin Web Framework
Gin Github 地址： GitHub - gin-gonic/gin: Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.

二.Gin 环境搭建

要安装 Gin 软件包，需要先安装 Go 并设置 Go 工作区,详情见: [go学习笔记.第二章] 2.go语言的开发工具以及安装和配置SDK

  1. 下载并安装 gin


go get -u github.com/gin-gonic/gin

由于网络原因国内部分用户可能没法直接下载第三方包,go get 失败,Golang Gin中没法下载第三方包解决办法如下:

//打开终端并执行
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

2.将 gin 引入到代码中


import "github.com/gin-gonic/gin"

3. 如果使用诸如 http.StatusOK 之类的常量，则需要引入 net/http 包


import "net/http"

4.新建main.go配置路由

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
// 创建gin的默认路由引擎
r := gin.Default()
// 配置路由
r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{ // c.JSON：返回 JSON 格式的数据
        "message": "Hello world!", })
    })

// 浏览器访问请求127.0.0.1:8080/ping路由时,调用回调函数
r.GET("/ping", func(c *gin.Context) {
        //浏览器输出
        //c.JSON(200, gin.H{
        //    "message": "pong",
        //})
         c.String(http.StatusOK, "值:%v", "你好")
    })

//监听并在 0.0.0.0:8080 上启动服务(启动一个web服务)
r.Run()
// 监听并在 0.0.0.0:8000 上启动服务(启动一个web服务)
//r.Run("8000") 
}

5.运行项目

go run main.go

6.要改变默认启动的端口

r.Run(":9000")

三.golang程序的热加载

所谓热加载就是当对代码进行修改时，程序能够自动重新加载并执行，这在开发中
是非常便利的，可以快速进行代码测试，省去了每次手动重新编译,beego 中可以使用官方给提供bee工具来热加载项目，但是 gin 中并没有官方提供的热加载工具，这个时候要实现热加载就可以借助第三方的工具

工具 1（推荐）：GitHub - gravityblast/fresh: Build and (re)start go web apps after saving/creating/deleting source files.

//进入终端执行
go get github.com/pilu/fresh
//然后运行命令
fresh

//或者进入终端执行
go install github.com/pilu/fresh@latest
//然后运行命令
fresh

工具 2：GitHub - codegangsta/gin: Live reload utility for Go web servers

//进入终端执行
go get -u github.com/codegangsta/gin
//然后运行命令
gin run main.go

四.Gin框架中的路由

1.路由概述

路由（Routing）是由一个 URI（或者叫路径）和一个特定的 HTTP 方法（GET、POST 等）
组成的，涉及到应用如何响应客户端对某个网站节点的访问 ,RESTful API 是目前比较成熟的一套互联网应用程序的 API 设计理论，所以在设计路由的时候建议参考 RESTful API 指南,在 RESTful 架构中，每个网址代表一种资源，不同的请求方式表示执行不同的操作：

GET（SELECT）

从服务器取出资源（一项或多项）

POST（CREATE）

在服务器新建一个资源

PUT（UPDATE）

在服务器更新资源（客户端提供改变后的完整资源）

DELETE（DELETE）

从服务器删除资源

  1. 简单的路由配置

当用 GET 请求访问一个网址的时候 
r.GET("网址", func(c *gin.Context) {
    c.String(200, "Get")
})
当用 POST 访问一个网址的时候 
r.POST("网址", func(c *gin.Context) {
    c.String(200, "POST")
})
当用 PUT 访问一个网址的时候 
r.PUT("网址", func(c *gin.Context) {
    c.String(200, "PUT")
})
当用 DELETE 访问一个网址的时候 
r.DELETE("网址", func(c *gin.Context) {
    c.String(200, "DELETE")
})
路由里面获取 Get 传值 
//  域名/news?aid=20
r.GET("/news", func(c *gin.Context) {
    aid := c.Query("aid")
    c.String(200, "aid=%s", aid)
})
动态路由 
// 域名/user/20
r.GET("/user/:uid", func(c *gin.Context) {
    uid := c.Param("uid")
    c.String(200, "userID=%s", uid)
})
完整的代码案例如下: 
package main

import (
    _ "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

func main()  {
    r := gin.Default()  // 创建gin的默认路由引擎
    //配置路由
    // 浏览器访问请求127.0.0.1:8080/ping路由时,调用回调函数
    r.GET("/ping", func(c *gin.Context) {
        //浏览器输出
        //c.JSON(200, gin.H{
        //    "message": "pong",
        //})
        c.String(http.StatusOK, "值:%v", "你好")
    })
    r.GET("/news", func(c *gin.Context) {
        //使用http.StatusOK状态码
        c.String(http.StatusOK, "新闻页11面")
    })
    r.POST("/add", func(c *gin.Context) {
        c.String(200, "这是一个POST请求,主要用于增加数据")
    })
    r.PUT("/edit", func(c *gin.Context) {
        c.String(200, "这是一个PUT请求,主要用于修改数据")
    })
    r.DELETE("/delete", func(c *gin.Context) {
        c.String(200, "这是一个DELETE请求,主要用于增删除数据")
    })
    r.Run() // 监听并在 0.0.0.0:8080 上启动服务(启动一个web服务)
}

3.c.String() c.JSON() c.JSONP() c.XML() c.HTML()

返回一个字符串 
r.GET("/news", func(c *gin.Context) {
    aid := c.Query("aid")
    c.String(200, "aid=%s", aid)
})
返回一个 JSON 数据 
    //方法一:自己拼接JSON
    r.GET("/json", func(c *gin.Context) {
        //返回json数据,使用 map[string]interface
        //c.JSON(返回的状态码, 任意类型的数据(如:map,struct,...)
        c.JSON(200, map[string]interface{}{
            "success": true,
            "msg":     "你好",
        })
    })
    //方法二:gin中的H函数
    r.GET("/json2", func(c *gin.Context) {
        //返回json数据,使用gin中的H函数, gin.H 是 map[string]interface{}的缩写
        c.JSON(200, gin.H{
            "success": true,
            "msg":     "你好gin",
        })
    })
    //方法三:使用结构体
    r.GET("/json3", func(c *gin.Context) {
        //实例化一个结构体
        a := &Article{
            Title:   "标题",
            Desc:    "说明",
            Content: "内容",
        }
        c.JSON(200, a)
    })
JSOPN: jsonp请求 主要用来解决跨域问题 
    //jsonp请求 主要用来解决跨域问题
    //http://127.0.0.1:8080/jsonp?callback=call
    //call({"title":"标题-jsonp","desc":"说明-jsonp","content":"内容-jsonp"});
    r.GET("/jsonp", func(c *gin.Context) {
        //实例化一个结构体
        a := &Article{
            Title:   "标题-jsonp",
            Desc:    "说明-jsonp",
            Content: "内容-jsonp",
        }
        c.JSONP(200, a)
    })
返回 XML 数据 
    //方法一:使用gin.H返回
    r.GET("/xml", func(c *gin.Context) {
        c.XML(http.StatusOK, gin.H{
            "success": true,
            "msg":     "成功xml",
        })
    })
    //方法二:使用结构体
    r.GET("/xmlStruct", func(c *gin.Context) {
        //实例化一个结构体
        a := &Article{
            Title:   "标题-xmlStruct",
            Desc:    "说明-xmlStruct",
            Content: "内容-xmlStruct",
        }
        c.XML(200, a)
    })
返回HTML数据 
     //初始化路由
     r := gin.Default()
     //加载templates文件中所有模板文件,以便后续c.HTML()渲染文件时使用
     r.LoadHTMLGlob("templates/*")
     r.GET("/news", func(c *gin.Context) {
        //使用模板文件渲染HTML文件
        //前提: r.LoadHTMLGlob("templates/*")
        //HTML(状态码, 要渲染的文件名, 加载的参数)
        c.HTML(http.StatusOK, "news.html", gin.H{
            "title": "我是一个news",
        })
    })
完整代码案例如下: 
package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

type Article struct {
    Title   string `json:"title"`
    Desc    string `json:"desc"`
    Content string `json:"content"`
}

func main() {
    //初始化路由
    r := gin.Default()
    //加载templates文件中所有模板文件,以便后续c.HTML()渲染文件时使用
    r.LoadHTMLGlob("templates/*")
    //配置路由
    r.GET("/", func(c *gin.Context) {
        c.String(200, "首页")
    })
    r.GET("/json", func(c *gin.Context) {
        //返回json数据,使用 map[string]interface
        //c.JSON(返回的状态码, 任意类型的数据(如:map,struct,...)
        c.JSON(200, map[string]interface{}{
            "success": true,
            "msg":     "你好",
        })
    })
    r.GET("/json2", func(c *gin.Context) {
        //返回json数据,使用gin中的H函数
        c.JSON(200, gin.H{
            "success": true,
            "msg":     "你好gin",
        })
    })
    r.GET("/json3", func(c *gin.Context) {
        //实例化一个结构体
        a := &Article{
            Title:   "标题",
            Desc:    "说明",
            Content: "内容",
        }
        c.JSON(200, a)
    })
    //jsonp请求 主要用来解决跨域问题
    //http://127.0.0.1:8080/jsonp?callback=call
    //call({"title":"标题-jsonp","desc":"说明-jsonp","content":"内容-jsonp"});
    r.GET("/jsonp", func(c *gin.Context) {
        //实例化一个结构体
        a := &Article{
            Title:   "标题-jsonp",
            Desc:    "说明-jsonp",
            Content: "内容-jsonp",
        }
        c.JSONP(200, a)
    })
    r.GET("/xml", func(c *gin.Context) {
        c.XML(http.StatusOK, gin.H{
            "success": true,
            "msg":     "成功xml",
        })
    })
    r.GET("/news", func(c *gin.Context) {
        //使用模板文件渲染HTML文件
        //前提: r.LoadHTMLGlob("templates/*")
        //HTML(状态码, 要渲染的文件名, 加载的参数)
        c.HTML(http.StatusOK, "news.html", gin.H{
            "title": "我是一个news",
        })
    })
    r.GET("/goods", func(c *gin.Context) {
        //使用模板文件渲染HTML文件
        //前提: r.LoadHTMLGlob("templates/*")
        //HTML(状态码, 要渲染的文件名, 加载的参数)
        c.HTML(http.StatusOK, "goods.html", gin.H{
            "title": "我是一个goods",
            "price": 12.99,
        })
    })
    r.Run() // 启动一个web服务
}

[下一节][golang gin框架] 2.Gin HTML模板渲染以及模板语法,自定义模板函数,静态文件服务

zhoupenghui168
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Gin 从零开始搭建gin项目框架
kevink的博客
03-25 2460
欢迎大家访问我的博客http://blog.ayla1688.cool 原文连接http://blog.ayla1688.cool/archives/413.html 一、创建项目 新建文件夹 test 进入文件夹，在终端执行 go mod init ** go mod init ** 是使用go module 的管理包，前提是设置做了以下设置 GO111MODULE = on GOPROXY=https://goproxy.cn,direct 执行 ** go mod init ** 后， 将在
go的安装、gin安装以及GoLand的配置
xiaojuliet的专栏
01-08 4251
随着开发进行，需要再次获取一份工程项目的源码，此时源码保存在 /home/davy/projectB 目录下，如果此时需要编译 projectB 目录的项目，但开发者忘记设置 GOPATH 而直接使用命令行编译，则当前的 GOPATH 指向的是 /home/davy/projectA 目录，而不是开发者编译时期望的 projectB 目录。注意：如果没有创建"/Users/xll/go"这个目录，安装gin的时候，go get命令会自动创建该目录并将gin安装到"/Users/xll/go/pkg"下；
Go语言中的gin框架之GET/POST请求参数接收传值（五）
06-15
本次请求类型基本都包含了，仅供参考研究。
Golang Gin框架快速入门
最新发布
席万里的博客
05-17 442
Golang Gin框架快速入门
golang（gin 路由初始化 +gorm 初始化及配置）
m0_49827178的博客
12-28 596
主要用于gorm配置及初始化的使用记录
Go get 因被墙下载gin失败
qq_41188944的博客
08-05 2758
现在我们的目标是下载gin， 首先查阅文档，发现安装及其简单，官方给的文档简洁明了。 第一步下载安装： $ go get -u github.com/gin-gonic/gin 第二????步导入： import "github.com/gin-gonic/gin" 然后我们就来了，咦为什么安装过程中各种404呢。思索一下，被墙了，然后去找国内镜像云。 国内镜像云配置方法如下。 其中有四个分别是官方/七牛/其他/阿里。这里一看这里有官方啊，那我们用官方。 # 启用 Go Modules
go学习之路（1）——创建一个gin/gorm项目
weixin_42425391的博客
02-28 454
go语言后端，使用gin搭建简单的项目框架实现
Go语言中的Gin框架的初步使用
ZN175623的博客
11-05 1517
2、这时候如果遇到问题资源加载不了，解决方法是使用代理（这块有个 go env 的命令，可以查看当前配置），在cmd中运行。设置后，重新运行 go get -u github.com/gin-gonic/gin 可以很快速的安装。1、框架文档介绍：go get -u github.com/gin-gonic/gin。Gin RestFul 非常简单。
golang的热加载fresh
qq_39490637的博客
10-08 978
golang热加载fresh
Golang 基于Gin框架搭建的完整脚手架
qq_45061361的博客
09-07 3211
golang gin web脚手架 服务器脚手架 组件封装 工具函数
golang 网络框架之gin的使用方法
09-18
在这个例子中，`gin.New()` 创建了一个新的Gin实例，然后我们定义了一个GET路由`/ping`，当访问这个路由时，会返回“hello world”。`r.Run()` 启动服务器并监听8080端口。 对于更复杂的请求处理，Gin提供了一个名...
golang实战使用gin+xorm搭建go语言web框架详解.pdf
09-19
golang实战使用gin+xorm搭建go语言web框架详解.pdf
Golang-Gin框架示例二十多个源码
04-26
Golang-Gin框架示例二十多个源码，Gin框架应用全面，适合Golang爱好者学习
gin框架安装以及gin的请求路由
01-20
比如在 /e/golang/gin 安装gin 在git命令行中输入mkdir -p $GOPATH/gin1 然后没有报错的话就说明创建成功了，然后进入该文件下：cd $_ ， 由于这个go modules和GOPATH可能是天生不和，如果配置了GOPATH的话，这个go ...
使用go mod 飞速下载 gin,解决go get下载包失败的问题
weixin_44346470的博客
04-03 1790
快速下载gin,排依赖包下载失败的坑
Go配置文件热加载 - 发送系统信号（文末有福利鸭）
360技术
06-06 580
奇技指南在日常项目的开发中，我们经常会使用配置文件来保存项目的基本元数据。今天为大家介绍一下Go配置文件热加载 - 发送系统信号在日常项目的开发中，我们经常会使用配置文件...
Golang热加载配置实践
wenhao的专栏
11-22 5221
前言生产环境上所输出的日志级别较高不利于定位，会碰到这样一种场景，我们改配置修改日志级别，再重启，以期望定位问题，然而问题重启后不浮现了，所以热加载配置有必要添进去。实践直接上代码：package mainimport ( "encoding/json" "fmt" "io/ioutil" "os" "os/signal" "syscall"
gin框架学习-配置文件(config)
Batac的博客
11-11 4181
数据库、redis、fastDFS等处理已配置文件的形式可配置app.json: { "app_name": "Batac", "app_model": "debug", "app_host": "localhost", "app_port": "8080", "sms": { "sign_name": "云裳", "template_code": "YS_123456", "app_key": "", "app_secret": "", "r
Golang基于viper的配置热加载或动态变更方法介绍
Vancl_Wang Blog
11-25 5540
概述   在写web server时，往往需要引入各种各样的配置信息，如依赖的其他中间件（redis、elasticsearch）等，一旦这些服务发生变更，我们需要重新启动web server，以使配置生效。在Golang中，基于viper的动态配置就可以省去这些繁琐的步骤了。接下来用一个示例来说明如何使用viper的配置热加载： 项目结构   首先来看一下整个项目的目录结构: - Dynamic...
golang gin框架 项目实战
05-30
好的，我可以为您提供一些关于使用 Golang Gin 框架进行项目实战的建议。 首先，您需要安装 Golang 和 Gin 框架。安装过程可以参考官方文档进行操作。然后，您可以按照以下步骤进行项目实战： 1. 创建项目结构 在您的 GOPATH 目录下创建一个新的项目文件夹。通常情况下，您需要为项目创建以下子文件夹： ``` . ├── main.go ├── config │ ├── config.go │ └── ... ├── controller │ ├── home_controller.go │ └── ... ├── middleware │ ├── auth.go │ └── ... ├── model │ ├── user.go │ └── ... ├── router │ ├── router.go │ └── ... └── service ├── user_service.go └── ... ``` 2. 创建路由 在 router 文件夹中创建一个 router.go 文件，并编写以下代码： ```go package router import ( "github.com/gin-gonic/gin" "your-project/controller" "your-project/middleware" ) func SetupRouter() *gin.Engine { r := gin.Default() // 中间件 r.Use(middleware.AuthMiddleware()) // 路由 r.GET("/", controller.HomePageHandler) return r } ``` 在上面的代码中，我们使用了 gin 框架中的 gin.Default() 函数来创建一个默认的 gin.Engine 实例，并使用中间件来进行身份验证。然后我们定义了一个路由，将根路径映射到 HomePageHandler 方法。 3. 创建控制器 在 controller 文件夹中创建 home_controller.go 文件，并编写以下代码： ```go package controller import ( "github.com/gin-gonic/gin" "your-project/service" ) func HomePageHandler(c *gin.Context) { users := service.GetAllUsers() c.JSON(200, users) } ``` 在上面的代码中，我们定义了一个 HomePageHandler 方法，它接收一个 gin.Context 对象作为参数，并使用 service 层中的 GetAllUsers 函数获取所有用户的数据。然后我们使用 JSON 方法将数据以 JSON 格式返回给客户端。 4. 创建服务层 在 service 文件夹中创建 user_service.go 文件，并编写以下代码： ```go package service import "your-project/model" func GetAllUsers() []*model.User { // TODO: 查询数据库获取所有用户数据 return []*model.User{} } ``` 在上面的代码中，我们定义了一个 GetAllUsers 函数，它返回一个包含所有用户数据的切片。在实际项目中，我们需要查询数据库来获取这些数据。 5. 创建模型 在 model 文件夹中创建 user.go 文件，并编写以下代码： ```go package model type User struct { ID int `json:"id"` Name string `json:"name"` Age int `json:"age"` } ``` 在上面的代码中，我们定义了一个 User 结构体，它包含三个字段：ID、Name 和 Age。这些字段将用于存储每个用户的信息。 6. 创建配置文件 在 config 文件夹中创建 config.go 文件，并编写以下代码： ```go package config const ( DB_HOST = "localhost" DB_PORT = "3306" DB_USERNAME = "root" DB_PASSWORD = "password" DB_NAME = "your-database-name" ) ``` 在上面的代码中，我们定义了一些常量，用于存储数据库配置信息。这些常量将在连接数据库时使用。 7. 连接数据库 在 service 层中的 GetAllUsers 函数中，我们需要连接数据库来获取所有用户数据。可以使用以下代码来连接 MySQL 数据库： ```go package service import ( "database/sql" "fmt" "your-project/config" "your-project/model" ) func GetAllUsers() []*model.User { // 连接数据库 db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", config.DB_USERNAME, config.DB_PASSWORD, config.DB_HOST, config.DB_PORT, config.DB_NAME, )) if err != nil { panic(err) } defer db.Close() // 查询所有用户数据 rows, err := db.Query("SELECT * FROM users") if err != nil { panic(err) } // 解析查询结果 users := []*model.User{} for rows.Next() { user := &model.User{} err := rows.Scan(&user.ID, &user.Name, &user.Age) if err != nil { panic(err) } users = append(users, user) } return users } ``` 在上面的代码中，我们使用 sql.Open 函数来打开 MySQL 数据库连接。然后我们使用 db.Query 函数来查询所有用户数据，并使用 rows.Scan 函数将查询结果解析为 User 结构体的切片。 以上就是使用 Golang Gin 框架进行项目实战的流程。当然，在实际项目中，您需要根据自己的需求进行相应的修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值