彩虹女神跃长空,Go语言进阶之Go语言高性能Web框架Iris项目实战-项目结构优 ...

前文再续，上一回我们完成了用户管理模块的CURD(增删改查)功能，功能层面，无甚大观，但有一个结构性的缺陷显而易见，那就是项目结构过度耦合，项目的耦合性(Coupling)，也叫耦合度，进而言之，模块之间的关系，是对项目结构中各模块间相互联系紧密程度的一种量化。耦合的强弱取决于模块间调用的复杂性、调用模块之间的方式以及通过函数或者方法传送数据对象的多少。模块间的耦合度是指模块之间的依赖关系，包括包含关系、控制关系、调用关系、数据传递关系以及依赖关系。项目模块的相互依赖越多，其耦合性越强，同时表明其独立性越差，愈加难以维护。
项目结构优化

目前IrisBlog项目的问题就是独立性太差，截至目前为止，项目结构如下：

1. .  
2. ├── README.md  
3. ├── assets  
4. │ ├── css  
5. │ │ └── style.css  
6. │ └── js  
7. │     ├── axios.js  
8. │     └── vue.js  
9. ├── favicon.ico  
10. ├── go.mod  
11. ├── go.sum  
12. ├── main.go  
13. ├── model  
14. │ └── model.go  
15. ├── mytool  
16. │ └── mytool.go  
17. ├── tmp  
18. │ └── runner-build  
19. └── views  
20.     ├── admin  
21.     │ └── user.html  
22.     ├── index.html  
23.     └── test.html

复制代码

一望而知，前端页面(views)以及静态文件(assets)的工程化尚可，不再需要进行分层操作，但是在后端，虽然模型层(model.go)和工具层(mytool.go)已经分离出主模块，但主要业务代码还是集中在入口文件main.go中：

1. package main  
2.   
3. import (  
4.           
5.         "IrisBlog/model"  
6.         "IrisBlog/mytool"  
7.   
8.         "fmt"  
9.   
10.         "github.com/jinzhu/gorm"  
11.   
12.         _ "github.com/jinzhu/gorm/dialects/mysql"  
13.         "github.com/kataras/iris/v12"  
14. )  
15.   
16. func main() {  
17.   
18.         db, err := gorm.Open("mysql", "root:root@(localhost)/irisblog?charset=utf8mb4&parseTime=True&loc=Local")  
19.   
20.         if err != nil {  
21.                 fmt.Println(err)  
22.                 panic("无法连接数据库")  
23.         }  
24.         fmt.Println("连接数据库成功")  
25.   
26.         //单数模式  
27.         db.SingularTable(true)  
28.   
29.         // 创建默认表  
30.         db.AutoMigrate(&model.User{})  
31.   
32.         // 逻辑结束后关闭数据库  
33.         defer func() {  
34.                 _ = db.Close()  
35.         }()  
36.   
37.         app := newApp(db)  
38.   
39.         app.HandleDir("/assets", iris.Dir("./assets"))  
40.         app.Favicon("./favicon.ico")  
41.         app.Listen(":5000")  
42. }  
43.   
44. func newApp(db *gorm.DB) *iris.Application {  
45.   
46.         app := iris.New()  
47.   
48.         tmpl := iris.HTML("./views", ".html")  
49.         // Set custom delimeters.  
50.         tmpl.Delims("${", "}")  
51.         // Enable re-build on local template files changes.  
52.         tmpl.Reload(true)  
53.   
54.         app.RegisterView(tmpl)  
55.   
56.           
57.   
58.         app.Delete("/admin/user_action/", func(ctx iris.Context) {  
59.   
60.                 ID := ctx.URLParamIntDefault("id", 0)  
61.   
62.                 db.Delete(&model.User{}, ID)  
63.   
64.                 ret := map[string]string{  
65.                         "errcode": "0",  
66.                         "msg":     "删除用户成功",  
67.                 }  
68.                 ctx.JSON(ret)  
69.   
70.         })  
71.   
72.         app.Put("/admin/user_action/", func(ctx iris.Context) {  
73.   
74.                 ID := ctx.PostValue("id")  
75.                 Password := ctx.PostValue("password")  
76.   
77.                 user := &model.User{}  
78.                 db.First(&user, ID)  
79.   
80.                 user.Password = mytool.Make_password(Password)  
81.                 db.Save(&user)  
82.   
83.                 ret := map[string]string{  
84.                         "errcode": "0",  
85.                         "msg":     "更新密码成功",  
86.                 }  
87.                 ctx.JSON(ret)  
88.   
89.         })  
90.   
91.         app.Post("/admin/user_action/", func(ctx iris.Context) {  
92.   
93.                 username := ctx.PostValue("username")  
94.                 password := ctx.PostValue("password")  
95.   
96.                 fmt.Println(username, password)  
97.   
98.                 md5str := mytool.Make_password(password)  
99.   
100.                 user := &model.User{Username: username, Password: md5str}  
101.                 res := db.Create(user)  
102.   
103.                 if res.Error != nil {  
104.   
105.                         fmt.Println(res.Error)  
106.   
107.                         ret := map[string]string{  
108.                                 "errcode": "1",  
109.                                 "msg":     "用户名不能重复",  
110.                         }  
111.                         ctx.JSON(ret)  
112.   
113.                         return  
114.   
115.                 }  
116.   
117.                 ret := map[string]string{  
118.                         "errcode": "0",  
119.                         "msg":     "ok",  
120.                 }  
121.                 ctx.JSON(ret)  
122.   
123.         })  
124.   
125.           
126.   
127.         return app  
128.   
129. }

复制代码

入口文件main.go承载了太多业务，既需要负责数据库结构体的创建，又得操心模板的渲染和接口逻辑的编写，说白了：泥沙俱下，沉渣泛起。
事实上，像这样把所有代码都堆到一个文件中，还会带来协作问题，比如，当你花了一整天的时间，好不容易完成了一段业务逻辑，也通过了本地测试，准备第二天提交线上测试，但是第二天上班时却发现这个逻辑莫名其妙地开始报错了，这通常是因为有同事在你走后修改了你编写或者依赖的那个模块，归根结底，并不完全是协作的问题，项目结构也是因素之一。
多个研发同时修改了同一个源代码文件。虽然在规模相对较小、人员较少的项目中，这种问题或许并不严重，但是随着项目的增长，研发人员的增加，这种每天早上刚上班时都要经历一遍的痛苦就会越来越多，甚至会严重到让有的团队在长达数周的时间内都不能发布一个稳定的项目版本，因为每个人都在不停地修改自己的代码，以适应其他人所提交的变更，周而复始，恶性循环。
所以我们必须把业务单独抽离出来，比如用户管理其实是后台模块功能，只有特定的管理员才可能在其页面进行操作，所以我们可以单独创建一个控制层：

1. mkdir handler  
2. cd hanler

复制代码

随后编写后台控制逻辑admin.go:

1. package handler  
2.   
3. import (  
4.   
5.         "github.com/kataras/iris/v12"  
6. )  
7.   
8. //用户管理页面模板  
9. func Admin_user_page(ctx iris.Context) {  
10.   
11.         ctx.View("/admin/user.html")  
12.   
13. }

复制代码

这里把用户管理页面的解析函数单独抽离在handler包中，注意函数的首字母要进行大写处理，因为首字母小写函数是私有函数，只能在包内使用，无法被别的包调用。
随后改造入口文件main.go逻辑:

1. app.Get("/admin/user/", handler.Admin_user_page)

复制代码

路由匹配时，只需要引入handler包中的Admin_user_page函数就可以了。
随后，对路由进行分组优化，同属一个业务的模块绑定在同一个分组中：

1. adminhandler := app.Party("/admin")  
2.         {  
3.                 adminhandler.Use(iris.Compression)  
4.                 adminhandler.Get("/user/", handler.Admin_user_page)  
5.                 adminhandler.Get("/userlist/", handler.Admin_userlist)  
6.                 adminhandler.Delete("/user_action/", handler.Admin_userdel)  
7.                 adminhandler.Put("/user_action/", handler.Admin_userupdate)  
8.                 adminhandler.Post("/user_action/", handler.Admin_useradd)  
9.   
10.         }

复制代码

如此，业务和路由解析就彻底分开了，结构体创建函数也清爽了不少：

1. func newApp(db *gorm.DB) *iris.Application {            app := iris.New()            tmpl := iris.HTML("./views", ".html")            tmpl.Delims("${", "}")            tmpl.Reload(true)            app.RegisterView(tmpl)            adminhandler := app.Party("/admin")  
2.         {  
3.                 adminhandler.Use(iris.Compression)  
4.                 adminhandler.Get("/user/", handler.Admin_user_page)  
5.                 adminhandler.Get("/userlist/", handler.Admin_userlist)  
6.                 adminhandler.Delete("/user_action/", handler.Admin_userdel)  
7.                 adminhandler.Put("/user_action/", handler.Admin_userupdate)  
8.                 adminhandler.Post("/user_action/", handler.Admin_useradd)  
9.   
10.         }          return app    }

复制代码

数据层结构优化

业务层进行了拆分，但是数据层还集成在入口文件中main.go:

1. package main  
2.   
3. import (  
4.         "IrisBlog/handler"  
5.         "IrisBlog/model"  
6.   
7.         "fmt"  
8.   
9.         "github.com/jinzhu/gorm"  
10.   
11.         _ "github.com/jinzhu/gorm/dialects/mysql"  
12.         "github.com/kataras/iris/v12"  
13. )  
14.   
15. func main() {  
16.   
17.         db, err := gorm.Open("mysql", "root:root@(localhost)/irisblog?charset=utf8mb4&parseTime=True&loc=Local")  
18.   
19.         if err != nil {  
20.                 fmt.Println(err)  
21.                 panic("无法连接数据库")  
22.         }  
23.         fmt.Println("连接数据库成功")  
24.   
25.         //单数模式  
26.         db.SingularTable(true)  
27.   
28.         // 创建默认表  
29.         db.AutoMigrate(&model.User{})  
30.   
31.         // 逻辑结束后关闭数据库  
32.         defer func() {  
33.                 _ = db.Close()  
34.         }()  
35.   
36.         app := newApp(db)  
37.   
38.         app.HandleDir("/assets", iris.Dir("./assets"))  
39.         app.Favicon("./favicon.ico")  
40.         app.Listen(":5000")  
41. }

复制代码

这里的含义是，一旦进入入口逻辑，就立刻初始化数据库，随后执行业务代码，当业务执行完毕后，利用延迟函数defer关闭数据库链接。
这种逻辑的弊端是，一旦数据库服务挂掉，整个项目服务也会受影响，再者，很多纯静态化页面并不需要数据库链接，每一次都链接数据库，显然是画蛇添足。
所以单独建立数据包：

1. mkdir database  
2. cd database

复制代码

建立数据层逻辑database.go:

1. package database  
2.   
3. import (  
4.         "IrisBlog/model"  
5.         "fmt"  
6.   
7.         "github.com/jinzhu/gorm"  
8.   
9.         _ "github.com/jinzhu/gorm/dialects/mysql"  
10. )  
11.   
12. func Db() *gorm.DB {  
13.   
14.         db, err := gorm.Open("mysql", "root:root@(localhost)/irisblog?charset=utf8mb4&parseTime=True&loc=Local")  
15.   
16.         if err != nil {  
17.                 fmt.Println(err)  
18.                 panic("无法连接数据库")  
19.         }  
20.         fmt.Println("连接数据库成功")  
21.   
22.         //单数模式  
23.         db.SingularTable(true)  
24.   
25.         // 创建默认表  
26.         db.AutoMigrate(&model.User{})  
27.   
28.   
29.         return db  
30. }

复制代码

这里我们构建函数Db()，它返回一个数据库操作的结构体指针，专门用来执行数据库操作，需要注意的是，删除函数内之前的延后defer关闭链接函数，否则链接在函数体内就关闭了，调用方就无法使用数据库了。
调用上，直接调用database包中的Db()，就可以直接使用数据库指针了：

1. //用户列表接口  
2. func Admin_userlist(ctx iris.Context) {  
3.   
4.         db := database.Db()  
5.   
6.         var users []model.User  
7.         res := db.Find(&users)  
8.         // 逻辑结束后关闭数据库  
9.         defer func() {  
10.                 _ = db.Close()  
11.         }()  
12.   
13.         ctx.JSON(res)  
14.   
15. }

复制代码

随后，继续优化入口文件：

1. package main    import (          "IrisBlog/handler"          "github.com/kataras/iris/v12"  )    func main() {            app := newApp()            app.HandleDir("/assets", iris.Dir("./assets"))          app.Favicon("./favicon.ico")          app.Listen(":5000")  }    func newApp() *iris.Application {            app := iris.New()            tmpl := iris.HTML("./views", ".html")            tmpl.Delims("${", "}")            tmpl.Reload(true)            app.RegisterView(tmpl)            adminhandler := app.Party("/admin")  
2.         {  
3.                 adminhandler.Use(iris.Compression)  
4.                 adminhandler.Get("/user/", handler.Admin_user_page)  
5.                 adminhandler.Get("/userlist/", handler.Admin_userlist)  
6.                 adminhandler.Delete("/user_action/", handler.Admin_userdel)  
7.                 adminhandler.Put("/user_action/", handler.Admin_userupdate)  
8.                 adminhandler.Post("/user_action/", handler.Admin_useradd)  
9.   
10.         }        }

复制代码

这里优化了main函数，使其逻辑更加简明和清晰。
最后，优化数据层逻辑database.go:

1. package database  
2.   
3. import (  
4.         "IrisBlog/model"  
5.         "fmt"  
6.   
7.         "github.com/jinzhu/gorm"  
8.   
9.         _ "github.com/jinzhu/gorm/dialects/mysql"  
10.         _ "github.com/jinzhu/gorm/dialects/sqlite"  
11. )  
12.   
13. const db_type int = 1  
14.   
15. func sqlite3() *gorm.DB {  
16.   
17.         db, err := gorm.Open("sqlite3", "/tmp/IrisBlog.db")  
18.   
19.         if err != nil {  
20.                 fmt.Println(err)  
21.                 panic("无法连接数据库")  
22.         }  
23.         fmt.Println("连接sqlite3数据库成功")  
24.   
25.         return db  
26.   
27. }  
28.   
29. func mysql() *gorm.DB {  
30.   
31.         db, err := gorm.Open("mysql", "root:root@(localhost)/irisblog?charset=utf8mb4&parseTime=True&loc=Local")  
32.   
33.         if err != nil {  
34.                 fmt.Println(err)  
35.                 panic("无法连接数据库")  
36.         }  
37.         fmt.Println("连接mysql数据库成功")  
38.   
39.         return db  
40.   
41. }  
42.   
43. func Db() *gorm.DB {  
44.   
45.         switch db_type {  
46.         case 0:  
47.                 db := mysql()  
48.                 //单数模式  
49.                 db.SingularTable(true)  
50.                 // 创建默认表  
51.                 db.AutoMigrate(&model.User{})  
52.                 return db  
53.         case 1:  
54.                 db := sqlite3()  
55.                 //单数模式  
56.                 db.SingularTable(true)  
57.                 // 创建默认表  
58.                 db.AutoMigrate(&model.User{})  
59.                 return db  
60.         default:  
61.                 panic("未知的数据库")  
62.         }  
63.   
64.   
65. }

复制代码

这里我们分别封装mysql和sqlite3数据库指针函数，然后通过switch语句来根据不同的开发环境而进行切换和控制。
至此，项目结构的首次结构性优化就完成了，优化后的结构如下：

1. ├── README.md  
2. ├── assets  
3. │ ├── css  
4. │ │ └── style.css  
5. │ └── js  
6. │     ├── axios.js  
7. │     └── vue.js  
8. ├── database  
9. │ └── database.go  
10. ├── favicon.ico  
11. ├── go.mod  
12. ├── go.sum  
13. ├── handler  
14. │ └── admin.go  
15. ├── main.go  
16. ├── model  
17. │ └── model.go  
18. ├── mytool  
19. │ └── mytool.go  
20. ├── tmp  
21. │ └── runner-build  
22. └── views  
23.     ├── admin  
24.     │ └── user.html  
25.     ├── index.html  
26.     └── test.html

复制代码

结语

为什么我们一开始不直接采用低耦合高内聚的项目架构？因为别人的经验并不是我们的经验，只有真正经历过才是真实的开发经验，项目开发没有标准答案，只有选择，然后承担后果，只有尝试过苦涩的果实之后，下一次才会做出正确的选择。该项目已开源在Github：https://github.com/zcxey2911/IrisBlog ，与君共觞，和君共勉。

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