init

6 years ago · cb49025e3c
23 changed files with 1430 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,16 @@
 # Binaries for programs and plugins
 *.exe
 *.exe~
 *.dll
 *.so
 *.dylib
 # Test binary, build with `go test -c`
 *.test
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 .idea
 dev.bat
 test.go
--- a/README.md
+++ b/README.md
@ -0,0 +1,257 @@
 ## 内部使用基于go-chi的web框架
 # 框架引入
 > go get -u github.com/wailovet/osmanthuswine
 ### 目录结构
 ```
 app
 |--index
      |--index.go
 html
 |--静态文件....
 main.go
 config.json
 ```
 # 开始
 #### 创建以上目录结构
 + /config.json 配置文件
 ```json
 {
  "port": "8808",
  "host": "0.0.0.0",
  "cross_domain": "*",
  "post_max_memory": 1024000,
  "update_path": "new_exe",
  "db": {
    "host": "",
    "port": "",
    "user": "",
    "password": "",
    "name": "",
    "max_open_conn": 500
  }
 }
 ```
 + /main.go文件
 ```
 package main
 import (
 	"./app/index"
 	"github.com/wailovet/osmanthuswine"
 	"github.com/wailovet/osmanthuswine/src/core"
 )
 func main() {
 	//注册index控制器
 	core.GetInstanceRouterManage().Registered(&index.Index{})
 	//主程序执行
 	osmanthuswine.Run()
 }
 ```
 + /app/index/index.go文件
 ```
 package index
 import (
    "github.com/wailovet/osmanthuswine/src/core"
 )
 type Index struct {
    core.Controller
 }
 func (that *Index) Index() {
    that.DisplayByData(that.Request.REQUEST)
 }
 ```
 ## core.Controller.Request 使用说明
 #### 输入参数 
 + that.Request.GET["参数"] //类型:map[string]string
 + that.Request.POST["参数"] //类型:map[string]string
 + that.Request.REQUEST["参数"] //类型:map[string]string , 为GET以及POST的合并值,当出现值冲突时GET参数会被覆盖
 #### session与cookie获取
 + that.Request.SESSION["参数"] //类型:map[string]string
 + that.Request.COOKIE["参数"] //类型:map[string]string
 #### header信息获取
 + that.Request.HEADER["参数"] //类型:map[string]string
 #### 该取值一般以POST-RAW形式传入原始数据,有可能
 + that.Request.BODY //类型:string
 #### 快速获取上传的文件
 + that.Request.FILE //类型:*multipart.FileHeader
 #### 获取上传的所有文件
 + that.Request.FILES //类型:map[string][]*multipart.FileHeader
 ## core.Controller 使用说明
 #### 输出显示
 > 即使输出时不处于函数结尾,也无需return
 + that.DisplayByData(data interface{})
 ```
 {
    "code":0,
    "data":data,
    "msg":""
 }
 ```
 - - -
 + that.DisplayBySuccess(msg string)
 ```
 {
    "code":0,
    "data":null,
    "msg":msg
 }
 ```
 - - -
 + that.DisplayByError(msg string, code int)
 ```
 {
    "code":code,
    "data":null,
    "msg":msg
 }
 ```
 - - -
 + that.Display(data interface{}, msg string, code int)
 ```
 {
    "code":code,
    "data":data,
    "msg":msg
 }
 ```
 - - -
 + that.DisplayByString(data string)
 ```
 data //直接输出data以string形式
 ```
 - - -
 + that.DisplayByRaw(data []byte)
 ```
 data //直接输出data以[]byte形式,可用于直接输出二进制文件
 ```
 - - -
 ##### 20190416新增
 + that.CheckErrDisplayByError(err error,msg...)
 ```
 err //错误信息,自动判断是否等于nil,如果等于nil该语句会被忽略
 msg //错误文案提示,不填直接输出err.Error()
 ```
 #### session操作
 > 目前session实现基于securecookie,以加密形式储存在cookie中,注意不要存放大量数据,以免超过cookie的最大储存值
 + that.SetSession(name string, value string) //设置session
 + that.DeleteSession(name string) //删除session
 + that.ClearSession() //清空session
 #### cookie操作
 > 尽量以session的形式操作
 + that.SetCookie(name string, value string)
 ## 数据库操作
 > 目前框架中集成gorm与xorm框架
 + core.GetXormAuto() //获取xorm实例
 + core.GetGormAuto() //获取gorm实例
 #### 数据库配置
 ```
 实例的数据库配置来自于相同目录下的config.json或者private.json文件
 {
  ...其他配置
  "db": {
    "host": "",
    "port": "",
    "user": "",
    "password": "",
    "name": "",
    "prefix": "",
    "max_open_conn": 500
  }
 } 
 prefix为表前缀
 max_open_conn为可支持最大连接数(未测试是否可用
 ```
 ## 支持WebSocket
 > 当传入core.GetInstanceRouterManage().Registered的对象继承自core.WebSocket时,协议升级为websocket,路由地址忽略最后方法名
 #### 集成melody库,使用详情https://github.com/olahol/melody
 ```
 package index
 import (
 	"github.com/wailovet/osmanthuswine/src/core"
 	"gopkg.in/olahol/melody.v1"
 )
 type Index struct {
 	core.WebSocket
 }
 func (that *Wstest) HandleConnect(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandlePong(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandleMessage(session *melody.Session, data []byte) {
 	that.GetMelody().Broadcast(data)
 	//implement
 }
 func (that *Wstest) HandleMessageBinary(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleSentMessage(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleSentMessageBinary(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleDisconnect(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandleError(session *melody.Session, err error) {
 	//implement
 }
 ```
 ```
 //javascript
 var ws = new WebSocket("ws://127.0.0.1/Api/Index/Index")
 ```
 > PS:不同url对应不同的melody实例
 ## 杂项
 > 热更新,仅支持linux
 ```
 默认情况下,检测同路径下的<文件名_update>,如果该文件与当前文件不一致,则进行热更,已连接的连接无需断连
 可在config.json中配置检测的文件名
 {
    ...其他配置
    "update_path": "需要检测的文件路径"
 }
 备注:需要检测的文件路径最好不要与当前运行的文件路径相同
 ```
--- a/example/app/wstest.go
+++ b/example/app/wstest.go
@ -0,0 +1,43 @@
 package app
 import (
 	"github.com/wailovet/osmanthuswine/src/core"
 	"gopkg.in/olahol/melody.v1"
 )
 type Wstest struct {
 	core.WebSocket
 }
 func (that *Wstest) HandleConnect(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandlePong(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandleMessage(session *melody.Session, data []byte) {
 	that.GetMelody().Broadcast(data)
 	//implement
 }
 func (that *Wstest) HandleMessageBinary(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleSentMessage(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleSentMessageBinary(session *melody.Session, data []byte) {
 	//implement
 }
 func (that *Wstest) HandleDisconnect(session *melody.Session) {
 	//implement
 }
 func (that *Wstest) HandleError(session *melody.Session, err error) {
 	//implement
 }
--- a/example/config.json
+++ b/example/config.json
@ -0,0 +1,8 @@
 {
  "port": "20180",
  "host": "0.0.0.0",
  "cross_domain": "*",
  "post_max_memory": 1024000,
  "api_router": "/Api/*",
  "update_path": "example_update"
 }
--- a/example/main.go
+++ b/example/main.go
@ -0,0 +1,13 @@
 package main
 import (
 	"github.com/wailovet/osmanthuswine"
 	"github.com/wailovet/osmanthuswine/example/app"
 	"github.com/wailovet/osmanthuswine/src/core"
 )
 func main() {
 	core.GetInstanceRouterManage().Registered(&app.Wstest{})
 	core.GetInstanceRouterManage().Registered(&app.Test{})
 	osmanthuswine.Run()
 }
--- a/example/private.json
+++ b/example/private.json
@ -0,0 +1,11 @@
 {
  "db": {
    "host": "",
    "port": "",
    "user": "",
    "password": "",
    "name": "",
    "prefix": "",
    "max_open_conn": 500
  }
 }
--- a/osmanthuswine.go
+++ b/osmanthuswine.go
@ -0,0 +1,157 @@
 package osmanthuswine
 import (
 	"errors"
 	"fmt"
 	"github.com/go-chi/chi"
 	"github.com/go-chi/chi/middleware"
 	"github.com/wailovet/osmanthuswine/src/core"
 	"github.com/wailovet/osmanthuswine/src/helper"
 	"github.com/wailovet/osmanthuswine/src/session"
 	"github.com/wailovet/overseer"
 	"github.com/wailovet/overseer/fetcher"
 	"io/ioutil"
 	"log"
 	"net"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"runtime/debug"
 	"strings"
 	"time"
 )
 var chiRouter *chi.Mux
 func GetChiRouter() *chi.Mux {
 	if chiRouter == nil {
 		chiRouter = chi.NewRouter()
 		chiRouter.Use(middleware.RequestID)
 		chiRouter.Use(middleware.RealIP)
 		chiRouter.Use(middleware.Logger)
 		chiRouter.Use(middleware.Recoverer)
 		chiRouter.Use(middleware.Timeout(60 * time.Second))
 	}
 	return chiRouter
 }
 func Run() {
 	path, _ := GetCurrentPath()
 	os.Chdir(path)
 	log.Println("工作目录:", path)
 	cc := core.GetInstanceConfig()
 	if runtime.GOOS == "windows" || cc.UpdatePath == "" {
 		listener, err := net.Listen("tcp", cc.Host+":"+cc.Port)
 		if err != nil {
 			log.Fatal(err.Error())
 		}
 		RunProg(overseer.State{
 			Listener: listener,
 		})
 	} else {
 		overseer.Run(overseer.Config{
 			Program: RunProg,
 			Address: cc.Host + ":" + cc.Port,
 			Fetcher: &fetcher.File{
 				Path:     cc.UpdateDir + cc.UpdatePath,
 				Interval: time.Second * 10,
 			},
 		})
 	}
 }
 func RunProg(state overseer.State) {
 	cc := core.GetInstanceConfig()
 	helper.GetInstanceLog().Out("开始监听:", cc.Host+":"+cc.Port)
 	r := GetChiRouter()
 	apiRouter := cc.ApiRouter
 	r.HandleFunc(apiRouter, func(writer http.ResponseWriter, request *http.Request) {
 		requestData := core.Request{}
 		sessionMan := session.New(request, writer)
 		requestData.REQUEST = make(map[string]string)
 		//GET
 		requestData.SyncGetData(request)
 		//POST
 		requestData.SyncPostData(request, cc.PostMaxMemory)
 		//HEADER
 		requestData.SyncHeaderData(request)
 		//COOKIE
 		requestData.SyncCookieData(request)
 		//SESSION
 		requestData.SyncSessionData(sessionMan)
 		responseHandle := core.Response{OriginResponseWriter: writer, Session: sessionMan}
 		defer func() {
 			errs := recover()
 			if errs == nil {
 				return
 			}
 			errtxt := fmt.Sprintf("%v", errs)
 			if errtxt != "" {
 				responseHandle.DisplayByError(errtxt, 500, strings.Split(string(debug.Stack()), "\n\t")...)
 			}
 		}()
 		core.GetInstanceRouterManage().RouterSend(request.URL.Path, requestData, responseHandle, cc.CrossDomain)
 	})
 	r.HandleFunc("/*", func(writer http.ResponseWriter, request *http.Request) {
 		path := request.URL.Path
 		if path == "/" {
 			path = "/index.html"
 		}
 		helper.GetInstanceLog().Out("静态文件:", "./html"+path)
 		f, err := os.Stat("./html" + path)
 		if err == nil {
 			if f.IsDir() {
 				path += "/index.html"
 			}
 			data, err := ioutil.ReadFile("./html" + path)
 			if err == nil {
 				writer.Write(data)
 				return
 			}
 		}
 		writer.WriteHeader(404)
 		writer.Write([]byte(err.Error()))
 	})
 	http.Serve(state.Listener, r)
 	//http.ListenAndServe(cc.Host+":"+cc.Port, r)
 }
 func GetCurrentPath() (string, error) {
 	file, err := exec.LookPath(os.Args[0])
 	if err != nil {
 		return "", err
 	}
 	path, err := filepath.Abs(file)
 	if err != nil {
 		return "", err
 	}
 	i := strings.LastIndex(path, "/")
 	if i < 0 {
 		i = strings.LastIndex(path, "\\")
 	}
 	if i < 0 {
 		return "", errors.New(`error: Can't find "/" or "\".`)
 	}
 	return string(path[0 : i+1]), nil
 }
--- a/src/core/config.go
+++ b/src/core/config.go
@ -0,0 +1,122 @@
 package core
 import (
 	"encoding/json"
 	"io/ioutil"
 	"log"
 	"os"
 )
 type Config struct {
 	Port          string `json:"port"`
 	Host          string `json:"host"`
 	CrossDomain   string `json:"cross_domain"`
 	ApiRouter     string `json:"api_router"`
 	PostMaxMemory int64  `json:"post_max_memory"`
 	Db            struct {
 		Host        string            `json:"host"`
 		Port        string            `json:"port"`
 		User        string            `json:"user"`
 		Password    string            `json:"password"`
 		Name        string            `json:"name"`
 		Prefix      string            `json:"prefix"`
 		MaxOpenConn int               `json:"max_open_conn"`
 		Params      map[string]string `json:"params"`
 		Debug       bool              `json:"debug"`
 	} `json:"db"`
 	Redis struct {
 		Addr     string `json:"addr"`
 		Password string `json:"password"`
 		Db       int    `json:"db"`
 	} `json:"redis"`
 	UpdateDir  string `json:"update_dir"`
 	UpdatePath string `json:"update_path"`
 }
 var instanceConfig *Config
 var configFile = "./config.json"
 var privateConfigFile = "./private.json"
 func SetConfigFile(c string) {
 	configFile = c
 }
 func SetConfig(c *Config) {
 	instanceConfig = c
 }
 func GetInstanceConfig() *Config {
 	if instanceConfig == nil {
 		instanceConfig = &Config{
 			Host:          "localhost",
 			Port:          "8808",
 			ApiRouter:     "/Api/*",
 			CrossDomain:   "*",
 			PostMaxMemory: 1024 * 1024 * 10,
 			Db: struct {
 				Host        string            `json:"host"`
 				Port        string            `json:"port"`
 				User        string            `json:"user"`
 				Password    string            `json:"password"`
 				Name        string            `json:"name"`
 				Prefix      string            `json:"prefix"`
 				MaxOpenConn int               `json:"max_open_conn"`
 				Params      map[string]string `json:"params"`
 				Debug       bool              `json:"debug"`
 			}{
 				Host:        "localhost",
 				Port:        "3306",
 				User:        "root",
 				Password:    "root",
 				Name:        "test",
 				Prefix:      "",
 				MaxOpenConn: 500,
 				Params: map[string]string{
 					"charset":   "utf8mb4",
 					"parseTime": "true",
 				},
 				Debug: true,
 			},
 			Redis: struct {
 				Addr     string `json:"addr"`
 				Password string `json:"password"`
 				Db       int    `json:"db"`
 			}{
 				Addr:     "localhost:6379",
 				Password: "",
 				Db:       0,
 			},
 			UpdateDir:  "",
 			UpdatePath: os.Args[0] + "_update",
 		}
 		instanceConfig.ReadConfig(configFile)
 		instanceConfig.ReadPrivateConfig(privateConfigFile)
 	}
 	return instanceConfig
 }
 func (c *Config) ReadConfig(file string) {
 	configText, err := ioutil.ReadFile(file)
 	if err != nil {
 		log.Println("配置文件错误,启动失败:", err.Error())
 		os.Exit(0)
 	}
 	err = json.Unmarshal(configText, c)
 	if err != nil {
 		log.Println("配置文件错误,启动失败:", err.Error())
 		os.Exit(0)
 	}
 }
 func (c *Config) ReadPrivateConfig(file string) {
 	configText, err := ioutil.ReadFile(file)
 	if err != nil {
 		log.Println("未加载", privateConfigFile, ":", err.Error())
 		return
 	}
 	err = json.Unmarshal(configText, c)
 	if err != nil {
 		log.Println("未加载", privateConfigFile, ":", err.Error())
 	}
 }
--- a/src/core/controller.go
+++ b/src/core/controller.go
@ -0,0 +1,25 @@
 package core
 import "encoding/json"
 type Controller struct {
 	Response
 	Request Request
 }
 func (c *Controller) ControllerInit(req Request, res Response) {
 	c.Request = req
 	c.Session = res.Session
 	c.OriginResponseWriter = res.OriginResponseWriter
 }
 func (c *Controller) RequestToStruct(v interface{}) error {
 	if c.Request.BODY != "" {
 		err := json.Unmarshal([]byte(c.Request.BODY), v)
 		if err == nil {
 			return err
 		}
 	}
 	data, _ := json.Marshal(c.Request.REQUEST)
 	return json.Unmarshal(data, v)
 }
--- a/src/core/db.go
+++ b/src/core/db.go
@ -0,0 +1,121 @@
 package core
 import (
 	"fmt"
 	"github.com/go-sql-driver/mysql"
 	"github.com/jinzhu/gorm"
 	"strings"
 	"time"
 )
 var instanceDb *gorm.DB
 func GetDb() (*gorm.DB, error) {
 	if instanceDb == nil {
 		config := GetInstanceConfig()
 		mysqlConfig := mysql.NewConfig()
 		mysqlConfig.User = config.Db.User
 		mysqlConfig.DBName = config.Db.Name
 		mysqlConfig.Passwd = config.Db.Password
 		mysqlConfig.Params = config.Db.Params
 		mysqlConfig.Net = "tcp"
 		mysqlConfig.Addr = config.Db.Host + ":" + config.Db.Port
 		db, err := gorm.Open("mysql", mysqlConfig.FormatDSN())
 		gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
 			if len(defaultTableName) > len(config.Db.Prefix) && defaultTableName[:len(config.Db.Prefix)] == config.Db.Prefix {
 				return defaultTableName
 			}
 			return config.Db.Prefix + defaultTableName
 		}
 		db.DB().SetMaxOpenConns(config.Db.MaxOpenConn)
 		db.SingularTable(true)
 		instanceDb = db
 		return instanceDb, err
 	}
 	return instanceDb, nil
 }
 func GetGormAuto() *gorm.DB {
 	return GetDbAuto()
 }
 func GetDbAuto() *gorm.DB {
 	db, err := GetDb()
 	if err != nil {
 		panic("数据库访问错误")
 	}
 	return db
 }
 func DbQuery(query string, args ...interface{}) []map[string]interface{} {
 	db := GetDbAuto()
 	rows, _ := db.DB().Query(query, args...) // Note: Ignoring errors for brevity
 	defer rows.Close()
 	cols, _ := rows.Columns()
 	var data []map[string]interface{}
 	for rows.Next() {
 		columns := make([]interface{}, len(cols))
 		columnPointers := make([]interface{}, len(cols))
 		for i, _ := range columns {
 			columnPointers[i] = &columns[i]
 		}
 		// Scan the result into the column pointers...
 		if err := rows.Scan(columnPointers...); err != nil {
 			panic(err)
 		}
 		// Create our map, and retrieve the value for each column from the pointers slice,
 		// storing it in the map with the name of the column as the key.
 		m := make(map[string]interface{})
 		for i, colName := range cols {
 			val := columnPointers[i].(*interface{})
 			m[colName] = *val
 		}
 		data = append(data, m)
 	}
 	return data
 }
 var isUpdateComment = make(map[string]bool)
 func GetDbAutoMigrate(values ...interface{}) *gorm.DB {
 	db := GetDbAuto()
 	db.AutoMigrate(values...)
 	for _, value := range values {
 		scope := db.NewScope(value)
 		tableName := scope.TableName()
 		_, isOk := isUpdateComment[tableName]
 		if !isOk {
 			field := scope.Fields()
 			for e := range field {
 				comment := field[e].Tag.Get("comment")
 				if len(strings.Trim(comment, " ")) > 0 {
 					fieldType := db.Dialect().DataTypeOf(field[e].StructField)
 					scope.Raw(fmt.Sprintf("ALTER TABLE `%v` MODIFY COLUMN `%v` %v COMMENT '%v';", tableName, field[e].DBName, fieldType, comment)).Exec()
 				}
 			}
 		}
 		isUpdateComment[tableName] = true
 	}
 	return db
 }
 func init() {
 	go func() {
 		for {
 			if instanceDb != nil {
 				err := instanceDb.DB().Ping()
 				if err != nil {
 					println(err.Error())
 					instanceDb.Close()
 					instanceDb = nil
 				}
 			}
 			time.Sleep(time.Second)
 		}
 	}()
 }
--- a/src/core/redis.go
+++ b/src/core/redis.go
@ -0,0 +1,36 @@
 package core
 import (
 	"github.com/go-redis/redis"
 	"time"
 )
 var instanceRedis *redis.Client
 func GetRedis() *redis.Client {
 	if instanceRedis == nil {
 		config := GetInstanceConfig()
 		instanceRedis = redis.NewClient(&redis.Options{
 			Addr:     config.Redis.Addr,
 			Password: config.Redis.Password, // no password set
 			DB:       config.Redis.Db,       // use default DB
 		})
 	}
 	return instanceRedis
 }
 func init() {
 	go func() {
 		for {
 			if instanceRedis != nil {
 				err := instanceRedis.Ping().Err()
 				if err != nil {
 					println(err.Error())
 					instanceRedis.Close()
 					instanceRedis = nil
 				}
 			}
 			time.Sleep(time.Second)
 		}
 	}()
 }
--- a/src/core/request.go
+++ b/src/core/request.go
@ -0,0 +1,117 @@
 package core
 import (
 	"github.com/wailovet/osmanthuswine/src/session"
 	"io/ioutil"
 	"log"
 	"mime/multipart"
 	"net/http"
 	"net/url"
 )
 type Request struct {
 	GET           map[string]string
 	POST          map[string]string
 	REQUEST       map[string]string
 	COOKIE        map[string]string
 	SESSION       map[string]string
 	HEADER        map[string]string
 	BODY          string
 	FILES         map[string][]*multipart.FileHeader
 	FILE          *multipart.FileHeader
 	OriginRequest *http.Request
 }
 func (r *Request) SyncGetData(request *http.Request) {
 	if r.OriginRequest == nil {
 		r.OriginRequest = request
 	}
 	get := request.URL.Query()
 	r.GET = make(map[string]string)
 	for k := range get {
 		str := request.URL.Query().Get(k)
 		tmp, err := url.QueryUnescape(str)
 		if err != nil {
 			log.Println(err.Error())
 			r.GET[k] = str
 			r.REQUEST[k] = str
 		} else {
 			r.GET[k] = tmp
 			r.REQUEST[k] = tmp
 		}
 	}
 }
 func (r *Request) SyncPostData(request *http.Request, mem int64) {
 	if r.OriginRequest == nil {
 		r.OriginRequest = request
 	}
 	request.ParseForm()
 	request.ParseMultipartForm(mem)
 	r.POST = make(map[string]string)
 	post := request.PostForm
 	for k := range post {
 		str := request.PostFormValue(k)
 		tmp, err := url.QueryUnescape(str)
 		if err != nil {
 			log.Println(err.Error())
 			r.POST[k] = str
 			r.REQUEST[k] = str
 		} else {
 			r.POST[k] = tmp
 			r.REQUEST[k] = tmp
 		}
 	}
 	if request.MultipartForm != nil {
 		r.FILES = request.MultipartForm.File
 		if len(r.FILES) > 0 {
 			for fe := range r.FILES {
 				for fk := range r.FILES[fe] {
 					r.FILE = r.FILES[fe][fk]
 				}
 			}
 		}
 		mf := request.MultipartForm.Value
 		for k := range mf {
 			if len(mf[k]) > 0 {
 				r.POST[k] = mf[k][0]
 				r.REQUEST[k] = mf[k][0]
 			}
 		}
 	}
 	body, _ := ioutil.ReadAll(request.Body)
 	r.BODY = string(body)
 }
 func (r *Request) SyncHeaderData(request *http.Request) {
 	if r.OriginRequest == nil {
 		r.OriginRequest = request
 	}
 	r.HEADER = make(map[string]string)
 	header := request.Header
 	for k := range header {
 		if len(header[k]) > 0 {
 			r.HEADER[k] = header[k][0]
 		}
 	}
 }
 func (r *Request) SyncCookieData(request *http.Request) {
 	if r.OriginRequest == nil {
 		r.OriginRequest = request
 	}
 	cookie := request.Cookies()
 	r.COOKIE = make(map[string]string)
 	for k := range cookie {
 		r.COOKIE[cookie[k].Name] = cookie[k].Value
 	}
 }
 func (r *Request) SyncSessionData(session *session.Session) {
 	r.SESSION = session.GetSession()
 }
--- a/src/core/response.go
+++ b/src/core/response.go
@ -0,0 +1,115 @@
 package core
 import (
 	"encoding/json"
 	"github.com/wailovet/osmanthuswine/src/session"
 	"net/http"
 	"strings"
 )
 type ResponseData struct {
 	Code    int         `json:"code"`
 	Data    interface{} `json:"data"`
 	Message string      `json:"message"`
 }
 type Response struct {
 	Session              *session.Session
 	IsWebSocket          bool
 	OriginResponseWriter http.ResponseWriter
 }
 func (r *Response) DisplayByRaw(data []byte) {
 	if r.IsWebSocket {
 		panic(nil)
 		return
 	}
 	r.OriginResponseWriter.Header().Add("Content-Type", "application/json; charset=utf-8")
 	r.OriginResponseWriter.Write(data)
 	panic(nil)
 }
 func (r *Response) DisplayByString(data string) {
 	r.DisplayByRaw([]byte(data))
 }
 func (r *Response) Display(data interface{}, msg string, code int) {
 	result := ResponseData{code, data, msg}
 	text, err := json.Marshal(result)
 	if err != nil {
 		r.OriginResponseWriter.WriteHeader(500)
 		r.DisplayByString("服务器异常:" + err.Error())
 	}
 	r.DisplayByRaw(text)
 }
 func (r *Response) DisplayByError(msg string, code int, data ...string) {
 	result := ResponseData{code, data, msg}
 	text, err := json.Marshal(result)
 	if err != nil {
 		r.Display(nil, "JSON返回格式解析异常:"+err.Error(), 500)
 	}
 	r.DisplayByRaw(text)
 }
 func (r *Response) CheckErrDisplayByError(err error, msg ...string) {
 	if err == nil {
 		return
 	}
 	if len(msg) > 0 {
 		r.DisplayByError(strings.Join(msg, ","), 504)
 	} else {
 		r.DisplayByError(err.Error(), 504)
 	}
 }
 func (r *Response) DisplayBySuccess(msg string) {
 	result := ResponseData{0, nil, msg}
 	text, err := json.Marshal(result)
 	if err != nil {
 		r.Display(nil, "JSON返回格式解析异常:"+err.Error(), 500)
 	}
 	r.DisplayByRaw(text)
 }
 func (r *Response) DisplayByData(data interface{}) {
 	result := ResponseData{0, data, ""}
 	text, err := json.Marshal(result)
 	if err != nil {
 		r.Display(nil, "JSON返回格式解析异常:"+err.Error(), 500)
 	}
 	r.DisplayByRaw(text)
 }
 func (r *Response) SetSession(name string, value string) {
 	data := r.Session.GetSession()
 	data[name] = value
 	r.Session.SetSession(data)
 }
 func (r *Response) DeleteSession(name string) {
 	data := r.Session.GetSession()
 	delete(data, name)
 	r.Session.SetSession(data)
 }
 func (r *Response) ClearSession() {
 	data := make(map[string]string)
 	r.Session.SetSession(data)
 }
 func (r *Response) SetCookie(name string, value string) {
 	cookie := &http.Cookie{
 		Name:     name,
 		Value:    value,
 		Path:     "/",
 		Secure:   false,
 		HttpOnly: false,
 	}
 	http.SetCookie(r.OriginResponseWriter, cookie)
 }
 func (r *Response) SetHeader(name string, value string) {
 	r.OriginResponseWriter.Header().Set(name, value)
 }
--- a/src/core/router.go
+++ b/src/core/router.go
@ -0,0 +1,118 @@
 package core
 import (
 	"github.com/wailovet/osmanthuswine/src/interfaces"
 	"log"
 	"reflect"
 	"strings"
 	"unicode"
 )
 type RouterManage struct {
 	RegisteredData map[string]reflect.Type
 }
 var instanceRouterManage *RouterManage
 func GetInstanceRouterManage() *RouterManage {
 	if instanceRouterManage == nil {
 		instanceRouterManage = &RouterManage{} // not thread safe
 		instanceRouterManage.RegisteredData = make(map[string]reflect.Type)
 	}
 	return instanceRouterManage
 }
 func (rm *RouterManage) Registered(i interface{}) {
 	t := reflect.ValueOf(i)
 	GetInstanceRouterManage().RegisteredData[t.Type().String()] = reflect.Indirect(t).Type()
 }
 func (rm *RouterManage) GetModuleName(name string) string {
 	if name == "" {
 		return "index"
 	}
 	return strings.ToLower(name)
 }
 func (rm *RouterManage) GetControllerName(name string) string {
 	if name == "" {
 		return "Index"
 	}
 	for i, v := range name {
 		return string(unicode.ToUpper(v)) + name[i+1:]
 	}
 	return "Index"
 }
 func (rm *RouterManage) GetFunName(name string) string {
 	if name == "" {
 		return "Index"
 	}
 	for i, v := range name {
 		return string(unicode.ToUpper(v)) + name[i+1:]
 	}
 	return "Index"
 }
 func (rm *RouterManage) RouterSend(urlPath string, request Request, response Response, crossDomain string) {
 	tmp := strings.Split(urlPath, ".")
 	if len(tmp) > 1 {
 		urlPath = strings.Join(tmp[0:len(tmp)-1], ".")
 	}
 	sar := strings.Split(urlPath, "/")
 	for len(sar) < 5 {
 		sar = append(sar, "")
 	}
 	//过滤非 /Api开头的
 	module := rm.GetModuleName(sar[2])
 	controller := rm.GetControllerName(sar[3])
 	fun := rm.GetFunName(sar[4])
 	ctr := "*" + module + "." + controller
 	_, ok := rm.RegisteredData[ctr]
 	if !ok {
 		panic("未注册该组件:" + ctr)
 	}
 	vc := reflect.New(rm.RegisteredData[ctr])
 	wsinit := vc.MethodByName("WebSocketInit")
 	if wsinit.IsValid() {
 		response.IsWebSocket = true
 		hand := vc.Interface().(interfaces.WebSocketInterface)
 		ws := GetWebSocket(ctr+"-"+fun, hand)
 		hand.SetFunName(fun)
 		hand.WebSocketInit(ws)
 		defer func() {
 			errs := recover()
 			if errs == nil {
 				return
 			}
 			log.Printf("websocket error:%v", errs)
 		}()
 		_ = ws.HandleRequest(response.OriginResponseWriter, request.OriginRequest)
 		return
 	}
 	f := vc.MethodByName(fun)
 	if !f.IsValid() {
 		panic("组件找不到相应function:" + fun)
 	}
 	init := vc.MethodByName("ControllerInit")
 	if init.IsValid() {
 		init.Call([]reflect.Value{reflect.ValueOf(request), reflect.ValueOf(response)})
 		f.Call(nil)
 	} else {
 		//兼容模式
 		log.Println("兼容模式")
 		f.Call([]reflect.Value{reflect.ValueOf(request), reflect.ValueOf(response)})
 	}
 	response.OriginResponseWriter.Header().Set("Content-Type", "application/json;charset=UTF-8")
 	if crossDomain != "" {
 		response.OriginResponseWriter.Header().Set("Access-Control-Allow-Origin", crossDomain)
 	}
 }
--- a/src/core/websocket.go
+++ b/src/core/websocket.go
@ -0,0 +1,51 @@
 package core
 import (
 	"github.com/wailovet/osmanthuswine/src/interfaces"
 	"gopkg.in/olahol/melody.v1"
 	"net/http"
 	"sync"
 )
 var instanceMelody sync.Map
 type WebSocket struct {
 	ws      *melody.Melody
 	FunName string
 }
 func (that *WebSocket) SetFunName(funName string) {
 	that.FunName = funName
 }
 func (that *WebSocket) WebSocketInit(wsx *melody.Melody) {
 	that.ws = wsx
 }
 func (that *WebSocket) GetMelody() *melody.Melody {
 	return that.ws
 }
 func (that *WebSocket) GetWebSocket() *melody.Melody {
 	return that.ws
 }
 func GetWebSocket(group string, hand interfaces.WebSocketInterface) *melody.Melody {
 	var m *melody.Melody
 	tmp, ok := instanceMelody.Load(group)
 	if !ok {
 		m = melody.New()
 		m.Upgrader.CheckOrigin = func(r *http.Request) bool { return true }
 		m.HandleConnect(hand.HandleConnect)
 		m.HandleDisconnect(hand.HandleDisconnect)
 		m.HandlePong(hand.HandlePong)
 		m.HandleError(hand.HandleError)
 		m.HandleMessage(hand.HandleMessage)
 		m.HandleMessageBinary(hand.HandleMessageBinary)
 		m.HandleSentMessage(hand.HandleSentMessage)
 		m.HandleSentMessageBinary(hand.HandleSentMessageBinary)
 		instanceMelody.Store(group, m)
 	} else {
 		m = tmp.(*melody.Melody)
 	}
 	return m
 }
--- a/src/core/xorm.go
+++ b/src/core/xorm.go
@ -0,0 +1,71 @@
 package core
 import (
 	"github.com/go-sql-driver/mysql"
 	"github.com/xormplus/core"
 	"github.com/xormplus/xorm"
 	"time"
 )
 type Xorm struct {
 	db *xorm.Engine
 }
 var instanceXorm *Xorm
 func GetXormAuto() *xorm.Engine {
 	db, err := GetXorm()
 	if err != nil {
 		panic("数据库访问错误")
 	}
 	return db.db
 }
 func GetXorm() (*Xorm, error) {
 	if instanceXorm == nil {
 		config := GetInstanceConfig()
 		mysqlConfig := mysql.NewConfig()
 		mysqlConfig.User = config.Db.User
 		mysqlConfig.DBName = config.Db.Name
 		mysqlConfig.Passwd = config.Db.Password
 		mysqlConfig.Params = config.Db.Params
 		mysqlConfig.Net = "tcp"
 		mysqlConfig.Addr = config.Db.Host + ":" + config.Db.Port
 		engine, err := xorm.NewEngine("mysql", mysqlConfig.FormatDSN())
 		if config.Db.Prefix != "" {
 			tbMapper := core.NewPrefixMapper(core.SnakeMapper{}, config.Db.Prefix)
 			engine.SetTableMapper(tbMapper)
 		}
 		instanceXorm = &Xorm{db: engine}
 		instanceXorm.db.SetMaxOpenConns(config.Db.MaxOpenConn)
 		if config.Db.Debug {
 			instanceXorm.db.ShowSQL(true)
 		}
 		return instanceXorm, err
 	}
 	return instanceXorm, nil
 }
 func (x *Xorm) Ping() error {
 	session := x.db.NewSession()
 	defer session.Close()
 	return session.DB().Ping()
 }
 func init() {
 	go func() {
 		for {
 			if instanceXorm != nil {
 				err := instanceXorm.Ping()
 				if err != nil {
 					println(err.Error())
 					instanceXorm.db.Close()
 					instanceXorm = nil
 				}
 			}
 			time.Sleep(time.Second)
 		}
 	}()
 }
--- a/src/helper/db2struct.go
+++ b/src/helper/db2struct.go
@ -0,0 +1,30 @@
 package helper
 import (
 	"github.com/go-errors/errors"
 	"github.com/wailovet/db2struct"
 	"github.com/wailovet/osmanthuswine/src/core"
 	"strconv"
 )
 func GetStructByDb(tableName string, packageName string, structName string) (string, error) {
 	mariadbUser := core.GetInstanceConfig().Db.User
 	mariadbPassword := core.GetInstanceConfig().Db.Password
 	mariadbHost := core.GetInstanceConfig().Db.Host
 	mariadbPort, _ := strconv.Atoi(core.GetInstanceConfig().Db.Port)
 	mariadbDatabase := core.GetInstanceConfig().Db.Name
 	columnDataTypes, err := db2struct.GetColumnsFromMysqlTable(mariadbUser, mariadbPassword, mariadbHost, mariadbPort, mariadbDatabase, tableName)
 	if err != nil {
 		return "", errors.New("Error in selecting column data information from mysql information schema")
 	}
 	// Generate struct string based on columnDataTypes
 	struc, err := db2struct.Generate(*columnDataTypes, tableName, structName, packageName, true, true, false)
 	if err != nil {
 		return "", errors.New("Error in creating struct from json: " + err.Error())
 	}
 	return string(struc), nil
 }
--- a/src/helper/log.go
+++ b/src/helper/log.go
@ -0,0 +1,19 @@
 package helper
 import "log"
 type Log struct {
 }
 var instanceLog *Log
 func GetInstanceLog() *Log {
 	if instanceLog == nil {
 		instanceLog = &Log{} // not thread safe
 	}
 	return instanceLog
 }
 func (l *Log) Out(args ...interface{}) {
 	log.Println(args)
 }
--- a/src/helper/md5.go
+++ b/src/helper/md5.go
@ -0,0 +1,10 @@
 package helper
 import (
 	"crypto/md5"
 	"fmt"
 )
 func Md5(data string) string {
 	return fmt.Sprintf("%x", md5.Sum([]byte(data)))
 }
--- a/src/helper/uuid.go
+++ b/src/helper/uuid.go
@ -0,0 +1,8 @@
 package helper
 import "github.com/satori/go.uuid"
 func CreateUUID() string {
 	u1 := uuid.Must(uuid.NewV4())
 	return u1.String()
 }
--- a/src/helper/uuid_test.go
+++ b/src/helper/uuid_test.go
@ -0,0 +1,11 @@
 package helper
 import "testing"
 func TestCreateUUID(t *testing.T) {
 	s := CreateUUID()
 	println(s)
 	if len(s) != 36 {
 		t.Error("UUID长度错误")
 	}
 }
--- a/src/interfaces/websocket.go
+++ b/src/interfaces/websocket.go
@ -0,0 +1,21 @@
 package interfaces
 import (
 	"gopkg.in/olahol/melody.v1"
 )
 //WebSocketInterface interface
 type WebSocketInterface interface {
 	SetFunName(funName string)
 	WebSocketInit(ws *melody.Melody)
 	GetWebSocket() *melody.Melody
 	GetMelody() *melody.Melody
 	HandleConnect(*melody.Session)
 	HandlePong(*melody.Session)
 	HandleMessage(*melody.Session, []byte)
 	HandleMessageBinary(*melody.Session, []byte)
 	HandleSentMessage(*melody.Session, []byte)
 	HandleSentMessageBinary(*melody.Session, []byte)
 	HandleDisconnect(*melody.Session)
 	HandleError(*melody.Session, error)
 }
--- a/src/session/securecookie.go
+++ b/src/session/securecookie.go
@ -0,0 +1,50 @@
 package session
 import (
 	"github.com/gorilla/securecookie"
 	"net/http"
 )
 type Session struct {
 	secureCookie *securecookie.SecureCookie
 	r            *http.Request
 	w            http.ResponseWriter
 	data         map[string]string
 }
 func New(r *http.Request, w http.ResponseWriter) *Session {
 	session := &Session{} // not thread safe
 	var hashKey = []byte("osmanthuswine-very-secret")
 	// Block keys should be 16 bytes (AES-128) or 32 bytes (AES-256) long.
 	// Shorter keys may weaken the encryption used.
 	var blockKey = []byte("osmanthuswine-lot-secret")
 	session.secureCookie = securecookie.New(hashKey, blockKey)
 	session.r = r
 	session.w = w
 	session.data = make(map[string]string)
 	if cookie, err := session.r.Cookie("osmseccidhas"); err == nil {
 		session.secureCookie.Decode("osmseccidhas", cookie.Value, &session.data)
 	} else {
 		//helper.GetInstanceLog().Out(err.Error())
 	}
 	return session
 }
 func (session *Session) GetSession() map[string]string {
 	return session.data
 }
 func (session *Session) SetSession(value map[string]string) {
 	if encoded, err := session.secureCookie.Encode("osmseccidhas", value); err == nil {
 		cookie := &http.Cookie{
 			Name:     "osmseccidhas",
 			Value:    encoded,
 			Path:     "/",
 			Secure:   false,
 			HttpOnly: false,
 		}
 		http.SetCookie(session.w, cookie)
 		session.data = value
 	}
 }