type BaseController struct {
	beego.Controller
}

type JsonStruct struct {
	Code  int         `json:"code"`
	Msg   string      `json:"msg"`
	Data  interface{} `json:"data,omitempty"`
	Count int64       `json:"count,omitempty"`
}

func (c *BaseController) ReturnSuccess(msg string, data interface{}, count int64) {
	json := &JsonStruct{Code: 0, Msg: msg, Data: data, Count: count}
	c.Data["json"] = json
	c.ServeJSON()
}

func (c *BaseController) ReturnError(code int, msg string) {
	json := &JsonStruct{Code: code, Msg: msg}
	c.Data["json"] = json
	c.ServeJSON()
}

去掉返回值，直接就写入服务器，其他代码和之前基本一致。后续的使用方式，看下文。

水电费

这里采用注解的方式实现路由，只需要在routers文件夹下面的router.go文件添加 beego.Include(&controllers.LoginController{})一行代码即可。这样，http://localhost:8001/Login/login 接口我们就可以使用了。代码中可以看出，我们采用结构体的方式接受请求的参数，注意，json请求方式也是这么获取的。valid属性是验证器的属性，具体使用方式，本文不做具体探讨，后续会添加进来。首先我们从redis里面获取信息，没有就数据库取，这就有可能造成缓存击穿的根本原因。但是，作为登录接口，会出现雪崩的概率还是很低的，毕竟登录不会出现大范围的同时登录操作吧。这里使用了redis连接池的方式连接。checkParams函数，在实战中不要这么写，返回值不应该写在模块函数中，这里是为了验证，即使有返回，在Login请求接口中，后续代码会继续执行，但是前面已经写入到server中，web端不会继续出现。这里还有session的写入和读取，以及密码5次错误的限制，通过redis的方式实现的。换句话说，这个接口，使用了我们之前说到的所有方式。

这里延续的是登录接口的实现方式，这里主要看下数据库的写法。在models文件夹下面创建user.go文件。添加了时间，方便后续的改写做对比。性能不强求，先看用法，我们再来分析。

//验证登录信息
func LoginInfo(loginId string) (CLogin, error) {
	var (
		err  error
		user CLogin
	)
	o := orm.NewOrm()
	user = CLogin{LoginId: loginId}
	err = o.Read(&user, "LoginId")
	return user, err
}

//获取用户信息
func GetUserInfo(loginId string) ([]orm.Params, error) {
	var (
		err error
	)
	o := orm.NewOrm()
	var maps []orm.Params
	_, err = o.Raw("select l.* from c_login as l join c_roles as r on l.role_id=r.id where l.LoginId=?", loginId).Values(&maps)
	return maps, err
}

//获取角色信息
func GetRole(roleId int) ([]orm.Params, error) {
	var (
		err  error
		maps []orm.Params
	)
	o := orm.NewOrm()
	_, err = o.Raw("select * from  c_roles where id=?", roleId).Values(&maps)
	return maps, err
}

//获取角色权限
func GetRoleSession(roleId int) ([]orm.Params, error) {
	var (
		err  error
		maps []orm.Params
	)
	o := orm.NewOrm()
	_, err = o.Raw("select p.id,p.url,p.name, p.code,1 as checked from c_role_power as r join c_power as p on r.pid = p.id where r.rid=?", roleId).Values(&maps)
	return maps, err
}

//获取角色权限
func GetMenu() ([]orm.Params, error) {
	var (
		err  error
		maps []orm.Params
	)
	o := orm.NewOrm()
	_, err = o.Raw("select id,level,pid,name,url,icon,path,code from c_power where id>?", 0).Values(&maps)
	return maps, err
}

//通过id获取登录表信息
func LoginInfoFromId(id int) (*CLogin, error) {
	var (
		err error
		use CLogin
	)
	o := orm.NewOrm()
	querySetter := o.QueryTable("c_login")
	querySetter = querySetter.Filter("id", id)
	err = querySetter.One(&use)
	return &use, err
}

这是前面准备工作中的内容，直接照抄就可以了。切记，使用到的表记得注册。涉及到的结构体必须要使用前先注册，否则会报错gob: name not registered for interface
gob.Register(models.CLogin{})

这边笔者的请求时间大概是：180毫秒。不同环境时间不同，只要存在唯一变量就行了。

//添加协程处理，对比请求时间
// @router  /user/info [get]
func (c *LoginController) User() {
	var (
		user        models.CLogin
		err         error
		result      map[string]interface{}
		login       []orm.Params
		role        []orm.Params
		roleSession []orm.Params
		menu        []orm.Params
	)
	timeStart := time.Now().UnixNano()/1e6
	result = make(map[string]interface{})
	sessionData := c.GetSession("user")
	if nil != sessionData {
		user = sessionData.(models.CLogin)
	} else {
		c.ReturnError(-3001, "用户信息获取失败")
		return
	}
	var wg sync.WaitGroup//637毫秒
	//go 协程处理
	wg.Add(1)
	go func() {
		defer wg.Done()
		login, err = models.GetUserInfo(user.LoginId)
		if err == nil {
			tempLogin := login[0]
			for key := range tempLogin {
				result[key] = tempLogin[key]
			}
		}
	}()

	//go 协程处理
	wg.Add(1)
	go func() {
		defer wg.Done()
		role, err = models.GetRole(user.RoleId)
		if err == nil {
			result["role"] = role[0]
		}
	}()

	//go 协程处理
	wg.Add(1)
	go func() {
		defer wg.Done()
		roleSession, err = models.GetRoleSession(user.RoleId)
		if err == nil {
			result["role_session"] = roleSession
		} else {
			fmt.Println("获取role_session失败：", err)
		}
	}()

	//go 协程处理
	wg.Add(1)
	go func() {
		defer wg.Done()
		menu, err = models.GetMenu()
		byteJson, _ := json.Marshal(menu)
		tempData := make([]models.CPower, 0)
		menuData := make([]models.CPower, 0)
		err = json.Unmarshal(byteJson, &tempData)
		if err != nil {
			fmt.Println("获取 menu 失败：", err)
		}
		for key := range tempData {
			if menu[key]["level"] == "1" {
				menuData = append(menuData, tempData[key])
			}
		}
		for keyMenu := range menuData {
			childData := make([]models.CPower, 0)
			for key := range tempData {
				if menuData[keyMenu].Id == tempData[key].Pid {
					childData = append(childData, tempData[key])
					menuData[keyMenu].Child = childData
				}
			}
		}
		result["menu"] = menuData
	}()
	wg.Wait()

	timeEnd := time.Now().UnixNano()/1e6
	logs.Info("timeEnd-timeStart", timeEnd-timeStart)
	c.ReturnSuccess("请求成功", result, timeEnd-timeStart)
}

请求的时间是657毫秒。