作者：林冠宏 / 指尖下的幽灵
一个基础性、模块完整且安全可靠的服务端框架
你可以使用它
- 简单快速搭建自己的服务端
- 其他高级模块拓展等
具备的
- Token模块，
jwt - 加解密模块，
cipher-AES，可自行拓展其他 - 日志模块，
alecthomas/log4go - 路由模块，
gorilla/mux - 硬存储 / 软存储 采用
xorm框架 - 服务端通用的输出数据结构的整合，例如 json
- 各模块对应的单元测试例子
如果你想直接输出一条 json 给客户端，这样子
func main() {
router := new (mux.Router)
router.HandleFunc("/",test2).Methods("GET")
core.HttpListen(router)
}
func test2(w http.ResponseWriter,r *http.Request) {
// 非常简单的例子, 操作放在内部 , 可以使用 request 来获取自己的参数，再直接组织输出
core.HandlerMapWithOutputJson(w, func() map[string]interface{} {
m := map[string]interface{}{}
m["msg"] = "blow me a kiss"
return m
})
}
// 结果 ： {"msg":"blow me a kiss"}令牌机制
// core.ApiNormalHandler 不要求在请求头中传递 Token
router.Handle("/fuck",core.ApiNormalHandler(getToken)).Methods("GET")
// core.ApiRequestTokenHandler 要求在请求头中带上 Token
router.Handle("/check",core.ApiRequestTokenHandler(handleToken)).Methods("GET")
// 定义对应上下文的路由方法
func getToken(req *core.ReqContext) {
// 从 req 中读出内容
core.HandlerMapWithOutputJson(req.W, func() map[string]interface{} {
tokenStr,_ := core.BuildDefaultToken(func(tokenData *core.TokenData) {
tokenData.UserId = "123456"
tokenData.Roles = "normal"
})
return util.GetCommonSuccess(tokenStr)
})
}与数据库交互
func test3(w http.ResponseWriter,r *http.Request) {
core.HandlerMapWithOutputJson(w, func() map[string]interface{} {
// 插入一条评论
item := &model.Comment{
Id :util.NewId(), // 评论 id
UserId :"123456", // 评论人 id
Name :"LinGuanHong", // 评论人名称
Content :"hello word", // 评论内容
}
affect,_ := core.Engine.Insert(item) // 执行插入，传入 struct 引用
m := map[string]interface{}{}
if affect > 0 {
m["ret"] = "insert success"
comments := make([]model.Comment, 0)
core.Engine.Find(&comments) // select 出来，获取所有评论输出
m["msg"] = comments
}else{
m["ret"] = "insert failed"
}
return m
})
}
输出的结果是：
{
"msg": [
{
"id": "1kubpgh9pprrucy11e456fyytw",
"UserId": "123456",
"name": "LinGuanHong",
"content": "hello word"
}
],
"ret": "insert success"
}使用流程
目录如下
---- config
---- core
---- model
---- threeLibs
---- util
---- server.go1 在 config 放置配置文件
服务端配置 json 文件-- server.json，日志配置文件-- log.json 例如下面的，他们都会在运行程序后会自动解析和读取
2 threeLibs 目录放置了依赖的第三方库，例如 xorm，不需要你再去 go get
3 model 放置数据实体 struct
{
"Host": "127.0.0.1",
"Port": ":8884",
"FilePort":":8885",
"DbName":"lgh",
"DbUser":"root",
"DbPw":"123456",
"DbPort":"3306"
}{
"EnableConsole": true,
"ConsoleLevel": "DEBUG",
"EnableFile": true,
"FileLevel": "INFO",
"FileFormat": "",
"FileLocation": ""
}从一个最基础的例子开始：
func main() {
router := new (mux.Router)
router.HandleFunc("/",test).Methods("GET")
/** 在下面添加你的路由 */
/** add your routine func below */
core.HttpListen(router) // 简单的 http 监听，当然也提供了 https
}
func test(w http.ResponseWriter,r *http.Request) {
fmt.Fprintf(w,"======= hello world! =======")
}// http 监听
func HttpListen(router *mux.Router) {
SimpleInit() // 此处自动初始化 ---------- ①
url := config.ServerConfig.Host+config.ServerConfig.Port
util.LogInfo("服务启动于 : "+url)
err := http.ListenAndServe(url,router)
if err !=nil {
util.LogInfo("http error ===> : "+err.Error())
return
}
}// 绑定配置 json 的信息 以及 初始化 xorm mysql数据库引擎
func SimpleInit() {
config.BindServerConfig("server.json","log.json")
fmt.Println("BindServerConfig ==================>","success")
config.ConfigureLog(&config.LogConfig)
CreateDefaultMysqlEngine(
"mysql",
config.ServerConfig.DbUser,
config.ServerConfig.DbPw,
config.ServerConfig.DbName)
}服务端通用的输出数据结构的整合函数组
type FinalResult struct {
Data interface{}
}
type RetChannel chan FinalResult
func HandlerStruct(handle func() interface{}) *interface{} {
RetChannel := make(RetChannel, 1)
go func() {
result := FinalResult{}
data := handle()
result.Data = &data
RetChannel <- result
close(RetChannel)
}()
ret := <-RetChannel
return ret.Data.(*interface{})
}
func HandlerMap(handle func() map[string]interface{}) *map[string]interface{} {
RetChannel := make(RetChannel, 1)
go func() {
result := FinalResult{}
data := handle()
result.Data = &data
RetChannel <- result
close(RetChannel)
}()
ret := <-RetChannel
return ret.Data.(*map[string]interface{})
}
// 还有
// HandlerStructWithOutputXML // XML 的输出格式
// HandlerStructWithOutputString
func HandlerStructWithOutputJson(w http.ResponseWriter,handle func() interface{}) {
RetChannel := make(RetChannel, 1)
go func() {
result := FinalResult{}
data := handle()
result.Data = &data
RetChannel <- result
close(RetChannel)
}()
ret := <-RetChannel
mapRet := ret.Data.(*interface{})
util.RenderJson(w,mapRet)
}
func HandlerMapWithOutputJson(w http.ResponseWriter,handle func() map[string]interface{}){
RetChannel := make(RetChannel, 1)
go func() {
result := FinalResult{}
data := handle()
result.Data = &data
RetChannel <- result
close(RetChannel)
}()
ret := <-RetChannel
mapRet := ret.Data.(*map[string]interface{})
util.RenderJson(w,mapRet)
}就介绍这么多了