Go实战--golang中使用Goji微框架(Goji+Mongodb构建微服务)

Go 前端之家
前端之家收集整理的这篇文章主要介绍了Go实战--golang中使用Goji微框架(Goji+Mongodb构建微服务)，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

生命不止，继续 go go go!!!

今天跟大家分享一个web微框架Goji.

Goji

What is Goji?

枸杞？

Goji is a HTTP request multiplexer,similar to net/http.ServeMux. It compares incoming requests to a list of registered Patterns,and dispatches to the Handler that corresponds to the first matching Pattern. Goji also supports Middleware (composable shared functionality applied to every request) and uses the standard context to store request-scoped values.

官网：
https://goji.io/

github地址：
https://github.com/goji/goji

Star:
577

文档地址：
https://godoc.org/goji.io

获取：
go get goji.io

示例：

package main

import (
    "fmt"
    "net/http"

    "goji.io"
    "goji.io/pat"
)

func hello(w http.ResponseWriter,r *http.Request) {
    name := pat.Param(r,"name")
    fmt.Fprintf(w,"Hello,%s!",name)
}

func main() {
    mux := goji.NewMux()
    mux.HandleFunc(pat.Get("/hello/:name"),hello)

    http.ListenAndServe("localhost:8000",mux)
}

运行，浏览器访问：http://localhost:8000/hello/heyGoji
返回：Hello,heyGoji!

zenazn/goji

不要奇怪， zenazn/goji is new version of Goji，也就是一个作者。
This project has been superseded by a new version of Goji by the same author,which has very similar primitives and semantics,but has been updated to reflect several years of experience with this library and the surrounding Go ecosystem. This project is still well-loved and well-maintained,and will be for the foreseeable future,but new projects are encouraged to use goji.io instead.

Goji是一个用Go语言写的Web微框架。Goji的设计理念是简单、可组合性、自由。它具有以下特点：

  • 兼容net/http
  • url模式（同时支持 Sinatra 风格的 /foo/:bar 和 正则表达式）
  • 可重构中间件栈
  • 通过中间件和处理器处理上下文/环境对象
  • 自动支持 Einhorn、systemd等
  • 渐进停止，配合 Einhorn 可实现零下线时间的渐进重载

github地址：
https://github.com/zenazn/goji

Star:
3354

获取：
go get github.com/zenazn/goji

示例：

package main

import (
    "fmt"
    "net/http"

    "github.com/zenazn/goji"
    "github.com/zenazn/goji/web"
)

func hello(c web.C,w http.ResponseWriter,r *http.Request) {
    fmt.Fprintf(w,c.URLParams["name"])
}

func main() {
    goji.Get("/hello/:name",hello)
    goji.Serve()
}

运行：
2017/12/20 10:37:27.132172 Starting Goji on [::]:8000
2017/12/20 10:37:36.423659 [LAPTOP-MNU6522J/9tNAt5dWFL-000001] Started GET “/hello/heyGoji” from [::1]:19489
2017/12/20 10:37:36.423659 [LAPTOP-MNU6522J/9tNAt5dWFL-000001] Returning 200 in 0s

浏览器访问：http://localhost:8000/hello/heyGoji
返回：Hello,heyGoji!

应用

文件服务

package main

import (
    "fmt"
    "net/http"

    "github.com/zenazn/goji"
    "github.com/zenazn/goji/web"
)

func apiExampleHandler(context web.C,resp http.ResponseWriter,req *http.Request) {
    fmt.Fprint(resp,"You've hit the API!")
}

func main() {
    goji.Handle("/api",apiExampleHandler)

    // Static file handler should generally be the last handler registered. Otherwise,it'll match every path.
    // Be sure to use an absolute path.
    staticFilesLocation := "./"
    goji.Handle("/*",http.FileServer(http.Dir(staticFilesLocation)))

    goji.Serve()
}

运行，浏览器输入http://localhost:8000/

Goji Restful Api

package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    "goji.io"
    "goji.io/pat"
)

type book struct {
    ISBN    string "json:isbn"
    Title   string "json:name"
    Authors string "json:author"
    Price   string "json:price"
}

var bookStore = []book{
    book{
        ISBN:    "0321774639",Title:   "Programming in Go: Creating Applications for the 21st Century (Developer's Library)",Authors: "Mark Summerfield",Price:   "$34.57",},book{
        ISBN:    "0134190440",Title:   "The Go Programming Language",Authors: "Alan A. A. Donovan,Brian W. Kernighan",}

func main() {
    mux := goji.NewMux()
    mux.HandleFunc(pat.Get("/books"),allBooks)
    mux.HandleFunc(pat.Get("/books/:isbn"),bookByISBN)
    mux.Use(logging)
    http.ListenAndServe("localhost:8080",mux)
}

func allBooks(w http.ResponseWriter,r *http.Request) {
    jsonOut,_ := json.Marshal(bookStore)
    fmt.Fprintf(w,string(jsonOut))
}

func bookByISBN(w http.ResponseWriter,r *http.Request) {
    isbn := pat.Param(r,"isbn")
    for _,b := range bookStore {
        if b.ISBN == isbn {
            jsonOut,_ := json.Marshal(b)
            fmt.Fprintf(w,string(jsonOut))
            return
        }
    }
    w.WriteHeader(http.StatusNotFound)
}

func logging(h http.Handler) http.Handler {
    fn := func(w http.ResponseWriter,r *http.Request) {
        fmt.Printf("Received request: %v\n",r.URL)
        h.ServeHTTP(w,r)
    }
    return http.HandlerFunc(fn)
}

浏览器访问：
http://localhost:8080/books

返回：

// 20171220105345
// http://localhost:8080/books

Array[2][
  {
    "ISBN": "0321774639","Title": "Programming in Go: Creating Applications for the 21st Century (Developer's Library)","Authors": "Mark Summerfield","Price": "$34.57"
  },{
    "ISBN": "0134190440","Title": "The Go Programming Language","Authors": "Alan A. A. Donovan,"Price": "$34.57"
  }
]

认证
goji/httpauth
github地址：
https://github.com/goji/httpauth

获取：
go get github.com/goji/httpauth

package main

import (
    "net/http"

    "github.com/goji/httpauth"
    "github.com/zenazn/goji"
)

func main() {

    goji.Use(httpauth.SimpleBasicAuth("dave","password"))

    // myHandler requires HTTP Basic Auth to access
    goji.Get("/thing",myHandler)

    goji.Serve()
}

Goji+Mongodb搭建微服务

出自：
http://goinbigdata.com/how-to-build-microservice-with-mongodb-in-golang/

golang中如何使用mongodb，我们之前多次介绍过了，可以翻看之前的博客。
启动mongodb server：

mongod.exe --dbpath d:\mongodb_data\db

直接上代码：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    "goji.io"
    "goji.io/pat"
    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

func ErrorWithJSON(w http.ResponseWriter,message string,code int) {
    w.Header().Set("Content-Type","application/json; charset=utf-8")
    w.WriteHeader(code)
    fmt.Fprintf(w,"{message: %q}",message)
}

func ResponseWithJSON(w http.ResponseWriter,json []byte,"application/json; charset=utf-8")
    w.WriteHeader(code)
    w.Write(json)
}

type Book struct {
    ISBN    string   `json:"isbn"`
    Title   string   `json:"title"`
    Authors []string `json:"authors"`
    Price   string   `json:"price"`
}

func main() {
    session,err := mgo.Dial("localhost")
    if err != nil {
        panic(err)
    }
    defer session.Close()

    session.SetMode(mgo.Monotonic,true)
    ensureIndex(session)

    mux := goji.NewMux()
    mux.HandleFunc(pat.Get("/books"),allBooks(session))
    mux.HandleFunc(pat.Post("/books"),addBook(session))
    mux.HandleFunc(pat.Get("/books/:isbn"),bookByISBN(session))
    mux.HandleFunc(pat.Put("/books/:isbn"),updateBook(session))
    mux.HandleFunc(pat.Delete("/books/:isbn"),deleteBook(session))
    http.ListenAndServe("localhost:8080",mux)
}

func ensureIndex(s *mgo.Session) {
    session := s.Copy()
    defer session.Close()

    c := session.DB("store").C("books")

    index := mgo.Index{
        Key:        []string{"isbn"},Unique:     true,DropDups:   true,Background: true,Sparse:     true,}
    err := c.EnsureIndex(index)
    if err != nil {
        panic(err)
    }
}

func allBooks(s *mgo.Session) func(w http.ResponseWriter,r *http.Request) {
    return func(w http.ResponseWriter,r *http.Request) {
        session := s.Copy()
        defer session.Close()

        c := session.DB("store").C("books")

        var books []Book
        err := c.Find(bson.M{}).All(&books)
        if err != nil {
            ErrorWithJSON(w,"Database error",http.StatusInternalServerError)
            log.Println("Failed get all books: ",err)
            return
        }

        respBody,err := json.MarshalIndent(books,""," ")
        if err != nil {
            log.Fatal(err)
        }

        ResponseWithJSON(w,respBody,http.StatusOK)
    }
}

func addBook(s *mgo.Session) func(w http.ResponseWriter,r *http.Request) {
        session := s.Copy()
        defer session.Close()

        var book Book
        decoder := json.NewDecoder(r.Body)
        err := decoder.Decode(&book)
        if err != nil {
            ErrorWithJSON(w,"Incorrect body",http.StatusBadRequest)
            return
        }

        c := session.DB("store").C("books")

        err = c.Insert(book)
        if err != nil {
            if mgo.IsDup(err) {
                ErrorWithJSON(w,"Book with this ISBN already exists",http.StatusBadRequest)
                return
            }

            ErrorWithJSON(w,http.StatusInternalServerError)
            log.Println("Failed insert book: ",err)
            return
        }

        w.Header().Set("Content-Type","application/json")
        w.Header().Set("Location",r.URL.Path+"/"+book.ISBN)
        w.WriteHeader(http.StatusCreated)
    }
}

func bookByISBN(s *mgo.Session) func(w http.ResponseWriter,r *http.Request) {
        session := s.Copy()
        defer session.Close()

        isbn := pat.Param(r,"isbn")

        c := session.DB("store").C("books")

        var book Book
        err := c.Find(bson.M{"isbn": isbn}).One(&book)
        if err != nil {
            ErrorWithJSON(w,http.StatusInternalServerError)
            log.Println("Failed find book: ",err)
            return
        }

        if book.ISBN == "" {
            ErrorWithJSON(w,"Book not found",http.StatusNotFound)
            return
        }

        respBody,err := json.MarshalIndent(book,http.StatusOK)
    }
}

func updateBook(s *mgo.Session) func(w http.ResponseWriter,"isbn")

        var book Book
        decoder := json.NewDecoder(r.Body)
        err := decoder.Decode(&book)
        if err != nil {
            ErrorWithJSON(w,http.StatusBadRequest)
            return
        }

        c := session.DB("store").C("books")

        err = c.Update(bson.M{"isbn": isbn},&book)
        if err != nil {
            switch err {
            default:
                ErrorWithJSON(w,http.StatusInternalServerError)
                log.Println("Failed update book: ",err)
                return
            case mgo.ErrNotFound:
                ErrorWithJSON(w,http.StatusNotFound)
                return
            }
        }

        w.WriteHeader(http.StatusNoContent)
    }
}

func deleteBook(s *mgo.Session) func(w http.ResponseWriter,"isbn")

        c := session.DB("store").C("books")

        err := c.Remove(bson.M{"isbn": isbn})
        if err != nil {
            switch err {
            default:
                ErrorWithJSON(w,http.StatusInternalServerError)
                log.Println("Failed delete book: ",http.StatusNotFound)
                return
            }
        }

        w.WriteHeader(http.StatusNoContent)
    }
}

运行，使用curl post数据：

curl -X POST -H "Content-Type: application/json" -d '{"isbn": "0134190440","title": "The Go Programming Language","authors": ["Alan A. A. Donovan","Brian W. Kernighan"],"price": "$34.57"}' http://localhost:8080/books

读取：

curl -H "Content-Type: application/json" http://localhost:8080/books

返回：

[
  {
    "isbn": "0134190440","title": "The Go Programming Language","authors": [ "Alan A. A. Donovan","Brian W. Kernighan" ],"price": "$34.57" }
]

猜你在找的Go相关文章

golang简单实现jwt验证(beego、xorm、jwt)
程序目录结构 简单实现，用户登录后返回一个jwt的token，下次请求带上token请求用户信息接...
【工程实践】利用go语言写一个简单的Pow样例
本篇博客的主要内容是用go写一个简单的Proof-of-Work共识机制，不涉及到网络通信环节，只是...
【工程实践】go语言实现MerkleTree
简介 默克尔树（MerkleTree）是一种典型的二叉树结构，其主要特点为： 最下面的叶节点包含...
第九章 goroutine
接下来学习并发编程, 并发编程是go语言最有特色的地方, go对并发编程是原生支持. goroutin...
第十一章 运用广度优先搜索走迷宫
先普及一下, 什么是广度优先搜索 广度优先搜索类似于树的层次遍历。从图中的某一顶点出发，...
第十三章 go实现分布式网络爬虫---单机版爬虫
爬虫的分类 网络爬虫分为两类 1. 通用爬虫: 类似于baidu, google. 他们会把大量的数据挖下...
第十章 channel select 总结
感觉channel在理解起来还有点费劲的, 尤其是select的使用, 既要可以读数据, 又要可以写数据...
第十五章 并发版爬虫第二版 -- 完结
并发版爬虫, 在上一篇单机版爬虫的基础上演变而来 这里只有并发引擎的代码, 基本的解析器代...
第八章--性能优化--pprof详细研究
接着上次的博客: https://www.cnblogs.com/ITPower/articles/12315637.html ppro...
第八章 测试与性能调优--生成文档和测试示例代码
java也可以生成文档, 就像一个手册一样, 可以用来查看方法, 接口, 下面我们给go项目生成文...
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积