经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
快速搭建一个go语言web后端服务脚手架
来源：cnblogs　　作者：秋玻　　时间：2023/4/12 13:38:14　　对本文有异议

快速搭建一个go语言web后端服务脚手架
源码：https://github.com/weloe/go-web-demo

web框架使用gin，数据操作使用gorm，访问控制使用casbin

首先添加一下自定义的middleware

recover_control.go ，统一处理panic error返回的信息

  1. package middleware
  3. import (
  4. 	"fmt"
  5. 	"github.com/gin-gonic/gin"
  6. 	"go-web-demo/component"
  7. 	"log"
  8. 	"net/http"
  9. )
  11. func Recover(c *gin.Context) {
  12. 	defer func() {
  13. 		if r := recover(); r != nil {
  14. 			// print err msg
  15. 			log.Printf("panic: %v\n", r)
  16. 			// debug.PrintStack()
  17. 			// response same struct
  18. 			c.JSON(http.StatusBadRequest, component.RestResponse{Code: -1, Message: fmt.Sprintf("%v", r)})
  19. 		}
  20. 	}()
  22. 	c.Next()
  23. }

access_control.go 使用casbin进行访问控制的中间件

  1. package middleware
  3. import (
  4. 	"fmt"
  5. 	"github.com/casbin/casbin/v2"
  6. 	gormadapter "github.com/casbin/gorm-adapter/v3"
  7. 	"github.com/gin-gonic/gin"
  8. 	_ "github.com/go-sql-driver/mysql"
  9. 	"go-web-demo/component"
  10. 	"log"
  11. 	"net/http"
  12. )
  14. // DefaultAuthorize determines if current subject has been authorized to take an action on an object.
  15. func DefaultAuthorize(obj string, act string) gin.HandlerFunc {
  16. 	return func(c *gin.Context) {
  18. 		// Get current user/subject
  19. 		token := c.Request.Header.Get("token")
  20. 		if token == "" {
  21. 			c.AbortWithStatusJSON(http.StatusUnauthorized, component.RestResponse{Message: "token is nil"})
  22. 			return
  23. 		}
  24. 		username, err := component.GlobalCache.Get(token)
  25. 		if err != nil || string(username) == "" {
  26. 			log.Println(err)
  27. 			c.AbortWithStatusJSON(http.StatusUnauthorized, component.RestResponse{Message: "user hasn't logged in yet"})
  28. 			return
  29. 		}
  31. 		// Casbin enforces policy
  32. 		ok, err := enforce(string(username), obj, act, component.Enforcer)
  33. 		if err != nil {
  34. 			log.Println(err)
  35. 			c.AbortWithStatusJSON(http.StatusInternalServerError, component.RestResponse{Message: "error occurred when authorizing user"})
  36. 			return
  37. 		}
  38. 		if !ok {
  39. 			c.AbortWithStatusJSON(http.StatusForbidden, component.RestResponse{Message: "forbidden"})
  40. 			return
  41. 		}
  43. 		c.Next()
  44. 	}
  45. }
  47. func enforce(sub string, obj string, act string, enforcer *casbin.Enforcer) (bool, error) {
  48. 	// Load policies from DB dynamically
  49. 	err := enforcer.LoadPolicy()
  50. 	if err != nil {
  51. 		return false, fmt.Errorf("failed to load policy from DB: %w", err)
  52. 	}
  53. 	// Verify
  54. 	ok, err := enforcer.Enforce(sub, obj, act)
  55. 	return ok, err
  56. }
  58. func AuthorizeAdapterAndModel(obj string, act string, adapter *gormadapter.Adapter, model string) gin.HandlerFunc {
  59. 	return func(c *gin.Context) {
  61. 		// Get current user/subject
  62. 		token := c.Request.Header.Get("token")
  63. 		if token == "" {
  64. 			c.AbortWithStatusJSON(401, component.RestResponse{Message: "token is nil"})
  65. 			return
  66. 		}
  67. 		username, err := component.GlobalCache.Get(token)
  68. 		if err != nil || string(username) == "" {
  69. 			log.Println(err)
  70. 			c.AbortWithStatusJSON(401, component.RestResponse{Message: "user hasn't logged in yet"})
  71. 			return
  72. 		}
  74. 		// Load model configuration file and policy store adapter
  75. 		enforcer, err := casbin.NewEnforcer(model, adapter)
  76. 		// Casbin enforces policy
  77. 		ok, err := enforce(string(username), obj, act, enforcer)
  79. 		if err != nil {
  80. 			log.Println(err)
  81. 			c.AbortWithStatusJSON(500, component.RestResponse{Message: "error occurred when authorizing user"})
  82. 			return
  83. 		}
  84. 		if !ok {
  85. 			c.AbortWithStatusJSON(403, component.RestResponse{Message: "forbidden"})
  86. 			return
  87. 		}
  89. 		c.Next()
  90. 	}
  91. }

reader.go 读取yaml配置文件的根据类，使用了viter

  1. package config
  3. import (
  4. 	"fmt"
  5. 	"github.com/spf13/viper"
  6. 	"log"
  7. 	"sync"
  8. 	"time"
  9. )
  11. type Config struct {
  12. 	Server     *Server
  13. 	Mysql      *DB
  14. 	LocalCache *LocalCache
  15. 	Casbin     *Casbin
  16. }
  18. type Server struct {
  19. 	Port int64
  20. }
  22. type DB struct {
  23. 	Username string
  24. 	Password string
  25. 	Host     string
  26. 	Port     int64
  27. 	Dbname   string
  28. 	TimeOut  string
  29. }
  31. type LocalCache struct {
  32. 	ExpireTime time.Duration
  33. }
  35. type Casbin struct {
  36. 	Model string
  37. }
  39. var (
  40. 	once   sync.Once
  41. 	Reader = new(Config)
  42. )
  44. func (config *Config) ReadConfig() *Config {
  45. 	once.Do(func() {
  46. 		viper.SetConfigName("config")   // filename
  47. 		viper.SetConfigType("yaml")     // filename extension : yaml | json |
  48. 		viper.AddConfigPath("./config") // workspace dir : ./
  49. 		var err error
  50. 		err = viper.ReadInConfig() // read config
  51. 		if err != nil {            // handler err
  52. 			log.Fatalf(fmt.Sprintf("Fatal error config file: %s \n", err))
  53. 		}
  54. 		err = viper.Unmarshal(config)
  55. 		if err != nil {
  56. 			log.Fatalf(fmt.Sprintf("Fatal error viper unmarshal config: %s \n", err))
  57. 		}
  58. 	})
  59. 	return Reader
  60. }

配置文件

  1. server:
  2.   port: 8080
  4. mysql:
  5.   username: root
  6.   password: pwd
  7.   host: 127.0.0.1
  8.   port: 3306
  9.   dbname: casbin_demo
  10.   timeout: 10s
  12. localCache:
  13.   expireTime: 60
  15. casbin:
  16.   model: config/rbac_model.conf

persistence.go， gorm，bigcache, casbin 初始化，这里用的casbin是从数据库读取policy

  1. package component
  3. import (
  4. 	"fmt"
  5. 	"github.com/allegro/bigcache"
  6. 	"github.com/casbin/casbin/v2"
  7. 	gormadapter "github.com/casbin/gorm-adapter/v3"
  8. 	_ "github.com/go-sql-driver/mysql"
  9. 	"go-web-demo/config"
  10. 	"gorm.io/driver/mysql"
  11. 	"gorm.io/gorm"
  12. 	"log"
  13. 	"time"
  14. )
  16. var (
  17. 	DB          *gorm.DB
  18. 	GlobalCache *bigcache.BigCache
  19. 	Enforcer    *casbin.Enforcer
  20. )
  22. // CreateByConfig create components
  23. func CreateByConfig() {
  25. 	ConnectDB()
  27. 	CreateLocalCache()
  29. 	CreateCasbinEnforcer()
  30. }
  32. func ConnectDB() {
  33. 	// connect to DB
  34. 	var err error
  35. 	dbConfig := config.Reader.ReadConfig().Mysql
  36. 	if dbConfig == nil {
  37. 		log.Fatalf(fmt.Sprintf("db config is nil"))
  38. 	}
  39. 	// config
  40. 	username := dbConfig.Username
  41. 	password := dbConfig.Password
  42. 	host := dbConfig.Host
  43. 	port := dbConfig.Port
  44. 	Dbname := dbConfig.Dbname
  45. 	timeout := dbConfig.TimeOut
  47. 	dbUrl := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local&timeout=%s", username, password, host, port, Dbname, timeout)
  48. 	log.Println("connect db url: " + dbUrl)
  49. 	DB, err = gorm.Open(mysql.Open(dbUrl), &gorm.Config{})
  51. 	if err != nil {
  52. 		log.Fatalf(fmt.Sprintf("failed to connect to DB: %v", err))
  53. 	}
  54. }
  56. func CreateLocalCache() {
  57. 	var err error
  58. 	cacheConfig := config.Reader.ReadConfig().LocalCache
  59. 	if cacheConfig == nil {
  60. 		log.Fatalf(fmt.Sprintf("cache config is nil"))
  61. 	}
  62. 	// Initialize cache to store current user in cache.
  63. 	GlobalCache, err = bigcache.NewBigCache(bigcache.DefaultConfig(cacheConfig.ExpireTime * time.Second)) // Set expire time to 30 s
  64. 	if err != nil {
  65. 		log.Fatalf(fmt.Sprintf("failed to initialize cahce: %v", err))
  66. 	}
  67. }
  69. func CreateCasbinEnforcer() {
  70. 	var err error
  72. 	// casbin model
  73. 	config := config.Reader.ReadConfig().Casbin
  74. 	if config == nil {
  75. 		log.Fatalf(fmt.Sprintf("casbin config is nil"))
  76. 	}
  77. 	model := config.Model
  78. 	//Initialize casbin adapter
  79. 	adapter, _ := gormadapter.NewAdapterByDB(DB)
  81. 	// Load model configuration file and policy store adapter
  82. 	Enforcer, err = casbin.NewEnforcer(model, adapter)
  83. 	if err != nil {
  84. 		log.Fatalf(fmt.Sprintf("failed to create casbin enforcer: %v", err))
  85. 	}
  86.     
  87. }

到这里准备工作基本完成，我们来写一个通用的 登录，注册，退出 业务吧

user_handler.go

  1. package handler
  3. import (
  4. 	"fmt"
  5. 	"github.com/gin-gonic/gin"
  6. 	"github.com/gin-gonic/gin/binding"
  7. 	"go-web-demo/component"
  8. 	"go-web-demo/handler/request"
  9. 	"go-web-demo/service"
  10. 	"net/http"
  11. )
  13. func Login(c *gin.Context) {
  14. 	loginRequest := &request.Login{}
  15. 	err := c.ShouldBindBodyWith(loginRequest, binding.JSON)
  16. 	if err != nil {
  17. 		panic(fmt.Errorf("request body bind error: %v", err))
  18. 	}
  19. 	token := service.Login(loginRequest)
  21. 	c.JSON(http.StatusOK, component.RestResponse{Code: 1, Data: token, Message: loginRequest.Username + " logged in successfully"})
  23. }
  25. func Logout(c *gin.Context) {
  26. 	token := c.Request.Header.Get("token")
  28. 	if token == "" {
  29. 		panic(fmt.Errorf("token error: token is nil"))
  30. 	}
  32. 	bytes, err := component.GlobalCache.Get(token)
  34. 	if err != nil {
  35. 		panic(fmt.Errorf("token error: failed to get username: %v", err))
  36. 	}
  38. 	username := string(bytes)
  39. 	// Authentication
  41. 	// Delete store current subject in cache
  42. 	err = component.GlobalCache.Delete(token)
  43. 	if err != nil {
  44. 		panic(fmt.Errorf("failed to delete current subject in cache: %w", err))
  45. 	}
  47. 	c.JSON(http.StatusOK, component.RestResponse{Code: 1, Data: token, Message: username + " logout in successfully"})
  48. }
  50. func Register(c *gin.Context) {
  51. 	register := &request.Register{}
  52. 	err := c.ShouldBindBodyWith(register, binding.JSON)
  53. 	if err != nil {
  54. 		c.JSON(400, component.RestResponse{Code: -1, Message: " bind error"})
  55. 		return
  56. 	}
  58. 	service.Register(register)
  60. 	c.JSON(http.StatusOK, component.RestResponse{Code: 1, Data: nil, Message: "register successfully"})
  61. }

service.user.go

这里要注意 注册的时候我们做了两个操作，注册到user表，把policy写入到casbin_rule表，要保证他们要同时成功，所以要用事务

  1. func Login(loginRequest *request.Login) string {
  2. 	password := loginRequest.Password
  3. 	username := loginRequest.Username
  5. 	// Authentication
  6. 	user := dao.GetByUsername(username)
  7. 	if password != user.Password {
  8. 		panic(fmt.Errorf(username + " logged error : password error"))
  9. 	}
  11. 	// Generate random uuid token
  12. 	u, err := uuid.NewRandom()
  13. 	if err != nil {
  14. 		panic(fmt.Errorf("failed to generate UUID: %w", err))
  15. 	}
  16. 	// Sprintf token
  17. 	token := fmt.Sprintf("%s-%s", u.String(), "token")
  18. 	// Store current subject in cache
  19. 	err = component.GlobalCache.Set(token, []byte(username))
  20. 	if err != nil {
  21. 		panic(fmt.Errorf("failed to store current subject in cache: %w", err))
  22. 	}
  23. 	// Send cache key back to client cookie
  24. 	//c.SetCookie("current_subject", token, 30*60, "/resource", "", false, true)
  25. 	return token
  26. }
  28. func Register(register *request.Register) {
  29. 	var err error
  30. 	e := component.Enforcer
  31. 	err = e.GetAdapter().(*gormadapter.Adapter).Transaction(e, func(copyEnforcer casbin.IEnforcer) error {
  32. 		// Insert to table
  33. 		db := copyEnforcer.GetAdapter().(*gormadapter.Adapter).GetDb()
  34. 		res := db.Exec("insert into user (username,password) values(?,?)", register.Username, register.Password)
  36. 		//User has Username and Password
  37. 		//res := db.Table("user").Create(&User{
  38. 		//	Username: register.Username,
  39. 		//	Password: register.Password,
  40. 		//})
  42. 		if err != nil || res.RowsAffected < 1 {
  43. 			return fmt.Errorf("insert error: %w", err)
  44. 		}
  46. 		_, err = copyEnforcer.AddRoleForUser(register.Username, "role::user")
  47. 		if err != nil {
  48. 			return fmt.Errorf("add plocy error: %w", err)
  49. 		}
  50. 		return nil
  51. 	})
  53. 	if err != nil {
  54. 		panic(err)
  55. 	}
  57. }

dao.user.go 对数据库的操作

  1. package dao
  3. import "go-web-demo/component"
  5. type User struct {
  6. 	Id       int64 `gorm:"primaryKey"`
  7. 	Username string
  8. 	Password string
  9. 	Email    string
  10. 	Phone    string
  11. }
  13. func (u *User) TableName() string {
  14. 	return "user"
  15. }
  17. func GetByUsername(username string) *User {
  18. 	res := new(User)
  19. 	component.DB.Model(&User{}).Where("username = ?", username).First(res)
  20. 	return res
  21. }
  23. func Insert(username string, password string) (int64, error, int64) {
  24. 	user := &User{Username: username, Password: password}
  25. 	res := component.DB.Create(&user)
  27. 	return user.Id, res.Error, res.RowsAffected
  28. }

最后一步，启动web服务，配置路由

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"github.com/gin-contrib/cors"
  6. 	"github.com/gin-gonic/gin"
  7. 	"go-web-demo/component"
  8. 	"go-web-demo/config"
  9. 	"go-web-demo/handler"
  10. 	"go-web-demo/middleware"
  11. 	"log"
  12. )
  14. var (
  15. 	router *gin.Engine
  16. )
  18. func init() {
  19. 	//Initialize components from config yaml: mysql locaCache casbin
  20. 	component.CreateByConfig()
  22. 	// Initialize gin engine
  23. 	router = gin.Default()
  25. 	// Initialize gin middleware
  26. 	corsConfig := cors.DefaultConfig()
  27. 	corsConfig.AllowAllOrigins = true
  28. 	corsConfig.AllowCredentials = true
  29. 	router.Use(cors.New(corsConfig))
  30. 	router.Use(middleware.Recover)
  32. 	// Initialize gin router
  33. 	user := router.Group("/user")
  34. 	{
  35. 		user.POST("/login", handler.Login)
  36. 		user.POST("/logout", handler.Logout)
  37. 		user.POST("/register", handler.Register)
  38. 	}
  40. 	resource := router.Group("/api")
  41. 	{
  42. 		resource.Use(middleware.DefaultAuthorize("user::resource", "read-write"))
  43. 		resource.GET("/resource", handler.ReadResource)
  44. 		resource.POST("/resource", handler.WriteResource)
  45. 	}
  47. }
  49. func main() {
  50. 	// Start
  51. 	port := config.Reader.Server.Port
  52. 	err := router.Run(":" + port)
  53. 	if err != nil {
  54. 		panic(fmt.Sprintf("failed to start gin engine: %v", err))
  55. 	}
  56. 	log.Println("application is now running...")
  57. }

表结构和相关测试数据

  1. CREATE DATABASE /*!32312 IF NOT EXISTS*/`casbin_demo` /*!40100 DEFAULT CHARACTER SET utf8 */;
  3. USE `casbin_demo`;
  5. /*Table structure for table `casbin_rule` */
  7. DROP TABLE IF EXISTS `casbin_rule`;
  9. CREATE TABLE `casbin_rule` (
  10.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  11.   `ptype` varchar(100) NOT NULL,
  12.   `v0` varchar(100) DEFAULT NULL,
  13.   `v1` varchar(100) DEFAULT NULL,
  14.   `v2` varchar(100) DEFAULT NULL,
  15.   `v3` varchar(100) DEFAULT NULL,
  16.   `v4` varchar(100) DEFAULT NULL,
  17.   `v5` varchar(100) DEFAULT NULL,
  18.   PRIMARY KEY (`id`),
  19.   UNIQUE KEY `idx_casbin_rule` (`v0`,`v1`,`v2`,`v3`,`v4`,`v5`)
  20. ) ENGINE=InnoDB AUTO_INCREMENT=64 DEFAULT CHARSET=utf8;
  22. /*Data for the table `casbin_rule` */
  24. insert  into `casbin_rule`(`id`,`ptype`,`v0`,`v1`,`v2`,`v3`,`v4`,`v5`) values 
  26. (3,'p','role::admin','admin::resource','read-write','','',''),
  28. (5,'p','role::user','user::resource','read-write','','',''),
  30. (57,'g','test1','role::user','','','',''),
  32. (59,'g','role::admin','role::user','','','',''),
  34. (63,'g','test2','role::admin',NULL,NULL,NULL,NULL);
  36. /*Table structure for table `user` */
  38. DROP TABLE IF EXISTS `user`;
  40. CREATE TABLE `user` (
  41.   `id` int(11) NOT NULL AUTO_INCREMENT,
  42.   `username` varchar(50) DEFAULT NULL,
  43.   `password` varchar(50) DEFAULT NULL,
  44.   `email` varchar(50) DEFAULT NULL,
  45.   `phone` varchar(50) DEFAULT NULL,
  46.   PRIMARY KEY (`id`)
  47. ) ENGINE=InnoDB AUTO_INCREMENT=39 DEFAULT CHARSET=utf8;
  49. /*Data for the table `user` */
  51. insert  into `user`(`id`,`username`,`password`,`email`,`phone`) values 
  53. (36,'test1','123',NULL,NULL),
  55. (38,'test2','123',NULL,NULL);

原文链接：https://www.cnblogs.com/weloe/p/17309521.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang&nbsp;模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K &#127775; 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号