Golang 从0到1之任务提醒(二)

接着上篇文章Golang 从0到1之任务提醒(一)，上篇文章把基础功能搭建的差不多了。还剩下核心的定时推送消息以及接收微信消息处理。

定时器

如何定时执行提醒推送呢？

我们可以开启一个定时器，每小时去获取一次下一个小时内需要推送的任务。

package handlers
import (  "fmt"  "go-remind/logic"  "go-remind/models"  "go-remind/server"  "go-remind/tools"  "time")
var isFirst bool = true
func Scheduler() {  var job logic.JobLogic  for {    if !isFirst {      timer := time.NewTicker(1 * time.Hour)      <-timer.C    }    isFirst = false
    // 获取接下来一小时内需要发送的任务列表    now := tools.GetCurrTime()    h, _ := time.ParseDuration("1h")    jobs, err := job.GetJobsByTime(tools.TimeString(now), tools.TimeString(now.Add(1*h)))    if err != nil {      fmt.Printf("出错了：%v", err)      return    }    // 任务通道    ch := make(chan models.Job, 100)    jobFunc := func(ch <-chan models.Job) {      for item := range ch {        // 发送通知        go HandleJob(item)      }    }    // 处理任务    go jobFunc(ch)    // 投递任务    for _, job := range jobs {      ch <- job    }  }}

‍‍isFirst 默认值是 true。它的作用是，如果是第一次项目启动的时候，那么作为初始化先去拉取一遍小时内全量任务。我们看 Scheduler 逻辑，前半部分的逻辑就是通过定时器固定周期去拉取要执行的任务，然后创建一个缓冲的通道，

ch := make(chan models.Job, 100)

把从数据库中拉取的任务都丢进通道中，另开一个 G 用来从通道中接收并执行提醒任务。这里每个提醒任务都单独开启一个 G 执行。

jobFunc := func(ch <-chan models.Job) {      for item := range ch {        // 发送通知        go HandleJob(item)      }    }    // 处理任务    go jobFunc(ch)    // 投递任务    for _, job := range jobs {      ch <- job    }

主要看HandleJob(item) 操作，

func HandleJob(job models.Job) {  now := tools.GetCurrTime()  noticeTime, _ := time.ParseInLocation(tools.TimeFormat,    job.NoticeTime.Format(tools.TimeFormat), time.Local)  diff := noticeTime.Sub(now)  timer := time.NewTimer(diff)  <-timer.C

  var sendTool server.Message  sendTool = &server.SmsMsg{Job: job}  if job.Phone == "" {    sendTool = &server.EmailMsg{Job: job}  }  err := server.Notice(sendTool)  //成功与否  isOk := models.JobSuccess  jobLogic := logic.JobLogic{}  if err != nil {    isOk = models.JobFail    fmt.Printf("通知失败:%v", err)  }  _ = jobLogic.UpdateStatusById(job.Id, isOk)
}

前半部分就是计算当前时间距离任务执行间隔时间，对应单独设置一个定时器，任务的真正执行时间取决于用户自己设定的提醒时间。

这里实现并不是很好，想象我们当前一小时内有 10w 个任务，那么必然会开启 10w 个 G 来执行，每个 G 都有自己的定时器，在更极端的情况下，所有任务都集中在五十几分钟，你已经可以想象了。

我们可以分批去取，比如按照时间顺序每次获取 100 个任务 A，这样的话后100 个任务 B，他们在任务执行时间的关系一定是：B>=A。

然后通过 go 开箱即用的并发控制技术 sync.WaitGroup 来等待控制。这算是一种优化方向。

接下来看，

var sendTool server.Message

Message 是一个接口类型，代表发送任务通知的动作。

type Message interface {  SendMessage() error}

底下的 EmailMsg 和 PhoneMsg 都隐式实现了此接口，完成具体的发送操作洗细节。(ps:短信懒的接第三方了)

type EmailMsg struct {  Job models.Job}
func (email *EmailMsg) SendMessage() error {  fmt.Printf("成功给%s发送邮件\n", email.Job.Email)
  sendMail := gomail.NewMessage()  sendMail.SetHeader(`From`, ConfAll.Email.User)  sendMail.SetHeader(`To`, email.Job.Email)  sendMail.SetHeader(`Subject`, "来自吴亲库里的温馨提醒")  sendMail.SetBody(`text/html`, email.Job.Content)  err := gomail.NewDialer(    ConfAll.Email.Host, ConfAll.Email.Port, ConfAll.Email.User,    ConfAll.Email.Pass).DialAndSend(sendMail)  if err != nil {    return err  }  return nil}
type SmsMsg struct {  Job models.Job}
func (email *SmsMsg) SendMessage() error {  fmt.Printf("成功给%s发送短信\n", email.Job.Phone)  return nil}

回头看HandleJob，如果填了手机号，优先选择手机号，否则就发邮箱通知。

看这行代码，

  err := server.Notice(sendTool)

func Notice(msg Message) error {  return try.Do(func(attempt int) (retry bool, err error) {    err = msg.SendMessage()    if err != nil {      return attempt < try.MaxRetries, err    }    return true, nil  })}

msg.SendMessage 就是实际的执行发送操作，再看看 try.Do 是干嘛的。

// 最大允许重试次数var MaxRetries = 3var errMaxRetriesReached = errors.New("exceeded retry limit")
type Func func(attempt int) (retry bool, err error)
func Do(fn Func) error {  var err error  var cont bool  attempt := 1  for {    if attempt > 1 {      time.Sleep(2 * time.Second)    }    cont, err = fn(attempt)    if !cont || err == nil {      break    }    attempt++    if attempt > MaxRetries {      return errMaxRetriesReached    }  }  return err}

其实就是一个重试的操作，我稍微解释一下这段代码。

首先最外面是个死循环，如果 attempt 等于1，说明是第一次执行，运行自己传递的闭包函数，也就是执行任务。否则的话，代表此次是重试，先等待一段时间。

cont 表示是否超过最大重试次数，是个 bool 值。err 代码运行有无错误。那么底下这句代码就是判断：如果超过最大重试次数或者任务处理是正常的，两者有一个满足就可以退出这段程序了。

if !cont || err == nil {      break    }

这个函数最终返回一个 err，如果不为空，说明最终任务经历过重试还是执行失败，那么就真的失败了，标记任务失败。

  err := server.Notice(sendTool)  //成功与否  isOk := models.JobSuccess  jobLogic := logic.JobLogic{}
  if err != nil {    isOk = models.JobFail    fmt.Printf("通知失败:%v", err)  }  _ = jobLogic.UpdateStatusById(job.Id, isOk)

为什么需要重试？

简单的说，与外部有依赖的操作本身就是不可控的，尤其是网络波动。出现这种情况，就需要通过重试机制去保障服务的正常。

但是重试也是有限制的，不可能短期内无休止的去重试一个服务。抛开网络波动，在一定时间内重试失败大概率不要指望短时间能恢复服务了，这样造成的数据损失，在事后恢复，经常被人高大上称之为最终一致性，很多时候，往往就是人肉罢了。

这里很骚的一个操作，重试时间直接被我定住了，真实。

time.Sleep(2 * time.Second)

解析微信消息

接下来看看处理微信消息。上篇文章已经把主要微信接收的代码写上了，现在我们主要是解析发送的信息，入库而已。没什么黑科技，靠的就是正则匹配。

//时间匹配var TimeMatch = contentRegexp{regexp.MustCompile(  `(今天|明天|后天|大后天|[\d]{4}-[\d]{2}-[\d]{2}\s[\d]{2}:[\d]{2}|[\d]{8}\s[\d]{1,2}:[\d]{1,2}|[[\d]{1,2}:[\d]{1,2}|[\d]{1,2}(个月|小时|点|分钟|分|秒|周|天))`,)}
//手机号匹配var PhoneMatch = contentRegexp{regexp.MustCompile(  `(1[356789]\d)(\d{4})(\d{4})`,)}
//邮箱匹配var EmailMatch = contentRegexp{regexp.MustCompile(  `(\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*)`,)}

func HandleMessage(content string) (string, error) {  phone := tools.PhoneMatch.FindStringSubmatch(content)  email := tools.EmailMatch.FindStringSubmatch(content)  if phone == nil || email == nil {    return "不留下联系方式我咋么联系上你", RequestFormatErr  }  mmp := tools.TimeMatch.FindAllStringSubmatch(content, -1)  if mmp == nil {    return "我得再升升级才能满足你的时间格式", RequestFormatErr  }
  // 最大匹配到分  if len(mmp) > 3 {    mmp = mmp[:3]  }  var sendDate string  //....  //省略一万行解析代码  //...
  sendTimer := tools.StringToTimer(sendDate + ":00")  diff := sendTimer.Sub(tools.GetCurrTime())  if diff < 0 {    return "过期的时间就别让我通知了", RequestFormatErr  }
  jobLogic := &logic.JobLogic{}  job := logic.NewJob(content, sendTimer, phone[0], email[0])  err := jobLogic.Insert(job)  if err != nil {    return "请检查输入内容", RequestFormatErr  }
  if diff.Minutes() < 0 {    return fmt.Sprintf("%s秒后短信提醒内容:%s", tools.Decimal(diff.Seconds()), content), nil  }
  if diff.Hours() < 1 {    //小于1个小时直接加入到定时器    go func() {      HandleJob(job)    }()    return fmt.Sprintf("%s分钟后短信提醒内容:%s", tools.Decimal(diff.Minutes()), content), nil  }  return fmt.Sprintf("%s小时后短信提醒内容:%s", tools.Decimal(diff.Hours()), content), nil}

‍上面一部分主要是去解析数据，比如通知时间、手机号、邮箱。

后面还有一个操作，之前我们是以 1 小时为单位的定时器，如果这个新增任务的时间属于当前小时内的，那么我们在入库的同时丢给刚才的 HandleJob 。

然后在主函数中专门开个 g 去运行这个定时任务，这样整体的流程就连接起来了。

r := gin.Default()  go func() {    handlers.Scheduler()  }()  r.POST("/msg", handlers.Message)
  _ = r.Run(":8099")

到这里，我们就已经把最小可行性的项目运行起来了。

但是还是有很多可以优化的点，这个后续我随着优化。感兴趣的可以给我提 PR。

哦对了，单元测试都没写。咋么能不写单元测试呢，致命打击。

项目放在：https://github.com/wuqinqiang/go-remind 感兴趣可以看看。

推荐阅读：

在Go中，你犯过这些错误吗

资料下载

点击下方卡片关注公众号，发送特定关键字获取对应精品资料！

回复「电子书」，获取入门、进阶 Go 语言必看书籍。
回复「视频」，获取价值 5000 大洋的视频资料，内含实战项目（不外传）！
回复「路线」，获取最新版 Go 知识图谱及学习、成长路线图。
回复「面试题」，获取四哥精编的 Go 语言面试题，含解析。
回复「后台」，获取后台开发必看 10 本书籍。

对了，看完文章，记得点击下方的卡片。关注我哦~ ???

如果您的朋友也在学习 Go 语言，相信这篇文章对 TA 有帮助，欢迎转发分享给 TA，非常感谢！

96000Golang 从0到1之任务提醒(二)

Golang 从0到1之任务提醒(二)

文章评论