go web 项目记录（二）注册登录功能：0.简单实现

登录的流程

首先，咱们在浏览器栏输入：
api/name_login
然后弹出登录页面，让你输入用户名和密码
提交之后生成POST表单传到后端
后端去数据库看有没有这个用户，没有就创建一个

注册路由

在main函数中加上

RegisterRouter(engine)

func RegisterRouter(engine *gin.Engine){
	new(controller.MemberController).Router(engine)
}

Controller层的处理

然后咱们在MemberController中写上对应的url和注册函数；
也就是engine.GET(“url”,注册函数)
这里的逻辑就是：
从POST表单中拿到用户名和密码
然后用这个用户名和密码去注册

表单实体绑定

要解决的第一个问题是，怎么把表单和一个对应的实体绑定起来？
咱们先在param/LoginParam.go中写好登录的参数：

package param

type LoginParam struct{
	Name string `form:"name"`
	PassWord string `form:"password"`
}

这样，我们就可以用ShouldBind函数来实现将表单从context绑定到loginParam对象中

var loginParam param.LoginParam
err := context.ShouldBind(&loginParam)

下一步，咱们调用MemberService注册，我们传过去用户名和密码，收到的是用户实体，那么我们现在就创建用户实体，顺便把数据库表中用户表也建起来，用户实体和用户表字段一一对应哦

建立用户模型和用户表

用户模型model/Member.go：

package model

type Member struct {
	Id           int64   `xorm:"pk autoincr" json:"id"`
	UserName     string  `xorm:"varchar(20)" json:"user_name"`
	Mobile       string  `xorm:"varchar(11)" json:"mobile"`
	Password     string  `xorm:"varchar(255)" json:"password"`
	RegisterTime int64   `xorm:"bigint" json:"register_time"`
	Avatar       string  `xorm:"varchar(255)" json:"avatar"`
	Balance      float64 `xorm:"double" json:"balance"`
	IsActive     int8    `xorm:"tinyint" json:"is_active"`
	City         string  `xorm:"varchar(10)" json:"city"`
}

连接数据库

在配置文件中加入数据库的配置

"database": {
    "driver": "mysql",
    "user": "root",
    "password": "12345678",
    "host": "127.0.0.1",
    "port": "3306",
    "db_name": "cloudrestaurant",
    "charset": "utf8mb4",
    "show_sql": true
}

然后在解析配置的文件tool/Config.go中加入数据库的配置结构：
在Config类型中加入：

Database DatabaseConfig `json:"database"`

加入DatabaseConfig类型：

type DatabaseConfig struct{
	Driver string `json:"driver"`
	User string `json:"user"`
	Password string `json:"password"`
	Host string `json:"host"`
	Port string `json:"port"`
	DbName string `json:"db_name"`
	Charset string `json:"charset"`
	ShowSql bool `json:"show_sql"`
}

配置完事之后就可以在主函数使用配置来连接数据库啦
这里咱们先import mysql驱动和xorm这两个包进来，帮助我们操作数据库
我们要使用xorm.NewEngine，
传入连接url：用户名:密码@tcp(localhost:3306)/数据库名?字符集=XX
返回xorm的引擎实例
这个引擎可以干嘛呢？
1.把数据库表字段和我们代码定义的对象属性绑定在一起（engine.Sync2）
2.可以在代码中执行一些sql语句查询，查询结果绑定到我们指定的对象中（engine.Where）
这里我们还要定义一个全局变量DbEngine，以后咱们的dao层是要用到的

package tool

import (
	_ "github.com/go-sql-driver/mysql"
	"github.com/go-xorm/xorm"
	"helloGin/model"
)

var DbEngine *Orm

type Orm struct{
	*xorm.Engine
}

func OrmEngine(config *Config)(*Orm,error){
	database := config.Database
	conn := database.User+":"+database.Password+"@tcp("+database.Host+":"+database.Port+")/"+database.DbName+"?charset="+database.Charset
	engine,err := xorm.NewEngine(database.Driver,conn)
	if err!=nil {
		return nil,err
	}

	engine.ShowSQL(database.ShowSql)

	err = engine.Sync2(new(model.Member))
	if err != nil {
		return nil,err
	}

	orm := new(Orm)
	orm.Engine=engine
	DbEngine=orm

	return orm,nil
}

controller层的代码

package controller

import (
	"github.com/gin-gonic/gin"
	"helloGin/param"
	"helloGin/service"
	"helloGin/tool"
)

type MemberController struct{

}

func (login *MemberController) Router(engine *gin.Engine){
	engine.POST("/api/name_login",login.NameLogin)
}

func (login *MemberController) NameLogin(context *gin.Context){
	//从context中拿到用户名和密码
	var loginParam param.LoginParam
	err := tool.Decode(context.Request.Body,&loginParam)
	if err != nil {
		tool.Fail(context,"登录参数解析失败0.0")
	}

	//调用用户服务来注册/登录
	ms := service.MemberService{}
	member := ms.NameLogin(loginParam.Name,loginParam.PassWord)
	if  != nil {
		tool.Success(context,"登录失败0.0")
	}
	tool.Fail(context,"登录成功0.0")
}

sevice层的处理

这里我们要写一个用户注册的服务给controller层使用，controller传过来两个参数：用户名和密码，返回一个用户对象
那么这里我们的逻辑就是：
根据用户名和密码去数据库拿到对应的用户
如果在数据库中用户名不存在就创建一个用户

package service

import (
	"helloGin/dao"
	"helloGin/model"
	"helloGin/tool"
	"time"
)

type MemberService struct{

}

func (ms *MemberService) NameLogin(name string,password string) *model.Member{
	md := dao.MemberDao{tool.DbEngine}
	member := md.Query(name,password)
	if member.Id != 0 {
		return member
	}

	user := model.Member{}
	user.UserName = name
	user.Password = password
	user.RegisterTime = time.Now().Unix()
	md.InsertMember(user)

	return &user
}

dao层的处理

package dao

import (
	"helloGin/model"
	"helloGin/tool"
	"log"
)

type MemberDao struct{
	*tool.Orm
}

func (md *MemberDao) Query(username string,password string) *model.Member{
	var member model.Member
	_,err := md.Where("user_name = ? and password = ?",username,password).Get(&member)
	if err != nil {
		log.Fatal(err.Error())
	}

	return &member
}

func (md *MemberDao) InsertMember(member model.Member) int64 {
	result,err := md.InsertOne(&member)
	if err != nil {
		log.Fatal(err.Error())
		return 0
	}
	return result
}

存在的问题

1.注册登录的逻辑有问题
原来的逻辑是：
用户传过来（用户名+密码）
到数据库去判断（用户名+密码）是否存在
存在就登录成功
不存在就注册这个（用户名+密码），登录成功

问题：如果用户输入的用户名存在，但是输错密码了，那按照上面的逻辑，我们还是去注册这个（用户名+输错的密码）

逻辑应该改成：
用户传过来（用户名+密码）
到数据库去判断用户名是否存在
存在就判断密码是否正确，正确就登录成功，反之失败
不存在就注册这个（用户名+密码），登录成功

2.controller层中，调用用户注册服务，传过去（用户名+密码），应该返回（用户对象+是否登录成功）而不是只返回用户对象然后根据ID==0来判断是否登录成功

在基础的注册登录上还可以实现什么功能？

1.用户名不能包含敏感词汇
2.密码要求满足一定的密码等级
3.对密码进行加密存储
4.1个小时之内登录失败不能超过5次
5.异地登录给用户报警，用户可以冻结账户
6.其他登录方式
7.基于雪花算法生成用户id
8.提供记住密码功能
9.JWT认证
10.限制账号同一时间只能在一台设备登录