要访问查询字符串中给出的参数,我们在 utils 中创建一个函数,方便以后调用
```go
...
func getPage(r *http.Request) int {
url := r.URL // net/url.URL
query := url.Query() // Values (map[string][]string)
q := query.Get("page")
if q == "" {
return 1
}
page, err := strconv.Atoi(q)
if err != nil {
return 1
}
return page
}
```
在 vm 中建立分页的 BasePageViewModel
* PrevPage: 上一页的页码
* NextPage: 下一页的页码
* Total: 总页数
* CurrentPage: 当前页码
* Limit: 每页显示项目数
vm/g.go
```go
...
// BasePageViewModel struct
type BasePageViewModel struct {
PrevPage int
NextPage int
Total int
CurrentPage int
Limit int
}
// SetPrevAndNextPage func
func (v *BasePageViewModel) SetPrevAndNextPage() {
if v.CurrentPage > 1 {
v.PrevPage = v.CurrentPage - 1
}
if (v.Total-1)/v.Limit >= v.CurrentPage {
v.NextPage = v.CurrentPage + 1
}
}
// SetBasePageViewModel func
func (v *BasePageViewModel) SetBasePageViewModel(total, page, limit int) {
v.Total = total
v.CurrentPage = page
v.Limit = limit
v.SetPrevAndNextPage()
}
```
### 首页中的分页
model 中增加 FollowingPosts 的分页处理
model/user.go
```go
...
// FollowingPostsByPageAndLimit func
func (u *User) FollowingPostsByPageAndLimit(page, limit int) (*[]Post, int, error) {
var total int
var posts []Post
offset := (page - 1) * limit
ids := u.FollowingIDs()
if err := db.Preload("User").Order("timestamp desc").Where("user_id in (?)", ids).Offset(offset).Limit(limit).Find(&posts).Error; err != nil {
return nil, total, err
}
db.Model(&Post{}).Where("user_id in (?)", ids).Count(&total)
return &posts, total, nil
}
...
```
index 的 vm 中加入 BasePageViewModel
vm/index.go
```go
...
type IndexViewModel struct {
BaseViewModel
Posts []model.Post
Flash string
BasePageViewModel
}
// IndexViewModelOp struct
type IndexViewModelOp struct{}
// GetVM func
func (IndexViewModelOp) GetVM(username, flash string, page, limit int) IndexViewModel {
u, _ := model.GetUserByUsername(username)
posts, total, _ := u.FollowingPostsByPageAndLimit(page, limit)
v := IndexViewModel{}
v.SetTitle("Homepage")
v.Posts = *posts
v.Flash = flash
v.SetBasePageViewModel(total, page, limit)
v.SetCurrentUser(username)
return v
}
...
```
显示页中加入页码
templates/content/index.html
```markup
...
{{range .Posts}}
{{end}}
{{ if gt .PrevPage 0 }}
Newer posts
{{ end }}
{{ if gt .NextPage 0 }}
Older posts
{{ end }}
...
```
> Notice: 这里我们顺便在 Posts显示的时候将 Username 上加了 “/user/username” 的链接,方便我们快速访问用户profile
controller修改成新的 GetVM
```go
...
func indexHandler(w http.ResponseWriter, r *http.Request) {
tpName := "index.html"
vop := vm.IndexViewModelOp{}
page := getPage(r)
username, _ := getSessionUser(r)
if r.Method == http.MethodGet {
flash := getFlash(w, r)
v := vop.GetVM(username, flash, page, pageLimit)
templates[tpName].Execute(w, &v)
}
if r.Method == http.MethodPost {
r.ParseForm()
body := r.Form.Get("body")
errMessage := checkLen("Post", body, 1, 180)
if errMessage != "" {
setFlash(w, r, errMessage)
} else {
err := vm.CreatePost(username, body)
if err != nil {
log.Println("add Post error:", err)
w.Write([]byte("Error insert Post in database"))
return
}
}
http.Redirect(w, r, "/", http.StatusSeeOther)
}
}
...
```
### 个人主页中的分页
与首页分页类似，建立 profile 中的分页
model/post.go
```go
...
// GetPostsByUserIDPageAndLimit func
func GetPostsByUserIDPageAndLimit(id, page, limit int) (*[]Post, int, error) {
var total int
var posts []Post
offset := (page - 1) * limit
if err := db.Preload("User").Order("timestamp desc").Where("user_id=?", id).Offset(offset).Limit(limit).Find(&posts).Error; err != nil {
return nil, total, err
}
db.Model(&Post{}).Where("user_id=?", id).Count(&total)
return &posts, total, nil
}
```
vm/profile.go
```go
...
// ProfileViewModel struct
type ProfileViewModel struct {
BaseViewModel
Posts []model.Post
Editable bool
IsFollow bool
FollowersCount int
FollowingCount int
ProfileUser model.User
BasePageViewModel
}
// ProfileViewModelOp struct
type ProfileViewModelOp struct{}
// GetVM func
func (ProfileViewModelOp) GetVM(sUser, pUser string, page, limit int) (ProfileViewModel, error) {
v := ProfileViewModel{}
v.SetTitle("Profile")
u, err := model.GetUserByUsername(pUser)
if err != nil {
return v, err
}
posts, total, _ := model.GetPostsByUserIDPageAndLimit(u.ID, page, limit)
v.ProfileUser = *u
v.Editable = (sUser == pUser)
v.SetBasePageViewModel(total, page, limit)
if !v.Editable {
v.IsFollow = u.IsFollowedByUser(sUser)
}
v.FollowersCount = u.FollowersCount()
v.FollowingCount = u.FollowingCount()
v.Posts = *posts
v.SetCurrentUser(sUser)
return v, nil
}
...
```
templates/content/profile.html
```markup
...
{{range .Posts}}
{{end}}
{{ if gt .PrevPage 0 }}
Newer posts
{{ end }}
{{ if gt .NextPage 0 }}
Older posts
{{ end }}
...
```
controller/home.go
```go
...
func profileHandler(w http.ResponseWriter, r *http.Request) {
tpName := "profile.html"
vars := mux.Vars(r)
pUser := vars["username"]
sUser, _ := getSessionUser(r)
page := getPage(r)
vop := vm.ProfileViewModelOp{}
v, err := vop.GetVM(sUser, pUser, page, pageLimit)
if err != nil {
msg := fmt.Sprintf("user ( %s ) does not exist", pUser)
w.Write([]byte(msg))
return
}
templates[tpName].Execute(w, &v)
}
...
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/fd3c82514e78098e0f482f2be8c0797a0e6cef67)
## 更容易地发现和关注用户
相信你已经留意到了，应用没有一个很好的途径来让用户可以找到其他用户进行关注。实际上，现在根本没有办法在页面上查看到底有哪些用户存在。我将会使用少量简单的变更来解决这个问题。
我将会创建一个新的`Explore`页面。该页面看起来像是主页，但是却不是只显示已关注用户的动态，而是展示所有用户的全部动态。
我们现在导航中加入`Explore`
templates/\_base.html
```markup
...
Home
Explore
...
```
然后增加 `Explore` 页面， 不多说了，老套路
model/post.go
```go
...
// GetPostsByPageAndLimit func
func GetPostsByPageAndLimit(page, limit int) (*[]Post, int, error) {
var total int
var posts []Post
offset := (page - 1) * limit
if err := db.Preload("User").Offset(offset).Limit(limit).Order("timestamp desc").Find(&posts).Error; err != nil {
return nil, total, err
}
db.Model(&Post{}).Count(&total)
return &posts, total, nil
}
```
vm/explore.go
```go
package vm
import "github.com/bonfy/go-mega-code/model"
// ExploreViewModel struct
type ExploreViewModel struct {
BaseViewModel
Posts []model.Post
BasePageViewModel
}
// ExploreViewModelOp struct
type ExploreViewModelOp struct{}
// GetVM func
func (ExploreViewModelOp) GetVM(username string, page, limit int) ExploreViewModel {
// posts, _ := model.GetAllPosts()
posts, total, _ := model.GetPostsByPageAndLimit(page, limit)
v := ExploreViewModel{}
v.SetTitle("Explore")
v.Posts = *posts
v.SetBasePageViewModel(total, page, limit)
v.SetCurrentUser(username)
return v
}
```
templates/content/explore.html
```markup
{{define "content"}}
Hello, {{.CurrentUser}}!
{{range .Posts}}
{{end}}
{{ if gt .PrevPage 0 }}
Newer posts
{{ end }}
{{ if gt .NextPage 0 }}
Older posts
{{ end }}
{{end}}
```
controller/home.go
```go
...
func (h home) registerRoutes() {
r := mux.NewRouter()
r.HandleFunc("/logout", middleAuth(logoutHandler))
r.HandleFunc("/login", loginHandler)
r.HandleFunc("/register", registerHandler)
r.HandleFunc("/user/{username}", middleAuth(profileHandler))
r.HandleFunc("/follow/{username}", middleAuth(followHandler))
r.HandleFunc("/unfollow/{username}", middleAuth(unFollowHandler))
r.HandleFunc("/profile_edit", middleAuth(profileEditHandler))
r.HandleFunc("/explore", middleAuth(exploreHandler))
r.HandleFunc("/", middleAuth(indexHandler))
http.Handle("/", r)
}
...
func exploreHandler(w http.ResponseWriter, r *http.Request) {
tpName := "explore.html"
vop := vm.ExploreViewModelOp{}
username, _ := getSessionUser(r)
page := getPage(r)
v := vop.GetVM(username, page, pageLimit)
templates[tpName].Execute(w, &v)
}
```
通过这些细小的变更，应用的用户体验得到了大大的提升。现在，用户可以访问发现页来查看陌生用户的动态，并通过这些用户动态来关注用户，而需要的操作仅仅是点击用户名跳转到其个人主页并点击关注链接。令人叹为观止！对吧？
此时，我建议你在应用上再次尝试一下这个功能，以便体验最后的用户接口的完善。
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/4609f2bd8bf293ccd2dc1871a03e7e8c91d44706)
## Links
* [目录](/)
* 上一节: [08-Follower](/08-follower)
* 下一节: [10-Email-Support](/10-email-support)
# 10-Email-Support
这是Go-Mega系列的第十部分，本章我将告诉你，应用如何向你的用户发送电子邮件，以及如何在电子邮件支持之上构建密码重置功能。
现在，应用在数据库方面做得相当不错，所以在本章中，我想抛开这个主题，开始添加发送电子邮件的功能，这是大多数Web应用必需的另一个重要部分。
为什么应用需要发送电子邮件给用户？ 原因很多，但其中一个常见的原因是解决与认证相关的问题。 在本章中，我将为忘记密码的用户添加密码重置功能。 当用户请求重置密码时，应用将发送包含特制链接的电子邮件。 用户然后需要点击该链接才能访问设置新密码的表单。
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/10-Email-Support), [Diff](https://github.com/bonfy/go-mega-code/compare/09-Pagination...10-Email-Support), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.0.zip)
## 第三方库支持
本章我们需要两个第三方插件 `gomail` 以及 `jwt-go`
```
# gomail
$ go get gopkg.in/gomail.v2
# jwt-go
$ go get github.com/dgrijalva/jwt-go
```
## 加入mail支持
在 config 中增加 mail 设置
config.yml
```
mysql:
charset: utf8
db: dbname
host: localhost
password: password
user: root
mail:
smtp: smtp-server
smtp-port: 587
user: user
password: pwd
```
这里的 smtp server， 请查看你的邮件提供商的文档，比如 zoho mail 的 smtp 是 `smtp.zoho.com`
config/g.go
```go
...
// GetSMTPConfig func
func GetSMTPConfig() (server string, port int, user, pwd string) {
server = viper.GetString("mail.smtp")
port = viper.GetInt("mail.smtp-port")
user = viper.GetString("mail.user")
pwd = viper.GetString("mail.password")
return
}
```
在 controller/utils.go 封装 sendMail 函数，方便调用
controller/utils.go
```go
...
// Email
// sendEmail func
func sendEmail(target, subject, content string) {
server, port, usr, pwd := config.GetSMTPConfig()
d := gomail.NewDialer(server, port, usr, pwd)
d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
m := gomail.NewMessage()
m.SetHeader("From", usr)
m.SetHeader("To", target)
m.SetAddressHeader("Cc", usr, "admin")
m.SetHeader("Subject", subject)
m.SetBody("text/html", content)
if err := d.DialAndSend(m); err != nil {
log.Println("Email Error:", err)
return
}
}
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/f741e7875dba01644c7fe60faecc76c043fffe1e)
## 请求重置密码
我上面提到过，用户有权利重置密码。因此我将在登录页面提供一个链接：
templates/content/login.html
```markup
...
New User? Click to Register!
Forget Password? Click to Reset Password!
...
```
当用户点击链接时，会出现一个新的Web表单，要求用户输入注册的电子邮件地址，以启动密码重置过程。
vm/reset\_password\_request.go
```go
package vm
import (
"log"
"github.com/bonfy/go-mega-code/model"
)
// ResetPasswordRequestViewModel struct
type ResetPasswordRequestViewModel struct {
LoginViewModel
}
// ResetPasswordRequestViewModelOp struct
type ResetPasswordRequestViewModelOp struct{}
// GetVM func
func (ResetPasswordRequestViewModelOp) GetVM() ResetPasswordRequestViewModel {
v := ResetPasswordRequestViewModel{}
v.SetTitle("Forget Password")
return v
}
// CheckEmailExist func
func CheckEmailExist(email string) bool {
_, err := model.GetUserByEmail(email)
if err != nil {
log.Println("Can not find email:", email)
return false
}
return true
}
```
templates/content/reset\_password\_request.html
```markup
{{define "content"}}
Input your email address:
{{if .Errs}}
{{range .Errs}}
- {{.}}
{{end}}
{{end}}
{{end}}
```
controller/home.go
```go
...
r.HandleFunc("/reset_password_request", resetPasswordRequestHandler)
...
func resetPasswordRequestHandler(w http.ResponseWriter, r *http.Request) {
tpName := "reset_password_request.html"
vop := vm.ResetPasswordRequestViewModelOp{}
v := vop.GetVM()
if r.Method == http.MethodGet {
templates[tpName].Execute(w, &v)
}
if r.Method == http.MethodPost {
r.ParseForm()
email := r.Form.Get("email")
errs := checkResetPasswordRequest(email)
v.AddError(errs...)
if len(v.Errs) > 0 {
templates[tpName].Execute(w, &v)
} else {
log.Println("Send mail to", email)
vopEmail := vm.EmailViewModelOp{}
vEmail := vopEmail.GetVM(email)
var contentByte bytes.Buffer
tpl, _ := template.ParseFiles("templates/email.html")
if err := tpl.Execute(&contentByte, &vEmail); err != nil {
log.Println("Get Parse Template:", err)
w.Write([]byte("Error send email"))
return
}
content := contentByte.String()
go sendEmail(email, "Reset Password", content)
http.Redirect(w, r, "/login", http.StatusSeeOther)
}
}
}
```
controller 里涉及到了 email 的template
vm/email.go
```go
package vm
import (
"github.com/bonfy/go-mega-code/config"
"github.com/bonfy/go-mega-code/model"
)
// EmailViewModel struct
type EmailViewModel struct {
Username string
Token string
Server string
}
// EmailViewModelOp struct
type EmailViewModelOp struct{}
// GetVM func
func (EmailViewModelOp) GetVM(email string) EmailViewModel {
v := EmailViewModel{}
u, _ := model.GetUserByEmail(email)
v.Username = u.Username
v.Token, _ = u.GenerateToken()
v.Server = config.GetServerURL()
return v
}
```
templates/email.html
```markup
Dear {{.Username}},
To reset your password
click here
.
Alternatively, you can paste the following link in your browser's address bar:
{{.Server}}/reset_password/{{.Token}}
If you have not requested a password reset simply ignore this message.
This Email will expire in 2 hours.
Sincerely,
BONFY
```
上面简单的一封邮件，其实蕴含着两个 非常重要的 知识点：
### goroutine
原来 Flask-Mega 里面非常复杂的多线程操作，这里只用了一个 `go function()` 完成了
goroutine 可以说是 `Go` 这个语言的特色之一了，当然资料也比较多，大家可以深入了解下
这里我简单说下，就是 function 前面加个 go 关键字，就实现了 协程，用于高并发，而且性能非常好，是不是很cool！
### jwt
具体可以通过 [jwt.io](https://jwt.io/)了解下
或者中文的可以通过这片文章具体了解下 [直通车](https://juejin.im/post/5a437441f265da43294e54c3)
这里的邮件可以说是 JWT 的一个非常典型的应用场景，jwt 加密后的 URL 就是图中的一长串，其中其实隐含着 2 hour 过期时间
我们通过在 user.go 里加入两个function 就能实现, 密钥 `secret` 这里直接写在代码里，其实更优还是通过配置文件配置，又偷懒了
model/user.go
```go
...
// GenerateToken func
func (u *User) GenerateToken() (string, error) {
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
"username": u.Username,
"exp": time.Now().Add(time.Hour * 2).Unix(), // 可以添加过期时间
})
return token.SignedString([]byte("secret"))
}
// CheckToken func
func CheckToken(tokenString string) (string, error) {
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
// Don't forget to validate the alg is what you expect:
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
}
// hmacSampleSecret is a []byte containing your secret, e.g. []byte("my_secret_key")
return []byte("secret"), nil
})
if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
return claims["username"].(string), nil
} else {
return "", err
}
}
...
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/3e6471f01981dc176ee588579aa02aae4b6ad683)
## 重置密码
目前我们点击邮件中的邮件是不能操作的，因为我们其实并没有 `/reset_password` 这个handler，那这里我们来完成它
其实密码重置就是一个简单的表单， 两个密码框，检验输入一致以及符合密码规范就可以了，操作起来不算太复杂。
vm/reset\_password.go
```go
package vm
import (
"github.com/bonfy/go-mega-code/model"
)
// ResetPasswordViewModel struct
type ResetPasswordViewModel struct {
LoginViewModel
Token string
}
// ResetPasswordViewModelOp struct
type ResetPasswordViewModelOp struct{}
// GetVM func
func (ResetPasswordViewModelOp) GetVM(token string) ResetPasswordViewModel {
v := ResetPasswordViewModel{}
v.SetTitle("Reset Password")
v.Token = token
return v
}
// CheckToken func
func CheckToken(tokenString string) (string, error) {
return model.CheckToken(tokenString)
}
// ResetUserPassword func
func ResetUserPassword(username, password string) error {
return model.UpdatePassword(username, password)
}
```
templates/content/reset\_password.html
```markup
{{define "content"}}
Register
{{if .Errs}}
{{range .Errs}}
- {{.}}
{{end}}
{{end}}
{{end}}
```
controller/home.go
```go
...
r.HandleFunc("/reset_password/{token}", resetPasswordHandler)
...
func resetPasswordHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
token := vars["token"]
username, err := vm.CheckToken(token)
if err != nil {
w.Write([]byte("The token is no longer valid, please go to the login page."))
}
tpName := "reset_password.html"
vop := vm.ResetPasswordViewModelOp{}
v := vop.GetVM(token)
if r.Method == http.MethodGet {
templates[tpName].Execute(w, &v)
}
if r.Method == http.MethodPost {
log.Println("Reset password for ", username)
r.ParseForm()
pwd1 := r.Form.Get("pwd1")
pwd2 := r.Form.Get("pwd2")
errs := checkResetPassword(pwd1, pwd2)
v.AddError(errs...)
if len(v.Errs) > 0 {
templates[tpName].Execute(w, &v)
} else {
if err := vm.ResetUserPassword(username, pwd1); err != nil {
log.Println("reset User password error:", err)
w.Write([]byte("Error update user password in database"))
return
}
http.Redirect(w, r, "/login", http.StatusSeeOther)
}
}
}
```
就这样我们完成了重置密码的功能，虽然设计到的页面比较多，不过只要我们思路清晰，一步一个脚印，还是能非常容易就能实现了。
现在输入新的密码，保存后，就可以用新密码登陆了。
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/4bc0b9304d60db854cb11b8ba5c5e908566da9a6)
>
> Notice: 本章还涉及到一些后端验证，在这里没有一一列举，大家还是请看下源码diff，可以更完整的了解代码
## Links
* [目录](/)
* 上一节: [09-Pagination](/09-pagination)
* 下一节: [11-Facelift](/11-facelift)
# 11-Facelift
在本章中，我暂停一下后端的工作，并花点时间向你展示如何使应用看起来更加优雅和专业。
本章主要是用到了 前端的 Bootstrap
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/11-Facelift), [Diff](https://github.com/bonfy/go-mega-code/compare/10-Email-Support...11-Facelift), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.1.zip)
## CSS 框架
虽然我们可以争辩说写代码不容易，但是与那些必须让网页在所有Web浏览器上具有良好一致外观的网页设计师相比，我们的痛苦不值一提。 虽然近年来这种情况得到一定程度的缓解，但是在一些浏览器中仍然存在着晦涩的错误或奇怪的设定，这使得设计网页的任务变得非常困难。 如果还需要兼容屏幕限制设备（诸如平板电脑和智能手机）的浏览器，则更加困难。
如果你和我一样，只是一个想创建出规范网页的开发人员，没有时间或兴趣去学习底层机制并通过编写原生HTML和CSS来实现它，那么唯一可行的解决方案是使用CSS框架来简化任务。 通过这种方式，你会失去一些创造性的自由，但另一方面，无需通过太多的功夫就可以让网页在所有浏览器中看起来都不错。 CSS框架为普通类型的用户界面元素提供了高级CSS类的集合，其中包含预定义样式。 大多数这样的框架还提供JavaScript插件，以实现不能纯粹使用HTML和CSS来完成的功能。
## Bootstrap简介
最受欢迎的CSS框架之一是由Twitter推出的[Bootstrap](http://getbootstrap.com/)。 如果你想看看这个框架可以设计的页面类型，文档有一些[示例](https://getbootstrap.com/docs/4.1/examples/)。
这些是使用Bootstrap来设置网页风格的一些好处：
* 在所有主流网页浏览器中都有相似的外观
* 自动处理PC桌面，平板电脑和手机屏幕尺寸
* 可定制的布局
* 精心设计的导航栏，表单，按钮，警示，弹出窗口等
## Bootstrap美化
由于我们所有的页面都是继承自 `templates/_base.html`，所以我们需要在 \_base.html 中引入 bootstrap
templates/\_base.html
```markup
{{if .Title}}
{{.Title}} - blog
{{else}}
Welcome to blog!
{{end}}
{{template "content" .}}
```
接着我们主要优化的是表单和按钮
* 所有表单上加上 `class="form-control"`
* 所有按钮上加上 `class="btn btn-outline-primary"`
* 所有的分页按钮优化
```markup
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/ca5ccbaa06d9d4041357979246ed92c031ea722e)
## 自定义 404 界面
我们现在的404界面还是 `gorilla/mux` 的默认界面，现在我们美化下
vm/notfound.go
```go
package vm
// NotFoundMessage struct
type NotFoundMessage struct {
Flash string
}
```
templates/404.html
```markup
Page Not Found
{{if .Flash}}
{{.Flash}}
{{else}}
Page Not Found
{{end}}
Sorry, but the page you were trying to view does not exist.
```
controller/home.go
```go
...
r.NotFoundHandler = http.HandlerFunc(notfoundHandler)
r.HandleFunc("/404", notfoundHandler)
...
func notfoundHandler(w http.ResponseWriter, r *http.Request) {
flash := getFlash(w, r)
message := vm.NotFoundMessage{Flash: flash}
tpl, _ := template.ParseFiles("templates/404.html")
tpl.Execute(w, &message)
}
...
```
运行程序，在浏览器中输入一个没有指定的 url，例如: `http://127.0.0.1:8888/nosuchpage`
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/f90f32b1233c1e76dfbdba1c89649fbdd05d46cb)
## Links
* [目录](/)
* 上一节: [10-Email-Support](/10-email-support)
* 下一节: [12-Dates-And-Times](/12-dates-and-times)
# 12-Dates-And-Times
在本章，我们将讨论下 **Go** 处理日期和时间的方法，以及优化 User 及 Post 对象中的时间对象
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/12-Dates-And-Times), [Diff](https://github.com/bonfy/go-mega-code/compare/11-Facelift...12-Dates-And-Times), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.2.zip)
## 优化 User 的 LastSeen
Flask-Mega 主要是用了它灵活的模板功能，以及 Moment.js 来在前端实现了时间日期的优化，与之不同，我们主要采用的是后端来实现同样的功能
model/user.go
```go
...
// FormattedLastSeen func
func (u *User) FormattedLastSeen() string {
return u.LastSeen.Format("2006-01-02 15:04:05")
}
...
```
templates/content/profile.html
```markup
...
Last seen on: {{ .ProfileUser.FormattedLastSeen }}
...
```
> Notice: 虽然我也比较喜欢其他语言的 %Y-%m-%d %H:%M:%S" layout 形式，但是无奈 Go 就是 "2006-01-02 15:04:05" 这样的layout，没有道理可讲，我有时候甚至怕它搞错 01 和 02 哪个是月 哪个表示 日
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/01611b3d27f6c78ca6c53878502f539695d1170b)
## 优化 Post 的 Timestamp
我们目标是显示成 `user said 35 minutes ago: post message` 这样的形式，这就需要我们对时间日期进行转换
简单点，我们就在 utils.go 中实现一个 `FromTime` 函数
model/utils.go
```go
...
const (
minute = 1
hour = minute * 60
day = hour * 24
month = day * 30
year = day * 365
quarter = year / 4
)
// FromDuration returns a friendly string representing an approximation of the
// given duration
func FromDuration(d time.Duration) string {
seconds := round(d.Seconds())
if seconds < 30 {
return "less than a minute"
}
if seconds < 90 {
return "1 minute"
}
minutes := div(seconds, 60)
if minutes < 45 {
return fmt.Sprintf("%0d minutes", minutes)
}
hours := div(minutes, 60)
if minutes < day {
return fmt.Sprintf("about %s", pluralize(hours, "hour"))
}
if minutes < (42 * hour) {
return "1 day"
}
days := div(hours, 24)
if minutes < (30 * day) {
return pluralize(days, "day")
}
months := div(days, 30)
if minutes < (45 * day) {
return "about 1 month"
}
if minutes < (60 * day) {
return "about 2 months"
}
if minutes < year {
return pluralize(months, "month")
}
rem := minutes % year
years := minutes / year
if rem < (3 * month) {
return fmt.Sprintf("about %s", pluralize(years, "year"))
}
if rem < (9 * month) {
return fmt.Sprintf("over %s", pluralize(years, "year"))
}
years++
return fmt.Sprintf("almost %s", pluralize(years, "year"))
}
// FromTime returns a friendly string representing the approximate difference
// from the given time and time.Now()
func FromTime(t time.Time) string {
now := time.Now()
var d time.Duration
var suffix string
if t.Before(now) {
d = now.Sub(t)
suffix = "ago"
} else {
d = t.Sub(now)
suffix = "from now"
}
return fmt.Sprintf("%s %s", FromDuration(d), suffix)
}
func pluralize(i int, s string) string {
var buf bytes.Buffer
buf.WriteString(fmt.Sprintf("%d %s", i, s))
if i != 1 {
buf.WriteString("s")
}
return buf.String()
}
func round(f float64) int {
return int(math.Floor(f + .50))
}
func div(numerator int, denominator int) int {
rem := numerator % denominator
result := numerator / denominator
if rem >= (denominator / 2) {
result++
}
return result
}
```
现在我们可以使用 `FromTime` 函数实现我们的功能了
model/post.go
```go
...
// FormattedTimeAgo func
func (p *Post) FormattedTimeAgo() string {
return FromTime(*p.Timestamp)
}
...
```
templates/content/index.html & profile.html & explore.html
```markup
...
{{range .Posts}}
{{end}}
...
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/b5cdcf1fec212a012486928d2bc0ad3052d37d51)
>
> 写在最后: 突然发现模板可以使用 类的 Function, 所以前面 User 的 Avatar 字段貌似就没有那么必要了，直接用个function来实现，而且好处是不用去关心更改邮箱后的 SetAvatar,不过我任性，就不改了，我也是才发现 Go 模板还有这个妙用的
## Links
* [目录](/)
* 上一节: [11-Facelift](/11-facelift)
* 下一节: [13-Javascript-Magic](/13-javascript-magic)
# 13-Javascript-Magic
在本章，我们将添加一个功能，当你将鼠标悬停在用户的昵称上时，会弹出一个漂亮的窗口。
社交网站的常见用户交互模式是，当你将鼠标悬停在用户的名称上时，可以在弹出窗口中显示用户的主要信息。 如果你从未注意到这一点，请访问Twitter，Facebook，LinkedIn或任何其他主要社交网站，当你看到用户名时，只需将鼠标指针放在上面几秒钟即可看到弹出窗口。
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/13-Javascript-Magic), [Diff](https://github.com/bonfy/go-mega-code/compare/12-Dates-And-Times...13-Javascript-Magic), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.3.zip)
## 服务器端支持
在深入研究客户端之前，让我们先了解一下支持这些用户弹窗所需的服务器端的工作。 用户弹窗的内容将由新路由返回，它是现有个人主页路由的简化版本。
viewmodel 我们偷下懒，由于Popup的 vm 和 Profile 的相似，我们直接在 `vm/profile.go`中加入 GetPopupVM 来获得 Popup 的 vm
vm/profile.go
```go
...
// GetPopupVM func
func (ProfileViewModelOp) GetPopupVM(sUser, pUser string) (ProfileViewModel, error) {
v := ProfileViewModel{}
v.SetTitle("Profile")
u, err := model.GetUserByUsername(pUser)
if err != nil {
return v, err
}
v.ProfileUser = *u
v.Editable = (sUser == pUser)
if !v.Editable {
v.IsFollow = u.IsFollowedByUser(sUser)
}
v.FollowersCount = u.FollowersCount()
v.FollowingCount = u.FollowingCount()
v.SetCurrentUser(sUser)
return v, nil
}
...
```
controller/home.go
```go
...
r.HandleFunc("/user/{username}/popup", popupHandler)
...
func popupHandler(w http.ResponseWriter, r *http.Request) {
tpName := "popup.html"
vars := mux.Vars(r)
pUser := vars["username"]
sUser, _ := getSessionUser(r)
vop := vm.ProfileViewModelOp{}
v, err := vop.GetPopupVM(sUser, pUser)
if err != nil {
msg := fmt.Sprintf("user ( %s ) does not exist", pUser)
w.Write([]byte(msg))
return
}
templates[tpName].Execute(w, &v)
}
...
```
templates/content/popup.html
```markup
 |
{{.ProfileUser.Username}}
{{if .ProfileUser.AboutMe}}
{{ .ProfileUser.AboutMe }}
{{end}}
{{if .ProfileUser.LastSeen}}
Last seen on: {{ .ProfileUser.FormattedLastSeen }}
{{end}}
{{ .FollowersCount }} followers, {{ .FollowingCount }} following.
{{if .Editable}}
Edit your profile
{{else}}
{{if .IsFollow}}
Unfollow
{{else}}
Follow
{{end}}
{{end}}
|
```
当用户将鼠标指针悬停在用户名上时，随后小节中编写的JavaScript代码将会调用此路由。客户端将服务器端返回的响应中的html内容显示在弹出窗口中。 当用户移开鼠标时，弹出窗口将被删除。 听起来很简单，对吧？
如果你想了解弹窗像什么样，现在可以运行应用，跳转到任何用户的个人主页，然后在地址栏的URL中追加*/popup*以查看全屏版本的弹出窗口内容。
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/f48f4a33425c1a10622ab721adee43053cf96ccc)
## 客户端Ajax
我们在 \_base.html 中加入 popup 的 Ajax,这样所有继承它的页面也同样继承了 popup的功能
templates/\_base.html
```markup
...
...
```
然后我们在需要有 Popup 功能的地方，就是所有的用户Post的头像地方加入 `class='user_popup'`
templates/content/index.html & explore.html & profile.html
```markup
...
said {{.FormattedTimeAgo}}:
{{ .Body }} |
...
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/8259a0b1347ea5aeab1b6b7351b88d147ce3c01b)
## Links
* [目录](/)
* 上一节: [12-Dates-And-Times](/12-dates-and-times)
* 下一节: [14-Deployment-On-Heroku](/14-deployment-on-heroku)
# 14-Deployment-On-Heroku
在本章，我会将应用部署到Heroku云平台
许多云托管提供商提供了一个应用程序可以运行的托管平台。 你只需提供部署到这些平台上的实际应用程序，因为硬件，操作系统，脚本语言解释器，数据库等都由该服务管理。 这种服务称为平台即服务（PaaS）。
[Heroku](https://www.heroku.com/),这是一种流行的云托管服务,对Python、Go、Nodejs等应用程序支持都很好,关键还免费,而且默认支持HTTPS
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/14-Deployment-On-Heroku), [Diff](https://github.com/bonfy/go-mega-code/compare/13-Javascript-Magic...14-Deployment-On-Heroku), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.4.zip)
## Heroku
Heroku 是首批PaaS平台之一。 它以Ruby的应用程序的托管服务开始，随后逐渐发展到支持诸多其他语言，如Java，Node.js，Python 还有Go。
在 Heroku 中部署Web应用程序主要是通过git版本控制工具完成的，因此你必须将应用程序放在git代码库中。 在通过git将应用程序上传到 Heroku 的服务器之后，你的工作基本就完成了，只需等待几秒钟，应用程序就会上线。 整个操作流程就是这么简单。
Heroku提供不同的服务级别，允许你自主选择为应用程序提供多少计算能力和运行时间，随着用户群的增长，你需要购买更多的“dynos”计算单元。
## 创建Heroku账户
在部署应用到 Heroku 之前，你需要拥有一个帐户。 所以请访问 `heroku.com` 并创建一个免费账户。 一旦注册成功并登录到 Heroku，你将可以访问一个dashboard，其中列出了你的所有应用程序。
## 安装Heroku命令行工具
我们可以在 Heroku 的 dashboard 上完成所有操作，不过还有个更简便的方法，就是安装Heroku cli 工具
```
$ brew install heroku
```
然后我们可以通过命令行来登陆 Heroku
```
$ heroku login
```
## 创建Heroku应用
要用Heroku注册一个新应用，需要在应用程序根目录下使用`apps:create`子命令，并将应用程序名称作为唯一参数传递：
```
$ heroku apps:create go-mega
Creating ⬢ go-mega... done
https://go-mega.herokuapp.com/ | https://git.heroku.com/go-mega.git
```
## 创建 Heroku 数据库
Heroku 只有Postgres数据库是免费的，Mysql是收费的，所以我们还是创建 Postgres 数据库
```
$ heroku addons:add heroku-postgresql:hobby-dev
Creating heroku-postgresql:hobby-dev on ⬢ go-mega... free
Database has been created and is available
! This database is empty. If upgrading, you can transfer
! data from another database with pg:copy
Created postgresql-angular-82467 as DATABASE_URL
Use heroku addons:docs heroku-postgresql to view documentation
```
## 初始化数据
```
$ heroku config
=== go-mega Config Vars
DATABASE_URL: ******************
```
#### 针对Heroku做些代码优化
由于Heroku采用的是 Configvar 的设置环境变量的方式，而且我们把 config.yml git ignore了，所以加入 `os.Getenv` 的方式去获取Configvar的环境变量，包括 DBTYPE, EMAIL相关，以及Heroku postgres 提供的 DATABASE\_URL
config/g.go
```go
package config
import (
"fmt"
"log"
"os"
"strconv"
"github.com/spf13/viper"
)
func init() {
projectName := "go-mega"
dbType := GetDBType()
log.Println("OS DBTYPE:", dbType)
if IsHeroku() {
log.Println("Get Env from os.env")
} else {
log.Println("Init viper")
getConfig(projectName)
}
}
func getConfig(projectName string) {
viper.SetConfigName("config") // name of config file (without extension)
viper.AddConfigPath(".") // optionally look for config in the working directory
viper.AddConfigPath(fmt.Sprintf("$HOME/.%s", projectName)) // call multiple times to add many search paths
viper.AddConfigPath(fmt.Sprintf("/data/docker/config/%s", projectName)) // path to look for the config file in
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s", err))
}
}
// GetMysqlConnectingString func
func GetMysqlConnectingString() string {
usr := viper.GetString("mysql.user")
pwd := viper.GetString("mysql.password")
host := viper.GetString("mysql.host")
db := viper.GetString("mysql.db")
charset := viper.GetString("mysql.charset")
return fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?charset=%s&parseTime=true&loc=Local", usr, pwd, host, db, charset)
}
// GetHerokuConnectingString func
func GetHerokuConnectingString() string {
return os.Getenv("DATABASE_URL")
}
// GetSMTPConfig func
func GetSMTPConfig() (server string, port int, user, pwd string) {
if IsHeroku() {
server = os.Getenv("MAIL_SMTP")
port, _ = strconv.Atoi(os.Getenv("MAIL_SMTP_PORT"))
user = os.Getenv("MAIL_USER")
pwd = os.Getenv("MAIL_PASSWORD")
return
}
server = viper.GetString("mail.smtp")
port = viper.GetInt("mail.smtp-port")
user = viper.GetString("mail.user")
pwd = viper.GetString("mail.password")
return
}
// GetServerURL func
func GetServerURL() (url string) {
if IsHeroku() {
url = os.Getenv("SERVER_URL")
return
}
url = viper.GetString("server.url")
return
}
// GetDBType func
func GetDBType() string {
dbtype := os.Getenv("DBTYPE")
return dbtype
}
// IsHeroku func
func IsHeroku() bool {
return GetDBType() == "heroku"
}
```
修改ConnectToDB函数，支持postgres的数据库形式
model/g.go
```go
...
// ConnectToDB func
func ConnectToDB() *gorm.DB {
if config.IsHeroku() {
return ConnectToDBByDBType("postgres", config.GetHerokuConnectingString())
}
return ConnectToDBByDBType("mysql", config.GetMysqlConnectingString())
}
// ConnectToDBByDBType func
func ConnectToDBByDBType(dbtype, connectingStr string) *gorm.DB {
log.Println("DB Type:", dbtype, "\nConnet to db...")
db, err := gorm.Open(dbtype, connectingStr)
if err != nil {
panic("Failed to connect database")
}
db.SingularTable(true)
return db
}
```
cmd/db\_init/main.go
```go
...
_ "github.com/jinzhu/gorm/dialects/postgres"
...
```
main.go 与数据初始化无关，不过最后部署还是要做响应的调整
main.go
```go
...
_ "github.com/jinzhu/gorm/dialects/postgres"
...
port := os.Getenv("PORT")
log.Println("Running on port: ", port)
http.ListenAndServe(":"+port, context.ClearHandler(http.DefaultServeMux))
```
### 数据init
```
$ export DATABASE_URL=postgres://xxxxxxx
$ export DBTYPE=heroku
$ go run cmd/db_init/main.go
```
然后我们会发现数据初始化就完成了，让我们确认下
```
# 安装 psql
$ brew install postgresql
$ heroku pg:psql
$ DATABASE=> select * from post;
id | user_id | body | timestamp
----+---------+---------------------------------+-------------------------------
1 | 1 | Beautiful day in Portland! | 2018-10-23 07:13:30.664214+00
2 | 2 | The Avengers movie was so cool! | 2018-10-23 07:13:36.118051+00
3 | 2 | Sun shine is beautiful | 2018-10-23 07:13:38.502164+00
# 退出
$ DATABASE=> \q
```
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/43cd0173a5c698b191e42e2c4b244645be01ddd7)
## 部署 Heroku
### 设置Config Vars
可以访问 dashboard 的Config Vars 进行设置
也可以通过heroku cli
```
$ heroku config:set DBTYPE=heroku
# 设置root url
$ heroku config:set SERVER_URL=https://go-mega.herokuapp.com
# 设置mail
$ heroku config:set MAIL_SMTP=smtp.zoho.com
$ heroku config:set MAIL_SMTP_PORT=587
$ heroku config:set MAIL_USER=your_username
$ heroku config:set MAIL_PASSWORD=your_password
# 查看config
$ heroku config
```
### Procfile
Procfile
```
web: go-mega-code
```
现在我们可以通过 `heroku local`来在本地查看应用
```
$ heroku local
```
### Go dep
目前我们的代码和配置都已经完成了，不过部署 heroku 还需要我们提供依赖，我们这里使用 `Godep`
可以参照[Go Dependencies via Godep](https://devcenter.heroku.com/articles/go-dependencies-via-godep)
```
$ go get -u github.com/tools/godep
$ godep save ./...
# 结果可以看见多了两个文件夹: vendor/ 和 Godeps/
```
### Push heroku
```
# Remote add heroku
$ heroku git:remote -a go-mega
set git remote heroku to https://git.heroku.com/go-mega.git
$ git remote -v
heroku https://git.heroku.com/go-mega.git (fetch)
heroku https://git.heroku.com/go-mega.git (push)
origin git@github.com:bonfy/go-mega-code.git (fetch)
origin git@github.com:bonfy/go-mega-code.git (push)
# push branch to heroku master
$ git push heroku 14-Deployment-On-Heroku:master
```
现在访问 就能看见 Demo 了
> Notice: Heroku 绑定域名要收费，所以这里就不绑定域名了
> 本小节 [Diff](https://github.com/bonfy/go-mega-code/commit/6dd19e4cd7e692e28bc1a091318b1d2a8a6126f7)
## Links
* [目录](/)
* 上一节: [13-Javascript-Magic](/13-javascript-magic)
* 下一节: [15-Deployment-On-Linux](/15-deployment-on-linux)
# 15-Deployment-On-Linux
在本章，我将会把应用部署到Linux服务器, 与上一章相比，这种是比较传统的方式
*本章的GitHub链接为：* [Source](https://github.com/bonfy/go-mega-code/tree/15-Deployment-On-Linux), [Diff](https://github.com/bonfy/go-mega-code/compare/14-Deployment-On-Heroku...15-Deployment-On-Linux), [Zip](https://github.com/bonfy/go-mega-code/archive/v1.5.zip)
## Vultr
当提到“传统托管”时，意思是应用是手动或通过原始服务器机器上的脚本安装部署的。 该过程涉及安装应用程序、其依赖项和生产规模的Web服务器，并配置系统以确保其安全。
当你要部署自己的项目时，要问的第一个问题是在哪找服务器。 目前有很多经济的托管服务。 只需每月2.5 - 5美元，[Vultr](https://www.vultr.com/),[Digital Ocean](https://www.digitalocean.com/)和[Linode](https://www.linode.com/)
这里我选择的是 Vultr 创建了 CentOS 7 的linux 服务器
> 广告: 这里大家可以通过这个地址注册 Vultr，我会得到 10 dollar 的奖励，如果想搞个VPS自己玩玩的同学可以考虑下，还能搭个那啥用(自己体会) 链接:
## ssh 免密登陆
```
$ ssh-keygen -t rsa -C 'your email'
$ scp ~/.ssh/id_rsa.pub username@hostname:~/ # 将公钥文件复制至ssh服务器
$ ssh username@hostname # 使用用户名和密码方式登录至ssh服务器
$ mkdir .ssh # 若.ssh目录已存在，可省略此步
$ cat id_rsa.pub >> .ssh/authorized_keys # 将公钥文件id_rsa.pub文件内容追加到authorized_keys文件
```
以后登录ssh 只要输入 `ssh username@hostname` 即可不用输入密码啦
## 安装mysql
```
$ ssh username@hostname
# Install
$ yum -y install mariadb mariadb-serve
# Start mariadb
$ sudo systemctl start mariadb
$ sudo systemctl enable mariadb
# Securing the MariaDB Server
# Set Password
$ sudo mysql_secure_installation
# crate database
$ mysql -uroot -p
$ MariaDB > create database go-mega;
```
## 部署应用
与 Python 相比，Go 部署应用还是算比较方便的，因为它可以编译
### Makefile
为了方便部署，我们这边建一个 `Makefile` 方便我们部署
Makefile
```
.PHONY: clean upload-vps
# Put your server ip or nickname here
host = ny
clean:
@echo "clean..."
@rm -rf app/
@echo "success clean"
build-db:
@echo "run build db..."
@env GOOS=linux go build -o app/db cmd/db_init/main.go
@echo "success build db"
build-server:
@echo "begin build server..."
@env GOOS=linux go build -o app/server main.go
@echo "success build server"
upload-vps: clean build-db build-server
@echo "begin run vps upload..."
@echo "Host: $(host)"
@scp -r app root@$(host):go-mega
@scp config.yml root@$(host):go-mega/
@scp -r templates root@$(host):go-mega/templates
@echo "success vps upload"
```
注意 上面的 Host 修改成 你自己的 Host ip address 或者 Host 别名
然后我们就比较方便了运行
```
$ make upload-vps
```
就可以了，我们可以登录到我们的vps上查看，就多了一个 go-mega 的文件夹了
这里简要做个说明
* clean: 清楚上次的编译二进制文件
* build-db: 编译 cmd/db\_init/main.go -> app/db
* build-server: 编译 main.go -> app/server
* upload-vps: 将 /app 和 templates 文件夹上传到 vps的 \~/go-mega 里
### 运行
```
$ ssh ssh username@hostname
$ cd go-mega
# 设置环境变量 以及 config.yml
$ vi config.yml # 按照config.yml.sample 设置
$ export PORT=8000
# 初始化数据库
$ ./db
# 启动应用
$ nohup ./server &
# 这个时候服务已经启动了，这个时候如果想要访问应用可以使用 nginx反代到 80端口 或者 防火墙开放你设置的端口
# 最好是使用nginx，不过这里为了演示，我们开放下端口
$ firewall-cmd --zone=public --add-port=8000/tcp
```
这个时候我们访问 `http://xxx.xxx.xxx.xxx:8000` 就可以访问你刚才发布的应用了, 大功告成
> 这里暂时不是HTTPS的，如果设置HTTPS，需要你自己申请HTTPS证书和配置nginx，这方面比 Heroku 还是麻烦点
## Links
* [目录](/)
* 上一节: [14-Deployment-On-Heroku](/14-deployment-on-heroku)
* 下一节: [16](/16-summary)
# 16-Summary
前两章部署之后，我们的程序其实就能顺利在服务器上运行，接受用户使用了
我们也终于来到了本系列的最后一章，让我们来总结一下
## 知识点
本系列教程使用 Go 语言从无到有实现一个类似初级版 Twitter 的 web网站，主要涉及到了以下的知识点:
* 表单
* 模板
* 数据库
* 路由
* 登陆验证
* MVC
* 分页
* Mail
* 部署
* Ajax
* Jwt
与原教程 Flask-Mega 相比，我们主要少了 `全文搜索`、`Docker`、`用户通知` 这几个章节
* 其中 Docker 对于 Go 程序来说还是很方便的，因为 Go 可以直接编译成二进制程序，所以一种写 Dockerfile 的思路就是先编译 然后 COPY 进 container 就行了
* 全文搜索 其实是对 Elasticsearch 的依赖，其实 Go 也有响应的库支持，这里不引入只是一开始就只打算加一个数据库，不想涉及更多的依赖，增加程序的复杂性
* 用户通知其实是对 Ajax 和 API 的更深入的一种实现，其实有了前面的知识，还是很容易能完成这个功能，如果说有点难度，只是 Go 的Template 没有Flask 那么灵活而已
## 总结
这是我第一次系统性地完成编写一套系列教程
由于有个Flask-Mega的模板在，在章节设计方面已经节省了好多时间，不过 代码 和 文字方面还是要花费不少的精力，基本上3天一章已经是极限（毕竟还是要上班养家糊口的）
通过编写这个系列教程，也算是我自己重新梳理了下知识结构，相信有这个教程在，也避免了我写完就忘的神奇特性（以前也写过好多程序，过段时间回首，知识剩下的就不多了）
好记性不如烂笔头，写下来方便自己，如果还能方便他人，那真的是再好不过了。
## 后续
后续首要第一件事情就是休息，先休息一段时间
然后在下面几方面好好整理，写点东西
* Test
* Restful API
* GraphQL
## 支持我
如果您感觉有收获，欢迎给我打赏，以激励我输出更多优质内容，感谢支持！
