From 13215d259c30e79d32bdf08e979a0f4c16ef6879 Mon Sep 17 00:00:00 2001 From: vCaesar Date: Sun, 8 Jan 2017 20:37:28 +0800 Subject: [PATCH 1/3] Update preface word --- zh/01.0.md | 2 +- zh/01.2.md | 2 +- zh/05.4.md | 2 +- zh/05.6.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/zh/01.0.md b/zh/01.0.md index 4aa68fb1..09fb00ac 100644 --- a/zh/01.0.md +++ b/zh/01.0.md @@ -20,4 +20,4 @@ Go是一种编译型语言，它结合了解释型语言的游刃有余，动态 ## links * [目录]() - * 下一节: [Go安装](<01.1.md>) + * 下一节: [安装Go](<01.1.md>) diff --git a/zh/01.2.md b/zh/01.2.md index a1bdf280..5c708666 100644 --- a/zh/01.2.md +++ b/zh/01.2.md @@ -176,5 +176,5 @@ go get本质上可以理解为首先第一步是通过源码工具clone代码到 ## links * [目录]() - * 上一节: [GO安装](<01.1.md>) + * 上一节: [安装Go](<01.1.md>) * 下一节: [GO 命令](<01.3.md>) diff --git a/zh/05.4.md b/zh/05.4.md index 7b75671a..da81ec06 100644 --- a/zh/05.4.md +++ b/zh/05.4.md @@ -131,4 +131,4 @@ Go实现的支持PostgreSQL的驱动也很多，因为国外很多人在开发 ## links * [目录]() * 上一节: [使用SQLite数据库](<05.3.md>) - * 下一节: [使用beedb库进行ORM开发](<05.5.md>) + * 下一节: [使用Beego orm库进行ORM开发](<05.5.md>) diff --git a/zh/05.6.md b/zh/05.6.md index 9b43866c..e72c5f02 100644 --- a/zh/05.6.md +++ b/zh/05.6.md @@ -193,5 +193,5 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个 ## links * [目录]() - * 上一节: [使用beedb库进行ORM开发](<05.5.md>) + * 上一节: [使用Beego orm库进行ORM开发](<05.5.md>) * 下一节: [小结](<05.7.md>) From 4deec3503558e9d58232c32af0662e546c682e4f Mon Sep 17 00:00:00 2001 From: vCaesar Date: Sun, 8 Jan 2017 21:06:51 +0800 Subject: [PATCH 2/3] Update redis link and Update mgo --- en/05.6.md | 75 +++++++++++++++++++++++++++++++----------------------- zh/05.6.md | 56 +++++++++++++++++++++++----------------- 2 files changed, 75 insertions(+), 56 deletions(-) diff --git a/en/05.6.md b/en/05.6.md index 05f023ce..0fa888c6 100644 --- a/en/05.6.md +++ b/en/05.6.md @@ -10,10 +10,10 @@ redis is a key-value storage system like Memcached, that supports the string, li There are some Go database drivers for redis: - [https://github.com/garyburd/redigo](https://github.com/garyburd/redigo) +- [https://github.com/go-redis/redis](https://github.com/go-redis/redis) +- [https://github.com/hoisie/redis](https://github.com/hoisie/redis) - [https://github.com/alphazero/Go-Redis](https://github.com/alphazero/Go-Redis) -- [http://code.google.com/p/tideland-rdc/](http://code.google.com/p/tideland-rdc/) - [https://github.com/simonz05/godis](https://github.com/simonz05/godis) -- [https://github.com/hoisie/redis.go](https://github.com/hoisie/redis.go) Let's see how to use the driver that redigo to operate on a database: ```Go @@ -142,46 +142,57 @@ Figure 5.1 MongoDB compared to Mysql The best driver for mongoDB is called `mgo`, and it is possible that it will be included in the standard library in the future. +Install mgo: + +```Go + go get gopkg.in/mgo.v2 +``` + Here is the example: +```Go package main - + import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "log" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" ) - + type Person struct { - Name string - Phone string + Name string + Phone string } - + func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() - - session.SetMode(mgo.Monotonic, true) - - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } - - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } - - fmt.Println("Phone:", result.Phone) + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() + + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) + + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } + + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Phone:", result.Phone) } +``` + We can see that there are no big differences when it comes to operating on mgo or beedb databases; they are both based on structs. This is the Go way of doing things. ## Links diff --git a/zh/05.6.md b/zh/05.6.md index e72c5f02..f42032f9 100644 --- a/zh/05.6.md +++ b/zh/05.6.md @@ -10,10 +10,10 @@ redis是一个key-value存储系统。和Memcached类似，它支持存储的val Go目前支持redis的驱动有如下 - https://github.com/garyburd/redigo (推荐) +- https://github.com/go-redis/redis +- https://github.com/hoisie/redis - https://github.com/alphazero/Go-Redis -- http://code.google.com/p/tideland-rdc/ - https://github.com/simonz05/godis -- https://github.com/hoisie/redis.go 我以redigo驱动为例来演示如何进行数据的操作: ```Go @@ -145,6 +145,12 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个 目前Go支持mongoDB最好的驱动就是[mgo](http://labix.org/mgo)，这个驱动目前最有可能成为官方的pkg。 +安装mgo: + +```Go + go get gopkg.in/mgo.v2 +``` + 下面我将演示如何通过Go来操作mongoDB： ```Go @@ -152,38 +158,40 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个 import ( "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "log" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } ``` From 52fcfce8e4fe0b604dfde192691e71ef2af94766 Mon Sep 17 00:00:00 2001 From: vCaesar Date: Sun, 8 Jan 2017 21:22:13 +0800 Subject: [PATCH 3/3] Update other mgo --- de/05.6.md | 69 +++++++++++++++++++++++++++------------------------ en/05.6.md | 44 ++++++++++++++++---------------- es/05.6.md | 52 ++++++++++++++++++++------------------ ja/05.6.md | 16 ++++++++---- pt-br/05.6.md | 66 ++++++++++++++++++++++++++---------------------- zh/05.6.md | 44 ++++++++++++++++---------------- 6 files changed, 156 insertions(+), 135 deletions(-) diff --git a/de/05.6.md b/de/05.6.md index bf3bdc0a..930dd1e8 100644 --- a/de/05.6.md +++ b/de/05.6.md @@ -66,44 +66,49 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be Here is the example: +```Go + package main - + import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) - + type Person struct { - Name string - Phone string - } - - func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() - - session.SetMode(mgo.Monotonic, true) - - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } - - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } - - fmt.Println("Phone:", result.Phone) + Name string + Phone string } + func main() { + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() + + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) + + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } + + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Phone:", result.Phone) + } + +``` We can see that there are no big differences when it comes to operating on mgo or beedb databases; they are both based on structs. This is the Go way of doing things. ## Links diff --git a/en/05.6.md b/en/05.6.md index 0fa888c6..4f83df2c 100644 --- a/en/05.6.md +++ b/en/05.6.md @@ -155,40 +155,40 @@ Here is the example: import ( "fmt" - "log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - // Optional. Switch the session to a monotonic behavior. - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - log.Fatal(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - log.Fatal(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } ``` diff --git a/es/05.6.md b/es/05.6.md index b69f6da8..3a1096ba 100644 --- a/es/05.6.md +++ b/es/05.6.md @@ -65,44 +65,48 @@ Figura 5.1 MongoDB comparada con Mysql El mejor manejador para mongoDB es llamado `mgo`, y es posible que se incluya en la librería estándar en el futuro. Aquí está un ejemplo -``` +```Go + package main import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } + ``` Como podemos ver no hay muchas diferencias en lo que respecta a operar con mgo o bases de datos beedb; ambas son basadas en estructuras. Esta es la manera en que Go hace las cosas. diff --git a/ja/05.6.md b/ja/05.6.md index 36c80693..e59e6f4a 100644 --- a/ja/05.6.md +++ b/ja/05.6.md @@ -66,16 +66,19 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン 次にどのようにしてGoからmongoDBを操作するのかご説明します： +```Go + package main import ( "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string + Name string Phone string } @@ -86,24 +89,27 @@ MongoDBは高性能でオープンソース、モードレスなドキュメン } defer session.Close() + // Optional. Switch the session to a monotonic behavior. session.SetMode(mgo.Monotonic, true) c := session.DB("test").C("people") err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, &Person{"Cla", "+55 53 8402 8510"}) if err != nil { - panic(err) + log.Fatal(err) } result := Person{} err = c.Find(bson.M{"name": "Ale"}).One(&result) if err != nil { - panic(err) + log.Fatal(err) } fmt.Println("Phone:", result.Phone) } +``` + mgoの操作方法とbeedbの操作方法はほとんど似ていることがわかります。どちらもstructに基づいて操作する方法です。これこそがGo Styleです。 diff --git a/pt-br/05.6.md b/pt-br/05.6.md index bf3bdc0a..ab798a70 100644 --- a/pt-br/05.6.md +++ b/pt-br/05.6.md @@ -66,44 +66,50 @@ The best driver for mongoDB is called `mgo`, and it is possible that it will be Here is the example: +```Go + package main - + import ( - "fmt" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" + "fmt" + "gopkg.in/mgo.v2" + "gopkg.in/mgo.v2/bson" + "log" ) - + type Person struct { - Name string - Phone string + Name string + Phone string } - + func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() - - session.SetMode(mgo.Monotonic, true) - - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - panic(err) - } - - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - panic(err) - } - - fmt.Println("Phone:", result.Phone) + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() + + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) + + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } + + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Phone:", result.Phone) } +``` + We can see that there are no big differences when it comes to operating on mgo or beedb databases; they are both based on structs. This is the Go way of doing things. ## Links diff --git a/zh/05.6.md b/zh/05.6.md index f42032f9..fd913fb6 100644 --- a/zh/05.6.md +++ b/zh/05.6.md @@ -158,40 +158,40 @@ MongoDB是一个高性能，开源，无模式的文档型数据库，是一个 import ( "fmt" - "log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" + "log" ) type Person struct { - Name string - Phone string + Name string + Phone string } func main() { - session, err := mgo.Dial("server1.example.com,server2.example.com") - if err != nil { - panic(err) - } - defer session.Close() + session, err := mgo.Dial("server1.example.com,server2.example.com") + if err != nil { + panic(err) + } + defer session.Close() - // Optional. Switch the session to a monotonic behavior. - session.SetMode(mgo.Monotonic, true) + // Optional. Switch the session to a monotonic behavior. + session.SetMode(mgo.Monotonic, true) - c := session.DB("test").C("people") - err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, - &Person{"Cla", "+55 53 8402 8510"}) - if err != nil { - log.Fatal(err) - } + c := session.DB("test").C("people") + err = c.Insert(&Person{"Ale", "+55 53 8116 9639"}, + &Person{"Cla", "+55 53 8402 8510"}) + if err != nil { + log.Fatal(err) + } - result := Person{} - err = c.Find(bson.M{"name": "Ale"}).One(&result) - if err != nil { - log.Fatal(err) - } + result := Person{} + err = c.Find(bson.M{"name": "Ale"}).One(&result) + if err != nil { + log.Fatal(err) + } - fmt.Println("Phone:", result.Phone) + fmt.Println("Phone:", result.Phone) } ```