教你如何搭建自己的go-gin框架

发布于

1、使用http包默认启动web服务

Go语言内置了 net/http库，封装了HTTP网络编程的基础的接口，我们实现的ebb Web 框架便是基于net/http的。我们接下来通过一个例子，简单介绍下这个库的使用。

go mode init explame

package main

import (
    "fmt"
    "net/http"
)

func indexHandler(w http.ResponseWriter,r *http.Request){
    fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

func helloHandler(w http.ResponseWriter,r *http.Request){
    fmt.Fprintf(w,"URL.PATH=%q\n Header=%q\n",r.URL.Path,r.Header)
}

func main(){
    http.HandleFunc("/",indexHandler)
    http.HandleFunc("/hello",helloHandler)
    http.ListenAndServe(":8080",nil)
}

go build .
./examplde.exe 

启动web服务

访问 127.0.0.1:8080/   
访问 127.0.0.1:8080/hello

main 函数的最后一行，是用来启动 Web 服务的，第一个参数是地址，:9999表示在 9999 端口监听。而第二个参数则代表处理所有的HTTP请求的实例，nil 代表使用标准库中的实例处理。第二个参数，则是我们基于net/http标准库实现Web框架的入口

2、接下来我们需要自己实现

  • 新建examplde2目录
  • 新建ebb目录
  • 在ebb目录 执行 go mod init ebb
package ebb

import (
    "net/http"
    "log"
)

//定义框架请求处理方法
type HandlerFunc func(w http.ResponseWriter,req *http.Request)


//核心结构体
type Engine struct{
    router map[string]HandlerFunc //简单使用map记录路由信息
}

//实例化结构体
func New() *Engine{
    engine := &Engine{
        router : make(map[string]HandlerFunc),
    }
    return engine
}

//添加到结构体路由
func (engine *Engine) addRoute(mothod string,pattern string,handler HandlerFunc){
    key := mothod+"-"+pattern
    engine.router[key] = handler
}

func (engine *Engine) GET(pattern string,handler HandlerFunc){
    engine.addRoute("GET",pattern,handler)
}

func (engine *Engine) POST(pattern string,handler HandlerFunc){
    engine.addRoute("POST",pattern,handler)
}

//启动服务
func (engine *Engine) Run(addr string) (err error){
    return http.ListenAndServe(addr,engine)
}

//engine 实现ServeHTTP接口（所有的请求都会走到这）
//查找是否路由映射表存在，如果存在则调用，否则返回404
func (engine *Engine) ServeHTTP(w http.ResponseWriter,req *http.Request){

    key := req.Method + "-" + req.URL.Path
    if handler, ok := engine.router[key]; ok {
        handler(w, req)
    } else {
        log.Printf("404 NOT FOUND: %s\n", req.URL)
    }
}

  • 在exmpale2目录下新建main.go 并且执行 go mod init example

  • 编辑go.mod(在 go.mod 中使用 replace 将 ebb 指向 ./ebb)

module example

go 1.14

require ebb v0.0.0

replace ebb => ./ebb
  • 编辑main.go
package main

import (
    "ebb"
    "fmt"
    "net/http"
)

func main(){
    r := ebb.New()

    r.GET("/index",func(w http.ResponseWriter,req *http.Request){
        fmt.Fprintf(w, "URL.Path = %q\n", req.URL.Path)
    })

    r.GET("/hello", func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintln(w, req.Header)
    })

    r.Run(":8080")
}

框架流程

  • 定义HandlerFunc（框架的请求方法）
  • 定义核心结构体Engine 目前只存储路由信息，路由信息由映射表实现（路由只支持静态路由）
  • GET、POST提供路由注册
  • Run封装http.ListenAndServe
  • 核心结构体Engine实现ServeHTTP接口（所有请求），查找路由并执行

到目前为止，一个简易的框架已经OK、后续我们会将HandlerFunc方法优化，也就是Context.期待下一篇文章

封装context

简单说下本章的重点

抽离路由

  • 新建router.go
 package ebb

type router struct{
    handlers map[string]HandlerFunc
}

func newRouter() *router{
    return &router{handlers:make(map[string]HandlerFunc)}
}

func (r *router) addRoute(method string,pattern string,handler HandlerFunc){
    key := method+"-"+pattern
    r.handlers[key] = handler
}

设计Context的必要性

  • 对外接口简化调用 （封装了writer和request）
  • 提供了扩展性（比如支持动态参数、支持中间件等等）
package ebb


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

type H map[string]interface{}

type Context struct{
    //write and request
    Writer http.ResponseWriter
    Request *http.Request
    //request info
    Method string
    Path string
    //response
    HttpCode int
}


func newContext(w http.ResponseWriter,r *http.Request) *Context{
    context := &Context{
        Writer:w,
        Request:r,
        Path:   r.URL.Path,
        Method: r.Method,
    }

    return context
} 

func (c *Context) PostForm(key string) string {
    return c.Request.FormValue(key)
}

func (c *Context) Query(key string) string {
    return c.Request.URL.Query().Get(key)
}

func (c *Context) Status(code int) {
    c.HttpCode = code
    c.Writer.WriteHeader(code)
}

func (c *Context) SetHeader(key string, value string) {
    c.Writer.Header().Set(key, value)
}

func (c *Context) Write(data []byte){
    c.Writer.Write(data)
}


func (c *Context) String(code int,message string,v ...interface{}){
    c.SetHeader("Content-Type", "text/plain")
    c.Status(code)
    c.Write([]byte(fmt.Sprintf(message, v...)))
}

func (c *Context) JSON(code int, obj interface{}) {
    c.SetHeader("Content-Type", "application/json")
    c.Status(code)
    data,err:= json.Marshal(obj)
    if err!=nil {
        http.Error(c.Writer, err.Error(), 500)
    }
    c.Write(data)
}

func (c *Context) HTML(code int,html string){
    c.SetHeader("Content-Type", "text/html")
    c.Status(code)
    c.Write([]byte(html))
}
  • 修改ebb.go
package ebb

import (
    "net/http"
)

//重新定义框架请求处理方法
type HandlerFunc func(*Context)

//核心结构体
type Engine struct{
    router *router 
}

//实例化结构体
func New() *Engine{
    engine := &Engine{
        router : newRouter(),
    }
    return engine
}

//添加到结构体路由
func (engine *Engine) addRoute(mothod string,pattern string,handler HandlerFunc){
    engine.router.addRoute(mothod,pattern,handler)
}

func (engine *Engine) GET(pattern string,handler HandlerFunc){
    engine.addRoute("GET",pattern,handler)
}

func (engine *Engine) POST(pattern string,handler HandlerFunc){
    engine.addRoute("POST",pattern,handler)
}

//启动服务
func (engine *Engine) Run(addr string) (err error){
    return http.ListenAndServe(addr,engine)
}

//engine 实现ServeHTTP接口（所有的请求都会走到这）
//查找是否路由映射表存在，如果存在则调用，否则返回404
func (engine *Engine) ServeHTTP(w http.ResponseWriter,req *http.Request){
    c := newContext(w, req)
    engine.handleHTTPRequest(c)
}

//v2 新增
func (engine *Engine) handleHTTPRequest(c *Context){
    key := c.Method + "-" + c.Path
    if handler, ok := engine.router.handlers[key]; ok {
        handler(c)
    } else {
        c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
    }
}

入口文件应用

package main

import (
    "ebb"
)


func main(){
    r := ebb.New()

    r.GET("/", func(c *ebb.Context) {
        c.HTML(200, "<h1>Hello ebb</h1>")
    })
    r.GET("/hello", func(c *ebb.Context) {
        c.String(200, "hello %s, you from %s\n", c.Query("name"), c.Path)
    })

    r.POST("/login", func(c *ebb.Context) {
        c.JSON(200, ebb.H{
            "name": c.PostForm("name"),
        })
    })


    r.Run(":8080")
}

动态路由设计

简单说下本章的重点

1、Trie 前缀树实现

package ebb

import (
    //"fmt"
    "strings"
)

type node struct {
    pattern  string // 待匹配路由，例如 /p/:lang
    part     string // 路由中的一部分，例如 :lang
    children []*node // 子节点，例如 [doc, tutorial, intro]
    isWild   bool // 是否精确匹配，part 含有 : 或 * 时为true
}

func (n *node) matchChild(part string) *node {
    for _, child := range n.children {
        if child.part == part || child.isWild {
            return child
        }
    }
    return nil
}
// 所有匹配成功的节点，用于查找
func (n *node) matchChildren(part string) []*node {
    nodes := make([]*node, 0)
    for _, child := range n.children {
        if child.part == part || child.isWild {
            nodes = append(nodes, child)
        }
    }
    return nodes
}

func parsePattern(pattern string) []string {
    vs := strings.Split(pattern, "/")
    parts := make([]string, 0)
    for _, item := range vs {
        if item != "" {
            parts = append(parts, item)
            if item[0] == '*' {
                break
            }
        }
    }

    return parts
}


func (n *node) insert(pattern string, parts []string, height int) {
    if len(parts) == height {
        n.pattern = pattern
        return
    }

    part := parts[height]
    child := n.matchChild(part)
    if child == nil {
        child = &node{part: part, isWild: part[0] == ':' || part[0] == '*'}
        n.children = append(n.children, child)
    }
    child.insert(pattern, parts, height+1)
}

func (n *node) search(parts []string, height int) *node {
    if len(parts) == height || strings.HasPrefix(n.part, "*") {
        if n.pattern == "" {
            return nil

        }
        return n
    }

    part := parts[height]
    children := n.matchChildren(part)

    for _, child := range children {
        result := child.search(parts, height+1)
        if result != nil {
            return result
        }
    }

    return nil
}

2、优化路由类

package ebb

import (
    "strings"
)

type router struct{
    roots map[string]*node
    handlers map[string]HandlerFunc
}

func newRouter() *router{
    return &router{
        roots:make(map[string]*node),
        handlers:make(map[string]HandlerFunc),
    }
}

func (r *router) addRoute(method string,pattern string,handler HandlerFunc){
    parts := parsePattern(pattern)
    key := method + "-" + pattern
    _, ok := r.roots[method]
    if !ok {
        r.roots[method] = &node{}
    }
    r.roots[method].insert(pattern, parts, 0)
    r.handlers[key] = handler
}

func (r *router) getRoute(method string, pattern string) (*node, map[string]interface{}) {
    searchParts := parsePattern(pattern)
    params := make(map[string]interface{})
    root, ok := r.roots[method]

    if !ok {
        return nil, nil
    }

    n := root.search(searchParts, 0)

    if n != nil {
        parts := parsePattern(n.pattern)
        for index, part := range parts {
            if part[0] == ':' {
                params[part[1:]] = searchParts[index]
            }
            if part[0] == '*' && len(part) > 1 {
                params[part[1:]] = strings.Join(searchParts[index:], "/")
                break
            }
        }
        return n, params
    }

    return nil, nil
}

3、优化核心ebb的handleHTTPRequest

func (engine *Engine) handleHTTPRequest(c *Context){
    node,params := engine.router.getRoute(c.Method,c.Path)
    if node != nil {
        c.Params = params //将params的值存储到Context
        key := c.Method + "-" + node.pattern
        //调用实际的方法
        engine.router.handlers[key](c)
    }else{
        c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
    }
}

4、优化Context将动态参数存储以及获取

package ebb


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

type H map[string]interface{}

type Context struct{
    //write and request
    Writer http.ResponseWriter
    Request *http.Request
    //request info
    Method string
    Path string
    Params map[string]interface{}
}


func newContext(w http.ResponseWriter,r *http.Request) *Context{
    context := &Context{
        Writer:w,
        Request:r,
        Path:   r.URL.Path,
        Method: r.Method,
        Params: make(map[string]interface{}),
    }

    return context
} 

func (c *Context) Param(key string) string{
    value, _ := c.Params[key].(string)
    return value
}

func (c *Context) PostForm(key string) string {
    return c.Request.FormValue(key)
}

func (c *Context) Query(key string) string {
    return c.Request.URL.Query().Get(key)
}

func (c *Context) Status(code int) {
    c.Writer.WriteHeader(code)
}

func (c *Context) SetHeader(key string, value string) {
    if value == "" {
        c.Writer.Header().Del(key)
        return
    }
    c.Writer.Header().Set(key, value)
}

func (c *Context) GetHeader(key string) string{
    return c.Request.Header.Get(key)
}

func (c *Context) Write(data []byte){
    c.Writer.Write(data)
}


func (c *Context) String(code int,message string,v ...interface{}){
    c.SetHeader("Content-Type", "text/plain")
    c.Status(code)
    c.Write([]byte(fmt.Sprintf(message, v...)))
}

func (c *Context) JSON(code int, obj interface{}) {
    c.SetHeader("Content-Type", "application/json")
    c.Status(code)
    data,err:= json.Marshal(obj)
    if err!=nil {
        http.Error(c.Writer, err.Error(), 500)
    }
    c.Write(data)
}

func (c *Context) HTML(code int,html string){
    c.SetHeader("Content-Type", "text/html")
    c.Status(code)
    c.Write([]byte(html))
}

5、编写单元测试

package ebb

import (
    "net/http/httptest"
    "testing"
)


func PerformRequest(mothod string,url string ,body io.Reader,e *Engine) (w *httptest.ResponseRecorder){
    w = httptest.NewRecorder()
    r := httptest.NewRequest(mothod, url, body)
    r.Header.Set("Content-Type", "application/json")
    e.ServeHTTP(w,r)
    return w
}

package ebb


import (
    "testing"
    "bytes"
    "encoding/json"
    "github.com/stretchr/testify/assert"
)

func TestGetRoute(t *testing.T) {
    r := newRouter()
    r.addRoute("GET", "/", nil)
    r.addRoute("GET", "/hello/:name", nil)
    r.addRoute("GET", "/hello/b/c", nil)
    n, params := r.getRoute("GET", "/index/baibai")

    if assert.NotNil(t, n,"404 not found ") {
        assert.Equal(t,n.pattern,"/hello/:name","should match /hello/:name")
        assert.Equal(t,params["name"],"baibai","name should be equel to 'baibai'")
    }

}
func TestParsePattern(t *testing.T) {
    assert.Equal(t,parsePattern("/p/:name"),[]string{"p",":name"},"not parsePattern :name")
    assert.Equal(t,parsePattern("/p/*"),[]string{"p","*"},"not parsePattern *")
    assert.Equal(t,parsePattern("/p/*name/*"),[]string{"p","*name"},"parsePattern not truncation")
}
func TestRouter(t *testing.T){
    r := New()

    r.POST("/login/*filepath", func(c *Context) {
        c.JSON(200, H{
            "name": c.PostForm("name"),
        })
    })

    param := `{"name":"56789","state":3}`

    w := PerformRequest("POST","/login/123213?name=1233",bytes.NewBufferString(param),r)

    s := struct{
        Name string `json:"name"`
    }{}
    json.Unmarshal([]byte(w.Body.String()),&s)
    assert.Equal(t,s.Name,"1233","PostForm error")
}

6、在本章节我们主要优化了路由，并支持动态参数

接下来我们会陆续实现路由的分组、中间件等等

路由分组

简单说下本章的重点

1、路由分组的概念

如果没有路由分组，我们需要针对每一个路由进行控制。但是真实的业务场景中，往往某一组路由需要相似的处理，大部分的分组是由前缀来区分的、并且可以支持分组的嵌套

2、定义路由分组

package ebb

type RouterGroup struct {
    prefix      string
    middlewares []HandlerFunc // support middleware
    parent      *RouterGroup  // support nesting
    engine      *Engine       // all groups share a Engine instance
}

func (group *RouterGroup) Group(prefix string) *RouterGroup {
    engine := group.engine
    newGroup := &RouterGroup{
        prefix: group.prefix + prefix,//支持分组嵌套
        parent: group,
        engine: engine,
    }
    engine.groups = append(engine.groups, newGroup)
    return newGroup
}

func (group *RouterGroup) addRoute(method string, comp string, handler HandlerFunc) {
    pattern := group.prefix + comp
    group.engine.router.addRoute(method, pattern, handler)
}

// GET defines the method to add GET request
func (group *RouterGroup) GET(pattern string, handler HandlerFunc) {
    group.addRoute("GET", pattern, handler)
}

// POST defines the method to add POST request
func (group *RouterGroup) POST(pattern string, handler HandlerFunc) {
    group.addRoute("POST", pattern, handler)
}

2、优化engine结构

//核心结构体
type Engine struct{
    *RouterGroup //v4新增  顶级路由组
    router *router 
    groups []*RouterGroup // v4新增
}

//实例化结构体
func New() *Engine{
    engine := &Engine{
        router : newRouter(),
    }
    engine.RouterGroup = &RouterGroup{engine: engine}
    engine.groups = []*RouterGroup{engine.RouterGroup}
    return engine
}

3、单元测试

package ebb


import (
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestRouteGroup(t *testing.T) {
    r := New()
    v2 := r.Group("/v2")
    {
        v2.GET("/hello/:name", func(c *Context) {
            // expect /hello/ebbktutu
            c.String(200, "hello %s, you're at %s\n", c.Param("name"), c.Path)
        })
        v2.POST("/login", func(c *Context) {
            c.JSON(200, H{
                "username": c.PostForm("username"),
                "password": c.PostForm("password"),
            })
        })

    }
    n, params := r.router.getRoute("GET", "v2/hello/baibai")
    if assert.NotNil(t, n,"404 not found ") {
        assert.Equal(t,n.pattern,"/v2/hello/:name","should match /hello/:name")
        assert.Equal(t,params["name"],"baibai","name should be equel to 'baibai'")
    }

}

4、分组使用案例

package main

import (
    "ebb"
)


func main(){
    r := ebb.New()

    r.GET("/index", func(c *ebb.Context) {
        c.HTML(200, "<h1>Index Page</h1>")
    })
    v1 := r.Group("/v1")
    {
        v1.GET("/", func(c *ebb.Context) {
            c.HTML(200, "<h1>Hello ebb</h1>")
        })

        v1.GET("/hello", func(c *ebb.Context) {
            c.String(200, "hello %s, you're at %s\n", c.Query("name"), c.Path)
        })
    }
    v2 := r.Group("/v2")
    {
        v2.GET("/hello/:name", func(c *ebb.Context) {
            // expect /hello/ebbktutu
            c.String(200, "hello %s, you're at %s\n", c.Param("name"), c.Path)
        })
        v2.POST("/login", func(c *ebb.Context) {
            c.JSON(200, ebb.H{
                "username": c.PostForm("username"),
                "password": c.PostForm("password"),
            })
        })

    }    
    r.Run(":8080")
}

5、本章节我们实现了路由分组（路由加前缀）

接下来到了重头戏，中间件的实现以及具体案例

路由支持中间件

简单说下本章的重点

1、重点

  • 中间件的目的是为了让web框架灵活支持用户某些自定义行为，对外开放一个接口
  • 核心的点在什么时候插入、以及中间件传入的支持参数

2、思路

  • 1、作用于每一条路由规则
  • 2、作用于Context、依次执行该路由说匹配的中间件
  • 3、中间件也和控制器层一样传入Context、接入点是框架接收到请求初始化Context对象后，允许用户使用自己定义的中间件做一些额外的处理、另外通过调用(*Context).Next()函数，中间件可等待用户自己定义的 Handler处理结束后，再做一些额外的操作

3、Context支持

package ebb


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


type Context struct{
    //write and request
    Writer http.ResponseWriter
    Request *http.Request
    //request info
    Method string
    Path string
    Params map[string]interface{}
    HttpCode int
    //middleware  新增
    handlers HandlersChain
    index    int
}


func newContext(w http.ResponseWriter,r *http.Request) *Context{
    context := &Context{
        Writer:w,
        Request:r,
        Path:   r.URL.Path,
        Method: r.Method,
        Params: make(map[string]interface{}),
        index:  -1,
    }

    return context
} 

//本次新增
func (c *Context) Next() {
    c.index++
    for c.index < len(c.handlers) {
        c.handlers[c.index](c)
        c.index++
    }
}

4、routerGroup支持

package ebb

type HandlersChain []HandlerFunc //新增

type RouterGroup struct {
    prefix      string
    middlewares HandlersChain // support middleware
    parent      *RouterGroup  // support nesting
    engine      *Engine       // all groups share a Engine instance
}

func (group *RouterGroup) Group(prefix string) *RouterGroup {
    engine := group.engine
    newGroup := &RouterGroup{
        prefix: group.prefix + prefix,//支持分组嵌套
        parent: group,
        engine: engine,
    }
    engine.groups = append(engine.groups, newGroup)
    return newGroup
}

//添加中间件 v5新增
func (group *RouterGroup) Use(middlewares ...HandlerFunc){
    group.middlewares = append(group.middlewares, middlewares...)
}

//合并handlers
func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
    finalSize := len(group.middlewares) + len(handlers)
    mergedHandlers := make(HandlersChain, finalSize)
    copy(mergedHandlers, group.middlewares)
    copy(mergedHandlers[len(group.middlewares):], handlers)
    return mergedHandlers
}

func (group *RouterGroup) addRoute(method string, comp string, handler ...HandlerFunc) {
    pattern := group.prefix + comp
        //添加的路由的时候将中间件合并到 路由handles
    handlers := group.combineHandlers(handler)
    group.engine.router.addRoute(method, pattern, handlers)
}

// GET defines the method to add GET request
func (group *RouterGroup) GET(pattern string, handler ...HandlerFunc) {
    group.addRoute("GET", pattern, handler...)
}

// POST defines the method to add POST request
func (group *RouterGroup) POST(pattern string, handler ...HandlerFunc) {
    group.addRoute("POST", pattern, handler...)
}

5、路由支持

package ebb


import (
    "strings"
)

type router struct{
    roots map[string]*node
    handlers map[string]HandlersChain  //新增
}

func newRouter() *router{
    return &router{
        roots:make(map[string]*node),
        handlers:make(map[string]HandlersChain),
    }
}

func (r *router) addRoute(method string,pattern string,handlers HandlersChain){
    parts := parsePattern(pattern)
    key := method + "-" + pattern
    _, ok := r.roots[method]
    if !ok {
        r.roots[method] = &node{}
    }
    r.roots[method].insert(pattern, parts, 0)
    r.handlers[key] = append(r.handlers[key],handlers...) //合并中间件和handlers
}

6、ebb支持

package ebb

import (
    "net/http"
)

//定义框架请求处理方法
type HandlerFunc func(*Context)

//核心结构体
type Engine struct{
    *RouterGroup //v4新增  顶级路由组
    router *router 
    groups []*RouterGroup // v4新增
}

//实例化结构体
func New() *Engine{
    engine := &Engine{
        router : newRouter(),
    }
    engine.RouterGroup = &RouterGroup{engine: engine}
    engine.groups = []*RouterGroup{engine.RouterGroup}
    return engine
}

//新增
func Default() *Engine{
    engine := New()
    engine.Use(Logger(),Recovery())
    return engine
}

//启动服务
func (engine *Engine) Run(addr string) (err error){
    return http.ListenAndServe(addr,engine)
}

//engine 实现ServeHTTP接口（所有的请求都会走到这）
//查找是否路由映射表存在，如果存在则调用，否则返回404
func (engine *Engine) ServeHTTP(w http.ResponseWriter,req *http.Request){
    c := newContext(w, req)
    engine.handleHTTPRequest(c)
}

//v2 新增
func (engine *Engine) handleHTTPRequest(c *Context){
    node,params := engine.router.getRoute(c.Method,c.Path)
    if node != nil {
        c.Params = params
        key := c.Method + "-" + node.pattern
        //赋值
        c.handlers = engine.router.handlers[key]
    }else{
        c.handlers = append(c.handlers, func(c *Context) {
            c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
        })
    }
        //真正调度执行中间件以及具体handler
    c.Next()
}

7、新增logger中间件

package ebb

import (
    "time"
    "log"
)

func Logger() HandlerFunc {
    return func(c *Context) {
        // Start timer
        t := time.Now()
        // Process request
        c.Next()
        // Calculate resolution time
        log.Printf("[%d] %s in %v", c.HttpCode, c.Request.RequestURI, time.Since(t))
    }
}

8、新增错误异常中间件

package ebb


import (
    "fmt"
    "log"
    "net/http"
    "runtime"
    "strings"
)

// print stack trace for debug
func trace(message string) string {
    var pcs [32]uintptr
    n := runtime.Callers(3, pcs[:]) // skip first 3 caller

    var str strings.Builder
    str.WriteString(message + "\nTraceback:")
    for _, pc := range pcs[:n] {
        fn := runtime.FuncForPC(pc)
        file, line := fn.FileLine(pc)
        str.WriteString(fmt.Sprintf("\n\t%s:%d", file, line))
    }
    return str.String()
}

func Recovery() HandlerFunc {
    return func(c *Context) {
        defer func() {
            if err := recover(); err != nil {
                message := fmt.Sprintf("%s", err)
                log.Printf("%s\n\n", trace(message))
                c.JSON(http.StatusInternalServerError, "Internal Server Error")
            }
        }()
        c.Next()
    }
}

9、使用案例

package main

import (
    "ebb"
)


func main(){
    r := ebb.Default()
    r.GET("/panic",func(c *ebb.Context) {
        panic("err")
    })

    r.POST("/login/*name",func(c *ebb.Context) {
        c.JSON(200, ebb.H{
            "name": c.Param("name"),
        })
    })
    r.Run(":8080")
}

到目前为止，框架的基本架构已确立，后续就是一些补充性的功能，以及优化点 看起来是不是和gin框架非常类似 下一章节我们实现对go模板的使用封装

模板处理

简单说下本章的重点

1、支持静态服务器

func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
    absolutePath := joinPaths(group.prefix, relativePath)
    fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
    return func(c *Context) {
        file := c.Param("filepath")
        // Check if file exists and/or if we have permission to access it
        f, err := fs.Open(file);
        defer f.Close()
        if  err != nil {
            c.Status(http.StatusNotFound)
            return
        }
        fileServer.ServeHTTP(c.Writer, c.Request)
    }
}

// serve static files
func (group *RouterGroup) Static(relativePath string, root string) {
    handler := group.createStaticHandler(relativePath, http.Dir(root))
    urlPattern := joinPaths(relativePath, "/*filepath")
    // Register GET handlers
    group.GET(urlPattern, handler)
}


func joinPaths(absolutePath, relativePath string) string {
    if relativePath == "" {
        return absolutePath
    }
    finalPath := path.Join(absolutePath, relativePath)
    return finalPath
}

2、单元测试

func TestStaticFile(t *testing.T){
    r := Default()
    r.Static("/assets", "./")
    w := PerformRequest("GET","/assets/go.mod",bytes.NewBufferString(""),r)
    fmt.Printf(w.Body.String())
}

3、模板渲染

type Engine struct{
    *RouterGroup //v4新增  顶级路由组
    router *router 
    groups []*RouterGroup // v4新增
    //html/template
    HTMLRender  *template.Template
    HTMLdelimsLeft string
    HTMLdelimsRight string
    funcMap     template.FuncMap
}

func (engine *Engine) SetFuncMap(funcName string,f interface{}) {
    funcMap := template.FuncMap{
        funcName: f,
    }
    engine.funcMap = funcMap
}

func (engine *Engine) LoadHTMLGlob(pattern string) {
    engine.HTMLdelimsLeft = "{"
    engine.HTMLdelimsRight= "}"
    engine.HTMLRender = template.Must(template.New("").Delims(engine.HTMLdelimsLeft,engine.HTMLdelimsRight).Funcs(engine.funcMap).ParseGlob(pattern))
}

func (engine *Engine) ServeHTTP(w http.ResponseWriter,req *http.Request){
    c := newContext(w, req)
    c.engine = engine //新增
    engine.handleHTTPRequest(c)
}

4、改造Context HTML方法

func (c *Context) HTML(code int,TmpName string,data interface{}){
    c.SetHeader("Content-Type", "text/html")
    c.Status(code)
    if err := c.engine.HTMLRender.ExecuteTemplate(c.Writer, TmpName, data); err != nil {
        c.JSON(500, err.Error())
    }
}

5、demo

package main

import (
    "ebb"
    "time"
    "fmt"
)

type student struct {
    Name string
    Age  int8
}

func FormatDate(t time.Time) string {
    year, month, day := t.Date()
    Hour,Minute,Second := t.Hour(),t.Minute(),t.Second()
    return fmt.Sprintf("%d-%02d-%02d %d:%d:%d", year, month, day,Hour,Minute,Second)
}

func main(){
    r := ebb.Default()
    r.GET("/panic",func(c *ebb.Context) {
        panic("err")
    })

    r.POST("/login/*name",func(c *ebb.Context) {
        c.JSON(200, ebb.H{
            "name": c.Param("name"),
        })
    })
    r.Static("/assets", "./static")
    r.SetFuncMap("formatDate",FormatDate)
    r.LoadHTMLGlob("templates/*")
    stu1 := &student{Name: "Geektutu", Age: 20}
    stu2 := &student{Name: "Jack", Age: 22}

    r.GET("/students", func(c *ebb.Context) {
        c.HTML(200, "students.tmpl", ebb.H{
            "title":  "ebb  students",
            "now":   time.Now(),
            "stuArr": [2]*student{stu1, stu2},
        })
    })
    r.Run(":8080")
}

<html>
<body>
    <p>hello, {.title}</p>
    <p>now : {.now |formatDate}</p>
    {range $index, $ele := .stuArr }
    <p>{ $index }: { $ele.Name } is { $ele.Age } years old</p>
    { end }
</body>
</html>

自此带着大家搭建gin已经完结，希望大家有所收获，不白看，多动手

来源：https://studygolang.com/user/18211167516/articles

评论

发表评论

此博客中的热门博文

Base：一种Acid的替代方案

发布于
本文是Ebay的架构师在2008年发表给ACM的文章,是一篇解释BASE原则,或者说最终一致性的经典文章. 文中Dan讨论了BASE与ACID原则的基本差异, 以及如何设计大型网站以满足不断增长的可伸缩性需求,期间如何对业务做调整与折衷. 以及一些具体的折衷技术的介绍. 在数据库分区中，以一致性换取可用性会显著提高系统伸缩性。 在过去的十年里，网络应用越来越普及。不管你正在为终端用户还是应用程序开发人员构建应用程序(即服务)，您都希望您的应用程序得到广泛的采用，而广泛采用将会带来交易增长。如果您的应用程序依赖于持久化，那么数据存储可能会成为您的瓶颈。 有两种方法可用于扩展任何应用程序。第一个，也是最简单的，是垂直扩展:将应用程序移动到更大的计算机上。垂直扩展不影响数据的合理性，但是有几个限制。最明显的限制是超过系统的最大可用容量。垂直扩展也很昂贵，因为增加交易容量通常需要购买下一个更大的系统。垂直扩展通常会带来供应商依赖，从而进一步增加成本 水平扩展提供了更多的灵活性，但也相当复杂。水平数据扩展可以沿着两个维度进行。功能扩展，包括按功能分组数据，还有将不同的功能组分布到不同数据库。第二个维度是在功能区域内分割数据，分布到不同数据库，这也叫分片。图1说明了横向数据扩展策略。 如图1所示，水平扩展的两种方法都可以同时应用。用户、产品和事务可以在不同的数据库中。此外，每个功能区域都可以根据交易量跨多个数据库分割。如图所示，功能区域可以相互独立扩展。 功能分区 功能分区对于获得高的可伸缩性非常重要。任何优秀的数据库架构都会将schema分解为按功能分组的表。用户、产品、交易和通信都是功能的例子。利用诸如外键之类的数据库概念是保持这些功能区域一致性的常见方法。 依赖于数据库约束来确保跨功能组的一致性，会导致数据库在部署策略上的高耦合。为了使约束生效，表必须驻留在单个数据库服务器上，从而不能在交易数量增长时水平伸缩。在许多情况下，最简单的扩展方案是将功能组数据移动到相互独立数据库服务器上。 当交易量非常高的时候，不同的功能数据将在不同的数据库服务器。这需要将数据约束从数据库移出并在应用程序解决。这就带来了本文后面将讨论的几个挑战。 CAP原理 加州大学伯克利分校(University of California, Berkeley)教授、Ink...
阅读全文

Mifare Classic card(M1卡)破解过程记录(准备+理论+获取扇区密钥+数据分析)

发布于
首先认识一下一卡通的类型，市面上常见的一卡通是IC卡的一种，IC卡即集成电路卡，也是广义上的智能卡，准备篇介绍一些智能卡的基础知识，帮助我们确定卡的类型和使用的设备， 目前淘宝上提供了设备和全套软件，确定好方法就可以自动化破解，下面的内容比较详细，不用全部看完也能破解，但了解一下可以提高效率 。 按照使用方式分类： · 接触式IC卡： 符合 ISO 7816 标准，卡片表面包含金属触点，读写需要 IO 线路接触，即需要插卡使用，如手机的 SIM 卡模块 · 非接触式IC卡： 符合 ISO/IEC 14443 标准，由 IC 芯片、感应天线组成，封装在一个标准的 PVC 卡片内，芯片及天线无任何外露 部分，通过 RFID 感应使用，校园卡及身份证都是这一类型。 · 双界面卡IC： 又称组合卡 / 双端口 卡，是 同时兼备接触和非接触两种界面通信的多功能卡 ，将非接触 IC 卡的方便性和接触 IC 卡的安全性融为一体，使之成为一卡多用的极佳载体，代表着未来 IC 卡的主要发展方向，银行卡就是这一类型。 需要注意的是我们平时见到的某些门禁卡虽然也是通过感应使用，但不一定是IC卡，现在有相当一部分便宜的门禁使用的是磁卡和ID卡，ID卡使用RFID射频技术，但其频率一般较低，一般为125KHz,如爱特梅尔的T5577卡，不可写入用户数据，其记录内容仅限卡号只可由芯片厂一次性写入，开发商只可读出卡号加以利用，所以只用于身份识别，不能用于消费，其成本相对非接触式IC卡较低，一般使用字典攻击的方式就能复制。 智能卡按照工作频率分类： 区分ID卡和IC卡——读卡判断法 读卡判断法是判断卡智能卡类型最准确的方法，这需要可识别多类型卡的设备支持，例如手机NFC或者pn532开发板、ACR122U读卡器以及Proxmark3。使用手机NFC是最为便捷的方法，在支持全功能NFC的手机上下载MIFARE Classic Tools，给予权限后将卡片贴在NFC感应区根据提示读取标签后查看标签信息。下面是两种不同容量的IC卡的显示，如果RF技术这栏显示ISO/IEC 14443，说明就是典型的13.56MHz的非接触式IC卡，这也是生活中使用最多的类型。             ...
阅读全文

如何优雅的关闭容器

发布于
最近把 Docker 官方的 Docker Reference 文档又读了一遍，发现有些细节深究起来，还是有很多可挖的。针对写 Dockerfile ，大部分时候只要照葫芦画瓢，基本也不会有什么大的问题，但是如果再深入理解一下那就更有意思了。 要说如何优雅的关闭容器，那就不得不提到信号（Signal）的理念，以及 Dockerfile 中 ENTRYPOINT 和 CMD 指令了。在具体说优雅关闭之前，先了解一下信号这个 Linux 中的基础概念。 1 信号 信号是事件发生时对进程的通知机制，有时也称之为软件中断。 信号有不同的类型，Linux 对标准信号的编号为 1~31，可以通过 kill -l 获取信号名称： # kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM ... ... 实际列出的信号超过了 31 个，有些是其它名称的同义词，有些则是定义但未使用的。以下介绍几个常用的信号： 1) SIGHUP 当终端断开（挂机）时，将发送该信号给终端控制进程。 SIGHUP 信号还可用于守护进程（比如，init 等）。许多守护进程会在收到 SIGHUP 信号时重新进行初始化并重读配置文件。 2) SIGINT 当用户键入终端中断字符（通常为 Control-C ） 时，终端驱动程序将发送该信号给前台进程组。该信号的默认行为是终止进程。 3) SIGQUIT 当用户在键盘上键入退出字符（通常为 Control-\ ）时，该信号将发往前台进程组。默认情况下，该信号终止进程，并生成用于调试的核心转储文件。进程如果陷入无限循环，或者不再响应时，使用 SIGQUIT 信号就很合适。 9) SIGKILL 此信号为 "必杀（sure kill）" 信号，处理器程序无...
阅读全文

为什么要建模；怎么建模才合理；“领域”模型具体指什么?（DDD）

发布于
要回答这个问题，需要三步走：为什么要建模；怎么建模才合理；“领域”模型具体指什么。 为什么要建模 客户在专卖店买了个手机，留下了自己的名字和电话，店员做了记录。客人来时，只要店员能在记录里查到客人名字和电话的订单，就说明客人曾经买过手机。 什么人需要查看订单呢？店员 A 需要查看，店员 B 也需要查看。客人来咨询的时候，应该能随时调取。老板也需要查看，用来汇总销售情况。大家都要看，格式就必须统一，要不然有的只记了电话，有的只记了名字，有的什么都没记，就乱套了。 大家商量之后决定：订单必须包括客户名字、电话和购买的商品。那么就有“订单 = 名字 + 电话 + 商品信息”。这是店员和老板的 心智模型 （ mental model ）。 要用一个数字系统来支持订单的管理，必须形成对应的 数据模型 （data model），称之为 数据建模 （data modeling），中文简称 建模 。电脑采用数字化的精确储存，所以数据的格式必须提前明确，比如名字是 2-4 个 中文字符 ，电话是 11 位数字等等。 建模本质上是一种抽象。抽象就是归类，其目的是减轻认知的负担，避免重复的思考和工作，提升人的计算能力。所以，“通用”是建模的第一步，接下来我们还需要“复用”建好的模型。 假设手机卖出之后，客户需要维修服务。 客户来到店里，询问店员，店员查询确认了订单，然后把客人引到门店旁边的维修中心。维修中心的工程师拿到订单，发现手机已经过了保修期，所以他写了一个维修单，把客户的名字、电话、手机信息、维修费用写到上面。客户交了费，拿到修好的手机，走了。 这引出一个问题。维修中心需要的客户信息，其实在店员那边有，没有必要自己再抄一遍，否则很容易出错，还会遇到信息同步的问题。那么，我们就需要再做一次建模，把客户的名字和电话从订单模型中拿出来，单独做一个 客户模型 。订单和维修单都复用这个客户模型。 这样，我们就得到了如下三个模型。 订单 = 客户 + 商品信息 维修单 = 客户 + 商品信息 + 维修信息 客户 = 名字 + 电话 这里，维修单模型里面似乎包含了一个完整的订单（客户 + 商品信息），为什么不直接复用订单呢？也许是因为维修部门也负责别的地方购买的商品。另外，客户的名字和电话更新之后，是不是要直接修改已经完成的订单和维修单呢？值得商榷，已经完成的信息不应该有意料之外的变化。还有，如...
阅读全文

小程序框架全面测评

发布于
最近前端届多端框架频出，相信很多有代码多端运行需求的开发者都会产生一些疑惑：这些框架都有什么优缺点？到底应该用哪个？ 作为 Taro 开发团队一员，笔者想在本文尽量站在一个客观公正的角度去评价各个框架的选型和优劣。但宥于利益相关，本文的观点很可能是带有偏向性的，大家可以带着批判的眼光去看待，权当抛砖引玉。 那么，当我们在讨论多端框架时，我们在谈论什么： 多端 笔者以为，现在流行的多端框架可以大致分为三类： 1. 全包型 这类框架最大的特点就是从底层的渲染引擎、布局引擎，到中层的 DSL，再到上层的框架全部由自己开发，代表框架是 Qt 和 Flutter。这类框架优点非常明显：性能（的上限）高；各平台渲染结果一致。缺点也非常明显：需要完全重新学习 DSL（QML/Dart），以及难以适配中国特色的端：小程序。 这类框架是最原始也是最纯正的的多端开发框架，由于底层到上层每个环节都掌握在自己手里，也能最大可能地去保证开发和跨端体验一致。但它们的框架研发成本巨大，渲染引擎、布局引擎、DSL、上层框架每个部分都需要大量人力开发维护。 2. Web 技术型 这类框架把 Web 技术（JavaScript，CSS）带到移动开发中，自研布局引擎处理 CSS，使用 JavaScript 写业务逻辑，使用流行的前端框架作为 DSL，各端分别使用各自的原生组件渲染。代表框架是 React Native 和 Weex，这样做的优点有： 开发迅速 复用前端生态 易于学习上手，不管前端后端移动端，多多少少都会一点 JS、CSS 缺点有： 交互复杂时难以写出高性能的代码，这类框架的设计就必然导致 JS 和 Native 之间需要通信，类似于手势操作这样频繁地触发通信就很可能使得 UI 无法在 16ms 内及时绘制。React Native 有一些声明式的组件可以避免这个问题，但声明式的写法很难满足复杂交互的需求。 由于没有渲染引擎，使用各端的原生组件渲染，相同代码渲染的一致性没有第一种高。 3. JavaScript 编译型 这类框架就是我们这篇文章的主角们： Taro 、 WePY 、 uni-app 、 mpvue 、 chameleon ，它们的原理也都大同小异：先以 JavaScript 作为基础选定一个 DSL 框架...
阅读全文

打造一个可国内访问的Blogger（Blogspot）方法

发布于
  Blog‍‌‍‌​‌‌‌‌​‌​‍‌​‍‌‍‍​‌‌‍‌​‌‍​‍‌​​‍‌‌‌​‌‍‌‌​‍‍‍​‍‍‌​​‍‌‍‌​‍‌‍‍​‌‌‍‌​‌‍​‍‌​​‍​‍‍‍​‌‍‍‌ger,一个干爽、免费的博客发布平台，作为主流的发布，提供免费的托管，免去了Typecho&Wordpress高昂的服务器费用，避免了Hexo&Jekyll静态博客无后台的缺陷，与CSDN、简书相比，可以绑定域名，界面干净，无广告【当然可以自己放自己的广告】。 实际上，当今写博客的软件数不胜数，主要分为一下三类： 服务器部署：典型代表：Wordpress\Typecho 无服务器托管：典型代表：Hexo\Jekyll\Gidea\Hugo\Hola等等 集成型网站：Blogger、简书、CSDN、cnblog、wodemo等等 上面所有软件，优缺点都有，具体看个人选择 当然，个人认为Typecho适合做个人博客，Hexo可以作为要求不高的人。集成性网站最主要的是只要安安心心写文章，不用管后端乱七八糟的代码。当然，最有问题的是大多数都不支持绑定域名，而且经常往网站上塞广告，自定义范围也不够。 接下来，我们扯扯集成博客中的一股清流：Blogger Blogger.com是由Pyra Labs公司创立，是目前全球用户数量最多的个人网志服务提供商。Pyra Labs和Blogger.com均被Google公司收购，成为其旗下的一项服务内容。 Blogger提供免费主机Blogspot.com存放博客，用户不必写任何代码或者安装服务器软件或脚本，通过所见即所得界面轻松地创建、发布、维护和修改自己的网志。 Blogger允许有经验的用户自行设计博客界面，其模板支持使用HTML和CSS进行编辑 实际上，由于Blogger托管于谷歌，写作域名  www.blogger.com  和托管域名  *.blogspot.com  均被MainLand所Ban。但是接下来来，我会讲讲如何打造一个能在国内大陆访问的Blogger 1. 注册Blogger 众所周知，请善用技术上网。 用谷歌账号登录 ( https://www.blogger.com ) ，没有？不是⑧不是吧不是扒，都0202年了，还不会去注册一个谷歌账号？ 进入控制台，新建一个博客： 绑...
阅读全文

自己制作蔬果汁方法与食谱

发布于
在城市生活的年轻人，应该有不少是靠外卖和速食解决一日三餐的，即便是出门吃饭，或者公司学校有食堂，大部分外食也都是重油重辣，碳水和肉食居多，猪扒盖饭、牛油火锅麻辣烫、回转寿司、小烧烤……太难吃到一份达到营养均衡标准的饭了。对营养有更多兴趣的朋友可以看一下中国营养协会2021年发布的 《中国居民膳食指南科学研究报告》 。 兼顾工作日快速的生活节奏和健康营养的饮食品质是我一直想要达到的平衡。 饮用蔬果汁的初衷 最开始想要自己制作蔬果汁的原因是感觉日常饮食不够健康，摄入的蔬菜种类少并且量也不多。工作日忙碌也来不及，在家做早餐通常会以碳水为主，面包、煎饼、饺子之类的，搭配一点水果，或者蔬菜沙拉，但要说完全做到荤素搭配，每天都能有足量的蔬菜摄入，确实有点难度。早上吃下一盘沙拉需要的时间，远比喝一杯蔬果汁要久，所以想到了蔬果汁作为解决方案。 随着慢慢尝试制作蔬果汁，对它在日常餐食中的认识也有了一些新的变化。 理想状态下，饮用蔬果汁可以增加食物摄入种类，通过几种食材搭配的方法，把平时因为种种原因不吃的食材添加进来，增加饮食的丰富度。平时不爱吃的苦瓜、胡萝卜，不容易在饮食中足量摄入的富含膳食纤维的食物，比如芹菜（西芹）等，都可以通过和其他食材搭配的方式，改善口感和味道，变成更容易入口的蔬果汁。 想要一餐吃点 100g 蔬菜有时候确实不太容易，但 100g 蔬菜融入蔬果汁，喝起来就会顺利很多。 当然在蔬果汁里增加一些饱腹类的坚果，或者水果比如香蕉、牛油果，也能帮助快速补充能量。由于蔬果汁制作快速，能在日常比较高效地达到均衡饮食的目的。快速打一杯蔬果汁，搭配早餐、午餐或者晚餐。 图片来源：Unsplash @freestocks 初识蔬果汁 蔬果汁比较标准的定义是蔬菜、水果、含有蛋白质的食材、含脂肪的食材以及富含其他风味进行调节的食材，按比较合理的比例随意组合，搅碎组合而成的饮品。但我也没有如此严格地按照什么都加的思路做，偶尔也有只包括其中一两种的情况，和家里食材的储存量有比较直接的关系??。但一般还是会尽量按照什么都吃一点的原则进行。 蔬果汁理论上不等同于果汁，单纯水果搭配组合榨取的果汁含糖量会比配合其他食材更高，不太建议经常饮用，尤其是健身减肥或者有健康隐患的人士。其次，因为水果偏甜的口感比蔬菜更容易入口，相信大部分人吃水果的量会远大于蔬菜，而蔬果汁是为了尽量弥补非水果类在日常饮食中...
阅读全文

设计师别担心，微软雅黑这样使用不侵权

发布于
这几天设计圈都被一条字体侵权消息刷屏，一公司在没有获得字体版权的情况下使用微软雅黑做印刷品，样稿印刷厂印了5000万张已经全国商用，公司损失2860万，裁员42人，含8个主管。 现在各位设计师都知道，微软雅黑版权是属于方正的，并不能免费使用！在大家惊叹赔偿金额的时候，方正官方出来辟谣： 这次事件，方正字体给我们间接地上了一课：想安全使用我们的字体？乖乖付费吧。同时还告诉那些没有买过版权的公司：该交保护费了。目前事件已在百度热点搜索排名第三，也让中国很多非设计行业人员了解了方正。 不过在大家都在聚焦新闻本身的时候，有没有想过，什么样的字体行为会受到侵权呢？ 在设计行业中，常见的微软雅黑字体侵权主要表现在线上的banner、广告、页面、电影等，线下的印刷品、户外广告、书籍等。各位设计师对这些都非常清楚：无版权，不可商用。 UI前端和微软雅黑 但是在UI设计这块，我们在电脑网页中显示的微软雅黑有版权吗？公司官网显示的文章字体都是微软雅黑，这样会侵权吗？我们再回顾下微软雅黑的历史。 “微软雅黑”字体是“北大方正电子有限公司”设计开发的字体作品。该字体与著名的“方正兰亭黑系列字体”（该系列字体共有十一个不同粗细版本，共十一款字体）系出同源，前者针对屏幕显示，后者针对印刷用。方正公司拥有“方正兰亭黑系列字体”的全部版权。但微软雅黑的版权分为两个部分，在Windows系统的内嵌使用，包括屏幕输出和个人使用为目的的打印，这部分微软已经向方正支付了版权授权费用，所有正版Windows用户均可放心使用。但是以商业发布为目的的微软雅黑版权，仍由北大方正保留。 微软公司在开发新一代操作系统时，为了改善屏幕字体的视觉效果，委托方正公司设计两款字体。微软公司将此两款字体命名为“微软雅黑”和“微软雅黑 Bold”。 这里我们可以看到一个关键词“屏幕输出”，即电脑屏幕上显示和我们关系最大。设计师设计完网页之后，前端需要进行代码制作，这时候使用的微软雅黑字体，其实就是属于屏幕输出。 如果要深入搞清楚这个，我们就要了解网页中是如何显示字体的。前端网页字体的定义主要有两种方式：font-family和@font-face。关于这些前端基础知识，各位UI设计师必须要了解下。 font-family font-family属于前端css属性中最基础...
阅读全文

一个没有任何底子的人怎么学唱歌？

发布于
首先教你一个不用任何复杂东西的练唱歌的方法，不用乐器、不用乐理、不用别人教的方法，只要你天天哼唱就好了。首先打开喉咙（不是嘴巴张很大，嘴唇微微闭着也没问题，舒适就好），然后保持口部咽东西的位置（下咽一口唾沫的地方）含了一大块糖的感觉（为了口腔内有空间），（发 欧 这个音就能得到空间）有一定空间。不让下巴紧张。然后哼唱你自己喜欢（不要歌词 就是跟着音调哼），但感觉不困难的歌曲，哼的时候。力度柔和，声音连续。没有气了，或者感觉气不足就自动换气。每天对着墙角练十几分钟（一开始近一些，闭着眼睛来，监听自己声音好听舒适），任何时候嗓子不舒服都要停止，起声也要柔和。一个月，你就会感觉唱歌容易了很多，稳定很多，用哼唱指导你唱歌，怎么哼着用力，就怎么唱。（ 之后想进阶再看分割线下面的文章。 ） 很多人说看不懂，那就降低难度了，详细的把哼唱写了一篇，您可以试试，这里是链接 【哼 唱】自我练声练唱的终极奥义! - Chester的文章 - 知乎 Chester：【哼 唱】自我练声练唱的终极奥义! ? zhuanlan.zhihu.com 有人提到打开 我把打开文章链接也附上吧 声乐老师说的“打开”是什么？我要清晰的通俗的解释！ - Chester的文章 - 知乎 Chester：声乐老师说的“打开”是什么？我要清晰的通俗的解释！ ? zhuanlan.zhihu.com 还可以关注下我的专栏（尽力做到通俗易懂） 通俗易懂的唱歌原理 ? zhuanlan.zhihu.com 没有稳定喉位，就没有高质量的高音。没有理解核心肌肉的对抗原理，声音就不容易控制和延长，音准也会不好。 （耐心看完你会发现新世界） 1 首先明确高音不是大力的喊 而是维持住 下部平衡对抗(发声时主力是不断的向下渐变用力) 然后去被动得到高位置共鸣 加到整体声音里（喉咙内部打开通畅） 2 懂了先找胸口发声位置 发声位置再向下找丹田气息支撑，然后让这个胸口发声位置向下找的力与腰腹的气息支持（被动用不要故意挤）相结合，让发声点与气息搭上（吸气是深吸气，不多吸，一口就够，目的下降横膈膜以及下放喉位，但胸部不动不憋。）你可以理解为先吸气，下降横膈膜给气息空间不要吸太多，下放喉位（非大力压喉），找到胸口发声位置，发声位置向下找后腰小腹的气息支持，根据不同音高渐变的持续垂直向下搭气息，稳喉头，不断的打开得到高位置共鸣（根据不同音...
阅读全文

开源数据库中间件的对比、选取和搭建

发布于
Proxy式架构和客户端式架构的优劣     Proxy式架构 客户端式架构 优点 1， 集中式管理监控和升级维护方便 2， 解决连接数问题 1.     应用直连数据库性能高 2.     无需中间层集群，没有额外成本开销 劣势 1， 需要中间层集群，有硬件成本开销 2， 多一跳(hop)有一定性能损失 3，中间层做数据合并，需要做隔离机制 1.     客户端和应用耦合，管理监控和升级维护麻烦 2.     不解决连接数问题   选择困难症时期： 在选取中间件的时候 我们会考虑社区的活跃度 版本的更新情况，维护成本，而这些综合比较起来我们初步定了 DBProxy，kingshard，mycat，其中DBProxy采用c，kingshard采用golang，mycat采用java，而考虑C的维护成本，我们暂时放下了（此处没有歧视C的意思，只是想说C太高深了），而kingshard是由个人组织开发的，mycat由一个团队维护，对于使用哪一种，暂时没有完全定一来。 我们从另一个方面来考虑一下，其实使用中间件的时候，大部分是已经到了不得不分表分库的情况下了（这是根据本人从业的公司情况，不一定都如此），那么要分表，我们来考虑中间件使用的情况，假设我们要查id从1到100范围的值，而我们现在分了16张表，那么其实我们要做的是select 每一张表，把符合id在1到100的查出来，再把数据组合到一起，返回给你，那么这里其实你需要查16张表，表的数量越多，你其实查的很多，从这个角度来看，哪一种更有优势呢？似乎是采用golang的kingshard，大家都知道golang具有良好的并发性能，语言非常简洁，对于维护人员上手也是比较快的，综合考虑一下，我们选择了kingshard。 安装： kingshard的安装，比较简单，我这里也是作者那里过来，但是对于不是很熟悉go的，又想马上看到kingshard的惊人效果来说，切记不要浮躁。 1. 安装Go语言环境（Go版本1.6以上），具体步骤请Goog...
阅读全文