以注册为例展示对service层的调用

一、编写注册接口进行测试

一切看起来都是那么的完么，编写一下注册接口，测试一下

在main.go中定义注册路由和注册方法 15、以注册为例展示对service层的调用 - 图1

注册方法

15、以注册为例展示对service层的调用 - 图2

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     _ "github.com/go-sql-driver/mysql"
  7.     "github.com/go-xorm/xorm"
  8.     "hello/model"
  9.     "hello/service"
  10.     "html/template"
  11.     "log"
  12.     "math/rand"
  13.     "net/http"
  14. )
  16. // 登录方法
  17. func userLogin(writer http.ResponseWriter, request *http.Request) {
  18.     //数据库操作
  19.     //逻辑处理
  20.     //restapi json/xml 返回
  21.     //1.获取前端传递的参数
  22.     //mobile,passwd
  23.     //如何获取参数
  24.     //解析参数
  25.     request.ParseForm()
  26.     mobile := request.PostForm.Get("mobile")
  27.     passwd := request.PostForm.Get("passwd")
  29.     loginOk := false
  30.     if mobile == "15313311315" && passwd == "123456" {
  31.         loginOk = true
  32.     }
  34.     if loginOk {
  35.         //{"id":1,"token":"xx"}
  36.         data := make(map[string]interface{})
  37.         data["id"] = 1
  38.         data["token"] = "test"
  39.         Resp(writer, 0, data, "登录成功")
  40.     } else {
  41.         Resp(writer, -1, nil, "密码不正确")
  42.     }
  43. }
  45. var userService service.UserService
  47. // 注册方法
  48. func userRegister(writer http.ResponseWriter, request *http.Request) {
  49.     //数据库操作
  50.     //逻辑处理
  51.     //restapi json/xml 返回
  52.     //1.获取前端传递的参数
  53.     //mobile,passwd
  54.     //如何获取参数
  55.     //解析参数
  56.     request.ParseForm()
  57.     mobile := request.PostForm.Get("mobile")
  58.     plainpwd := request.PostForm.Get("passwd")
  59.     nickname := fmt.Sprintf("user%06d", rand.Int31())
  60.     avatar := ""
  61.     sex := model.SEX_UNKNON
  62.     user, err := userService.Register(mobile, plainpwd, nickname, avatar, sex)
  63.     //登录失败
  64.     if err != nil {
  65.         Resp(writer, -1, nil, err.Error())
  66.     } else {
  67.         Resp(writer, 0, user, "")
  68.     }
  69. }
  71. func RegisterView() {
  72.     //把模版解析并且显示出来
  73.     //tpl得到模版的指针
  74.     //ParseGlob 满足这种格式的都可以解析出来 ** 表示目录  * 表示文件
  75.     tpl, err := template.ParseGlob("view/**/*") //filename是模版的相对路径
  76.     //如果报错就不用继续走啦
  77.     if err != nil {
  78.         //直接退出和fmt.Printf不一样
  79.         log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  80.     }
  82.     for _, v := range tpl.Templates() {
  83.         //参数2 模版的名称是view视图上方define定义的名字
  84.         //参数3 需要往视图传递的数据，不需要nil
  85.         tplname := v.Name()
  86.         //循环注册
  87.         http.HandleFunc(tplname, func(writer http.ResponseWriter, request *http.Request) {
  88.             tpl.ExecuteTemplate(writer, tplname, nil)
  89.         })
  90.     }
  92. }
  94. // 定义一个全局变量 对应的是一个指针
  95. var DbEngin *xorm.Engine
  97. // init 在main函数运行的时候自动运行的
  98. func init() {
  99.     //DbEngin进行初始化
  100.     driverName := "mysql"
  101.     DsName := "root:@(127.0.0.1:3306)/chat?charset=utf8"
  102.     DbEngin, err := xorm.NewEngine(driverName, DsName)
  103.     if err != nil {
  104.         //直接退出和fmt.Printf不一样
  105.         log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  106.     }
  108.     //进行一些设置，在调试模式的设置
  109.     //是否显示sql语句
  110.     DbEngin.ShowSQL(true)
  111.     //数据库最大链接数，线上环境自己设置，这个直接影响数据库的性能
  112.     DbEngin.SetMaxOpenConns(2)
  113.     //自动建表User
  114.     //DbEngin.Sync2(new(User))
  115.     //打印一下是否初始化成功
  116.     fmt.Println("init data base ok")
  117. }
  119. type H struct {
  120.     Code int         `json:"code"`
  121.     Msg  string      `json:"msg"`
  122.     Data interface{} `json:"data,omitempty"` //omitempty如果为空则不显示
  123. }
  125. func Resp(w http.ResponseWriter, code int, data interface{}, msg string) {
  126.     //设置header 为JSON 默认的text/html,所以特别指出返回的为application/json
  127.     w.Header().Set("Content-Type", "application/json")
  128.     //设置200状态
  129.     w.WriteHeader(http.StatusOK)
  131.     //定义一个结构体
  132.     h := H{
  133.         Code: code,
  134.         Msg:  msg,
  135.         Data: data,
  136.     }
  137.     //将结构体转化成JSON字符串
  138.     ret, err := json.Marshal(h)
  139.     if err != nil {
  140.         log.Println(err.Error())
  141.     }
  143.     //输出
  144.     w.Write([]byte(ret))
  145. }
  146. func main() {
  147.     //把前端请求的格式和封装处理函数进行绑定的标签
  148.     //绑定请求和处理函数
  149.     http.HandleFunc("/user/login", userLogin)
  150.     //注册路由
  151.     http.HandleFunc("/user/register", userRegister)
  152.     //1.提供静态资源目录支持
  153.     //http.Handle("/", http.FileServer(http.Dir("."))) //当前目录
  154.     //2.提供指定目录的静态文件支持
  155.     http.Handle("/asset/", http.FileServer(http.Dir("."))) //第一个是格式
  157.     /*
  158.         //定义可以允许访问的模版 user/login.shtml
  159.         http.HandleFunc("/user/login.shtml", func(writer http.ResponseWriter, request *http.Request) {
  160.             //把模版解析并且显示出来
  161.             //tpl得到模版的指针
  162.             tpl, err := template.ParseFiles("view/user/login.html") //filename是模版的相对路径
  163.             if err != nil {
  164.                 //直接退出和fmt.Printf不一样
  165.                 log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  166.             }
  168.             //参数2 模版的名称是view视图上方define定义的名字
  169.             //参数3 需要往视图传递的数据，不需要nil
  170.             tpl.ExecuteTemplate(writer, "/user/login.shtml", nil)
  171.         })
  173.         //定义可以允许访问的模版 user/register.shtml
  174.         http.HandleFunc("/user/register.shtml", func(writer http.ResponseWriter, request *http.Request) {
  175.             //把模版解析并且显示出来
  176.             //tpl得到模版的指针
  177.             tpl, err := template.ParseFiles("view/user/register.html") //filename是模版的相对路径
  178.             if err != nil {
  179.                 //直接退出和fmt.Printf不一样
  180.                 log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  181.             }
  183.             //参数2 模版的名称是view视图上方define定义的名字
  184.             //参数3 需要往视图传递的数据，不需要nil
  185.             tpl.ExecuteTemplate(writer, "/user/register.shtml", nil)
  186.         })
  187.     */
  189.     RegisterView()
  190.     //启动web服务器
  191.     http.ListenAndServe(":8080", nil)
  192. }

启动服务，如果服务启动失败，则按照一下步骤进行排错 15、以注册为例展示对service层的调用 - 图3

如果启动服务报以下错误，说明没有表结构

15、以注册为例展示对service层的调用 - 图4

需要使用以下解决方案,以下方法可以方法可以自动创建表结构 15、以注册为例展示对service层的调用 - 图5

之后在请求就可以得到一些相关信息 15、以注册为例展示对service层的调用 - 图6

service/init.go代码

  1. package service
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "github.com/go-xorm/xorm"
  7.     "hello/model"
  8.     "log"
  9. )
  11. // 定义一个全局变量 对应的是一个指针
  12. var DbEngin *xorm.Engine
  14. // init 在main函数运行的时候自动运行的
  15. func init() {
  16.     //DbEngin进行初始化
  17.     driverName := "mysql"
  18.     DsName := "root:@(127.0.0.1:3306)/chat?charset=utf8"
  19.     //这个操作有可能是变量再次赋值了，所以有可能是个nil
  20.     //DbEngin, err := xorm.NewEngine(driverName, DsName)
  21.     //if err != nil {
  22.     //    //直接退出和fmt.Printf不一样
  23.     //    log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  24.     //}
  26.     err := errors.New("")
  27.     DbEngin, err = xorm.NewEngine(driverName, DsName)
  28.     if nil != err && "" != err.Error() {
  29.         //直接退出和fmt.Printf不一样
  30.         log.Fatal(err.Error()) //Fatal函数作用，如果模版渲染出错了，这个应用不用往下跑了，直接退出
  31.     }
  33.     //进行一些设置，在调试模式的设置
  34.     //是否显示sql语句
  35.     DbEngin.ShowSQL(true)
  36.     //数据库最大链接数，线上环境自己设置，这个直接影响数据库的性能
  37.     DbEngin.SetMaxOpenConns(2)
  38.     //自动建表User
  39.     DbEngin.Sync2(new(model.User))
  40.     //打印一下是否初始化成功
  41.     fmt.Println("init data base ok")
  42. }

发现返回的结果集没有token,进行处理下token 15、以注册为例展示对service层的调用 - 图7

再次运行发现token已经存在了 15、以注册为例展示对service层的调用 - 图8

到此我们的注册逻辑就已经全部完毕了