bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-25 09:15:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

完善控制器demo

Browse Source
This commit is contained in:
John
2017-12-30 18:35:24 +08:00
parent 0d291af378
commit 14d1e55829
20 changed files with 248 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
g/frame/ginstance/ginstance.go
View File

@ -14,7 +14,6 @@ import (
"gitee.com/johng/gf/g/os/genv"
"gitee.com/johng/gf/g/os/gview"
"gitee.com/johng/gf/g/os/gfile"
"gitee.com/johng/gf/g/net/ghttp"
"gitee.com/johng/gf/g/os/gconsole"
"gitee.com/johng/gf/g/database/gdb"
"gitee.com/johng/gf/g/frame/gconfig"
@ -40,16 +39,6 @@ func Set(k string, v interface{}) {
instances.Set(k, v)
}
// 核心对象：Server
// 框架支持多服务器对象，通过传入不同的name进行区分
func Server(names...string) *ghttp.Server {
name := "default"
if len(names) > 0 {
name = names[0]
}
return ghttp.GetServer(name)
}
// 核心对象：View
func View() *gview.View {
result := Get(FRAME_CORE_COMPONENT_NAME_VIEW)

2
g/frame/gmvc/view.go
View File

@ -53,7 +53,7 @@ func (view *View) Parse(file string) ([]byte, error) {
if err != nil {
return nil, err
}
// 绑定函数
// 绑定函数，对基类的include进行覆盖(由于涉及到模板变量的传递)
tpl.BindFunc("include", view.funcInclude)
// 执行解析
view.mu.RLock()

19
g/g.go
View File

@ -14,31 +14,20 @@ import (
// 单例HTTP Server
// 框架支持多服务器对象，通过传入不同的name进行区分
// HTTPServer启动时支持命令行参数： xxx --cfgpath=xxx --viewpath=xxx
func HTTPServer(names...string) *ghttp.Server {
name := "default"
if len(names) > 0 {
name = names[0]
}
return ghttp.GetServer(name)
return ghttp.GetServer(names...)
}
// 单例TCP Server
// 框架支持多服务器对象，通过传入不同的name进行区分
func TCPServer(names...string) *gtcp.Server {
name := "default"
if len(names) > 0 {
name = names[0]
}
return gtcp.GetServer(name)
return gtcp.GetServer(names...)
}
// 单例HTTP Server
// 框架支持多服务器对象，通过传入不同的name进行区分
func UDPServer(names...string) *gudp.Server {
name := "default"
if len(names) > 0 {
name = names[0]
}
return gudp.GetServer(name)
return gudp.GetServer(names...)
}

39
g/net/ghttp/http_server.go
View File

@ -23,6 +23,7 @@ import (
)
const (
gDEFAULT_SERVER = "default"
gDEFAULT_DOMAIN = "default"
gDEFAULT_METHOD = "all"
gHTTP_METHODS = "GET,PUT,POST,DELETE,PATCH,HEAD,CONNECT,OPTIONS,TRACE"
@ -58,7 +59,11 @@ var serverMapping = gmap.NewStringInterfaceMap()
// 获取/创建一个默认配置的HTTP Server(默认监听端口是80)
// 单例模式，请保证name的唯一性
func GetServer(name string) (*Server) {
func GetServer(names...string) (*Server) {
name := gDEFAULT_SERVER
if len(names) > 0 {
name = names[0]
}
if s := serverMapping.Get(name); s != nil {
return s.(*Server)
}
@ -308,7 +313,11 @@ func (s *Server)bindHandlerByMap(m HandlerMap) error {
}
// 将方法名称按照设定的规则转换为URI并附加到指定的URI后面
func (s *Server)appendMethodNameToUri(uri string, name string) string {
func (s *Server)appendMethodNameToUriWithPattern(pattern string, name string) string {
// 检测域名后缀
array := strings.Split(pattern, "@")
// 分离URI(其实可能包含HTTP Method)
uri := array[0]
uri = strings.TrimRight(uri, "/") + "/"
// 方法名中间存在大写字母，转换为小写URI地址以“-”号链接每个单词
for i := 0; i < len(name); i++ {
@ -317,23 +326,27 @@ func (s *Server)appendMethodNameToUri(uri string, name string) string {
}
uri += strings.ToLower(string(name[i]))
}
// 加上指定域名后缀
if len(array) > 1 {
uri += "@" + array[1]
}
return uri
}
// 注意该方法是直接绑定方法的内存地址，执行的时候直接执行该方法，不会存在初始化新的控制器逻辑
// 注意该方法是直接绑定函数的内存地址，执行的时候直接执行该方法，不会存在初始化新的控制器逻辑
func (s *Server)BindHandler(pattern string, handler HandlerFunc) error {
return s.bindHandlerItem(pattern, HandlerItem{nil, "", handler})
}
// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
// 需要注意对象方法的定义必须按照ghttp.HandlerFunc来定义
func (s *Server)BindObject(uri string, obj interface{}) error {
func (s *Server)BindObject(pattern string, obj interface{}) error {
m := make(HandlerMap)
v := reflect.ValueOf(obj)
t := v.Type()
for i := 0; i < v.NumMethod(); i++ {
name := t.Method(i).Name
key := s.appendMethodNameToUri(uri, name)
key := s.appendMethodNameToUriWithPattern(pattern, name)
m[key] = HandlerItem{nil, "", v.Method(i).Interface().(func(*Server, *ClientRequest, *ServerResponse))}
}
return s.bindHandlerByMap(m)
@ -341,7 +354,7 @@ func (s *Server)BindObject(uri string, obj interface{}) error {
// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
// 需要注意对象方法的定义必须按照ghttp.HandlerFunc来定义
func (s *Server)BindObjectRest(uri string, obj interface{}) error {
func (s *Server)BindObjectRest(pattern string, obj interface{}) error {
m := make(HandlerMap)
v := reflect.ValueOf(obj)
t := v.Type()
@ -350,7 +363,7 @@ func (s *Server)BindObjectRest(uri string, obj interface{}) error {
if _, ok := s.methodsMap[strings.ToUpper(name)]; !ok {
continue
}
key := name + ":" + uri
key := name + ":" + pattern
m[key] = HandlerItem{nil, "", v.Method(i).Interface().(func(*Server, *ClientRequest, *ServerResponse))}
}
return s.bindHandlerByMap(m)
@ -358,7 +371,7 @@ func (s *Server)BindObjectRest(uri string, obj interface{}) error {
// 绑定控制器，控制器需要实现gmvc.Controller接口
// 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话
func (s *Server)BindController(uri string, c Controller) error {
func (s *Server)BindController(pattern string, c Controller) error {
// 遍历控制器，获取方法列表，并构造成uri
m := make(HandlerMap)
v := reflect.ValueOf(c)
@ -368,17 +381,17 @@ func (s *Server)BindController(uri string, c Controller) error {
if name == "Init" || name == "Shut" {
continue
}
key := s.appendMethodNameToUri(uri, name)
key := s.appendMethodNameToUriWithPattern(pattern, name)
m[key] = HandlerItem{v.Elem().Type(), name, nil}
}
return s.bindHandlerByMap(m)
}
// 绑定控制器，控制器需要实现gmvc.Controller接口
// 绑定控制器(RESTFul)，控制器需要实现gmvc.Controller接口
// 方法会识别HTTP方法，并做REST绑定处理，例如：Post方法会绑定到HTTP POST的方法请求处理，Delete方法会绑定到HTTP DELETE的方法请求处理
// 因此只会绑定HTTP Method对应的方法，其他方法不会自动注册绑定
// 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话
func (s *Server)BindControllerRest(uri string, c Controller) error {
func (s *Server)BindControllerRest(pattern string, c Controller) error {
// 遍历控制器，获取方法列表，并构造成uri
m := make(HandlerMap)
v := reflect.ValueOf(c)
@ -395,13 +408,13 @@ func (s *Server)BindControllerRest(uri string, c Controller) error {
if _, ok := s.methodsMap[strings.ToUpper(name)]; !ok {
continue
}
key := name + ":" + uri
key := name + ":" + pattern
m[key] = HandlerItem{v.Elem().Type(), name, nil}
}
return s.bindHandlerByMap(m)
}
// 绑定方法，pattern支持http method
// 绑定控制器方法，pattern支持http method
// pattern的格式形如：/user/list, put:/user, delete:/user
// 这种方式绑定的控制器每一次请求都会初始化一个新的控制器对象进行处理，对应不同的请求会话
func (s *Server)BindControllerMethod(pattern string, c Controller, method string) error {

67
g/net/ghttp/http_server_domain.go
View File

@ -25,7 +25,7 @@ func (s *Server) Domain(domain string) *Domain {
if r := domains.Get(domain); r != nil {
return r.(*Domain)
}
d := &Domain{
d := &Domain{
s : s,
m : make(map[string]bool),
}
@ -37,17 +37,64 @@ func (s *Server) Domain(domain string) *Domain {
return d
}
// 绑定方法
func (d *Domain) BindControllerMethod(pattern string, c Controller, method string) error {
return d.s.BindControllerMethod(pattern, c, method)
}
// 绑定控制器
func (d *Domain) BindController(uri string, c Controller) error {
// 注意该方法是直接绑定方法的内存地址，执行的时候直接执行该方法，不会存在初始化新的控制器逻辑
func (d *Domain) BindHandler(pattern string, handler HandlerFunc) error {
for domain, _ := range d.m {
if err := d.s.BindController(uri + "@" + domain, c); err != nil {
if err := d.s.bindHandlerItem(pattern + "@" + domain, HandlerItem{nil, "", handler}); err != nil {
return err
}
}
return nil
}
}
// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
// 需要注意对象方法的定义必须按照ghttp.HandlerFunc来定义
func (d *Domain) BindObject(pattern string, obj interface{}) error {
for domain, _ := range d.m {
if err := d.s.BindObject(pattern + "@" + domain, obj); err != nil {
return err
}
}
return nil
}
// 绑定对象到URI请求处理中，会自动识别方法名称，并附加到对应的URI地址后面
// 需要注意对象方法的定义必须按照ghttp.HandlerFunc来定义
func (d *Domain) BindObjectRest(pattern string, obj interface{}) error {
for domain, _ := range d.m {
if err := d.s.BindObjectRest(pattern + "@" + domain, obj); err != nil {
return err
}
}
return nil
}
// 绑定控制器
func (d *Domain) BindController(pattern string, c Controller) error {
for domain, _ := range d.m {
if err := d.s.BindController(pattern + "@" + domain, c); err != nil {
return err
}
}
return nil
}
// 绑定控制器(RESTFul)
func (d *Domain) BindControllerRest(pattern string, c Controller) error {
for domain, _ := range d.m {
if err := d.s.BindControllerRest(pattern + "@" + domain, c); err != nil {
return err
}
}
return nil
}
// 绑定控制器方法
func (d *Domain) BindControllerMethod(pattern string, c Controller, method string) error {
for domain, _ := range d.m {
if err := d.s.BindControllerMethod(pattern + "@" + domain, c, method); err != nil {
return err
}
}
return nil
}

10
g/net/gtcp/tcp.go
View File

@ -11,6 +11,10 @@ import (
"gitee.com/johng/gf/g/container/gmap"
)
const (
gDEFAULT_SERVER = "default"
)
// tcp server结构体
type Server struct {
address string
@ -22,7 +26,11 @@ var serverMapping = gmap.NewStringInterfaceMap()
// 获取/创建一个空配置的TCP Server
// 单例模式，请保证name的唯一性
func GetServer(name string) (*Server) {
func GetServer(names...string) (*Server) {
name := gDEFAULT_SERVER
if len(names) > 0 {
name = names[0]
}
if s := serverMapping.Get(name); s != nil {
return s.(*Server)
}

10
g/net/gudp/udp.go
View File

@ -11,6 +11,10 @@ import (
"gitee.com/johng/gf/g/container/gmap"
)
const (
gDEFAULT_SERVER = "default"
)
// tcp server结构体
type Server struct {
address string
@ -22,7 +26,11 @@ var serverMapping = gmap.NewStringInterfaceMap()
// 获取/创建一个空配置的UDP Server
// 单例模式，请保证name的唯一性
func GetServer(name string) (*Server) {
func GetServer(names...string) (*Server) {
name := gDEFAULT_SERVER
if len(names) > 0 {
name = names[0]
}
if s := serverMapping.Get(name); s != nil {
return s.(*Server)
}

12
g/os/gview/gview.go
View File

@ -87,6 +87,9 @@ func (view *View) Template(file string) (*Template, error) {
content : gfile.GetContents(path),
funcmap : make(map[string]interface{}),
}
// 绑定内置inluce方法
t.BindFunc("include", t.funcInclude)
// 将模板对象注册到内部map中
view.tpls.Set(path, t)
return t, nil
}
@ -134,3 +137,12 @@ func (t *Template) Parse(data map[string]interface{}) ([]byte, error) {
return buffer.Bytes(), nil
}
// 模板内置方法：include
func (t *Template) funcInclude(file string) template.HTML {
content, err := t.Parse(nil)
if err != nil {
return template.HTML(err.Error())
}
return template.HTML(content)
}

23
geg/database/gmq/gmq.go
View File

@ -1,23 +0,0 @@
package main
import (
"gitee.com/johng/gf/g/database/gmq"
"fmt"
)
func main() {
mq, err := gmq.New("/tmp/gmq")
if err != nil {
fmt.Println(err)
}
//t1 := gtime.Microsecond()
//for i := 0; i < 10; i++ {
// mq.Group("test").Push([]byte("gmq_message_" + strconv.Itoa(i)))
//}
//fmt.Println("push cost:", gtime.Microsecond() - t1)
fmt.Println(string(mq.Group("test").Pop()))
fmt.Println("length", mq.Group("test").Length())
//fmt.Println(mq.Group("test").Add([]byte("gmq_message")))
//fmt.Println(mq.Group("test").Remove(1000))
}

14
geg/database/mysql/mysql.go
View File

@ -126,13 +126,13 @@ func create() {
// 数据写入
func insert() {
fmt.Println("insert:")
r, err := db.Insert("user", &gdb.Map {
r, err := db.Insert("user", gdb.Map {
"name": "john",
})
if (err == nil) {
uid, err2 := r.LastInsertId()
if err2 == nil {
r, err = db.Insert("user_detail", &gdb.Map {
r, err = db.Insert("user_detail", gdb.Map {
"uid" : uid,
"site" : "http://johng.cn",
})
@ -166,7 +166,7 @@ func query() {
// replace into
func replace() {
fmt.Println("replace:")
r, err := db.Save("user", &gdb.Map {
r, err := db.Save("user", gdb.Map {
"uid" : 1,
"name" : "john",
})
@ -182,7 +182,7 @@ func replace() {
// 数据保存
func save() {
fmt.Println("save:")
r, err := db.Save("user", &gdb.Map {
r, err := db.Save("user", gdb.Map {
"uid" : 1,
"name" : "john",
})
@ -198,7 +198,7 @@ func save() {
// 批量写入
func batchInsert() {
fmt.Println("batchInsert:")
err := db.BatchInsert("user", &gdb.List {
err := db.BatchInsert("user", gdb.List {
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
@ -213,7 +213,7 @@ func batchInsert() {
// 数据更新
func update1() {
fmt.Println("update1:")
r, err := db.Update("user", &gdb.Map {"name": "john1"}, "uid=?", 1)
r, err := db.Update("user", gdb.Map {"name": "john1"}, "uid=?", 1)
if (err == nil) {
fmt.Println(r.LastInsertId())
fmt.Println(r.RowsAffected())
@ -301,7 +301,7 @@ func linkopUpdate1() {
// 通过Map指针方式传参方式
func linkopUpdate2() {
fmt.Println("linkopUpdate2:")
r, err := db.Table("user").Data(&gdb.Map{"name" : "john2"}).Condition("name=?", "john").Update()
r, err := db.Table("user").Data(gdb.Map{"name" : "john2"}).Condition("name=?", "john").Update()
if (err == nil) {
fmt.Println(r.RowsAffected())
} else {

16
geg/database/pgsql/pgsql.go
View File

@ -14,7 +14,7 @@ var db gdb.Link
func init () {
gdb.AddDefaultConfigNode(gdb.ConfigNode {
Host : "127.0.0.1",
Port : 5432,
Port : "5432",
User : "postgres",
Pass : "123456",
Name : "test",
@ -59,14 +59,14 @@ func create() {
// 数据写入
func insert() {
fmt.Println("insert:")
r, err := db.Insert("user", &gdb.Map {
r, err := db.Insert("user", gdb.Map {
"uid" : 1,
"name": "john",
})
if (err == nil) {
uid, err2 := r.LastInsertId()
if err2 == nil {
r, err = db.Insert("user_detail", &gdb.Map {
r, err = db.Insert("user_detail", gdb.Map {
"uid" : string(uid),
"site" : "http://johng.cn",
})
@ -100,7 +100,7 @@ func query() {
// replace into
func replace() {
fmt.Println("replace:")
r, err := db.Save("user", &gdb.Map {
r, err := db.Save("user", gdb.Map {
"uid": "1",
"name": "john",
})
@ -116,7 +116,7 @@ func replace() {
// 数据保存
func save() {
fmt.Println("save:")
r, err := db.Save("user", &gdb.Map {
r, err := db.Save("user", gdb.Map {
"uid" : "1",
"name" : "john",
})
@ -132,7 +132,7 @@ func save() {
// 批量写入
func batchInsert() {
fmt.Println("batchInsert:")
err := db.BatchInsert("user", &gdb.List {
err := db.BatchInsert("user", gdb.List {
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
{"name": "john_" + strconv.FormatInt(time.Now().UnixNano(), 10)},
@ -147,7 +147,7 @@ func batchInsert() {
// 数据更新
func update1() {
fmt.Println("update1:")
r, err := db.Update("user", &gdb.Map {"name": "john1"}, "uid=?", 1)
r, err := db.Update("user", gdb.Map {"name": "john1"}, "uid=?", 1)
if (err == nil) {
fmt.Println(r.LastInsertId())
fmt.Println(r.RowsAffected())
@ -215,7 +215,7 @@ func linkopUpdate1() {
// 通过Map指针方式传参方式
func linkopUpdate2() {
fmt.Println("linkopUpdate2:")
r, err := db.Table("user").Data(&gdb.Map{"name" : "john2"}).Condition("name=?", "john").Update()
r, err := db.Table("user").Data(gdb.Map{"name" : "john2"}).Condition("name=?", "john").Update()
if (err == nil) {
fmt.Println(r.RowsAffected())
} else {

18
geg/frame/mvc/controller/demo/hello.go Normal file
View File

@ -0,0 +1,18 @@
package demo
import (
"gitee.com/johng/gf/g"
"gitee.com/johng/gf/g/net/ghttp"
)
// 初始化控制器对象，并绑定操作到Web Server
func init() {
// 将URI映射到指定的方法中执行
g.HTTPServer().BindHandler("/hello", Hello)
}
// 用于函数映射
func Hello(s *ghttp.Server, r *ghttp.ClientRequest, w *ghttp.ServerResponse) {
w.WriteString("Hello World!")
}

40
geg/frame/mvc/controller/demo/rest.go Normal file
View File

@ -0,0 +1,40 @@
package demo
import (
"gitee.com/johng/gf/g/frame/gmvc"
"gitee.com/johng/gf/g"
)
// 测试控制器
type ControllerRest struct {
gmvc.Controller
}
// 初始化控制器对象，并绑定操作到Web Server
func init() {
// 控制器公开方法中与HTTP Method方法同名的方法将会绑定映射
g.HTTPServer().BindControllerRest("/user", &ControllerRest{})
}
// RESTFul - GET
func (c *ControllerUser) Get() {
c.Response.WriteString("RESTFul HTTP Method GET")
}
// RESTFul - POST
func (c *ControllerUser) Post() {
c.Response.WriteString("RESTFul HTTP Method POST")
}
// RESTFul - DELETE
func (c *ControllerUser) Delete() {
c.Response.WriteString("RESTFul HTTP Method DELETE")
}
// 该方法无法映射，将会无法访问到
func (c *ControllerUser) Hello() {
c.Response.WriteString("Hello")
}

25
geg/frame/mvc/controller/demo/test.go Normal file
View File

@ -0,0 +1,25 @@
package demo
import (
"gitee.com/johng/gf/g"
"gitee.com/johng/gf/g/net/ghttp"
)
// 测试绑定对象
type T struct {}
// 初始化控制器对象，并绑定操作到Web Server
func init() {
// 只能通过RESTFul方式访问接口，这里为测试方便，使用的是Get
//g.HTTPServer().BindObject("/test", &T{})
// 只有localhost域名下才能访问该对象，
// 对应URL为：http://localhost:8199/test/show
// 通过该地址将无法访问到内容：http://127.0.0.1:8199/test/show
g.HTTPServer().Domain("localhost").BindObject("/test", &T{})
}
// 用于对象映射
func (t *T) Show(s *ghttp.Server, r *ghttp.ClientRequest, w *ghttp.ServerResponse) {
w.WriteString("It's show time bibi!")
}

28
geg/frame/mvc/controller/demo/user.go Normal file
View File

@ -0,0 +1,28 @@
package demo
import (
"gitee.com/johng/gf/g"
"gitee.com/johng/gf/g/frame/gmvc"
)
// 定义业务相关的控制器对象，
// 建议命名规范中控制器统一使用Controller前缀，后期代码维护时便于区分
type ControllerUser struct {
gmvc.Controller
}
// 初始化控制器对象，并绑定操作到Web Server
func init() {
// 绑定控制器到指定URI，所有控制器的公开方法将会映射到指定URI末尾
// 例如该方法执行后，查看效果可访问：http://127.0.0.1:8199/user/info
g.HTTPServer().BindController("/user", &ControllerUser{})
}
// 定义操作逻辑 - 展示模板
func (c *ControllerUser) Info() {
c.View.Assign("name", "john")
c.View.Display("user/index")
}

43
geg/frame/mvc/controller/user/user.go
View File

@ -1,43 +0,0 @@
package user
import (
"gitee.com/johng/gf/g/net/ghttp"
"gitee.com/johng/gf/g/frame/gmvc"
"gitee.com/johng/gf/g/frame/ginstance"
)
// 定义业务相关的控制器对象
type ControllerUser struct {
gmvc.Controller
}
// 测试绑定对象
type T struct {
}
func (t *T) Test(s *ghttp.Server, r *ghttp.ClientRequest, w *ghttp.ServerResponse) {
w.WriteString("Test")
}
func (t *T) Get(s *ghttp.Server, r *ghttp.ClientRequest, w *ghttp.ServerResponse) {
w.WriteString("Http Method GET")
}
// 初始化控制器对象，并绑定操作到Web Server
func init() {
//ghttp.GetServer("johng").Domain("localhost").BindHandler("/user", u.Info)
//ghttp.GetServer("johng").BindHandler("/test", Test)
ginstance.Server().BindObjectRest("/test", &T{})
ginstance.Server().BindController("/user", &ControllerUser{})
}
// 定义操作逻辑
func (c *ControllerUser) Info() {
c.Response.WriteString("hello world!")
//c.View.Assign("name", "john")
//c.View.Display("user/index")
}

2
geg/frame/mvc/main.go
View File

@ -2,7 +2,7 @@ package main
import (
"gitee.com/johng/gf/g"
_ "gitee.com/johng/gf/geg/frame/mvc/controller/user"
_ "gitee.com/johng/gf/geg/frame/mvc/controller/demo"
)
func main() {

156
geg/net/gluster_client.go
View File

@ -1,156 +0,0 @@
package main
import (
"fmt"
"gitee.com/johng/gf/g/net/ghttp"
)
var kvUrl string = "http://192.168.2.102:4168/kv"
var nodeUrl string = "http://192.168.2.102:4168/node"
var serviceUrl string = "http://192.168.2.102:4168/service"
// kv操作
func addKV() {
c := ghttp.NewClient()
r := c.Put(kvUrl, "{\"name1\":\"john1\", \"name2\":\"john2\"}")
fmt.Println("addKV:", r.ReadAll())
}
func getAllKV() {
c := ghttp.NewClient()
r := c.Get(kvUrl)
fmt.Println("getAllKV:", r.ReadAll())
}
func getOneKV() {
c := ghttp.NewClient()
r := c.Get(kvUrl + "?k=name1")
fmt.Println("getOneKV:", r.ReadAll())
}
func editKV() {
c := ghttp.NewClient()
r := c.Post(kvUrl, "{\"name1\":\"john3\", \"name2\":\"john4\"}")
fmt.Println("editKV:", r.ReadAll())
}
func removeKV() {
c := ghttp.NewClient()
r := c.Delete(kvUrl, "[\"name1\"]")
fmt.Println("removeKV:", r.ReadAll())
}
// node操作
func addNode() {
c := ghttp.NewClient()
r := c.Put(nodeUrl, "[\"172.17.42.1\"]")
fmt.Println("addNode:", r.ReadAll())
}
func getAllNode() {
c := ghttp.NewClient()
r := c.Get(nodeUrl)
fmt.Println("getAllNode:", r.ReadAll())
}
func removeNode() {
c := ghttp.NewClient()
r := c.Delete(nodeUrl, "[\"172.17.42.1\"]")
fmt.Println("removeNode:", r.ReadAll())
}
// service操作
func getAllService() {
c := ghttp.NewClient()
r := c.Get(serviceUrl)
fmt.Println("getAllService:", r.ReadAll())
}
func getOneService() {
c := ghttp.NewClient()
r := c.Get(serviceUrl + "?name=Site Database")
fmt.Println("getOneService:", r.ReadAll())
}
func addDatabaseService() {
c := ghttp.NewClient()
s := `
{
"name" : "Site Database",
"type" : "mysql",
"list" : [
{"host":"192.168.2.102", "port":"3306", "user":"root", "pass":"123456", "database":"test"},
{"host":"192.168.2.124", "port":"3306", "user":"root", "pass":"123456", "database":"tongwujie"}
]
}
`
r := c.Put(serviceUrl, s)
fmt.Println("addDatabaseService:", r.ReadAll())
}
func editDatabaseService() {
c := ghttp.NewClient()
s := `
{
"name" : "Site Database2",
"type" : "mysql",
"list" : [
{"host":"192.168.2.102", "port":"3306", "user":"root", "pass":"123456", "database":"test"},
{"host":"192.168.2.124", "port":"3306", "user":"root", "pass":"123456", "database":"tongwujie"}
]
}
`
r := c.Post(serviceUrl, s)
fmt.Println("editDatabaseService:", r.ReadAll())
}
func removeDatabaseService() {
c := ghttp.NewClient()
r := c.Delete(serviceUrl, "[\"Site Database2\"]")
fmt.Println("removeDatabaseService:", r.ReadAll())
}
func addWebService() {
c := ghttp.NewClient()
s := `
{
"name" : "Site",
"type" : "web",
"list" : [
{"url":"http://baidu.com", "check":"http://itsadeadlink.com"},
{"url":"http://baidu.com"}
]
}
`
r := c.Put(serviceUrl, s)
fmt.Println("addWebService:", r.ReadAll())
}
func editWebService() {
c := ghttp.NewClient()
s := `
{
"name" : "Site2",
"type" : "web",
"list" : [
{"url":"http://baidu.com"},
{"url":"http://baidu.com"}
]
}
`
r := c.Post(serviceUrl, s)
fmt.Println("editWebService:", r.ReadAll())
}
func removeWebService() {
c := ghttp.NewClient()
r := c.Delete(serviceUrl, "[\"Site2\"]")
fmt.Println("removeWebService:", r.ReadAll())
}
func main() {
addWebService()
}

5
geg/net/http_client.go
View File

@ -7,8 +7,7 @@ import (
func main() {
c := ghttp.NewClient()
r := c.Get("http://192.168.2.124")
c := ghttp.NewClient()
r, _ := c.Get("http://192.168.2.124")
fmt.Println(r.StatusCode)
}

2
geg/net/http_server.go
View File

@ -13,7 +13,7 @@ func HelloServer2(w http.ResponseWriter, r *http.Request) {
io.WriteString(w, "hello2\n")
}
func main() {
s := ghttp.NewServer()
s := ghttp.GetServer()
s.SetAddr(":8199")
s.SetIndexFolder(true)
s.SetServerRoot("/home/john/Workspace/")