快速搭建一个go语言web后端服务脚手架

快速搭建一个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);

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！