前言

开始接触后端开发是从 nodejs 开始，最开始使用的框架是 express，后来陆续接触了其它的框架，觉得最熟悉的还是koa。使用 golang 做后端开发时，对比使用过 gin，echo 以及 iris 三个框架，它们的用法都类似（都支持中间件，中间件的处理也类似），但是在开发过程中还是钟情于 koa 的处理方式，失败则 throw error，成功则将响应数据赋值至 ctx.body，简单易懂。

概述

造一个新的轮子的时候，首先考虑的是满足自己的需求，弱水三千只取一瓢饮，对我来说，新轮子的满足我所需要的一瓢则是重中之重。

• 请求经过中间件的处理方式为由外至内，响应时再由内至外
• 所有的处理函数都一致（参数、类型等），每个处理函数都有可以是其它处理函数的前置中间件
• 请求处理成功时，直接赋值至 Body(interface{})，由中间件将 interface{} 序列化（如 json，xml 等）
• 请求处理失败时，返回 error，由中间件将 error 转换为相应的 HTTP 响应（golang 中的 error 为 interface，可自定义相应的 Error 实例）

elton 参考 koa 的实现，能够简单的添加各类中间件，中间件的执行也和 koa 一样，如下图所示的洋葱图，从外层往内层递进，再从内层返回外层（也可以未至最内层则直接往上返回）。

下面我们先看一下简单的处理成功与出错的例子：

package main

import (
	"bytes"
	"errors"

	"github.com/vicanso/elton"
)

func main() {
	d := elton.New()

	d.GET("/", func(c *elton.Context) (err error) {
		c.BodyBuffer = bytes.NewBufferString("hello world")
		return
	})

	d.GET("/error", func(c *elton.Context) (err error) {
		err = errors.New("my error")
		return
	})

	d.ListenAndServe(":7001")
}

如代码所示，处理过程非常简单，响应数据由BodyBuffer中获取，如果流程出错，直接返回Error则可。不过例子中的与koa的处理还是有所差距，koa中返回数据时可以随意的指定各种Object(转换为json)，而在golang中因为是强类型，所以需要使用interface{}的形式返回，再通过中间件将各类不同的struct转换至BodyBuffer，以及设置Content-Type 。

中间件

在 elton 中有两类中间件是必须了解的，一是将 Context.Body(interface{}) 转换至对应的响应数据的 Responder 中间件，另外一个就是将 Error 转换至对应的响应数据的 Error 中间件。在详解这两类中间件之前，我们首先来了解一下 elton 的中间件的一些基本概念。

elton 中间件的处理函数是Handler func(*Context) error，可以通过Use方法添加至全局的中间件，也可单独添加至单一组或单一的路由处理。中间件处理也非常简单，如果出错，返回 Error（后续的处理函数不再执行）。在当前函数中已完成处理，则无需要调用Context.Next()，需要转至下一处理函数，则调用Context.Next()则可。

package main

import (
	"bytes"
	"log"
	"time"

	"github.com/vicanso/elton"
)

func main() {
	d := elton.New()

	// logger
	d.Use(func(c *elton.Context) (err error) {
		err = c.Next()
		rt := c.GetHeader("X-Response-Time")
		log.Printf("%s %s - %s\n", c.Request.Method, c.Request.RequestURI, rt)
		return
	})

	// x-response-time
	d.Use(func(c *elton.Context) (err error) {
		start := time.Now()
		err = c.Next()
		c.SetHeader("X-Response-Time", time.Since(start).String())
		return
	})

	d.GET("/", func(c *elton.Context) (err error) {
		c.BodyBuffer = bytes.NewBufferString("hello world")
		return
	})

	d.ListenAndServe(":7001")
}

responder 中间件

HTTP 的响应主要分三部分，HTTP 响应状态码，HTTP 响应头以及 HTTP 响应体。前两部分比较简单，格式统一，但是 HTTP 响应体对于不同的应用有所不同。在 elton 的处理中，会将 BodyBuffer 的相应数据在响应时作为 HTTP 响应体输出。在实际应用中，有些会使用 json，有些是 xml 或者自定义的响应格式。因此在elton是提供了Body(interface{}) 属性，允许将响应数据赋值至此字段，再由相应的中间件转换为对应的 BodyBuffer 以及设置Content-Type。

在实际使用中，HTTP 接口的响应主要还是以json为主，因此 elton-responder 提供了将 Body 转换为对应的 BodyBuffer(json) 的处理，主要的处理如下：

// New create a responder
func New(config Config) elton.Handler {
	skipper := config.Skipper
	if skipper == nil {
		skipper = elton.DefaultSkipper
	}
	marshal := standardJSON.Marshal
	if config.Fastest {
		marshal = fastJSON.Marshal
	}
	return func(c *elton.Context) (err error) {
		if skipper(c) {
			return c.Next()
		}
		err = c.Next()
		if err != nil {
			return
		}
		// 如果已设置了BodyBuffer，则已生成好响应数据，跳过
		if c.BodyBuffer != nil {
			return
		}

		if c.StatusCode == 0 && c.Body == nil {
			// 如果status eltone 与 body 都为空，则为非法响应
			err = errInvalidResponse
			return
		}
		// 如果body是reader，则跳过
		if c.IsReaderBody() {
			return
		}

		ct := elton.HeaderContentType

		hadContentType := false
		// 判断是否已设置响应头的Content-Type
		if c.GetHeader(ct) != "" {
			hadContentType = true
		}

		statusCode := c.StatusCode
		if statusCode == 0 {
			statusCode = http.StatusOK
		}

		var body []byte
		if c.Body != nil {
			switch c.Body.(type) {
			case string:
				if !hadContentType {
					c.SetHeader(ct, elton.MIMETextPlain)
				}
				body = []byte(c.Body.(string))
			case []byte:
				if !hadContentType {
					c.SetHeader(ct, elton.MIMEBinary)
				}
				body = c.Body.([]byte)
			default:
				// 转换为json
				buf, err := marshal(c.Body)
				if err != nil {
					c.Cod().EmitError(c, err)
					statusCode = http.StatusInternalServerError
					he := hes.NewWithErrorStatusCode(err, statusCode)
					he.Exception = true
					c.SetHeader(ct, elton.MIMEApplicationJSON)
					body = he.ToJSON()
					err = nil
				} else {
					if !hadContentType {
						c.SetHeader(ct, elton.MIMEApplicationJSON)
					}
					body = buf
				}
			}
		}
		c.BodyBuffer = bytes.NewBuffer(body)
		c.StatusCode = statusCode
		return nil
	}
}

代码的处理步骤如下：

1、前置判断是否跳过中间件，主要判断条件为：是否出错，或者已设置BodyBuffer(表示已完成响应数据的处理)或者 Body 为 Reader (以流的形式输出响应数据)。

2、如果 Body 的类型为 string，则将 string 转换为 bytes，如果未设置数据类型，则设置为text/plain; charset=UTF-8

3、如果 Body 的类型为 []byte，如果未设置数据类型，则设置为application/octet-stream

4、对于其它类型，则使用json.Marshal转换为对应的 []byte，如果未设置数据类型，则设置为application/json; charset=UTF-8

通过此中间件，在开发时可以简单的将各种 struct 对象，map 对象以json的形式返回，无需要单独处理数据转换，方便快捷。如果应用需要以 xml 等其它形式返回，则可自己编写自定义中间件来做转换处理。

error handler 中间件

elton 中默认的 Error 处理只是简单的输出err.Error()，而且状态码也只是简单的使用StatusInternalServerError，无法满足应用中的各类定制的出错方式。因此一般建议编写自定义的出错处理中间件，根据自定义的 Error 对象生成相应的出错响应数据。如 elton-error-handler 则针对返回的 hes对象对应生成相应的状态码，响应类型以及响应数据(json)：

// New create a error handler
func New(config Config) elton.Handler {
	skipper := config.Skipper
	if skipper == nil {
		skipper = elton.DefaultSkipper
	}
	return func(c *elton.Context) error {
		if skipper(c) {
			return c.Next()
		}
		err := c.Next()
		// 如果没有出错，直接返回
		if err == nil {
			return nil
		}
		he, ok := err.(*hes.Error)
		if !ok {
			he = hes.Wrap(err)
			he.StatusCode = http.StatusInternalServerError
			he.Exception = true
			he.Category = errErrorHandlerCategory
		}
		c.StatusCode = he.StatusCode
		if config.ResponseType == "json" {
			buf := he.ToJSON()
			c.BodyBuffer = bytes.NewBuffer(buf)
			c.SetHeader(elton.HeaderContentType, elton.MIMEApplicationJSON)
		} else {
			c.BodyBuffer = bytes.NewBufferString(he.Error())
			c.SetHeader(elton.HeaderContentType, elton.MIMETextPlain)
		}

		return nil
	}
}

后记

elton 提供更简单方便的 WEB 开发体验，主要实现的代码非常简单，更多的功能都依赖于各类中间件。需要查阅更多的中间件以及文档说明请查阅 github 项目中的说明。