从0开始,用Go语言搭建一个简单的后端业务系统

本文涉及的产品
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云数据库 RDS MySQL,集群系列 2核4GB
推荐场景:
搭建个人博客
云数据库 RDS MySQL,高可用系列 2核4GB
简介: 从0开始,用Go语言搭建一个简单的后端业务系统

Hello 小伙伴们,今天给大家带来了一份Go语言搭建后端业务系统的教程,restful风格哦,既然是简单的业务系统,那么必要的功能就少不了增删改查,也就是传说中的CRUD,当然相比Spring Boot而言,Go语言写后端业务系统不是那么的流行,但是对比一下我们也很容易能发现,Go语言搭建的Web后端系统的优势:

  • (1)内存占用更少
  • (2)启动速度更快
  • (3)代码更加简洁

OK,下面我们开始正文,首先看下完成后的成品吧:

1 业务&技术概括

1.1 业务功能

实体(NumInfo)

  • Id:主键
  • Name :名称
  • InfoKey :Key
  • InfoNum :Num

业务功能

  • 根据Key将Num加1
  • 根据Key查找
  • 根据ID查找
  • 添加一个
  • 根据ID删除一个
  • 查看全部
  • 根据ID修改一个
1.2 技术点

框架

  • Gin
  • Viper
  • GORM

数据库

  • MySQL

前端

  • JQuery
  • layUI

2 接口规范

## 根据Key将Num加1
http://localhost:9888/add/{key}
### req:
http://localhost:9888/add/zs
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":"true"
}
```
## 根据Key查找
http://localhost:9888/findByKey/{key}
### req:
http://localhost:9888/findByKey/zs
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":{
        "id":"1"
        "name":"zs",
        "info_key":"zs",
        "info_num":"12"
  }
}
```
## 根据ID查找
http://localhost:9888/findById/{id}
### req:
http://localhost:9888/findById/1
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":{
        "id":"1"
        "name":"zs",
        "info_key":"zs",
        "info_num":"12"
  }
}
```
## 添加一个
http://localhost:9888/saveInfo
### req:
http://localhost:9888/saveInfo
```json
{
  "name":"ww",
  "info_key":"ww"
}
```
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":"true"
}
```
## 根据ID删除一个
http://localhost:9888/deleteInfo/{id}
### req:
http://localhost:9888/deleteInfo/1
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":"true"
}
```
## 查看全部
http://localhost:9888/getAll
### req:
http://localhost:9888/getAll
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":[{
        "id":"1"
        "name":"zs",
        "info_key":"zs",
        "info_num":"12"
  },{
        "id":"2"
        "name":"ls",
        "info_key":"ls",
        "info_num":"12"
  }]
}
```
## 根据ID修改一个
http://localhost:9888/update
### req:
http://localhost:9888/update
{
    "id":"1"
    "name":"zs",
    "info_key":"zs",
    "info_num":"12"
}
### resp:
```json
{
    "code": "0",
    "msg": "true",
    "count": "0",
    "data":"true"
}
```

3 后端代码

整体结构:

3.1 DAO层

接口

package dao
import (
   "context"
   "count_num/pkg/entity"
)
type CountNumDAO interface {
   //添加一个
   AddNumInfo(ctx context.Context, info entity.NumInfo) bool
   //根据Key获取一个
   GetNumInfoByKey(ctx context.Context, url string) entity.NumInfo
   //查看全部
   FindAllNumInfo(ctx context.Context) []entity.NumInfo
   //根据Key修改
   UpdateNumInfoByKey(ctx context.Context, info entity.NumInfo) bool
   //删除一个
   DeleteNumInfoById(ctx context.Context, id int64) bool
   //根据ID获取一个
   GetNumInfoById(ctx context.Context, id int64) entity.NumInfo
   //根据ID修改
   UpdateNumInfoById(ctx context.Context, info entity.NumInfo) bool
}

实现

package impl
import (
   "context"
   "count_num/pkg/config"
   "count_num/pkg/entity"
   "gorm.io/gorm"
)
type CountNumDAOImpl struct {
   db *gorm.DB
}
func NewCountNumDAOImpl() *CountNumDAOImpl {
   return &CountNumDAOImpl{db: config.DB}
}
func (impl CountNumDAOImpl) AddNumInfo(ctx context.Context, info entity.NumInfo) bool {
   var in entity.NumInfo
   impl.db.First(&in, "info_key", info.InfoKey)
   if in.InfoKey == info.InfoKey { //去重
      return false
   }
   impl.db.Save(&info) //要使用指针
   return true
}
func (impl CountNumDAOImpl) GetNumInfoByKey(ctx context.Context, key string) entity.NumInfo {
   var info entity.NumInfo
   impl.db.First(&info, "info_key", key)
   return info
}
func (impl CountNumDAOImpl) FindAllNumInfo(ctx context.Context) []entity.NumInfo {
   var infos []entity.NumInfo
   impl.db.Find(&infos)
   return infos
}
func (impl CountNumDAOImpl) UpdateNumInfoByKey(ctx context.Context, info entity.NumInfo) bool {
   impl.db.Model(&entity.NumInfo{}).Where("info_key = ?", info.InfoKey).Update("info_num", info.InfoNum)
   return true
}
func (impl CountNumDAOImpl) DeleteNumInfoById(ctx context.Context, id int64) bool {
   impl.db.Delete(&entity.NumInfo{}, id)
   return true
}
func (impl CountNumDAOImpl) GetNumInfoById(ctx context.Context, id int64) entity.NumInfo {
   var info entity.NumInfo
   impl.db.First(&info, "id", id)
   return info
}
func (impl CountNumDAOImpl) UpdateNumInfoById(ctx context.Context, info entity.NumInfo) bool {
   impl.db.Model(&entity.NumInfo{}).Where("id", info.Id).Updates(entity.NumInfo{Name: info.Name, InfoKey: info.InfoKey, InfoNum: info.InfoNum})
   return true
}
3.2 Web层
package controller
import (
   "bytes"
   "count_num/pkg/dao/impl"
   "count_num/pkg/entity"
   "encoding/json"
   "github.com/gin-gonic/gin"
   "github.com/spf13/cast"
   "io/ioutil"
   "strconv"
)
type NumInfoControllerImpl struct {
   dao *impl.CountNumDAOImpl
}
type NumInfoController interface {
   AddNumByKey(c *gin.Context)
   FindNumByKey(c *gin.Context)
   SaveNumInfo(c *gin.Context)
   DeleteById(c *gin.Context)
   FindAll(c *gin.Context)
   FindNumById(c *gin.Context)
   Update(context *gin.Context)
}
func NewNumInfoControllerImpl() *NumInfoControllerImpl {
   return &NumInfoControllerImpl{dao: impl.NewCountNumDAOImpl()}
}
func (impl NumInfoControllerImpl) AddNumByKey(c *gin.Context) {
   key := c.Param("key")
   numInfo := impl.dao.GetNumInfoByKey(c, key)
   numInfo.InfoNum = numInfo.InfoNum + 1
   isOk := impl.dao.UpdateNumInfoByKey(c, numInfo)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": isOk})
}
func (impl NumInfoControllerImpl) FindNumByKey(c *gin.Context) {
   key := c.Param("key")
   numInfo := impl.dao.GetNumInfoByKey(c, key)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": numInfo})
}
func (impl NumInfoControllerImpl) SaveNumInfo(c *gin.Context) {
   body := c.Request.Body
   bytes, err := ioutil.ReadAll(body)
   info := entity.NumInfo{}
   json.Unmarshal(bytes, &info)
   if err != nil {
      panic(err)
   }
   isOk := impl.dao.AddNumInfo(c, info)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": isOk})
}
func (impl NumInfoControllerImpl) DeleteById(c *gin.Context) {
   id := c.Param("id")
   i, _ := strconv.Atoi(id)
   isOk := impl.dao.DeleteNumInfoById(c, int64(i))
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": isOk})
}
func (impl NumInfoControllerImpl) FindAll(c *gin.Context) {
   numInfos := impl.dao.FindAllNumInfo(c)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": len(numInfos), "data": numInfos})
}
func (impl NumInfoControllerImpl) FindNumById(c *gin.Context) {
   id := c.Param("id")
   i, _ := strconv.Atoi(id)
   numInfo := impl.dao.GetNumInfoById(c, int64(i))
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": numInfo})
}
func (impl NumInfoControllerImpl) Update(c *gin.Context) {
   body := c.Request.Body
   jsonBytes, err := ioutil.ReadAll(body)
   d := json.NewDecoder(bytes.NewReader(jsonBytes))
   d.UseNumber()
   m := make(map[string]string)
   d.Decode(&m)
   if err != nil {
      panic(err)
   }
   info := entity.NumInfo{
      Id:      cast.ToInt64(m["id"]),
      Name:    m["name"],
      InfoKey: m["info_key"],
      InfoNum: cast.ToInt64(m["info_num"]),
   }
   isOk := impl.dao.UpdateNumInfoById(c, info)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": isOk})
}

拦截器配置

package interceptor
import (
   "github.com/gin-gonic/gin"
   "log"
)
// HttpInterceptor 自定义拦截器
func HttpInterceptor() gin.HandlerFunc {
   return func(c *gin.Context) {
      // 设置 example 变量
      c.Set("example", "12345")
      // 请求前
      log.Print("--------------拦截器-------------")
      //定义错误,终止并返回该JSON
      //c.AbortWithStatusJSON(500, "error")
      //requestURI := c.Request.RequestURI
      //fmt.Println(requestURI)
      //通过请求
      c.Next()
   }
}

router

package web
import (
   "count_num/pkg/config"
   "count_num/pkg/web/controller"
   "count_num/pkg/web/interceptor"
   "github.com/gin-gonic/gin"
)
func RunHttp() {
   r := gin.Default()
   //增加拦截器
   r.Use(interceptor.HttpInterceptor())
   //解决跨域
   r.Use(config.CorsConfig())
   //路由组
   appInfoGroup := r.Group("/")
   {
      appInfoGroup.POST("/add/:key", controller.NewNumInfoControllerImpl().AddNumByKey)
      appInfoGroup.GET("/findByKey/:key", controller.NewNumInfoControllerImpl().FindNumByKey)
      appInfoGroup.GET("/findById/:id", controller.NewNumInfoControllerImpl().FindNumById)
      appInfoGroup.POST("/saveInfo", controller.NewNumInfoControllerImpl().SaveNumInfo)
      appInfoGroup.POST("/deleteInfo/:id", controller.NewNumInfoControllerImpl().DeleteById)
      appInfoGroup.GET("/getAll", controller.NewNumInfoControllerImpl().FindAll)
      appInfoGroup.POST("/update", controller.NewNumInfoControllerImpl().Update)
   }
   r.Run("127.0.0.1:" + config.PORT)
}
3.3 配置和实体结构体
package config
import (
   "fmt"
   _ "github.com/go-sql-driver/mysql"
   "github.com/spf13/viper"
   "gorm.io/driver/mysql"
   "gorm.io/gorm"
)
var DB *gorm.DB
func init() {
   var err error
   viper.SetConfigName("app")
   viper.SetConfigType("properties")
   viper.AddConfigPath("./")
   err = viper.ReadInConfig()
   if err != nil {
      panic(fmt.Errorf("Fatal error config file: %w \n", err))
   }
   if err := viper.ReadInConfig(); err != nil {
      if _, ok := err.(viper.ConfigFileNotFoundError); ok {
         fmt.Println("No file ...")
      } else {
         fmt.Println("Find file but have err ...")
      }
   }
   PORT = viper.GetString("server.port")
   url := viper.GetString("db.url")
   db := viper.GetString("db.databases")
   username := viper.GetString("db.username")
   password := viper.GetString("db.password")
   dsn := username + ":" + password + "@tcp(" + url + ")/" + db + "?charset=utf8mb4&parseTime=True&loc=Local"
   DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
   if err != nil {
      panic(err)
   }
}

跨域问题

package config
import (
   "github.com/gin-gonic/gin"
   "net/http"
)
var PORT string
func CorsConfig() gin.HandlerFunc {
   return func(c *gin.Context) {
      c.Header("Access-Control-Allow-Origin", "*") // 可将将 * 替换为指定的域名
      c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
      c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")
      c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")
      c.Header("Access-Control-Allow-Credentials", "true")
      c.Writer.Header().Set("Access-Control-Max-Age", "86400")
      if c.Request.Method == http.MethodOptions {
         c.AbortWithStatus(200)
      } else {
         c.Next()
      }
   }
}

实体

package entity
type NumInfo struct {
   Id      int64  `json:"id"`
   Name    string `json:"name"`
   InfoKey string `json:"info_key"`
   InfoNum int64  `json:"info_num"`
}
func (stu NumInfo) TableName() string {
   return "num_info"
}
3.4 启动主函数
package main
import "count_num/pkg/web"
func main() {
   web.RunHttp()
}
3.5 配置文件和SQL
server.port=9888
db.driver=mysql
db.url=127.0.0.1:3306
db.databases=test
db.username=root
db.password=12345

SQL文件

CREATE TABLE `num_info`
(
    `id`       int(11) NOT NULL AUTO_INCREMENT,
    `name`     varchar(255) DEFAULT NULL,
    `info_key` varchar(255) NOT NULL,
    `info_num` int(11) DEFAULT NULL,
    PRIMARY KEY (`id`, `info_key`)
) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;

4 前端代码

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>后台管理</title>
    <link rel="stylesheet" href="./layui/css/layui.css">
</head>
<body>
<div style="margin-left: 220px;position: absolute;top: 70px;width: 80%;">
    <button class="layui-btn layui-btn-normal" id="add_btn" lay-filter="add_btn">添加一个</button>
    <table id="demo" lay-filter="test"></table>
</div>
<script src="./layui/layui.js"></script>
<script src="./layui/jquery.min.js"></script>
<script>
    var base_url = 'http://localhost:9888'
    
    layui.use('element', function () {
        var element = layui.element;
    });
    layui.use('table', function () {
        var table = layui.table;
        //第一个实例
        table.render({
            elem: '#demo'
            , height: 500
            , url: base_url + '/getAll' //数据接口
            , page: false //开启分页
            , cols: [[ //表头
                {field: 'id', title: 'ID', width: '10%'}
                , {field: 'name', title: '名称', width: '30%'}
                , {field: 'info_key', title: '标记', sort: true, width: '20%'}
                , {field: 'info_num', title: '次数', width: '20%', sort: true}
                , {title: '操作', width: '20%', toolbar: '#barDemo'}
            ]]
        });
        //工具条事件
        table.on('tool(test)', function (obj) { 
            var data = obj.data; 
            var layEvent = obj.event; 
            var tr = obj.tr; 
            if ('edit' == layEvent) {
                layer.open({
                    title: '编辑',
                    type: 1,
                    content: '<form class="layui-form" style="margin-top: 20px;margin-right: 60px;">' +
                        '  <div class="layui-form-item">\n' +
                        '    <label class="layui-form-label">名称</label>\n' +
                        '    <div class="layui-input-inline">\n' +
                        '      <input type="text" class="layui-input" id="u_name" value="' + data.name + '">\n' +
                        '    </div>\n' +
                        '  </div>' +
                        '  <div class="layui-form-item">\n' +
                        '    <label class="layui-form-label">标记</label>\n' +
                        '    <div class="layui-input-inline">\n' +
                        '      <input type="text" class="layui-input" id="u_key" value="' + data.info_key + '">\n' +
                        '    </div>\n' +
                        '  </div>' +
                        '  <div class="layui-form-item">\n' +
                        '    <label class="layui-form-label">次数</label>\n' +
                        '    <div class="layui-input-inline">\n' +
                        '      <input type="text"  class="layui-input" id="u_num" value="' + data.info_num + '">\n' +
                        '    </div>\n' +
                        '  </div>' +
                        '<div class="layui-form-item">\n' +
                        '    <div class="layui-input-block">\n' +
                        '      <button class="layui-btn" type="button" οnclick="update()">确定修改</button>\n' +
                        '      <button type="reset" class="layui-btn layui-btn-primary">重置</button>\n' +
                        '    </div>\n' +
                        '  </div>' +
                        '  <input style="display: none;" id="u_id" value="' + data.id + '">' +
                        '</form>'
                });
            } else if ('del' == layEvent) {
                layer.confirm('确定删除吗?', function (index) {
                    //点击确认时执行
                    $.ajax({
                        url: base_url + '/deleteInfo/'+data.id,
                        type: 'POST',
                        success: function (r) {
                            if (r.data) {
                                location.reload();
                            }
                        }
                    })
                    layer.close(index);
                });
            }
        });
    });
    $('#add_btn').on('click', function () {
        layer.open({
            title: '添加',
            type: 1,
            content: '<form class="layui-form" style="margin-top: 20px;margin-right: 60px;">' +
                '  <div class="layui-form-item">\n' +
                '    <label class="layui-form-label">名称</label>\n' +
                '    <div class="layui-input-inline">\n' +
                '      <input type="text" class="layui-input" id="s_name">\n' +
                '    </div>\n' +
                '  </div>' +
                '  <div class="layui-form-item">\n' +
                '    <label class="layui-form-label">标记</label>\n' +
                '    <div class="layui-input-inline">\n' +
                '      <input type="text" class="layui-input" id="s_key">\n' +
                '    </div>\n' +
                '  </div>' +
                '<div class="layui-form-item">\n' +
                '    <div class="layui-input-block">\n' +
                '      <button class="layui-btn" οnclick="save()" type="button">立即提交</button>\n' +
                '      <button type="reset" class="layui-btn layui-btn-primary">重置</button>\n' +
                '    </div>\n' +
                '  </div>' +
                '</form>'
        });
    });
</script>
<script>
    function save() {
        var name = $("#s_name").val();
        var key = $("#s_key").val();
        $.ajax({
            url: base_url + '/saveInfo',
            type: 'POST',
            data: JSON.stringify({"name": name, "info_key": key}),  
            contentType: 'application/json',
            success: function (r) {
                if (r.data) {
                    location.reload();
                }
            }
        })
    }
    function update() {
        var id = $("#u_id").val();
        var name = $("#u_name").val();
        var key = $("#u_key").val();
        var num = $("#u_num").val();
        $.ajax({
            url: base_url + '/update',
            type: 'POST',
            data: JSON.stringify({"id": id, "name": name, "info_key": key, "info_num": num}),   
            contentType: 'application/json',
            success: function (r) {
                if (r.data) {
                    location.reload();
                }
            }
        })
    }
</script>
<script type="text/html" id="barDemo">
    <a class="layui-btn layui-btn-xs" lay-event="edit">编辑</a>
    <a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del">删除</a>
</script>
</body>
</html>

5 遇见的问题及排查方式

5.1 GORM的使用问题
5.1.1 自定义表名
func (stu NumInfo) TableName() string {
   return "num_info"
}
5.1.2 主键自增
impl.db.Save(&info) //要使用指针
5.2 跨域问题
func CorsConfig() gin.HandlerFunc {
   return func(c *gin.Context) {
      c.Header("Access-Control-Allow-Origin", "*") // 可将将 * 替换为指定的域名
      c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
      c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")
      c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")
      c.Header("Access-Control-Allow-Credentials", "true")
      c.Writer.Header().Set("Access-Control-Max-Age", "86400")
      if c.Request.Method == http.MethodOptions {
         c.AbortWithStatus(200)
      } else {
         c.Next()
      }
   }
}

在Gin中解决跨域问题

func RunHttp() {
   r := gin.Default()
   ......
   //解决跨域
   r.Use(config.CorsConfig())
   ......
   r.Run("127.0.0.1:" + config.PORT)
}
5.3 JSON字段转int64失效问题
func (impl NumInfoControllerImpl) Update(c *gin.Context) {
   body := c.Request.Body
   jsonBytes, err := ioutil.ReadAll(body)
   //先将JSON转为Map
   d := json.NewDecoder(bytes.NewReader(jsonBytes))
   d.UseNumber()
   m := make(map[string]string)
   d.Decode(&m)
   if err != nil {
      panic(err)
   }
   //再将Map转为实体
   info := entity.NumInfo{
      Id:      cast.ToInt64(m["id"]),
      Name:    m["name"],
      InfoKey: m["info_key"],
      InfoNum: cast.ToInt64(m["info_num"]),
   }
   isOk := impl.dao.UpdateNumInfoById(c, info)
   c.JSON(200, map[string]interface{}{"code": 0, "msg": "", "count": 0, "data": isOk})
}

6 总结

好了,今天的分享就到这里,虽然学习了很长时间的Go语言,但是搭建这样较为完整的业务系统的机会不是很多,过程中也遇到了几个问题,但是都利用官方文档或搜索引擎独立的解决了。

当然目前的后端业务系统只支持restful风格的Http请求,如果后续有时间的话还会增加相同功能的rpc接口来做扩展,相关的GitHub地址分享给大家,如果有哪些地方需要改良和优化,还大家请多多指教!

源码获取方式:关注公众号[ 扯编程的淡 ],回复:0615

相关实践学习
如何在云端创建MySQL数据库
开始实验后,系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心,利用清洁计算为万物互联的新世界提供源源不断的能源动力,目前开服的区域包括中国(华北、华东、华南、香港)、新加坡、美国(美东、美西)、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程,来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品:云服务器ECS 云服务器 ECS(Elastic Compute Service)是一种弹性可伸缩的计算服务,助您降低 IT 成本,提升运维效率,使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
相关文章
|
10天前
|
存储 JSON 监控
Viper,一个Go语言配置管理神器!
Viper 是一个功能强大的 Go 语言配置管理库,支持从多种来源读取配置,包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法,包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
30 2
|
9天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
19 2
|
9天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
21 2
|
4天前
|
Go API 数据库
Go 语言中常用的 ORM 框架,如 GORM、XORM 和 BeeORM,分析了它们的特点、优势及不足,并从功能特性、性能表现、易用性和社区活跃度等方面进行了比较,旨在帮助开发者根据项目需求选择合适的 ORM 框架。
本文介绍了 Go 语言中常用的 ORM 框架,如 GORM、XORM 和 BeeORM,分析了它们的特点、优势及不足,并从功能特性、性能表现、易用性和社区活跃度等方面进行了比较,旨在帮助开发者根据项目需求选择合适的 ORM 框架。
18 4
|
4天前
|
缓存 监控 前端开发
在 Go 语言中实现 WebSocket 实时通信的应用,包括 WebSocket 的简介、Go 语言的优势、基本实现步骤、应用案例、注意事项及性能优化策略,旨在帮助开发者构建高效稳定的实时通信系统
本文深入探讨了在 Go 语言中实现 WebSocket 实时通信的应用,包括 WebSocket 的简介、Go 语言的优势、基本实现步骤、应用案例、注意事项及性能优化策略,旨在帮助开发者构建高效稳定的实时通信系统。
28 1
|
7天前
|
Go
go语言中的continue 语句
go语言中的continue 语句
17 3
|
8天前
|
安全 Go 调度
探索Go语言的并发模型:goroutine与channel
在这个快节奏的技术世界中,Go语言以其简洁的并发模型脱颖而出。本文将带你深入了解Go语言的goroutine和channel,这两个核心特性如何协同工作,以实现高效、简洁的并发编程。
|
9天前
|
Go
go语言中的 跳转语句
【11月更文挑战第4天】
17 4
|
9天前
|
JSON 安全 Go
Go语言中使用JWT鉴权、Token刷新完整示例,拿去直接用!
本文介绍了如何在 Go 语言中使用 Gin 框架实现 JWT 用户认证和安全保护。JWT(JSON Web Token)是一种轻量、高效的认证与授权解决方案,特别适合微服务架构。文章详细讲解了 JWT 的基本概念、结构以及如何在 Gin 中生成、解析和刷新 JWT。通过示例代码,展示了如何在实际项目中应用 JWT,确保用户身份验证和数据安全。完整代码可在 GitHub 仓库中查看。
42 1
|
2天前
|
存储 Go PHP
Go语言中的加解密利器:go-crypto库全解析
在软件开发中,数据安全和隐私保护至关重要。`go-crypto` 是一个专为 Golang 设计的加密解密工具库,支持 AES 和 RSA 等加密算法,帮助开发者轻松实现数据的加密和解密,保障数据传输和存储的安全性。本文将详细介绍 `go-crypto` 的安装、特性及应用实例。
12 0