Why Python

Python是一个很酷的编程语言，它极致的简洁，极易上手，我们可以用它来做云计算、大数据分析，运维自动化，当然还可以写网站、做爬虫。

Why not Python

但我们也清楚地知道它会受限于GIL，还好我们有gevent，我们可以很愉快地monkey.patch_all()，然后用greenlet来处理，但即使这样，在并发量极高的情况下，它的效率就有些令我们担心了。

Golang or OpenResty

当我们开始关注高性能高并发服务端实现的时候，我们自然而然地将目光转向一些现代化的技术，这就是Golang和OpenResty，当然他们的核心都是将IO复用与协程进行有机的融合，但却有着截然不同的表现风格。如果你要问我更喜欢哪个，我会说both。当然下文我会介绍Golang。

Golang

我的哲学是，要熟悉一个编程语言，就是要从最简单的代码开始写起来。百试不爽。
万年不变的hello world先放这。
hello.go

package main //包声明

import "fmt" //导入包

func main() {
  fmt.Println("Hello, 世界")
}

用golang写个mongodb的api出来。
https://github.com/Hevienz/gokule
main.go

package main

import (
   "encoding/json"
   "github.com/cloudflare/conf"
   "gopkg.in/macaron.v1"  //Web框架Macaron
   "labix.org/v2/mgo"
   "log"
   "net/http"
   "os"
   "strconv"
)

// 声明包级别的变量
var ( 
   MONGO_URL string
   MONGO_DB  string
)

// 包初始化函数init
func init() {
   c, err := conf.ReadConfigFile("config.conf") //配置文件见config.conf
   e(err, true)
   MONGO_URL = c.GetString("MONGO_URL", "127.0.0.1:27017")
   MONGO_DB = c.GetString("MONGO_DB", "test")
}

func e(err error, fatal bool) (ret bool) {
   if err != nil {
      log.Println(err.Error())
      if fatal {
         os.Exit(1)
      }
      return true
   } else {
      return false
   }
}

func main() {
   ms, err := mgo.Dial(MONGO_URL)
   e(err, true)
   defer ms.Close() //延迟到函数将要返回时执行
   ms.SetMode(mgo.Monotonic, true)
   mdb := ms.DB(MONGO_DB)
   m := macaron.Classic()
   m.Map(mdb)
   m.Get("/", func(mdb *mgo.Database) string {
      names, err := mdb.CollectionNames()
      e(err, false)
      body, err := json.Marshal(names)
      e(err, false)
      return string(body)
   })
   m.Get("/:col", func(mdb *mgo.Database, ctx *macaron.Context, req *http.Request) string {
      req.ParseForm()
      mcol := mdb.C(ctx.Params(":col"))
      limit := 20
      offset := 0
      if t := req.FormValue("limit"); t != "" {
         limit, err = strconv.Atoi(t)
         e(err, false)
      }
      if t := req.FormValue("offset"); t != "" {
         offset, err = strconv.Atoi(t)
         e(err, false)
      }
      total_count, err := mcol.Find(nil).Count()
      e(err, false)
      items := []map[string]interface{}{}
      iter := mcol.Find(nil).Skip(offset).Limit(limit).Iter()
      for {
         item := map[string]interface{}{} 
         if iter.Next(&item) {
            // item := map[string]interface{}{} 不能写在这里，因为Map是引用类型
            items = append(items, item)
         } else {
            break
         }
      }
      dict := map[string]interface{}{
         "meta": map[string]int{"total_count": total_count, "offset": offset, "limit": limit},
         "data": items,
         "msg":  "success", 
        "code": 0,
      }
      body, err := json.Marshal(dict)
      e(err, false)
      return string(body)
   })
   m.Run()
}

config.conf

MONGO_URL=127.0.0.1:27017
MONGO_DB=devmgmt

继续看一个Kill MySQL慢查询的小工具。
https://github.com/Hevienz/stareMySQL
main.go

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql" //匿名导入
    "io/ioutil"
    "log"
    "os"
    "regexp"
    "strings"
    "time"
)

func e(err error, fatal bool) (ret bool) {
    if err != nil {
        log.Println(err.Error())
        if fatal {
            os.Exit(1)
        }
        return true
    } else {
        return false
    }
}

var (
    DBS = map[string]string{}
    dbs = map[string]*sql.DB{}
)

func init() {
    log.SetFlags(log.Flags() | log.Lshortfile)
    bytes, err := ioutil.ReadFile("config.conf") //见config.conf
    e(err, true)
    str := string(bytes)
    lines := strings.Split(str, "n")
    reg, err := regexp.Compile(`s+`)
    e(err, true)
    for num, line := range lines {
        if line == "" {
            continue
        }
        if strings.HasPrefix(line, "#") {
            continue
        }
        fields := reg.Split(line, -1)
        if len(fields) != 2 {
            log.Printf("Line %d is not match the config format.", num+1)
            continue
        }
        dbname := fields[0]
        dburi := fields[1]
        DBS[dbname] = dburi
        dbs[dbname] = init_db(dburi)
    }
}

func init_db(uri string) *sql.DB {
    db, err := sql.Open("mysql", uri)
    e(err, true)
    return db
}

func task(dbname string, db *sql.DB) {
    for {
        rows, err := db.Query("select id,info,time from information_schema.PROCESSLIST where time > 5 and command = 'Query';")
        if err != nil {
            log.Println(err.Error())
            dbs[dbname] = init_db(DBS[dbname])
            task(dbname, dbs[dbname])
            break
        }
        for rows.Next() {
            var id string
            var info string
            var time string
            err = rows.Scan(&id, &info, &time)
            if err != nil {
                log.Println(err.Error())
            } else {
                log.Printf("[FOUND SQL]: '%s'@'%s' (ConnectionId: %s, Time: %s)", info, dbname, id, time)
                _, err := db.Exec(fmt.Sprintf("kill %s;", id))
                if err != nil {
                    log.Println(err.Error())
                } else {
                    log.Printf("[KILLED SQL]: '%s'@'%s' (ConnectionId: %s, Time: %s)", info, dbname, id, time)
                }
            }
        }
        time.Sleep(1 * time.Second)
    }
}

func main() {
    for dbname, db := range dbs {
        go task(dbname, db) //用go关键字创建goroutine
    }
    c := make(chan int)
    <-c // 阻塞main goroutine
}

config.conf

# 配置文件以#开头的为注释
# 配置行 为 数据库昵称和数据库uri的组合，中间以若干空白为分隔

db1(127.0.0.1)      root:root.com@tcp(127.0.0.1:3306)/mysql?charset=utf8
vhost1              ds:root.com@tcp(192.2.3.143:3306)/mysql?charset=utf8

看个panic和recover的代码片段。

package main

import (
   "fmt"
)

func PanicAndRecover(input string) (res string) {
   defer func() {
      if p := recover(); p != nil { //从panic中恢复
         fmt.Printf("%T, %#vn", p, p)
         res = "error" //defer中修改函数的返回值
      }
   }()
   panic(input) //触发panic
   return "normal"
}

func main() {
   err := PanicAndRecover("ds")
   fmt.Println(err)
}

面向对象的例子。
https://github.com/Hevienz/go-mongo
mongo.go

package go_mongo

import (
    "gopkg.in/mgo.v2"
    "log"
    "os"
)

type Mongo struct{
    session *mgo.Session
}

func New(murls string) *Mongo {
    ms, err := mgo.Dial(murls)
    if err != nil {
        log.Printf("mgo.Dial, %sn", err)
        os.Exit(1)
    }
    return &Mongo{session: ms}
}

func (self *Mongo) Insert(mdbs string, mcols string, docs ...interface{}) error { //*Mongo类型的方法，docs是可变参数
    mdb := self.session.DB(mdbs)
    mcol := mdb.C(mcols)
    return mcol.Insert(docs...)
}

在main.go中使用包github.com/Hevienz/go-mongo。
main.go

package main
import (
   "github.com/Hevienz/go-mongo"
   "github.com/Hevienz/go-utils" //下文介绍
   "log"
)
func main() {
   doc := map[string]interface{}{"ds": "cc"}
   m := go_mongo.New("127.0.0.1:27017")
   go_utils.Dir(m) //调用go_utils包的Dir方法
   err := m.Insert("test", "ds", doc)
   if err != nil {
      log.Println(err)
   }
}

用反射实现类似Python中的build-in函数dir。
https://github.com/Hevienz/go-utils
dir.go

package go_utils

import (
    "reflect" //导入反射包
    "fmt"
    "strings"
)

func Dir(x interface{}) {
    v := reflect.ValueOf(x)
    t := v.Type()
    fmt.Printf("type %sn", t)

    for i := 0; i < v.NumMethod(); i++ {
        methType := v.Method(i).Type()
        fmt.Printf("func (%s) %s%sn", t, t.Method(i).Name,
            strings.TrimPrefix(methType.String(), "func"))
    }
}

其它重要的特性包括：接口，类型断言，类型分支，channel，互斥锁等，此处不再介绍。