北漂的女孩

Main.go

package main

import (
       "git.culiu.org/pintuan-go/controllers"
       "github.com/astaxie/beego"
       "golang.org/x/net/websocket"
)

func main() {
       if beego.BConfig.RunMode == "dev" {
              beego.BConfig.WebConfig.DirectoryIndex = true
              beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"
       }
       beego.Handler("/ws", websocket.Handler(controllers.SockServer))
       beego.Run()
}

Controllers

// Copyright 2013 Beego Samples authors
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.

package controllers

import (
       "github.com/astaxie/beego"
       "golang.org/x/net/websocket"
       "github.com/astaxie/beego/cache"
       m "git.culiu.org/pintuan-go/models"
       "time"
       "crypto/md5"
       "encoding/hex"
       "fmt"
)

// WebSocketController handles WebSocket requests.
type WebSocketController struct {
       beego.Controller
}

type OnlineUser struct {
       connection *websocket.Conn
       clientIP   string
       time       string
}

const TIME_FORMAT = "0000-00-00 00:00:00"

var (
       cached cache.Cache
       ActiveUsers = make(map[string]*OnlineUser)
)

func init() {
       cached, _ = cache.NewCache("memory", `{"interval":300}`)
}

//var TASK_CHANNEL = make(chan *OnlineUser)

func SockServer(ws *websocket.Conn) {

       onlineUser := &OnlineUser{
              connection:ws,
              clientIP:ws.Request().RemoteAddr,
              time:time.Now().Format(TIME_FORMAT),
       }

       hash := md5.New()
       hash.Write([]byte(onlineUser.clientIP))
       hashByte := hash.Sum(nil)
       hashStr := hex.EncodeToString(hashByte)
       ActiveUsers[hashStr] = onlineUser

       var orders []m.Order
       if cached.IsExist("last_order_limit") {
              orders = cached.Get("last_order_limit").([]m.Order)
       } else {
              orders = m.GetOrderLimit()
              cached.Put("last_order_limit", orders, 60 * time.Second)
       }
       orders = m.GetOrderLimit()
       fmt.Println(orders)
       onlineUser.pushToClient(orders)
       onlineUser.closeUser()
}
func (user *OnlineUser) pushToClient(rows []m.Order) {
       /*var list = make(map[int]int)
       var list_id []int*/

       type UserOrderInfo struct {
              User_id    int64  `json:"user_id"`
              Headimgurl string `json:"headimgurl"`
              Uname      string `json:"uname"`
              Order_id   int    `json:"order_id"`
              Order_sn   string `json:"order_sn"`
              Goods_id   int    `json:"goods_id"`
       }

       userOrderInfo := []UserOrderInfo{}

       for _, order := range rows {
              user_id := int64(order.User_id)
              //mysql查询出来的user_id不会重复，感觉这一部不用写   如果非得需要可以直接mysql去重查询
              /*if list[user_id] != 1 {
                     list[user_id] = 1
                     list_id = append(list_id, user_id)
              }*/
              userOne := m.GetUserInfoOne(user_id)
              userInfo := UserOrderInfo{
                     User_id:    user_id,
                     Headimgurl: userOne.Headimgurl,
                     Uname:      userOne.Uname,
                     Order_id:   order.Order_id,
                     Order_sn:   order.Order_sn,
                     Goods_id:   order.Goods_id,
              }
              userOrderInfo = append(userOrderInfo, userInfo)

       }
       err := websocket.JSON.Send(user.connection, userOrderInfo)
       if err != nil {
              fmt.Println(err)
              return
       }
}

func (user *OnlineUser) closeUser() {
       user.connection.Close()
       delete(ActiveUsers, user.clientIP)
}

User.go

package models

import (
       "github.com/astaxie/beego/orm"
       _ "github.com/go-sql-driver/mysql"
)

type Users struct {
       User_id    int64    `orm:"pk;"`
       Headimgurl string `orm:"size(255);"`
       Uname      string `orm:"size(255);"`
}

func init() {
       orm.RegisterModel(new(Users))
}

func (u *Users) TableName() string {
       return "hhs_users"
}

func GetUserInfoOne(user_id int64) (users Users) {
       o := orm.NewOrm()
       qs := o.QueryTable("hhs_users")
       qs.Filter("user_id", user_id).One(&users)
       return users
}

}

Order.go

package models

import (
       "github.com/astaxie/beego/orm"
       _ "github.com/go-sql-driver/mysql"
)

//订单表
type Order struct {
       Order_id int    `orm:"pk;"`
       Order_sn string `orm:"unique;size(30);"`
       User_id  int64    `orm:"int"`;
       Goods_id int    `orm:"int"`;
}

func init() {
       orm.RegisterModel(new(Order))
}

func (u *Order) TableName() string {
       return "hhs_order_info"
}


func GetOrderLimit() (orders []Order) {
       o := orm.NewOrm()
       qs := o.QueryTable("hhs_order_info")
       qs.Limit(5).OrderBy("order_id").All(&orders)
       return orders
}

Base.go

package models

import (
       "fmt"

       "github.com/astaxie/beego"
       "github.com/astaxie/beego/orm"
       _ "github.com/go-sql-driver/mysql"
)

func init() {
       var dsn string
       db_type := beego.AppConfig.String("db_type")
       db_host := beego.AppConfig.String("db_host")
       db_port := beego.AppConfig.String("db_port")
       db_user := beego.AppConfig.String("db_user")
       db_pass := beego.AppConfig.String("db_pass")
       db_name := beego.AppConfig.String("db_name")
       db_path := beego.AppConfig.String("db_path")
       db_sslmode := beego.AppConfig.String("db_sslmode")
       switch db_type {
       case "mysql":
              orm.RegisterDriver("mysql", orm.DRMySQL)
              dsn = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", db_user, db_pass, db_host, db_port, db_name)
              break
       case "postgres":
              orm.RegisterDriver("postgres", orm.DRPostgres)
              dsn = fmt.Sprintf("dbname=%s host=%s  user=%s  password=%s  port=%s  sslmode=%s", db_name, db_host, db_user, db_pass, db_port, db_sslmode)
       case "sqlite3":
              orm.RegisterDriver("sqlite3", orm.DRSqlite)
              if db_path == "" {
                     db_path = "./"
              }
              dsn = fmt.Sprintf("%s%s.db", db_path, db_name)
              break
       default:
              beego.Critical("Database driver is not allowed:", db_type)
       }
       orm.RegisterDataBase("default", db_type, dsn)
       orm.Debug = true

}

app.conf

appname = 打包名称
httpport = 运行端口
runmode = dev
autorender = false
copyrequestbody = true
EnableDocs = true

db_host = 数据库地址
db_port = 端口
db_user = 用户名
db_pass = 密码
db_name = 数据库名字
db_type = mysql（数据库类型）

目录接口