first commit
18650180552
parent
038862eaec
commit
edd5a83d3d
|
|
@ -0,0 +1,75 @@
|
|||
package config
|
||||
|
||||
import (
|
||||
"log"
|
||||
"gopkg.in/yaml.v2"
|
||||
"os"
|
||||
"runtime"
|
||||
)
|
||||
|
||||
var ostype = runtime.GOOS
|
||||
|
||||
var conf ConfAPI
|
||||
|
||||
type ConfAPI struct {
|
||||
ListenSvr int `yaml:"listen_svr"` // 服务监听端口
|
||||
ListenApi int `yaml:"listen_api"` // 服务监听端口
|
||||
RunMode string `yaml:"runmode"` // 服务运行模式
|
||||
MaxConn int `yaml:"max_conn"`
|
||||
Logs LogConfig `yaml:"logs"` // 日志
|
||||
Redis RedisConfig `yaml:"redis"`
|
||||
Mysql MysqlConfig `yaml:"mysql"` // 认证配置
|
||||
init bool
|
||||
}
|
||||
|
||||
type RedisConfig struct {
|
||||
Addr string `yaml:"addr"`
|
||||
Pwd string `yaml:"password"`
|
||||
DB int64 `yaml:"db"`
|
||||
}
|
||||
type LogConfig struct {
|
||||
Dir string `yaml:"dir"`
|
||||
File string `yaml:"file"`
|
||||
Level int `yaml:"level"`
|
||||
SaveFile bool `yaml:"savefile"`
|
||||
}
|
||||
type MysqlConfig struct {
|
||||
Addr string `yaml:"addr"`
|
||||
UserName string `yaml:"user"`
|
||||
Password string `yaml:"password"`
|
||||
Db string `yaml:"db"`
|
||||
MaxOpen int `yaml:"max_open"`
|
||||
MaxIdle int `yaml:"max_idle"`
|
||||
}
|
||||
var gConf ConfAPI
|
||||
func Init(path string) error {
|
||||
file,e := os.Open(path)
|
||||
if nil != e{
|
||||
log.Println(e.Error())
|
||||
return e
|
||||
}
|
||||
stat,_ := file.Stat()
|
||||
filec := make([]byte, stat.Size())
|
||||
file.Read(filec)
|
||||
e = yaml.Unmarshal(filec,&gConf)
|
||||
if nil != e{
|
||||
log.Println(e.Error())
|
||||
}
|
||||
gConf.init = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func GetPort() int {
|
||||
if gConf.init{
|
||||
return gConf.ListenApi
|
||||
}else {
|
||||
return 8001
|
||||
}
|
||||
}
|
||||
func GetMysqlConfig() *MysqlConfig{
|
||||
if gConf.init{
|
||||
return &gConf.Mysql
|
||||
}else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,550 @@
|
|||
package controller
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/md5"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"github.com/fatih/structs"
|
||||
"github.com/gin-gonic/gin"
|
||||
_ "github.com/go-sql-driver/mysql"
|
||||
"github.com/tommy351/gin-sessions"
|
||||
"io"
|
||||
"strconv"
|
||||
"time"
|
||||
"user/logs"
|
||||
"log"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"net/smtp"
|
||||
"regexp"
|
||||
"strings"
|
||||
"user/redis"
|
||||
"user/model"
|
||||
"user/db"
|
||||
)
|
||||
|
||||
type ReqSendEmailCode struct {
|
||||
EmailAdress string `json:"email_address"`
|
||||
}
|
||||
|
||||
type SetUserGroupReq struct {
|
||||
Id int64 `json:"id,omitempty"`
|
||||
Description string `json:"description"`
|
||||
GroupName string `json:"group_name"`
|
||||
UserIds []int `json:"user_ids"`
|
||||
}
|
||||
type RespBase struct {
|
||||
Msg string
|
||||
Status int
|
||||
Data interface{}
|
||||
}
|
||||
|
||||
func Auth(c *gin.Context) {
|
||||
var resp RespBase
|
||||
var statuscode int
|
||||
|
||||
statuscode = 200
|
||||
|
||||
var userinfo map[string] interface{}
|
||||
//var userSockToken map[string] interface{}
|
||||
|
||||
defer func() {
|
||||
c.JSON(statuscode, resp)
|
||||
}()
|
||||
|
||||
socketToken := c.Query("socketToken")
|
||||
struserinfo ,e := redis.Get(socketToken)
|
||||
|
||||
if e != nil{
|
||||
logs.Error(e.Error())
|
||||
return
|
||||
}
|
||||
|
||||
e = json.Unmarshal([]byte(struserinfo),userinfo)
|
||||
if nil != e{
|
||||
logs.Error(e.Error())
|
||||
return
|
||||
}
|
||||
}
|
||||
// SetUser godoc
|
||||
// @Summary SetUser
|
||||
// @Description set userinfo
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Param q query string false "name search by q"
|
||||
// @Success 200 {array} util.RespBase
|
||||
// @Failure 400 {object} util.RespBase
|
||||
// @Failure 404 {object} util.RespBase
|
||||
// @Failure 500 {object} util.RespBase
|
||||
// @Router /accounts [get]
|
||||
func SetUser(c *gin.Context){
|
||||
|
||||
}
|
||||
func DelUser(c *gin.Context){
|
||||
|
||||
}
|
||||
|
||||
func GetUser(c *gin.Context) {
|
||||
var resp RespBase
|
||||
resp.Msg = "操作失败"
|
||||
resp.Status = 20
|
||||
defer func() {
|
||||
c.JSON(200,resp)
|
||||
}()
|
||||
session := sessions.Get(c)
|
||||
userinfo := session.Get("")
|
||||
if userinfo == nil{
|
||||
logs.Error("error could not find key")
|
||||
return
|
||||
}
|
||||
var users map[string] interface{}
|
||||
e := json.Unmarshal([]byte(userinfo.(string)),&users)
|
||||
if nil != e {
|
||||
logs.Error(e.Error())
|
||||
}
|
||||
delete(users,"socketToken")
|
||||
resp.Status = 0
|
||||
resp.Msg = "操作成功"
|
||||
resp.Data = users
|
||||
|
||||
}
|
||||
// GetUsers godoc
|
||||
// @Summary GetUsers
|
||||
// @Description Get all user with query
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Param page query int 1 "分页的页数"
|
||||
// @Param pageSize query int 10 "name search by q"
|
||||
// @Param displayname query string false "name search by q"
|
||||
// @Param department_id query string false "name search by q"
|
||||
// @Param permission_type query string false "name search by q"
|
||||
// @Success 200 {array} util.RespBase
|
||||
// @Failure 400 {object} util.RespBase
|
||||
// @Failure 404 {object} util.RespBase
|
||||
// @Failure 500 {object} util.RespBase
|
||||
// @Router /api/users [get]
|
||||
func GetUsers(c *gin.Context) {
|
||||
var statuscode int
|
||||
var resp RespBase
|
||||
|
||||
resp.Msg = "获取失败"
|
||||
resp.Status = 0
|
||||
statuscode = 200
|
||||
|
||||
defer func() {
|
||||
c.JSON(statuscode,resp)
|
||||
}()
|
||||
//获取用户组信息
|
||||
var page int
|
||||
var pageSize int
|
||||
var displayname string
|
||||
var department_id string
|
||||
var permission_type string
|
||||
|
||||
displayname = c.Query("displayname")
|
||||
department_id = c.Query("department_id")
|
||||
permission_type = c.Query("permission_type")
|
||||
|
||||
if c.Query("page") == ""{
|
||||
page = 0
|
||||
}else {
|
||||
var err error
|
||||
page,err = strconv.Atoi(c.Query("page"))
|
||||
if err != nil{
|
||||
logs.Error("error ato i ")
|
||||
}
|
||||
}
|
||||
log.Println(pageSize,page)
|
||||
if c.Query("pageSize") == ""{
|
||||
pageSize = 10
|
||||
}else {
|
||||
var err error
|
||||
pageSize,err = strconv.Atoi(c.Query("pageSize"))
|
||||
if err != nil{
|
||||
logs.Error("error ato i ")
|
||||
}
|
||||
}
|
||||
session := sessions.Get(c)
|
||||
userinfo := session.Get("")
|
||||
var users map[string] interface{}
|
||||
e := json.Unmarshal([]byte(userinfo.(string)),&users)
|
||||
if nil != e {
|
||||
logs.Error(e.Error())
|
||||
}
|
||||
permission,ok := users["PermissionType"]
|
||||
if !ok{
|
||||
logs.Error("error could not find permission_type")
|
||||
return
|
||||
}
|
||||
// 部门组长只允许查看自己所在部门成员列表，且要过滤超级管理员
|
||||
if permission == 1 && department_id != ""{
|
||||
d ,_ := users["DepartmentId"]
|
||||
department_id = d.(string)
|
||||
}
|
||||
|
||||
respdata := make(map[string]interface{},1)
|
||||
var usersinfo []model.Users
|
||||
|
||||
if permission != 0{
|
||||
query := "select * from users "
|
||||
if displayname != "" || department_id != "" ||permission_type != ""{
|
||||
query += " where "
|
||||
}
|
||||
if displayname != ""{
|
||||
query += fmt.Sprintf("display_name like '%%%s%%'",displayname)
|
||||
}
|
||||
if department_id != ""{
|
||||
query += fmt.Sprintf("and department_id = %s",department_id)
|
||||
}
|
||||
if permission_type != ""{
|
||||
query += fmt.Sprintf("and permission_type = %s ",permission_type)
|
||||
}
|
||||
query += "order by id ASC "
|
||||
query += fmt.Sprintf("limit %d ",pageSize)
|
||||
query += fmt.Sprintf(" offset %d ",pageSize*page)
|
||||
|
||||
e := db.GetMysqlClient().Query2(query,&usersinfo)
|
||||
if e != nil{
|
||||
log.Println(e.Error())
|
||||
}
|
||||
respdata["rows"] = usersinfo
|
||||
respdata["total"] = len(usersinfo)
|
||||
respdata["page"] = page
|
||||
respdata["pageSize"] = pageSize
|
||||
}
|
||||
resp.Msg = "OK"
|
||||
resp.Data = respdata
|
||||
}
|
||||
|
||||
func CreateVerify(length int32) string{
|
||||
strAry := []byte{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
|
||||
result := string("")
|
||||
for i := int32(0); i < length; i++ {
|
||||
x := rand.Intn(len(strAry))
|
||||
result += string(strAry[x])
|
||||
}
|
||||
return result
|
||||
}
|
||||
/**
|
||||
* 取随机Token
|
||||
* @param {Number} length 取Token的长度
|
||||
* @return {string} 获取的Token
|
||||
*/
|
||||
func createToken(length int32) string{
|
||||
strAry := []byte{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '_' };
|
||||
result := string("")
|
||||
for i := int32(0); i < length; i++ {
|
||||
x := rand.Intn(len(strAry))
|
||||
result += string(strAry[x])
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func ByteSliceToString(b []byte) string {
|
||||
var ret string
|
||||
|
||||
for i := 0;i < len(b) ;i++{
|
||||
s := fmt.Sprintf("%02x",b[i])
|
||||
ret += string(s)
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func DefaultOption(c *gin.Context) {
|
||||
var resp RespBase
|
||||
|
||||
defer func() {
|
||||
c.JSON(204, resp)
|
||||
}()
|
||||
}
|
||||
// Login godoc
|
||||
// @Summary Login
|
||||
// @Description login
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Param logininfo query {object} LoginReq "登录请求参数"
|
||||
// @Success 200 {array} util.RespBase
|
||||
// @Failure 400 {object} util.RespBase
|
||||
// @Failure 404 {object} util.RespBase
|
||||
// @Failure 500 {object} util.RespBase
|
||||
// @Router /api/login [post]
|
||||
func Login(c *gin.Context) {
|
||||
type LoginReq struct {
|
||||
RememberMe int32 `json:"remember_me"`
|
||||
UserName string `json:"user_name"`
|
||||
UserPwd string `json:"user_pwd"`
|
||||
}
|
||||
var req LoginReq
|
||||
statusCode := 200
|
||||
var resp RespBase
|
||||
|
||||
defer func() {
|
||||
c.JSON(statusCode, resp)
|
||||
}()
|
||||
e := c.Bind(&req)
|
||||
if e!= nil{
|
||||
log.Println(e.Error())
|
||||
return
|
||||
}
|
||||
|
||||
h := md5.New()
|
||||
h.Write([]byte(req.UserPwd)) // 需要加密的字符串为 123456
|
||||
passmd5 := h.Sum(nil)
|
||||
var result []model.Users
|
||||
|
||||
er := db.GetMysqlClient().Query2("select * from users where user_name = ?",
|
||||
&result,req.UserName)
|
||||
if nil != er{
|
||||
log.Println(er.Error())
|
||||
}
|
||||
strpassmd5 := ByteSliceToString(passmd5)
|
||||
if len(result) == 1 {
|
||||
if result[0].UserPwd == strpassmd5 {
|
||||
socketToken := md5.New()
|
||||
socketToken.Write([]byte(createToken(6))) // 需要加密的字符串为 123456
|
||||
socketTokenMd5 := socketToken.Sum(nil)
|
||||
m := structs.Map(result[0])
|
||||
m["socketToken"] = ByteSliceToString(socketTokenMd5);
|
||||
sessionInfo,err := json.Marshal(m)
|
||||
if err != nil{
|
||||
log.Println(err.Error())
|
||||
}
|
||||
if req.RememberMe == 1{
|
||||
redis.Set(string(socketTokenMd5),string(sessionInfo),time.Second *2 * 24 * 3600 * 1000 )
|
||||
|
||||
}else {
|
||||
redis.Set(string(socketTokenMd5),string(sessionInfo),time.Second *8 * 3600 * 1000 )
|
||||
|
||||
}
|
||||
//存储session
|
||||
session := sessions.Get(c)
|
||||
session.Set("",string(sessionInfo))
|
||||
//session.
|
||||
var Options *sessions.Options
|
||||
if req.RememberMe == 1{
|
||||
Options = &sessions.Options{
|
||||
MaxAge: 2 * 24 * 3600 * 1000,
|
||||
}
|
||||
}else {
|
||||
Options = &sessions.Options{
|
||||
MaxAge: 8 * 3600 * 1000,
|
||||
}
|
||||
}
|
||||
session.Options(*Options)
|
||||
session.Save()
|
||||
|
||||
resp.Msg = "登录成功"
|
||||
resp.Status = 0
|
||||
resp.Data = string(sessionInfo)
|
||||
}else {
|
||||
statusCode = 422
|
||||
resp.Msg = "用户密码不正确"
|
||||
}
|
||||
}else {
|
||||
statusCode = 422
|
||||
resp.Msg = "登录账号不存在，请重新输入"
|
||||
}
|
||||
}
|
||||
|
||||
func Register(c *gin.Context) {
|
||||
type RegisterReq struct {
|
||||
DisplayName string `json:"display_name"`
|
||||
EmailAdress string `json:"email_address"`
|
||||
EmailCode string `json:"email_code"`
|
||||
UserName string `json:"user_name"`
|
||||
UserPwd string `json:"user_pwd"`
|
||||
}
|
||||
var req RegisterReq
|
||||
statusCode := 200
|
||||
var resp RespBase
|
||||
var user model.Users
|
||||
|
||||
resp.Msg = "失败"
|
||||
resp.Status = 1
|
||||
|
||||
defer func() {
|
||||
c.JSON(statusCode, resp)
|
||||
}()
|
||||
|
||||
e := c.Bind(&req)
|
||||
if e!= nil{
|
||||
log.Println(e.Error())
|
||||
return
|
||||
}
|
||||
|
||||
session := sessions.Get(c)
|
||||
email_code := session.Get(req.EmailAdress)
|
||||
|
||||
if email_code != req.EmailCode{
|
||||
resp.Msg = "验证码错误"
|
||||
resp.Status = 20
|
||||
return
|
||||
}
|
||||
|
||||
user.UserName = req.UserName
|
||||
user.EmailAddress = req.EmailAdress
|
||||
user.DisplayName = req.DisplayName
|
||||
|
||||
h := md5.New()
|
||||
h.Write([]byte(req.UserPwd))
|
||||
passwdmd5 := h.Sum(nil)
|
||||
strpassmd5 := ByteSliceToString(passwdmd5)
|
||||
user.UserPwd = strpassmd5
|
||||
user.UpdatedDate = time.Now().String()
|
||||
user.CreatedDate = time.Now().String()
|
||||
|
||||
n,er := db.GetMysqlClient().Insert("insert into users(user_name,user_pwd,created_date," +
|
||||
"updated_date,display_name,email_address) values (?,?,?,?,?,?)",
|
||||
user.UserName,user.UserPwd,user.CreatedDate,user.UpdatedDate,
|
||||
user.DisplayName,user.EmailAddress)
|
||||
if n == 0 || n < 0{
|
||||
statusCode = 422
|
||||
logs.Error(er.Error())
|
||||
resp.Msg = "失败，账号已经存在"
|
||||
resp.Status = 20
|
||||
return
|
||||
}
|
||||
if nil != er{
|
||||
statusCode = 422
|
||||
logs.Error(er.Error())
|
||||
resp.Msg = "失败"
|
||||
resp.Status = 20
|
||||
return
|
||||
}
|
||||
resp.Msg = "成功"
|
||||
resp.Status = 0
|
||||
}
|
||||
|
||||
func Logout(c *gin.Context) {
|
||||
var resp RespBase
|
||||
|
||||
resp.Msg = "退出成功"
|
||||
resp.Status = 0
|
||||
defer func() {
|
||||
c.JSON(200,resp)
|
||||
}()
|
||||
session := sessions.Get(c)
|
||||
session.Delete("")
|
||||
session.Save()
|
||||
}
|
||||
|
||||
|
||||
func Reader2Json(r io.ReadCloser) string{
|
||||
var ret string
|
||||
for i := 0;;i++{
|
||||
s := make([]byte,10)
|
||||
_,e := r.Read(s)
|
||||
ret += string(s)
|
||||
if e != nil{
|
||||
break
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func SendExternalEmail(msg interface{}) error{
|
||||
req := make(map[string] interface{},1)
|
||||
req["type"] = "text"
|
||||
req["action"] = "smtp-sys"
|
||||
req["apiType"] = "send"
|
||||
|
||||
content ,err := json.Marshal(msg)
|
||||
if err != nil{
|
||||
log.Println(err.Error())
|
||||
return errors.New("Json marshal error")
|
||||
}
|
||||
req["content"] = string(content)
|
||||
|
||||
var buffer bytes.Buffer
|
||||
b,e := json.Marshal(req)
|
||||
if e != nil{
|
||||
log.Println(e.Error())
|
||||
}
|
||||
buffer.Write(b)
|
||||
resp,err := http.Post("http://47.93.230.163:8091/msg/v1/send","application/json",&buffer)
|
||||
|
||||
if resp.StatusCode != 200{
|
||||
return errors.New("error send emain")
|
||||
}
|
||||
if err != nil{
|
||||
logs.Error("error send email")
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func SendToMail(title,user string, password string, host string, to string, content string,
|
||||
ifgenerate bool) error {
|
||||
var content_type string
|
||||
|
||||
hp := strings.Split(host, ":")
|
||||
auth := smtp.PlainAuth("", user, password, hp[0])
|
||||
|
||||
content_type = "Content-Type: text/plain" + "; charset=UTF-8"
|
||||
|
||||
msg := []byte("To: " + to + "\r\nFrom: " + user + "\r\nSubject: " + title + "\r\n" +
|
||||
content_type + "\r\n\r\n"+ content + "\r\n" )
|
||||
send_to := strings.Split(to, ";")
|
||||
|
||||
//检测是否是邮件地址
|
||||
for k,_ := range send_to{
|
||||
match, _ := regexp.MatchString("[\\w!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\\w](?:[\\w-]*[\\w])?\\.)+[\\w](?:[\\w-]*[\\w])?", send_to[k])
|
||||
if !match{
|
||||
return errors.New("Format Error")
|
||||
}
|
||||
}
|
||||
err := smtp.SendMail(host, auth, user,send_to, msg)
|
||||
if err !=nil{
|
||||
return err
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func SendEmailCode(c *gin.Context) {
|
||||
var req ReqSendEmailCode
|
||||
var resp RespBase = RespBase{Msg:"邮件已经存在",Status:0}
|
||||
statusCode := 200
|
||||
|
||||
defer func() {
|
||||
c.JSON(statusCode, resp)
|
||||
}()
|
||||
|
||||
e := c.Bind(&req)
|
||||
if nil != e{
|
||||
log.Println(e.Error())
|
||||
resp.Msg = "请求参数错误"
|
||||
return
|
||||
}
|
||||
//判断邮箱是否存在
|
||||
var users []model.Users
|
||||
db.GetMysqlClient().Query2("select * from users where email_adress = ?",&users,req.EmailAdress)
|
||||
if len(users) != 0{
|
||||
statusCode = 422
|
||||
return
|
||||
}
|
||||
//产生验证码
|
||||
verify := CreateVerify(6)
|
||||
session := sessions.Get(c)
|
||||
session.Set(req.EmailAdress,verify)
|
||||
/*
|
||||
var Options *sessions.Options
|
||||
|
||||
Options = &sessions.Options{
|
||||
MaxAge: 60,
|
||||
}
|
||||
session.Options(*Options)*/
|
||||
session.Save()
|
||||
sendcontent := make( map[string] interface{},1)
|
||||
sendcontent["subject"] = "邮箱验证码，请注意查收"
|
||||
sendcontent["receivers"] = req.EmailAdress
|
||||
sendcontent["content"] = string("您本次注册的验证码为:") + verify + string("，工作人员不会向您索取，请勿泄露。请尽快完成操作。")
|
||||
|
||||
e = SendExternalEmail(sendcontent)
|
||||
if e != nil{
|
||||
log.Println(e.Error())
|
||||
return
|
||||
}
|
||||
//成功
|
||||
resp.Msg = "发送成功"
|
||||
}
|
||||
|
|
@ -0,0 +1,598 @@
|
|||
// 数据库工具包
|
||||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"document/logs"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// 数据容器抽象对象定义
|
||||
type Database struct {
|
||||
Type string // 用来给SqlBuilder进行一些特殊的判断 (空值或mysql 皆表示这是一个MySQL实例)
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
// SQL异步执行队列定义
|
||||
type queueList struct {
|
||||
list []*QueueItem //队列列表
|
||||
sleeping chan bool
|
||||
loop chan bool
|
||||
lock sync.RWMutex
|
||||
quit chan bool
|
||||
quited bool
|
||||
}
|
||||
|
||||
// SQL异步执行队列子元素定义
|
||||
type QueueItem struct {
|
||||
DB *Database //数据库对象
|
||||
Query string //SQL语句字符串
|
||||
Params []interface{} //参数列表
|
||||
}
|
||||
|
||||
// 缓存数据对象定义
|
||||
type cache struct {
|
||||
data map[string]map[string]interface{}
|
||||
}
|
||||
|
||||
func (this *cache) Init() {
|
||||
this.data["default"] = make(map[string]interface{})
|
||||
}
|
||||
|
||||
// 设置缓存
|
||||
func (this *cache) Set(key string, value interface{}, args ...string) {
|
||||
var group string
|
||||
if len(args) > 0 {
|
||||
group = args[0]
|
||||
if _, exist := this.data[group]; !exist {
|
||||
this.data[group] = make(map[string]interface{})
|
||||
}
|
||||
} else {
|
||||
group = "default"
|
||||
}
|
||||
this.data[group][key] = value
|
||||
}
|
||||
|
||||
// 获取缓存数据
|
||||
func (this *cache) Get(key string, args ...string) interface{} {
|
||||
var group string
|
||||
if len(args) > 0 {
|
||||
group = args[0]
|
||||
} else {
|
||||
group = "default"
|
||||
}
|
||||
if g, exist := this.data[group]; exist {
|
||||
if v, ok := g[key]; ok {
|
||||
return v
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// 删除缓存数据
|
||||
func (this *cache) Del(key string, args ...string) {
|
||||
var group string
|
||||
if len(args) > 0 {
|
||||
group = args[0]
|
||||
} else {
|
||||
group = "default"
|
||||
}
|
||||
if g, exist := this.data[group]; exist {
|
||||
if _, ok := g[key]; ok {
|
||||
delete(this.data[group], key)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
lastError error
|
||||
Cache *cache
|
||||
queue *queueList
|
||||
Obj *Database
|
||||
)
|
||||
|
||||
func init() {
|
||||
Cache = &cache{data: make(map[string]map[string]interface{})}
|
||||
Cache.Init()
|
||||
queue = &queueList{}
|
||||
go queue.Start()
|
||||
}
|
||||
|
||||
// 关闭数据库连接
|
||||
func (this *Database) Close() {
|
||||
this.DB.Close()
|
||||
}
|
||||
|
||||
// 获取最后发生的错误字符串
|
||||
func LastErr() string {
|
||||
if lastError != nil {
|
||||
return lastError.Error()
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// 执行语句
|
||||
func (this *Database) Exec(query string, args ...interface{}) (sql.Result, error) {
|
||||
return this.DB.Exec(query, args...)
|
||||
}
|
||||
|
||||
// 查询单条记录
|
||||
func (this *Database) Query(query string, args ...interface{}) (*sql.Rows, error) {
|
||||
return this.DB.Query(query, args...)
|
||||
}
|
||||
|
||||
// 查询单条记录
|
||||
func (this *Database) QueryRow(query string, args ...interface{}) *sql.Row {
|
||||
return this.DB.QueryRow(query, args...)
|
||||
}
|
||||
|
||||
// Query2 查询实体集合
|
||||
// obj 为接收数据的实体指针
|
||||
func (this *Database) Query2(sql string, obj interface{}, args ...interface{}) error {
|
||||
var tagMap map[string]int
|
||||
var tp, tps reflect.Type
|
||||
var n, i int
|
||||
var err error
|
||||
var ret reflect.Value
|
||||
// 检测val参数是否为我们所想要的参数
|
||||
tp = reflect.TypeOf(obj)
|
||||
if reflect.Ptr != tp.Kind() {
|
||||
return errors.New("is not pointer")
|
||||
}
|
||||
|
||||
if reflect.Slice != tp.Elem().Kind() {
|
||||
return errors.New("is not slice pointer")
|
||||
}
|
||||
|
||||
tp = tp.Elem()
|
||||
tps = tp.Elem()
|
||||
if reflect.Struct != tps.Kind() {
|
||||
return errors.New("is not struct slice pointer")
|
||||
}
|
||||
|
||||
tagMap = make(map[string]int)
|
||||
n = tps.NumField()
|
||||
for i = 0; i < n; i++ {
|
||||
tag := tps.Field(i).Tag.Get("sql")
|
||||
if len(tag) > 0 {
|
||||
tagMap[tag] = i + 1
|
||||
}
|
||||
}
|
||||
|
||||
// 执行查询
|
||||
ret, err = this.queryAndReflect(sql, tagMap, tp, args...)
|
||||
if nil != err {
|
||||
return err
|
||||
}
|
||||
|
||||
// 返回结果
|
||||
reflect.ValueOf(obj).Elem().Set(ret)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// queryAndReflect 查询并将结果反射成实体集合
|
||||
func (this *Database) queryAndReflect(sql string,
|
||||
tagMap map[string]int,
|
||||
tpSlice reflect.Type, args ...interface{}) (reflect.Value, error) {
|
||||
|
||||
var ret reflect.Value
|
||||
|
||||
// 执行sql语句
|
||||
rows, err := this.DB.Query(sql, args...)
|
||||
if nil != err {
|
||||
return reflect.Value{}, err
|
||||
}
|
||||
|
||||
defer rows.Close()
|
||||
// 开始枚举结果
|
||||
cols, err := rows.Columns()
|
||||
if nil != err {
|
||||
return reflect.Value{}, err
|
||||
}
|
||||
|
||||
ret = reflect.MakeSlice(tpSlice, 0, 50)
|
||||
// 构建接收队列
|
||||
scan := make([]interface{}, len(cols))
|
||||
row := make([]interface{}, len(cols))
|
||||
for r := range row {
|
||||
scan[r] = &row[r]
|
||||
}
|
||||
|
||||
for rows.Next() {
|
||||
feild := reflect.New(tpSlice.Elem()).Elem()
|
||||
// 取得结果
|
||||
err = rows.Scan(scan...)
|
||||
// 开始遍历结果
|
||||
for i := 0; i < len(cols); i++ {
|
||||
n := tagMap[cols[i]] - 1
|
||||
|
||||
if n < 0 {
|
||||
continue
|
||||
}
|
||||
switch feild.Type().Field(n).Type.Kind() {
|
||||
case reflect.Bool:
|
||||
if nil != row[i] {
|
||||
feild.Field(n).SetBool("false" != string(row[i].([]byte)))
|
||||
} else {
|
||||
feild.Field(n).SetBool(false)
|
||||
}
|
||||
case reflect.String:
|
||||
if nil != row[i] {
|
||||
feild.Field(n).SetString(string(row[i].([]byte)))
|
||||
} else {
|
||||
feild.Field(n).SetString("")
|
||||
}
|
||||
case reflect.Float32:
|
||||
if nil != row[i] {
|
||||
//log.Println(row[i].(float32))
|
||||
switch reflect.TypeOf(row[i]).Kind(){
|
||||
case reflect.Slice:
|
||||
v, e := strconv.ParseFloat(string(row[i].([]byte)), 0)
|
||||
if nil == e {
|
||||
feild.Field(n).SetFloat(float64(v))
|
||||
//feild.Field(n).SetFloat(float64(row[i].(float32)))
|
||||
}
|
||||
break
|
||||
case reflect.Float64:
|
||||
feild.Field(n).SetFloat(float64(row[i].(float32)))
|
||||
}
|
||||
|
||||
} else {
|
||||
feild.Field(n).SetFloat(0)
|
||||
}
|
||||
case reflect.Float64:
|
||||
if nil != row[i] {
|
||||
//log.Println(row[i].(float32))
|
||||
//v, e := strconv.ParseFloat(string(row[i].([]byte)), 0)
|
||||
//if nil == e {
|
||||
feild.Field(n).SetFloat(row[i].(float64))
|
||||
//}
|
||||
} else {
|
||||
feild.Field(n).SetFloat(0)
|
||||
}
|
||||
case reflect.Int8:
|
||||
fallthrough
|
||||
case reflect.Int16:
|
||||
fallthrough
|
||||
case reflect.Int32:
|
||||
fallthrough
|
||||
case reflect.Int64:
|
||||
fallthrough
|
||||
case reflect.Int:
|
||||
if nil != row[i] {
|
||||
byRow, ok := row[i].([]byte)
|
||||
if ok {
|
||||
v, e := strconv.ParseInt(string(byRow), 10, 64)
|
||||
if nil == e {
|
||||
feild.Field(n).SetInt(v)
|
||||
}
|
||||
} else {
|
||||
v, e := strconv.ParseInt(fmt.Sprint(row[i]), 10, 64)
|
||||
if nil == e {
|
||||
feild.Field(n).SetInt(v)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
feild.Field(n).SetInt(0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = reflect.Append(ret, feild)
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
// 执行UPDATE语句并返回受影响的行数
|
||||
// 返回0表示没有出错, 但没有被更新的行
|
||||
// 返回-1表示出错
|
||||
func (this *Database) Update(query string, args ...interface{}) (int64, error) {
|
||||
ret, err := this.Exec(query, args...)
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
aff, err := ret.RowsAffected()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
return aff, nil
|
||||
}
|
||||
|
||||
// 执行DELETE语句并返回受影响的行数
|
||||
// 返回0表示没有出错, 但没有被删除的行
|
||||
// 返回-1表示出错
|
||||
func (this *Database) Delete(query string, args ...interface{}) (int64, error) {
|
||||
return this.Update(query, args...)
|
||||
}
|
||||
|
||||
func GenSql(obj interface{}) (string,error) {
|
||||
ret := ""
|
||||
typ := reflect.TypeOf(obj).Kind()
|
||||
if typ != reflect.Struct{
|
||||
return (""),errors.New("not a struct")
|
||||
}
|
||||
value := obj.(reflect.Value)
|
||||
num := value.NumField()
|
||||
for i := 0;i < num;i++{
|
||||
if i == 0{
|
||||
ret += "("
|
||||
}
|
||||
switch (value.Field(i).Type().Kind()){
|
||||
case reflect.String:
|
||||
str := value.Field(i).Interface().(string)
|
||||
if str[0] != '"'{
|
||||
ret += "\""
|
||||
str += "\""
|
||||
ret += str
|
||||
|
||||
}else{
|
||||
ret += value.Field(i).Interface().(string)
|
||||
}
|
||||
case reflect.Int:
|
||||
ret += fmt.Sprintf("%d",value.Field(i).Interface().(int))
|
||||
case reflect.Int8:
|
||||
ret += fmt.Sprintf("%d",value.Field(i).Interface().(int8))
|
||||
case reflect.Int32:
|
||||
ret += fmt.Sprintf("%d",value.Field(i).Interface().(int32))
|
||||
case reflect.Int64:
|
||||
ret += fmt.Sprintf("%d",value.Field(i).Interface().(int64))
|
||||
case reflect.Int16:
|
||||
ret += fmt.Sprintf("%d",value.Field(i).Interface().(int16))
|
||||
case reflect.Bool:
|
||||
if value.Field(i).Interface().(bool) {
|
||||
ret += fmt.Sprintf("true",)
|
||||
}else {
|
||||
ret += fmt.Sprintf("false",)
|
||||
}
|
||||
case reflect.Float32:
|
||||
ret += fmt.Sprintf("%x",value.Field(i).Interface().(float32))
|
||||
case reflect.Float64:
|
||||
ret += fmt.Sprintf("true",value.Field(i).Interface().(float64))
|
||||
}
|
||||
if i == num - 1{
|
||||
ret += ")"
|
||||
}else {
|
||||
ret += ","
|
||||
}
|
||||
}
|
||||
return ret,nil
|
||||
}
|
||||
func (this *Database) InsertObejct(tb_name string,obj interface{}) (int64,error) {
|
||||
var tagMap map[int]string
|
||||
var tp, tps reflect.Type
|
||||
var n, i int
|
||||
|
||||
// 检测val参数是否为我们所想要的参数
|
||||
tp = reflect.TypeOf(obj)
|
||||
if reflect.Ptr != tp.Kind() {
|
||||
return 0,errors.New("is not pointer")
|
||||
}
|
||||
|
||||
if reflect.Slice != tp.Elem().Kind() {
|
||||
return 0,errors.New("is not slice pointer")
|
||||
}
|
||||
|
||||
tp = tp.Elem()
|
||||
tps = tp.Elem()
|
||||
value := reflect.ValueOf(obj).Elem()
|
||||
|
||||
if reflect.Struct != tps.Kind() {
|
||||
return 0,errors.New("is not struct slice pointer")
|
||||
}
|
||||
for z := 0; z < value.Len();z ++ {
|
||||
tagMap = make(map[int]string)
|
||||
n = tps.NumField()
|
||||
var query_struct string
|
||||
for i = 0; i < n; i++ {
|
||||
tag := tps.Field(i).Tag.Get("sql")
|
||||
if len(tag) > 0 {
|
||||
tagMap[i] = tag
|
||||
}
|
||||
if i == 0{
|
||||
query_struct += "("
|
||||
}
|
||||
query_struct += tagMap[i]
|
||||
if i == n -1{
|
||||
query_struct += ")"
|
||||
}else {
|
||||
query_struct += ","
|
||||
}
|
||||
}
|
||||
vs ,e := GenSql(value.Index(z))
|
||||
if nil != e{
|
||||
logs.Error(e.Error())
|
||||
}
|
||||
query := "insert into " + tb_name + query_struct + "values " + vs
|
||||
_, e = this.Insert(query)
|
||||
if e != nil{
|
||||
logs.Error(e.Error())
|
||||
}
|
||||
}
|
||||
return 0,nil
|
||||
}
|
||||
// 执行INSERT语句并返回最后生成的自增ID
|
||||
// 返回0表示没有出错, 但没生成自增ID
|
||||
// 返回-1表示出错
|
||||
func (this *Database) Insert(query string, args ...interface{}) (int64, error) {
|
||||
ret, err := this.Exec(query, args...)
|
||||
if err != nil {
|
||||
return -1, err
|
||||
}
|
||||
last, err := ret.LastInsertId()
|
||||
if err != nil {
|
||||
return -1, err
|
||||
|
||||
}
|
||||
return last, nil
|
||||
}
|
||||
|
||||
type OneRow map[string]string
|
||||
type Results []OneRow
|
||||
|
||||
// 判断字段是否存在
|
||||
func (row OneRow) Exist(field string) bool {
|
||||
if _, ok := row[field]; ok {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// 获取指定字段的值
|
||||
func (row OneRow) Get(field string) string {
|
||||
if v, ok := row[field]; ok {
|
||||
return v
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// 获取指定字段的整数值, 注意, 如果该字段不存在则会返回0
|
||||
func (row OneRow) GetInt(field string) int {
|
||||
if v, ok := row[field]; ok {
|
||||
return Atoi(v)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// 获取指定字段的整数值, 注意, 如果该字段不存在则会返回0
|
||||
func (row OneRow) GetInt64(field string) int64 {
|
||||
if v, ok := row[field]; ok {
|
||||
return Atoi64(v)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// 设置值
|
||||
func (row OneRow) Set(key, val string) {
|
||||
row[key] = val
|
||||
}
|
||||
|
||||
// 查询不定字段的结果集
|
||||
func (this *Database) Select(query string, args ...interface{}) (Results, error) {
|
||||
rows, err := this.DB.Query(query, args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
cols, err := rows.Columns()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
colNum := len(cols)
|
||||
rawValues := make([][]byte, colNum)
|
||||
scans := make([]interface{}, len(cols)) //query.Scan的参数，因为每次查询出来的列是不定长的，所以传入长度固定当次查询的长度
|
||||
|
||||
// 将每行数据填充到[][]byte里
|
||||
for i := range rawValues {
|
||||
scans[i] = &rawValues[i]
|
||||
}
|
||||
|
||||
results := make(Results, 0)
|
||||
for rows.Next() {
|
||||
err = rows.Scan(scans...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
row := make(map[string]string)
|
||||
|
||||
for k, raw := range rawValues {
|
||||
key := cols[k]
|
||||
/*if raw == nil {
|
||||
row[key] = "\\N"
|
||||
} else {*/
|
||||
row[key] = string(raw)
|
||||
//}
|
||||
}
|
||||
results = append(results, row)
|
||||
}
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// 查询一行不定字段的结果
|
||||
func (this *Database) SelectOne(query string, args ...interface{}) (OneRow, error) {
|
||||
ret, err := this.Select(query, args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(ret) > 0 {
|
||||
return ret[0], nil
|
||||
}
|
||||
return make(OneRow), nil
|
||||
}
|
||||
|
||||
// 队列入栈
|
||||
func (this *queueList) Push(item *QueueItem) {
|
||||
this.lock.Lock()
|
||||
this.list = append(this.list, item)
|
||||
this.lock.Unlock()
|
||||
}
|
||||
|
||||
// 队列出栈
|
||||
func (this *queueList) Pop() chan *QueueItem {
|
||||
item := make(chan *QueueItem)
|
||||
go func() {
|
||||
defer close(item)
|
||||
for {
|
||||
switch {
|
||||
case len(this.list) == 0:
|
||||
timeout := time.After(time.Second * 2)
|
||||
select {
|
||||
case <-this.quit:
|
||||
this.quited = true
|
||||
return
|
||||
case <-timeout:
|
||||
//log.Println("SQL Queue polling")
|
||||
}
|
||||
default:
|
||||
this.lock.Lock()
|
||||
i := this.list[0]
|
||||
this.list = this.list[1:]
|
||||
this.lock.Unlock()
|
||||
select {
|
||||
case item <- i:
|
||||
return
|
||||
case <-this.quit:
|
||||
this.quited = true
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
return item
|
||||
}
|
||||
|
||||
// 执行开始执行
|
||||
func (this *queueList) Start() {
|
||||
for {
|
||||
if this.quited {
|
||||
return
|
||||
}
|
||||
c := this.Pop()
|
||||
item := <-c
|
||||
item.DB.Exec(item.Query, item.Params...)
|
||||
}
|
||||
}
|
||||
|
||||
// 停止队列
|
||||
func (this *queueList) Stop() {
|
||||
this.quit <- true
|
||||
}
|
||||
|
||||
// 向Sql队列中插入一条执行语句
|
||||
func (this *Database) Queue(query string, args ...interface{}) {
|
||||
item := &QueueItem{
|
||||
DB: this,
|
||||
Query: query,
|
||||
Params: args,
|
||||
}
|
||||
queue.Push(item)
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
_ "github.com/denisenkom/go-mssqldb"
|
||||
)
|
||||
|
||||
// ProcExec 执行存储过程, 返回受影响的行数
|
||||
func (this *Database) ExecProc(procname string, params ...interface{}) (int64, error) {
|
||||
result, err := this.Exec("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
affected, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
lastinsertid, err := result.LastInsertId()
|
||||
if err != nil {
|
||||
return affected, nil
|
||||
}
|
||||
return lastinsertid, nil
|
||||
}
|
||||
|
||||
// GetExecProcErr 执行存储过程, 返回是否在执行过程中出现错误
|
||||
func (this *Database) GetExecProcErr(procname string, params ...interface{}) error {
|
||||
_, err := this.ExecProc(procname, params...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ProcQuery 通过存储过程查询记录
|
||||
func (this *Database) ProcQuery(procname string, params ...interface{}) (rows *sql.Rows, err error) {
|
||||
rows, err = this.Query("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...)
|
||||
return
|
||||
}
|
||||
|
||||
// ProcQueryRow 通过存储过程查询单条记录
|
||||
func (this *Database) ProcQueryRow(procname string, params ...interface{}) *sql.Row {
|
||||
return this.QueryRow("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...)
|
||||
}
|
||||
|
||||
// ProcStatus 调用存储过程并获取最终的执行状态码和提示信息
|
||||
func (this *Database) ProcStatus(procname string, params ...interface{}) (int, string) {
|
||||
var status int
|
||||
var msg string
|
||||
err := this.QueryRow("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...).Scan(&status, &msg)
|
||||
if err != nil {
|
||||
return -99, err.Error()
|
||||
}
|
||||
return status, msg
|
||||
}
|
||||
|
||||
// ProcSelect 通过存储过程查询结果集
|
||||
func (this *Database) ProcSelect(procname string, params ...interface{}) (Results, error) {
|
||||
return this.Select("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...)
|
||||
}
|
||||
|
||||
// ProcSelectOne 通过存储查询一行不定字段的结果
|
||||
func (this *Database) ProcSelectOne(procname string, params ...interface{}) (OneRow, error) {
|
||||
return this.SelectOne("EXEC " + procname + " " + this.GetProcPlaceholder(len(params)), params...)
|
||||
}
|
||||
|
||||
// GetProcPlaceholder 按照指定数量生成调用存储过程时所用的参数占位符
|
||||
func (this *Database) GetProcPlaceholder(count int) (placeholder string) {
|
||||
placeholder = ""
|
||||
for i := 0; i < count; i++ {
|
||||
if i > 0 {
|
||||
placeholder += ","
|
||||
}
|
||||
placeholder += "?"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"user/config"
|
||||
"fmt"
|
||||
_ "github.com/go-sql-driver/mysql"
|
||||
"log"
|
||||
)
|
||||
|
||||
var gDb Database
|
||||
|
||||
func Init() {
|
||||
mysqlconf := config.GetMysqlConfig()
|
||||
log.Println(mysqlconf)
|
||||
cnn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8",mysqlconf.UserName,mysqlconf.Password,
|
||||
mysqlconf.Addr,mysqlconf.Db)
|
||||
_db,err := sql.Open("mysql",cnn)
|
||||
if err != nil{
|
||||
fmt.Println("connect sql server ",err.Error())
|
||||
}
|
||||
e := _db.Ping()
|
||||
if nil != e{
|
||||
fmt.Println(e.Error())
|
||||
}
|
||||
gDb = Database{Type:string(""),DB:_db}
|
||||
}
|
||||
|
||||
func GetMysqlClient() *Database {
|
||||
return &gDb
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,542 @@
|
|||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"errors"
|
||||
"strconv"
|
||||
"strings"
|
||||
"log"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"math/big"
|
||||
|
||||
"git.jiaxianghudong.com/go/utils"
|
||||
)
|
||||
|
||||
const (
|
||||
_ = iota
|
||||
TYPE_INSERT
|
||||
TYPE_DELETE
|
||||
TYPE_UPDATE
|
||||
TYPE_SELECT
|
||||
TYPE_INSERTUPDATE
|
||||
)
|
||||
|
||||
var (
|
||||
WrapSymbol = "`"
|
||||
DBType = "mysql"
|
||||
)
|
||||
|
||||
// SQL语句构造结构
|
||||
type SB struct {
|
||||
db *Database
|
||||
t int
|
||||
field, table, where, group, order, limit string
|
||||
values SBValues
|
||||
values2 SBValues
|
||||
ignore bool
|
||||
fullsql bool
|
||||
debug bool
|
||||
unsafe bool //是否进行安全检查, 专门针对无限定的UPDATE和DELETE进行二次验证
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// Exec返回结果
|
||||
type SBResult struct {
|
||||
Success bool //语句是否执行成功
|
||||
Code int //错误代码
|
||||
Msg string //错误提示信息
|
||||
LastID int64 //最后产生的ID
|
||||
Affected int64 //受影响的行数
|
||||
Sql string //最后执行的SQL
|
||||
}
|
||||
|
||||
// 值对象
|
||||
type SBValues map[string]interface{}
|
||||
|
||||
// 增量值
|
||||
type IncVal struct {
|
||||
Val int64
|
||||
BaseField string // 为空表示对当前字段累加
|
||||
}
|
||||
|
||||
// 向值对象中加入值
|
||||
func (v SBValues) Add(key string, val interface{}) {
|
||||
v[key] = val
|
||||
}
|
||||
|
||||
// 删除值对象中的某个值
|
||||
func (v SBValues) Del(key string) {
|
||||
delete(v, key)
|
||||
}
|
||||
|
||||
// 判断指定键是否存在
|
||||
func (v SBValues) IsExist(key string) bool {
|
||||
if _, exist := v[key]; exist {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// 获取键的整形值
|
||||
func (v SBValues) Get(key string) interface{} {
|
||||
if val, exist := v[key]; exist {
|
||||
return val
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// 获取键的字符串值
|
||||
func (v SBValues) GetString(key string) string {
|
||||
if val, exist := v[key]; exist {
|
||||
if trueVal, ok := val.(string); ok {
|
||||
return trueVal
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// 获取键的整形值
|
||||
func (v SBValues) GetInt(key string) int {
|
||||
if val, exist := v[key]; exist {
|
||||
if trueVal, ok := val.(int); ok {
|
||||
return trueVal
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// 获取键的无符号整形值
|
||||
func (v SBValues) GetUint(key string) uint {
|
||||
if val, exist := v[key]; exist {
|
||||
if trueVal, ok := val.(uint); ok {
|
||||
return trueVal
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// 获取键的64位整形值
|
||||
func (v SBValues) GetInt64(key string) int64 {
|
||||
if val, exist := v[key]; exist {
|
||||
if trueVal, ok := val.(int64); ok {
|
||||
return trueVal
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// 返回绑定完参数的完整的SQL语句
|
||||
func FullSql(str string, args ...interface{}) (string, error) {
|
||||
if !strings.Contains(str, "?") {
|
||||
return str, nil
|
||||
}
|
||||
sons := strings.Split(str, "?")
|
||||
|
||||
var ret string
|
||||
var argIndex int
|
||||
var maxArgIndex = len(args)
|
||||
|
||||
for _, son := range sons {
|
||||
ret += son
|
||||
|
||||
if argIndex < maxArgIndex {
|
||||
switch v := args[argIndex].(type) {
|
||||
case int:
|
||||
ret += strconv.Itoa(v)
|
||||
case int8:
|
||||
ret += strconv.Itoa(int(v))
|
||||
case int16:
|
||||
ret += strconv.Itoa(int(v))
|
||||
case int32:
|
||||
ret += utils.I64toA(int64(v))
|
||||
case int64:
|
||||
ret += utils.I64toA(v)
|
||||
case uint:
|
||||
ret += utils.UitoA(v)
|
||||
case uint8:
|
||||
ret += utils.UitoA(uint(v))
|
||||
case uint16:
|
||||
ret += utils.UitoA(uint(v))
|
||||
case uint32:
|
||||
ret += utils.Ui32toA(v)
|
||||
case uint64:
|
||||
ret += utils.Ui64toA(v)
|
||||
case float32:
|
||||
ret += utils.F32toA(v)
|
||||
case float64:
|
||||
ret += utils.F64toA(v)
|
||||
case *big.Int:
|
||||
ret += v.String()
|
||||
case bool:
|
||||
if v {
|
||||
ret += "true"
|
||||
} else {
|
||||
ret += "false"
|
||||
}
|
||||
case string:
|
||||
ret += "'" + strings.Replace(strings.Replace(v, "'", "", -1), `\`, `\\`, -1) + "'"
|
||||
case nil:
|
||||
ret += "NULL"
|
||||
default:
|
||||
return "", errors.New(fmt.Sprintf("invalid sql argument type: %v => %v (sql: %s)", reflect.TypeOf(v).String(), v, str))
|
||||
}
|
||||
|
||||
argIndex++
|
||||
}
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
// 构建SQL语句
|
||||
// param: returnFullSql 是否返回完整的sql语句(即:绑定参数之后的语句)
|
||||
func (q *SB) ToSql(returnFullSql ...bool) (str string, err error) {
|
||||
q.args = make([]interface{}, 0)
|
||||
|
||||
switch q.t {
|
||||
case TYPE_INSERT:
|
||||
if q.table == "" {
|
||||
err = errors.New("table cannot be empty.")
|
||||
return
|
||||
}
|
||||
if len(q.values) == 0 {
|
||||
err = errors.New("values cannot be empty.")
|
||||
return
|
||||
}
|
||||
if q.ignore {
|
||||
str = "INSERT IGNORE INTO " + q.table
|
||||
} else {
|
||||
str = "INSERT INTO " + q.table
|
||||
}
|
||||
var fields, placeholder string
|
||||
for k, v := range q.values {
|
||||
fields += "," + WrapSymbol + k + WrapSymbol
|
||||
placeholder += ",?"
|
||||
q.args = append(q.args, v)
|
||||
}
|
||||
str += " (" + utils.Substr(fields, 1) + ") VALUES (" + utils.Substr(placeholder, 1) + ")"
|
||||
case TYPE_DELETE:
|
||||
if q.table != "" {
|
||||
if q.where == "" && !q.unsafe {
|
||||
err = errors.New("deleting all data is not safe.")
|
||||
return
|
||||
}
|
||||
str = "DELETE " + q.table
|
||||
if q.table != "" {
|
||||
str += " FROM " + q.table
|
||||
}
|
||||
if q.where != "" {
|
||||
str += " WHERE " + q.where
|
||||
}
|
||||
}
|
||||
case TYPE_UPDATE:
|
||||
if q.table != "" {
|
||||
if q.where == "" && !q.unsafe {
|
||||
err = errors.New("updating all data is not safe.")
|
||||
return
|
||||
}
|
||||
str = "UPDATE " + q.table
|
||||
str += " SET " + utils.Substr(q.buildUpdateParams(q.values), 1)
|
||||
if q.where != "" {
|
||||
str += " WHERE " + q.where
|
||||
}
|
||||
}
|
||||
case TYPE_INSERTUPDATE:
|
||||
if q.table != "" {
|
||||
str = "INSERT INTO " + q.table
|
||||
var fields, placeholder string
|
||||
for k, v := range q.values {
|
||||
fields += "," + WrapSymbol + k + WrapSymbol
|
||||
placeholder += ",?"
|
||||
q.args = append(q.args, v)
|
||||
}
|
||||
str += " (" + utils.Substr(fields, 1) + ") VALUES (" + utils.Substr(placeholder, 1) + ") ON DUPLICATE KEY UPDATE "
|
||||
placeholder = q.buildUpdateParams(q.values2)
|
||||
str += utils.Substr(placeholder, 1)
|
||||
}
|
||||
case TYPE_SELECT:
|
||||
str = "SELECT " + q.field
|
||||
if q.table != "" {
|
||||
str += " FROM " + q.table
|
||||
}
|
||||
if q.where != "" {
|
||||
str += " WHERE " + q.where
|
||||
}
|
||||
if q.group != "" {
|
||||
str += " GROUP BY " + q.group
|
||||
}
|
||||
if q.order != "" {
|
||||
str += " ORDER BY " + q.order
|
||||
}
|
||||
if q.limit != "" && (q.db.Type == "" || q.db.Type == "mysql") {
|
||||
str += " LIMIT " + q.limit
|
||||
}
|
||||
}
|
||||
|
||||
if len(returnFullSql) == 1 && returnFullSql[0] {
|
||||
str, err = FullSql(str, q.args...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// 构造Update更新参数
|
||||
func (q *SB) buildUpdateParams(vals SBValues) string {
|
||||
var placeholder string
|
||||
for k, v := range vals {
|
||||
if iv, ok := v.(IncVal); ok {
|
||||
placeholder += "," + WrapSymbol + k + WrapSymbol + "=" + utils.Ternary(iv.BaseField == "", k, iv.BaseField).(string)
|
||||
if iv.Val >= 0 {
|
||||
placeholder += "+" + utils.I64toA(iv.Val)
|
||||
} else {
|
||||
placeholder += utils.I64toA(iv.Val)
|
||||
}
|
||||
} else {
|
||||
placeholder += "," + WrapSymbol + k + WrapSymbol + "=?"
|
||||
q.args = append(q.args, v)
|
||||
}
|
||||
}
|
||||
return placeholder
|
||||
}
|
||||
|
||||
// 设置数据库对象
|
||||
func (q *SB) DB(db *Database) *SB {
|
||||
q.db = db
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置FROM字句
|
||||
func (q *SB) From(str string) *SB {
|
||||
q.table = str
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置表名
|
||||
func (q *SB) Table(str string) *SB {
|
||||
return q.From(str)
|
||||
}
|
||||
|
||||
// 设置WHERE字句
|
||||
func (q *SB) Where(str string) *SB {
|
||||
q.where = str
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置GROUP字句
|
||||
func (q *SB) Group(str string) *SB {
|
||||
q.group = str
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置GROUP字句
|
||||
func (q *SB) Order(str string) *SB {
|
||||
q.order = str
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置LIMIT字句
|
||||
func (q *SB) Limit(count int, offset ...int) *SB {
|
||||
if len(offset) > 0 {
|
||||
q.limit = utils.Itoa(offset[0]) + "," + utils.Itoa(count)
|
||||
} else {
|
||||
q.limit = "0," + utils.Itoa(count)
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置安全检查开关
|
||||
func (q *SB) Unsafe(unsefe ...bool) *SB {
|
||||
if len(unsefe) == 1 && !unsefe[0] {
|
||||
q.unsafe = false
|
||||
} else {
|
||||
q.unsafe = true
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
// 是否Debug
|
||||
func (q *SB) Debug(debug ...bool) *SB {
|
||||
if len(debug) == 1 && !debug[0] {
|
||||
q.debug = false
|
||||
} else {
|
||||
q.debug = true
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置值
|
||||
func (q *SB) Value(m SBValues) *SB {
|
||||
q.values = m
|
||||
return q
|
||||
}
|
||||
|
||||
// 设置值2
|
||||
func (q *SB) Value2(m SBValues) *SB {
|
||||
q.values2 = m
|
||||
return q
|
||||
}
|
||||
|
||||
// 添加值
|
||||
func (q *SB) AddValue(key string, val interface{}) *SB {
|
||||
q.values.Add(key, val)
|
||||
return q
|
||||
}
|
||||
|
||||
// 添加值2
|
||||
func (q *SB) AddValue2(key string, val interface{}) *SB {
|
||||
q.values2.Add(key, val)
|
||||
return q
|
||||
}
|
||||
|
||||
// 获取一个值对象
|
||||
func NewValues() SBValues {
|
||||
return SBValues{}
|
||||
}
|
||||
|
||||
// 构建INSERT语句
|
||||
func Insert(ignore ...bool) *SB {
|
||||
var i bool
|
||||
if len(ignore) == 1 && ignore[0] {
|
||||
i = true
|
||||
}
|
||||
return &SB{t: TYPE_INSERT, db: Obj, ignore: i, values: SBValues{}, args: make([]interface{}, 0)}
|
||||
}
|
||||
|
||||
// 构建DELETE语句
|
||||
func Delete() *SB {
|
||||
return &SB{t: TYPE_DELETE, db: Obj}
|
||||
}
|
||||
|
||||
// 构建UPDATE语句
|
||||
func Update() *SB {
|
||||
return &SB{t: TYPE_UPDATE, db: Obj, values: SBValues{}, args: make([]interface{}, 0)}
|
||||
}
|
||||
|
||||
// 构建InsertUpdate语句, 仅针对MySQL有效, 内部使用ON DUPLICATE KEY UPDATE方式实现
|
||||
func InsertUpdate() *SB {
|
||||
return &SB{t: TYPE_INSERTUPDATE, db: Obj, values: SBValues{}, values2: SBValues{}, args: make([]interface{}, 0)}
|
||||
}
|
||||
|
||||
// 构建SELECT语句
|
||||
func Select(str ...string) *SB {
|
||||
fields := "*"
|
||||
if len(str) == 1 {
|
||||
fields = str[0]
|
||||
}
|
||||
return &SB{t: TYPE_SELECT, db: Obj, field: fields}
|
||||
}
|
||||
|
||||
// 获取构造SQL后的参数
|
||||
func (q *SB) GetArgs() []interface{} {
|
||||
return q.args
|
||||
}
|
||||
|
||||
//
|
||||
func (q *SB) FullSql(yes ...bool) *SB {
|
||||
if len(yes) == 1 {
|
||||
q.fullsql = yes[0]
|
||||
} else {
|
||||
q.fullsql = true
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
// 执行INSERT、DELETE、UPDATE语句
|
||||
func (q *SB) Exec(args ...interface{}) *SBResult {
|
||||
var err error
|
||||
sbRet := &SBResult{}
|
||||
sbRet.Sql, err = q.ToSql()
|
||||
if err != nil {
|
||||
sbRet.Msg = err.Error()
|
||||
} else {
|
||||
if q.debug {
|
||||
log.Println("\n\tSQL prepare statement:\n\t", sbRet.Sql, "\n\tMap args:\n\t", q.args, "\n\tParams:\n\t", args)
|
||||
}
|
||||
|
||||
var ret sql.Result
|
||||
var err error
|
||||
if q.fullsql {
|
||||
var sqlStr string
|
||||
sqlStr, err = FullSql(sbRet.Sql, append(q.args, args...)...)
|
||||
if err == nil {
|
||||
ret, err = q.db.Exec(sqlStr)
|
||||
}
|
||||
} else {
|
||||
ret, err = q.db.Exec(sbRet.Sql, append(q.args, args...)...)
|
||||
}
|
||||
if err != nil {
|
||||
sbRet.Msg = err.Error()
|
||||
} else {
|
||||
sbRet.Success = true
|
||||
switch q.t {
|
||||
case TYPE_INSERT:
|
||||
if DBType == "mysql" {
|
||||
last, err := ret.LastInsertId()
|
||||
if (err == nil) {
|
||||
sbRet.LastID = last;
|
||||
}
|
||||
}
|
||||
case TYPE_DELETE:
|
||||
fallthrough
|
||||
case TYPE_UPDATE:
|
||||
fallthrough
|
||||
case TYPE_INSERTUPDATE:
|
||||
aff, err := ret.RowsAffected()
|
||||
if (err == nil) {
|
||||
sbRet.Affected = aff
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return sbRet
|
||||
}
|
||||
|
||||
// 查询记录集
|
||||
func (q *SB) Query(args ...interface{}) (Results, error) {
|
||||
s, e := q.ToSql()
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
if q.debug {
|
||||
log.Println("\n\tSQL prepare statement:\n\t", s, "\n\tParams:\n\t", args)
|
||||
}
|
||||
return q.db.Select(s, args...)
|
||||
}
|
||||
|
||||
// 查询单行数据
|
||||
func (q *SB) QueryOne(args ...interface{}) (OneRow, error) {
|
||||
q.Limit(1, 0)
|
||||
s, e := q.ToSql()
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
if q.debug {
|
||||
log.Println("\n\tSQL prepare statement:\n\t", s, "\n\tParams:\n\t", args)
|
||||
}
|
||||
return q.db.SelectOne(s, args...)
|
||||
}
|
||||
|
||||
// 查询记录集
|
||||
func (q *SB) QueryAllRow(args ...interface{}) (*sql.Rows, error) {
|
||||
s, e := q.ToSql()
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
if q.debug {
|
||||
log.Println("\n\tSQL prepare statement:\n\t", s, "\n\tParams:\n\t", args)
|
||||
}
|
||||
return q.db.Query(s, args...)
|
||||
}
|
||||
|
||||
// 查询单行数据
|
||||
func (q *SB) QueryRow(args ...interface{}) *sql.Row {
|
||||
s, e := q.ToSql()
|
||||
if e != nil {
|
||||
return nil
|
||||
}
|
||||
if q.debug {
|
||||
log.Println("\n\tSQL prepare statement:\n\t", s, "\n\tParams:\n\t", args)
|
||||
}
|
||||
return q.db.QueryRow(s, args...)
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
package db
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"strconv"
|
||||
"database/sql"
|
||||
)
|
||||
|
||||
// 根据传入的字段列表生成相符数量的占位符
|
||||
func GetPlaceholderByFields(fileds string) string {
|
||||
fileds = strings.Replace(fileds, " ", "", -1)
|
||||
fileds = strings.Trim(fileds, ",")
|
||||
count := len(strings.Split(fileds, ","))
|
||||
ret := make([]string, count)
|
||||
for i := 0; i < count; i++ {
|
||||
ret[i] = "?"
|
||||
}
|
||||
return strings.Join(ret, ",")
|
||||
}
|
||||
|
||||
// Atoi 转换成整型
|
||||
func Atoi(s string, d ...int) int {
|
||||
i, err := strconv.Atoi(s)
|
||||
if err != nil {
|
||||
if len(d) > 0 {
|
||||
return d[0]
|
||||
} else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
return i
|
||||
}
|
||||
|
||||
// Atoi64 转换成整型int64
|
||||
func Atoi64(s string, d ...int64) int64 {
|
||||
i, err := strconv.ParseInt(s, 10, 64)
|
||||
if err != nil {
|
||||
if len(d) > 0 {
|
||||
return d[0]
|
||||
} else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
return i
|
||||
}
|
||||
|
||||
// 返回一个带有Null值的数据库字符串
|
||||
func NewNullString(s string) sql.NullString {
|
||||
if len(s) == 0 {
|
||||
return sql.NullString{}
|
||||
}
|
||||
return sql.NullString{
|
||||
String: s,
|
||||
Valid: true,
|
||||
}
|
||||
}
|
||||
|
||||
// 返回一个带有Null值的数据库整形
|
||||
func NewNullInt64(s int64, isNull bool) sql.NullInt64 {
|
||||
return sql.NullInt64{
|
||||
Int64: s,
|
||||
Valid: !isNull,
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
package logs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"runtime"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
LOG_ERROR = iota
|
||||
LOG_WARING
|
||||
LOG_INFO
|
||||
LOG_DEBUG
|
||||
)
|
||||
|
||||
var log *mylog
|
||||
|
||||
/*
|
||||
* 初始化
|
||||
*/
|
||||
func init() {
|
||||
log = newMylog()
|
||||
}
|
||||
|
||||
func Init(dir string, file string, level int, savefile bool) {
|
||||
log.setDir(dir)
|
||||
log.setFile(file)
|
||||
log.setLevel(level)
|
||||
log.setSavefile(savefile)
|
||||
}
|
||||
|
||||
func Error(err ...interface{}) {
|
||||
log.write(LOG_ERROR, fmt.Sprint(err...))
|
||||
}
|
||||
|
||||
func Waring(war ...interface{}) {
|
||||
log.write(LOG_WARING, fmt.Sprint(war...))
|
||||
}
|
||||
func SetLevel(level int) {
|
||||
log.setLevel(level)
|
||||
}
|
||||
func Info(info ...interface{}) {
|
||||
log.write(LOG_INFO, fmt.Sprint(info...))
|
||||
}
|
||||
|
||||
func Debug(deb ...interface{}) {
|
||||
log.write(LOG_DEBUG, fmt.Sprint(deb...))
|
||||
}
|
||||
|
||||
/*
|
||||
* 日志执行函数
|
||||
*/
|
||||
type mylog struct {
|
||||
log chan string // 日志chan
|
||||
dir string // 日志存放目录
|
||||
file string // 日志文件名
|
||||
savefile bool // 是否保存到文件
|
||||
level int // 日志级别
|
||||
}
|
||||
|
||||
func newMylog() *mylog {
|
||||
log := &mylog{}
|
||||
|
||||
log.log = make(chan string, 100)
|
||||
log.dir = "/opt/logs"
|
||||
log.file = "out"
|
||||
log.savefile = false
|
||||
|
||||
go log.run()
|
||||
return log
|
||||
}
|
||||
|
||||
func (l *mylog) setDir(dir string) {
|
||||
l.dir = dir
|
||||
}
|
||||
|
||||
func (l *mylog) setFile(file string) {
|
||||
l.file = file
|
||||
}
|
||||
|
||||
func (l *mylog) setSavefile(b bool) {
|
||||
l.savefile = b
|
||||
}
|
||||
|
||||
func (l *mylog) setLevel(level int) {
|
||||
l.level = level
|
||||
}
|
||||
|
||||
func (l *mylog) getLevelString(level int) string {
|
||||
switch level {
|
||||
case LOG_ERROR:
|
||||
return "ERROR"
|
||||
case LOG_WARING:
|
||||
return "WARING"
|
||||
case LOG_INFO:
|
||||
return "INFO"
|
||||
case LOG_DEBUG:
|
||||
return "DEBUG"
|
||||
}
|
||||
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
func (l *mylog) write(level int, str string) {
|
||||
// 判断级别
|
||||
if level > l.level {
|
||||
return
|
||||
}
|
||||
|
||||
// 输出日志
|
||||
pc, _, line, _ := runtime.Caller(2)
|
||||
p := runtime.FuncForPC(pc)
|
||||
t := time.Now()
|
||||
str = fmt.Sprintf("[%04d-%02d-%02d %02d:%02d:%02d] [%s] %s(%d): %s\n",
|
||||
t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(),
|
||||
l.getLevelString(level), p.Name(), line, str)
|
||||
// 输出到控制台
|
||||
if false == l.savefile {
|
||||
fmt.Print(str)
|
||||
return
|
||||
}
|
||||
|
||||
// 输出到文件
|
||||
l.log <- str
|
||||
}
|
||||
|
||||
func (l *mylog) run() {
|
||||
for {
|
||||
str := <-l.log
|
||||
|
||||
// 判断文件夹是否存在
|
||||
_, err := os.Stat(l.dir)
|
||||
if nil != err {
|
||||
os.MkdirAll(l.dir, os.ModePerm)
|
||||
}
|
||||
|
||||
// 获取时间
|
||||
t := time.Now()
|
||||
path := fmt.Sprintf("%s/%s-%04d-%02d-%02d.log", l.dir, l.file,
|
||||
t.Year(), t.Month(), t.Day())
|
||||
fp, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.ModePerm)
|
||||
if nil == err {
|
||||
fp.WriteString(str)
|
||||
fp.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"github.com/gin-gonic/gin"
|
||||
"log"
|
||||
"strconv"
|
||||
"user/controller"
|
||||
"user/config"
|
||||
"user/db"
|
||||
"user/logs"
|
||||
)
|
||||
|
||||
func InitMysql() {
|
||||
c := config.GetMysqlConfig()
|
||||
if c == nil{
|
||||
logs.Error("cannnot connect mysql server")
|
||||
}else {
|
||||
db.Init()
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
e := config.Init("user.yaml")
|
||||
if nil != e{
|
||||
log.Println(e.Error())
|
||||
}
|
||||
db.Init()
|
||||
r := gin.Default()
|
||||
{
|
||||
/** 添加或修改用户 **/
|
||||
r.POST("/api/user", controller.SetUser)
|
||||
/** 删除用户 **/
|
||||
r.DELETE("/api/user", controller.DelUser)
|
||||
/** 获取单独用户详情信息 methods(id) **/
|
||||
r.GET("/api/user", controller.GetUser)
|
||||
/** 获取所有用户 **/
|
||||
r.GET("/api/users", controller.GetUsers)
|
||||
/** 用户登录 **/
|
||||
r.POST("/api/login", controller.Login)
|
||||
/** 用户注册 **/
|
||||
r.POST("/api/register", controller.Register)
|
||||
/** 用户退出登陆 **/
|
||||
r.GET("/api/logout", controller.Logout)
|
||||
}
|
||||
r.Run(":" + strconv.Itoa(config.GetPort()))
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
package model
|
||||
|
||||
type Users struct {
|
||||
ID int64 `sql:"id" json:"id"`
|
||||
UserName string `sql:"user_name" json:"UserName"`
|
||||
UserPwd string `sql:"user_pwd" json:"UserPwd"`
|
||||
CreatedDate string `sql:"created_date" json:"CreatedDate"`
|
||||
UpdatedDate string `sql:"updated_date" json:"UpdatedDate"`
|
||||
DisplayName string `sql:"display_name" json:"DisplayName"`
|
||||
EmailAddress string `sql:"email_address" json:"EmailAddress"`
|
||||
Tel string `sql:"tel" json:"tel"`
|
||||
Avatar string `sql:"avatar" json:"Avatar"`
|
||||
}
|
||||
|
|
@ -0,0 +1,426 @@
|
|||
package redis
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
// "errors"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"gopkg.in/redis.v3"
|
||||
)
|
||||
|
||||
const maxConn = 100
|
||||
|
||||
var redisChan chan *redis.Client
|
||||
|
||||
var option *redis.Options
|
||||
|
||||
func Init(addr string, pwd string, db int64) error {
|
||||
option = &redis.Options{
|
||||
Addr: addr,
|
||||
Password: pwd,
|
||||
DB: db,
|
||||
}
|
||||
redisChan = make(chan *redis.Client, maxConn)
|
||||
for i := 0; i < maxConn; i++ {
|
||||
client, err := creatRedisClient(option)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
redisChan <- client
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// 创建redis对象
|
||||
func creatRedisClient(option *redis.Options) (*redis.Client, error) {
|
||||
|
||||
client := redis.NewClient(option)
|
||||
// 检测client有效性
|
||||
if nil != client {
|
||||
_, err := client.Ping().Result()
|
||||
if nil != err {
|
||||
client.Close()
|
||||
return nil, errors.New(fmt.Sprintf("fail to ping redis-svr,addr :%s , pwd :%s ,DB :%d", option.Addr, option.Password, option.DB))
|
||||
}
|
||||
} else {
|
||||
return nil, errors.New(fmt.Sprintf("fail to connect redis-svr,,addr :%s , pwd :%s ,DB :%d", option.Addr, option.Password, option.DB))
|
||||
}
|
||||
return client, nil
|
||||
}
|
||||
|
||||
// 获取redis
|
||||
func getRedis() (*redis.Client, error) {
|
||||
var client *redis.Client
|
||||
|
||||
select {
|
||||
case <-time.After(time.Second * 10):
|
||||
case client = <-redisChan:
|
||||
}
|
||||
|
||||
// 检测client有效性
|
||||
if nil != client {
|
||||
_, err := client.Ping().Result()
|
||||
if nil != err {
|
||||
client.Close()
|
||||
// 尝试3次重连
|
||||
for i := 0; i < 3; i++ {
|
||||
client, err = creatRedisClient(option)
|
||||
if client != nil {
|
||||
return client, err
|
||||
}
|
||||
}
|
||||
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return client, nil
|
||||
}
|
||||
|
||||
// 将redis链接放回连接池
|
||||
func relaseRedis(client *redis.Client) {
|
||||
select {
|
||||
case <-time.After(time.Second * 10):
|
||||
client.Close()
|
||||
case redisChan <- client:
|
||||
}
|
||||
}
|
||||
|
||||
func Get(key string) (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
val, err := client.Get(key).Result()
|
||||
if nil != err {
|
||||
if err.Error() == "redis: nil" {
|
||||
return "", nil
|
||||
}
|
||||
return "", err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
|
||||
// redis查询
|
||||
func Keys(key string) ([]string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if client == nil {
|
||||
return nil, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
val, err := client.Keys(key).Result()
|
||||
if nil != err {
|
||||
var nullResult = []string{""}
|
||||
return nullResult, err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
|
||||
func Set(key string, val string, expire ...time.Duration) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
var t time.Duration = 0
|
||||
|
||||
if len(expire) == 1 {
|
||||
t = expire[0]
|
||||
}
|
||||
|
||||
_, err = client.Set(key, val, t).Result()
|
||||
|
||||
return err
|
||||
}
|
||||
func HSet(key string, filed, val string) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
_, err = client.HSet(key, filed, val).Result()
|
||||
return err
|
||||
}
|
||||
func SIsMember(key string, val int32) (bool, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if client == nil {
|
||||
return false, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
isExist, err := client.SIsMember(key, val).Result()
|
||||
return isExist, err
|
||||
}
|
||||
func SAdd(key string, members ...string) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
_, err = client.SAdd(key, members...).Result()
|
||||
return err
|
||||
}
|
||||
func SRem(key string, members ...string) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
_, err = client.SRem(key, members...).Result()
|
||||
return err
|
||||
}
|
||||
func SMembers(key string) ([]string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if client == nil {
|
||||
return nil, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
members, err := client.SMembers(key).Result()
|
||||
return members, err
|
||||
}
|
||||
func HIncrBy(key, filed string, val int64) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
_, err = client.HIncrBy(key, filed, val).Result()
|
||||
return err
|
||||
}
|
||||
func LPush(key string, val ...string) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
_, err = client.LPush(key, val...).Result()
|
||||
return err
|
||||
}
|
||||
func BRPopLPush(source string, dest string, time time.Duration) (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.BRPopLPush(source, dest, time).Result()
|
||||
return val, err
|
||||
}
|
||||
func RPop(key string) (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.RPop(key).Result()
|
||||
return val, err
|
||||
}
|
||||
func LLen(key string) (int64, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if client == nil {
|
||||
return 0, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.LLen(key).Result()
|
||||
return val, err
|
||||
}
|
||||
func LTrim(key string, start, stop int64) (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.LTrim(key, start, stop).Result()
|
||||
return val, err
|
||||
}
|
||||
func LRange(key string, start, stop int64) ([]string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if client == nil {
|
||||
return nil, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
val, err := client.LRange(key, start, stop).Result()
|
||||
if nil != err {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
func UpdateExpire(key string, expire time.Duration) error {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if client == nil {
|
||||
return errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
_, err = client.Expire(key, expire).Result()
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func HGet(key string, hash string) (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.HGet(key, hash).Result()
|
||||
if nil != err {
|
||||
return "", err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
func HGetInt64(key string, hash string) (int64, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if client == nil {
|
||||
return 0, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.HGet(key, hash).Int64()
|
||||
if nil != err {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
func SCard(key string) (int64, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if client == nil {
|
||||
return 0, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
val, err := client.SCard(key).Result()
|
||||
if nil != err {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
return val, nil
|
||||
}
|
||||
|
||||
// 获取时间
|
||||
func Time() (int64, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if client == nil {
|
||||
return 0, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
// 读取redis时间
|
||||
r := client.Time()
|
||||
if nil == r {
|
||||
return 0, errors.New("read redis error")
|
||||
}
|
||||
|
||||
if nil != r.Err() {
|
||||
return 0, r.Err()
|
||||
}
|
||||
|
||||
return strconv.ParseInt(r.Val()[0], 10, 0)
|
||||
}
|
||||
|
||||
// 删除指定key的redis记录
|
||||
func Del(key string) (int64, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if client == nil {
|
||||
return 0, errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
var iResult int64
|
||||
cmdResult := client.Del(key)
|
||||
if nil == cmdResult.Err() {
|
||||
iResult, _ = cmdResult.Result()
|
||||
} else {
|
||||
iResult = 0
|
||||
}
|
||||
|
||||
return iResult, nil
|
||||
}
|
||||
|
||||
// 清空rendis_db
|
||||
func TruncateDB() (string, error) {
|
||||
client, err := getRedis()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if client == nil {
|
||||
return "", errors.New("failed to get rds client")
|
||||
}
|
||||
defer relaseRedis(client)
|
||||
|
||||
cmdResult := client.FlushDb()
|
||||
if cmdResult.Err() != nil {
|
||||
return "", cmdResult.Err()
|
||||
}
|
||||
|
||||
return cmdResult.Result()
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
listen_api: 4596
|
||||
runmode: debug
|
||||
max_conn: 1500
|
||||
logs:
|
||||
dir: "/var/log/user"
|
||||
file: "user.log"
|
||||
level: 1
|
||||
savefile: true
|
||||
redis:
|
||||
addr: 118.24.238.198
|
||||
password: 6379
|
||||
db: 1
|
||||
mysql:
|
||||
addr: 118.24.238.198
|
||||
user: server
|
||||
password: 123
|
||||
db: background
|
||||
max_open: 100
|
||||
MaxIdle: 99
|
||||
Loading…
Reference in New Issue