gin框架和xorm的学习

#联合使用（都在一个文件中使用）

package main

import (
	"github.com/go-xorm/xorm"
	"log"
	_"github.com/go-sql-driver/mysql"
	"fmt"
	"os"
	"github.com/gin-gonic/gin"
	"net/http"
	"time"
	"strconv"
)

type Person struct {
	Id int64
	UserName string
	UserSex string
	UserPs string
}

type Student struct {
	Id int64
	UserName string
	UserSex string
	UserAge int64
	CreatedTime time.Time `xorm:"created"`

}

type Worker struct {
	Id int64
	UserName string
	Money int
	Version int   `xorm:"version"`
}

var engine *xorm.Engine   //在外部申明一个变量，用来每次接口调用连接数据库

func init(){
	var err error
	engine,err = xorm.NewEngine("mysql","root:123456@tcp(localhost:3306)/ginmysql?charset=utf8")

	if err != nil {
		log.Fatal(err)
		return
	}
	//日志系统，输出到sql.log
	engine.ShowSQL(true)
    f,err := os.Create("sql.log")
    if err != nil {
    	fmt.Println(err.Error())
    	return
	}
    engine.SetLogger(xorm.NewSimpleLogger(f))
	//同步结构体与数据表，创建表
	if err = engine.Sync2(new(Person),new(Student),new(Worker));err != nil{
		log.Fatal(err)
	}

}

func NewPerson(username string,usersex string,userps string)error{
	_,err := engine.Insert(&Person{UserName:username,UserSex:usersex,UserPs:userps})
	return err
}

func QueryPerson(id int64)(*Person,error) {
	person := &Person{}
	has,err := engine.Id(id).Get(person)
	if err != nil {
		return nil,err
	}
	if !has {
		return nil,err
	}
	return person,nil
}

func AddStudent(c *gin.Context){
	UserName := c.Request.FormValue("username")
	UserSex := c.Request.FormValue("usersex")
    created := time.Now()
	res,err := engine.Insert(&Student{UserName:UserName,UserSex:UserSex,CreatedTime:created})
	if err != nil{
		log.Fatal(err)
		return
	}
	fmt.Println(res)
	c.String(http.StatusOK,"insert successful")
}

func QueryAdd(c *gin.Context) {

	//var s []Student
	//查询多条记录利用find方法

	//err := engine.SQL("select * from student where user_sex = '男'").Find(&s)
	//
	//if err != nil {
	//	log.Fatal(err)
	//}
	//c.JSON(http.StatusOK,gin.H{
	//	"user":s,
	//})
	//get方法  使用该方法时，是不是必须得new一个对象？
//student := new(Student)
var student Student   //这个也是可以的
	has,err := engine.Where("user_name=?","八法").Get(&student)
	if !has && err != nil {
		log.Fatal(err)
	}
	c.JSON(http.StatusOK,gin.H{
		"getuser":student,
	})
}
func IsExist(c *gin.Context) {

	//这个方法和get方法有不同之处，当查询记录是否存在时，用exist，当在上面的基础之上还要返回这条已存在的记录时，用get
	has,err := engine.SQL("select * from student where user_name = 'tony'").Exist()
	if err != nil {
		log.Fatal(err)
	}
	if !has {
		c.String(http.StatusBadRequest,"用户不存在")
	}else {
		c.String(http.StatusOK,"用户已经存在")
	}
}
func Update(c *gin.Context) {
	//UserName := c.Request.FormValue("username")
	//UserPs := c.Request.FormValue("userps")

	var p Person
	p.UserName = c.Request.FormValue("username")
	p.UserPs = c.Request.FormValue("userps")
	res,err := engine.Cols("user_name","user_ps").ID(4).Update(&p)
	if err != nil {
		log.Fatal(err)
		fmt.Println(err)
	}
	c.String(http.StatusOK,fmt.Sprintf("change successful %d",res))
}

func Count(c *gin.Context){
	var s Student
	total,err :=engine.SQL("select * from student where user_sex=?","男").Count(&s)
//	total,err := engine.Where("user_sex=?","男").Count(&s)  //这两句话都是一样的效果，之前不知何原因会报错
	if err != nil {
		log.Fatal(err)
	}
	c.String(http.StatusOK,fmt.Sprintf("男性人数为%d",total))
}

func QueryRows(c *gin.Context){
	var student Student
	students := make([]Student,0)
	usersex := c.Request.FormValue("usersex")
//	rows,err := engine.Where("user_sex=?",usersex).Rows(&student)  //这两个其实都可以

	rows,err := engine.SQL("select * from student where user_sex=?",usersex).Rows(&student)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next(){
		err := rows.Scan(&student)
		if err != nil {
			fmt.Println(err)
		}
		students = append(students,student)
	}
	c.JSON(http.StatusOK,gin.H{
		"data":students,
	})
}

func SumMysql(c *gin.Context){

	var s Student
	total,err := engine.Where("id>?",1).Sum(&s,"user_age")
	if err != nil{
		log.Fatal(err)
	}
   c.String(http.StatusOK,fmt.Sprintf("年龄总和为：%f",total))
}

func LeGuanSuo(c *gin.Context){
       	var w Worker
       	var err error
       	w.UserName = c.Request.FormValue("username")
       	 IntMoney := c.Request.FormValue("money")
       	 w.Money,err = strconv.Atoi(IntMoney)
       	res,err := engine.Insert(&w)

       	//id,err := res.RowsAffected()
       	fmt.Println(res)
       	if err != nil {
			c.String(404,"失败")
			log.Fatal(err)
		}else{
			c.String(200,"插入成功")
		}

}

func LeGuanSuoUpdate(c *gin.Context){
	//w := &Worker{}

	//乐观锁更新之前必须得先get，然后再update
	var w Worker
	var err error
	engine.ID(3).Get(&w)
	fmt.Println(w)
	w.UserName = c.Request.FormValue("username")
	fmt.Println(w.UserName)
	IntMoney := c.Request.FormValue("money")
	fmt.Println(IntMoney)
	w.Money,err = strconv.Atoi(IntMoney)
	fmt.Println(w.Money)
	res,err := engine.ID(3).Update(&w)
	fmt.Println(res,err)
	if err != nil {
		log.Fatal(err)
        return
	}
	if res != 0{
		c.String(200,fmt.Sprintf("更新行数 %d",res))
	}else{
		c.String(404,fmt.Sprintf("没更新啊"))
	}

}

func RollBack(){
	session := engine.NewSession()
	defer session.Close()
	err := session.Begin()
	user1 := Person{
		UserName:"电网",
		UserSex:"未知",
		UserPs:"正在启动中",
	}
	_,err = session.Insert(&user1)
	if err != nil {
		session.Rollback()
		return
	}
	user2 := Person{
		UserName:"闪电侠",
	}
	_,err = session.Where("id=?",7).Update(&user2)
	if err != nil {
		session.Rollback()
		return
	}
	err = session.Commit()
    if err != nil{
		return
	}
}
func main(){
	//err := NewPerson("hxh","nan","string")
	//
	//if err != nil {
	//	log.Fatal(err)
	//}
	//person,err := QueryPerson(1)
	//
	//fmt.Println(person)
	RollBack()

	router := gin.Default()

	router.GET("/student",AddStudent)

	router.GET("/query",QueryAdd)

	router.GET("/update",Update)

	router.GET("/isexist",IsExist)

	router.GET("/count",Count)

	router.GET("/queryrows",QueryRows)

	router.GET("/Sum",SumMysql)

	router.GET("/leguan",LeGuanSuo)

	router.GET("/leguanupdate",LeGuanSuoUpdate)

	router.Run(":8880")
}

#分文件提高代码可读性

在handler.go中的代码为

package apis

import (
	"github.com/gin-gonic/gin"
	"XinqunComment/model"
	"strconv"
	"log"
	"time"
	"os"
	"io"
	"strings"
	"net/http"
	"fmt"
	db "XinqunComment/mysqldb"
	)



func UserTalk(c *gin.Context){

	engine := db.GetEngine()
	var UserTalk model.Xq_user_talk
	var err error
	StringTalkType := c.Request.FormValue("TalkType")

	UserTalk.Talk_type,err = strconv.Atoi(StringTalkType)
	UserTalk.Talk_cont = c.Request.FormValue("TalkCont")
	UserTalk.Create_user = c.Request.FormValue("CreateUserId")
	UserTalk.Create_time = time.Now()
	UserTalk.Is_del = 0

	file,header,err := c.Request.FormFile("Image")
	if err != nil {
		log.Fatal(err)
	}
	FileName := header.Filename

	PictureName := strings.Split(FileName,".")
	Layout := strings.ToLower(PictureName[len(PictureName)-1])
	Path := UserTalk.Create_user + "." + Layout
	out,err := os.Create("upload/talk_photo/"+Path)
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()
	_,err = io.Copy(out,file)
	if err != nil{
		log.Fatal(err)
	}
	if Layout != "jpg" && Layout != "png" && Layout != "jpeg" {
		c.String(http.StatusBadRequest,"format error！")
		return
	}
	UserTalk.Talk_image = Path
	fmt.Println(UserTalk)
	res,err := engine.Insert(UserTalk)
	if err != nil{
		log.Fatal(err)
	}
	c.String(200,fmt.Sprintf("Release success %d",res))
}

func UserTalkReply(c *gin.Context){
	engine := db.GetEngine()
	var TalkReply model.Xq_user_talk_reply
	var err error

	TalkReply.User_id = c.Request.FormValue("UserId")
	TalkReply.Reply_user_id = c.Request.FormValue("ReplyUserId")
	TalkReply.Reply_cont = c.Request.FormValue("ReplyCont")
	TalkReply.Create_time = time.Now()
	TalkReply.Is_del = 0

	IntTalkId := c.Request.FormValue("TalkId")
	TalkReply.Talk_id,err = strconv.Atoi(IntTalkId)
	if err != nil {
		log.Fatal(err)
	}
	res,err := engine.Insert(&TalkReply)

	c.String(http.StatusOK,fmt.Sprintf("Release successful %d",res))

}

在model文件夹中的user_talk.go文件中

package model

import "time"

type Xq_user_talk struct {
	Talk_id int   `xorm:"pk"`
	Talk_type  int
	Talk_cont string
	Create_user string
	Create_time time.Time
	Update_time time.Time
	Is_del int
	Talk_image string
}

在model文件夹中的user_talk_reply.go文件中

package model

import "time"

type Xq_user_talk_reply struct {
	Reply_id int    `xorm:"pk"`
	User_id string
	Reply_user_id string
	Reply_cont string
	Create_time time.Time
	Update_time time.Time
	Is_del int
	Talk_id int
}

在mysqldb文件夹下的mysqldb.go主要是对数据库的连接操作

package mysqldb

import (
	"github.com/go-xorm/xorm"
	"os"
	"fmt"
	"XinqunComment/model"
	"log"
	_"github.com/go-sql-driver/mysql"
)

var engine *xorm.Engine

func init(){
	var err error
	engine,err = xorm.NewEngine("mysql","root:123456@tcp(localhost:3306)/xq_social_circle?charset=utf8")

	if err != nil {
		log.Fatal(err)
		return
	}else{
		fmt.Println("success")
	}
	//日志系统，输出到sql.log
	engine.ShowSQL(true)
	f,err := os.Create("sql.log")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	engine.SetLogger(xorm.NewSimpleLogger(f))
	//同步结构体与数据表，创建表
	if err = engine.Sync2(new(model.Xq_user_talk),new(model.Xq_user_talk_reply),new(model.Xq_user_complaint),new(model.Xq_user_follow),new(model.Xq_user_like),new(model.Xq_user));err != nil{
		log.Fatal(err)
	}

}

// GetEngine 获取Mysql链接
func GetEngine() *xorm.Engine {
	return engine
}

routers文件夹下主要是路由
router.go

package routers

import (
	"github.com/gin-gonic/gin"
    api "XinqunComment/apis"
)
func Router() *gin.Engine{

	router:= gin.Default()

	router.POST("/talk",api.UserTalk)

	router.GET("/getusertalk",api.GetUserTalk)

	router.GET("/talkreply",api.UserTalkReply)

	router.GET("getusertalkreply",api.GetUserTalkReply)

	router.GET("/usercomplaint",api.UserComplaint)

	router.GET("/userfollow",api.UserFollow)

	router.GET("/userlike",api.UserLike)

	return router
}

upload文件夹主要是存放上传的图片。
main.go中主要是调用函数运行程序

package main

import (
		_"XinqunComment/mysqldb"
	"XinqunComment/routers"
)


func main(){
	router := routers.Router()
	router.Run(":8998")
	//routers.Router(router)
}