Web框架

Flask
Django
Tornado
Twisted
ODOO

1.Tornado

Tornado：python编写的web服务器兼web应用框架

1.1.Tornado的优势


轻量级web框架
异步非阻塞IO处理方式
出色的抗负载能力
优异的处理性能，不依赖多进程/多线程，一定程度上解决C10K问题
WSGI全栈替代产品，推荐同时使用其web框架和HTTP服务器


1.2.Tornado VS Django

Django：重量级web框架，功能大而全，注重高效开发



内置管理后台
内置封装完善的ORM操作
session功能
后台管理
缺陷：高耦合



Tornado：轻量级web框架，功能少而精，注重性能优越



HTTP服务器
异步编程
WebSocket
缺陷：入门门槛较高


2.安装
输入命令：
pip install tornado

备注：

Tornado应该运行在类Unix平台，为了达到最佳的性能和扩展性，仅推荐Linux和BSD(充分利用Linux的epoll工具和BSD的kqueue达到高性能处理的目的)
3.使用
3.1.Tornado入门程序 - （一）
#-*- coding:utf-8 -*-
import tornado.web
import tornado.ioloop


#定义处理类型
class IndexHandler(tornado.web.RequestHandler):
    #添加一个处理get请求方式的方法
    def get(self):
        #向响应中，添加数据
        self.write('好看的皮囊千篇一律，有趣的灵魂万里挑一。')

if __name__ == '__main__':
    #创建一个应用对象
    app = tornado.web.Application([(r'/',IndexHandler)])
    #绑定一个监听端口
    app.listen(8888)
    #启动web程序，开始监听端口的连接
    tornado.ioloop.IOLoop.current().start()


1 .在pycharm中直接运行代码

2 .如果是在ubuntu，在命令窗口输入
python 文件名.py





4.Tornado 代码解析
4.1.入门程序代码解析


tornado.web：tornado的基础web框架

RequestHandler：封装对请求处理的所有信息和处理方法
get/post/..：封装对应的请求方式
write()：封装响应信息，写响应信息的一个方法



tornado.ioloop：核心io循环模块，封装linux的epoll和BSD的kqueue， tornado高性能处理的核心。

current()返回当前线程的IOLoop实例对象
start()启动IOLoop实力对象的IO循环，开启监听



4.2.httpserver底层处理

httpserver监听端口

tornado.httpserver.HTTPServer(app)
httpserver.listen(port)


httpserver实现多进程操作

tornado.httpserver.HTTPServer(app)
httpserver.bind(port)
httpserver.start(0/None/<0/num)

# -*- coding:utf-8 -*-
from tornado.web import Application,RequestHandler
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer

class IndexHandler(RequestHandler):
    def get(self):
        self.write('给自己一点时间，理清所有的荒唐与期望。')

if __name__ == '__main__':
    app = Application([(r'/',IndexHandler)])
    http_server = HTTPServer(app)
    #最原始的方式
    http_server.bind(8888)
    http_server.start(1)

    #启动Ioloop轮循监听
    IOLoop.current().start()




4.3.options配置

全局配置

tornado.options.define(
    name, default, type, multiple, help
)


命令行参数转换

tornado.options.parse_command_line()

#-*- coding:utf-8 -*-

from tornado.web import RequestHandler,Application
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer
import tornado.options

#定义变量
tornado.options.define('port',default=8000,type=int,help="this is the port >for application")

class IndexHandler(RequestHandler):
   def get(self):
       self.write('我们既然改变不了规则，那就做到最好')

if __name__ == '__main__':
   app = Application([(r'/',IndexHandler)])
   tornado.options.parse_command_line()

   http_server = HTTPServer(app)
   http_server.bind(tornado.options.options.port)
   http_server.start(1)
   #启动IOLoop轮循监听
   IOLoop.current().start()







配置文件

#即在当前py文件目录创建config文件，并在py代码中加入以下代码，
tornado.options.parse_config_file("./config")


配置模块：跟配置文件类似

4.4.application配置

程序调试之debug配置

#自动重启+取消缓存模板+取消缓存静态文件+提供追踪信息
tornado.web.Application([(..)], debug=True)

注：开发之初可以设置debug=True方便调试，开发完毕改为False.


路由信息初始化参数配置

tonado.web.Application([(r””, Handler, {k:v})])
def initialize(self, k)


路由名称设置及反解析

#名称设置
tornado.web.Application([
    url(r””, handler, {k,v}, name=“”)
])

#反解析操作
reverse_url(name)

实例
# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler, url
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer


class IndexHandler(RequestHandler):

    def get(self):
        self.write("<a href='"+self.reverse_url("login")+"'>用户登录</a>")


class RegistHandler(RequestHandler):
    def initialize(self, title):
        self.title = title

    def get(self):
        self.write("注册业务处理:" + str(self.title))


class LoginHandler(RequestHandler):
    def get(self):
        self.write("用户登录页面展示")

    def post(self):
        self.write("用户登录功能处理")


if __name__ == "__main__":
    app = Application(
        [
            (r"/", IndexHandler),
            (r"/regist", RegistHandler, {"title": "会员注册"}),
            url(r"/login", LoginHandler, name="login"),
        ]
    )

    http_server = HTTPServer(app)
    http_server.listen(8000)

    IOLoop.current().start()

4.5.参数传递

get方式传递参数

get_query_arguments(name,default=_ARG_DEFAULT,strip=True)
get_query_argument(name ,strip=True)


post方式传递参数

get_body_arguments(name, default=_ARG_DEFAULT,strip=True)
get_body_argument(name ,strip=True)

实例
# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer


class IndexHandler(RequestHandler):

    def get(self):
        # 获取get方式传递的参数
        username = self.get_query_argument("username")
        usernames = self.get_query_arguments("username")

        print (username)
        print (usernames)

    def post(self):
        # 获取post方式传递的参数
        username = self.get_body_argument("username")
        usernames = self.get_body_arguments("username")

        print (username)
        print (usernames)

if __name__ == "__main__":
    app = Application([(r"/",IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()

#网页运行时需要传入参数
#192.168.11.79:8000/?username=123


混合方式

get_arguments(..)/get_argument(..)

实例
# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop


class IndexHandler(RequestHandler):

    def get(self):
        # 获取get方式的参数
        user = self.get_argument("user")
        print("get方式获取参数：" + str(user))

    def post(self):
        # 获取post方式的参数
        user = self.get_argument("user")
        print("post方式获取参数：" + user.encode("utf-8"))


if __name__ == "__main__":
    app = Application([(r"/", IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()


其他参数

通过request获取参数数据
method/host/uri/path/query/version/headers/body/remote_ip/files

实例

request/json

# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop


class IndexHandler(RequestHandler):
    def get(self):
        print self.request

        json_str = {"username": "admin", "password": "123123"}
        self.write(json.dumps(json_str))



if __name__ == "__main__":
    app = Application([(r"/", IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()


header



.add_header() .set_header() .set_default_headers()

设置响应HTTP头, 前两者的不同点在于多次设置同一个项时, .add_header()会叠加参数, 而.set_header()则以最后一次为准.
.set_default_headers()比较特殊, 是一个空方法, 可根据需要重写, 作用是在每次请求初始化RequestHandler时设置默认headers.






.clear_header() .clear()

.clear_header()清除指定的headers, 而.clear()清除.set_default_headers()以外所有的headers设置.




# add_header
self.add_header('Foo', 'one')
self.add_header('Foo', 'two')
# set_header
self.set_header('Bar', 'one')
self.set_header('Bar', 'two')

# HTTP头的设置结果
# Foo → one, two
# Bar → two



# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop


class IndexHandler(RequestHandler):
    def set_default_headers(self):
        # 第二种响应头设置方式
        print("---------> 响应头set_default_headers()执行")
        self.set_header("Content-type", "application/json; charset=utf-8")
        self.set_header("qiku", "奇酷信息")

    def get(self):
        # 第一种操作响应头的方式：
        # self.set_header("Content-type", "application/json")
        print("---------->get方法执行")
        self.write("{'name':'jerry'}")
        self.set_header("qiku", "qikuedu.com")


if __name__ == "__main__":
    app = Application([(r"/", IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()


writerror

.send_error()用于发送HTTP错误页(状态码). 该操作会调用.clear() .set_status()
.write_error()用于清除headers, 设置状态码, 发送错误页. 重写.write_error()可以自定义错误页.



# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop


class IndexHandler(RequestHandler):

    def get(self):
        self.write("hello qikuedu.com")

        self.send_error(404, msg="页面丢失", info="家里服务器搞对象去了")

    def write_error(self, status_code, **kwargs):
        self.write("<h1>出错啦，工程师MM正在赶来的途中...</h1>")
        self.write("<p>错误信息:%s</p>" % kwargs["msg"])
        self.write("<p>错误描述:%s</p>" % kwargs["info"])


if __name__ == "__main__":
    app = Application([(r"/", IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()

数据流


.write()

将数据写入输出缓冲区. 如果直接传入dict, 那Tornado会自动将其识别为json, 并把Content-Type设置为application/json, 如果你不想要这个Content-Type, 那么在.write()之后, 调用.set_header()重新设置就好了. 需要注意的是, 如果直接传入的是list, 考虑到安全问题(json数组会被认为是一段可执行的JavaScript脚本, 且<script src="*/secret.json">可以绕过跨站限制),list将不会被转换成json.



.flush()

将输出缓冲区的数据写入socket. 如果设置了callback, 会在完成数据写入后回调. 需要注意的是, 同一时间只能有一个"等待"的flush callback, 如果"上一次"的flush callback还没执行, 又来了新的flush, 那么"上一次"的flush callback会被忽略掉.



.finish()

完成响应, 结束本次请求. 通常情况下, 请求会在return时自动调用.finish(), 只有在使用了异步装饰器@asynchronous或其他将._auto_finish设置为False的操作, 才需要手动调用.finish().



cookie


# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop


class IndexHandler(RequestHandler):

    def get(self):
        self.write("hello qikuedu.com")

        self.set_cookie("loginuser", "admin老王")

        print self.get_cookie("loginuser")

        print self.cookies


if __name__ == "__main__":
    app = Application([(r"/", IndexHandler)])

    app.listen(8000)

    IOLoop.current().start()

页面


.render()

返回渲染完成的html. 调用后不能再进行输出操作.



.redirect()

重定向, 可以指定3xx重定向状态码. 调用后不能再进行输出操作.



# 临时重定向 301
self.redirect('/foo')
# 永久重定向 302
self.redirect('/foo', permanent=True)
# 指定状态码, 会忽略参数 permanent
self.redirect('/foo', status=304)


redirect

# -*- coding:utf-8 -*-

from tornado.web import Application, RequestHandler, url
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer


class IndexHandler(RequestHandler):

    def get(self):
        self.write("<a href='"+self.reverse_url("login")+"'>用户登录</a>")


class RegistHandler(RequestHandler):
    def initialize(self, title):
        self.title = title

    def get(self):
        self.write("注册业务处理:" + str(self.title))


class LoginHandler(RequestHandler):
    def get(self):
        self.write("用户登录页面展示")

    def post(self):
        self.write("用户登录功能处理")


if __name__ == "__main__":
    app = Application(
        [
            (r"/", IndexHandler),
            (r"/regist", RegistHandler, {"title": "会员注册"}),
            url(r"/login", LoginHandler, name="login"),
        ]
    )

    http_server = HTTPServer(app)
    http_server.listen(8000)

    IOLoop.current().start()

随着Web最新发展趋势的不断升级，Web项目开发也越来越难，而且需要花费更多的开发时间。所以，Web程序员灵活运用Web开发框架显得更为重要。下面为大家简单的介绍一下Web框架的基本内容，希望对大家有帮助。

Web框架(Web framework)或者叫做Web应用框架(Web application framework)，是用于进行Web开发的一套软件架构。大多数的Web框架提供了一套开发和部署网站的方式。为Web的行为提供了一套支持支持的方法。使用Web框架，很多的业务逻辑外的功能不需要自己再去完善，而是使用框架已有的功能就可以。

Web框架的功能

Web框架使得在进行Web应用开发的时候，减少了工作量。Web框架主要用于动态网络开发，动态网络主要是指现在的主要的页面，可以实现数据的交互和业务功能的完善。使用Web框架进行Web开发的时候，在进行数据缓存、数据库访问、数据安全校验等方面，不需要自己再重新实现，而是将业务逻辑相关的代码写入框架就可以。也就是说，通过对Web框架进行主观上的“缝缝补补”，就可以实现自己进行Web开发的需求了。

以PHP为例，PHP可以在apache服务器上进行Web开发，而不必使用框架。使用PHP进行开的时候，在不适用框架的情况下，数据库连接就需要自己来实现，页面的生成和显示也是一样。比如框架的话可以完成避免sql注入的工作，而使用PHP在不用框架的情况下，这部分要自己做。
目前Python主流的框架有Django和Flask等。Django是一个比较重量级的框架，重量级的意思是说，Django几乎所有的功能都帮助开发者写好了，有时候如果想做一个简单的网站，并不需要太多功能，这时候使用Django的话，就比较不合适，因为在部署网站的时候会导致很多不必要的功能也部署了进来。而Flask是一个轻量级的框架，一些核心的功能实现了，但是实现的功能并没有Django那么多，这样可以进行自己的发挥，在Flask的基础上，如果想实现更多的功能，可以很方便地加入。

Java目前的主流开发框架是ssm(spring spring-mvc和mybatis)。相比之前的ssh(spring struts hibernate)，ssm也是比较轻量级的框架。

为了便于理解，个人创造了一个比方，如果将Web框架比作是旋律，歌词比作是业务逻辑，那么就是不同的歌曲。旋律可能有些地方不满足人的需求，可以进行修改。也可以在基础上增加新的旋律。或者是将框架比作素描的结果，然后在素描的基础上进行涂色，然后就可以成为一副画了。

总结

Web框架是用来进行Web应用开发的一个软件架构。主要用于动态网络开发。开发者在基于Web框架实现自己的业务逻辑。Web框架实现了很多功能，为实现业务逻辑提供了一套通用方法。



什么是Web框架、web框架有什么功能？

有需要资料的可以加我：腾讯QQ3249838614

或加入嵌入式就业交流群 551627734一起交流 学习 欢迎全国各地的大学生和各位行业大佬一起交流！

（STM32串口应用）http://www.makeru.com.cn/live/detail/1290.html?s=69821

（stm32电机驱动）http://www.makeru.com.cn/live/1392_1218.html?s=69821

（定时器）http://www.makeru.com.cn/live/1392_1199.html?s=69821

（DMA专题讲解）http://www.makeru.com.cn/live/1392_1020.html?s=69821]http://www.makeru.com.cn/live/1392_1048.html?s=69821http://www.makeru.com.cn/live/1392_1020.html?s=69821

（ ADC读取光照传感器）http://www.makeru.com.cn/live/1392_1004.html?s=69821

（STM32中断系统）http://www.makeru.com.cn/live/1392_1124.html?s=69821

（时钟系统）http://www.makeru.com.cn/live/1392_1082.html?s=69821

（stm32 实战之温湿度采集）http://www.makeru.com.cn/live/detail/1476.html?s=69821

  
原文：Top 6 web frameworks for Go as of 2017 

  作者：Edward Marinescu 

  译者：roy


译者注：本文介绍截至目前(2017年)最好的6个Go语言Web框架。以下为译文：



GO 语言爱好者的最佳Web框架

如果你是自己写一个小应用程序，那你可能不需要Web框架。但是如果你要做产品，那么你肯定需要一个好的框架。

如果你认为你有相应的知识和经验，你会自己编写所有的这些代码么？你有时间找到一个产品级的外部包来完成工作吗？你确定这与你应用程序的其它部分一致吗？

这些都是促使我们(即便是我们中最优秀的)使用框架的原因，如果其他人已经做了必要的艰苦的工作，我们不会想让自己重复这些工作。



简介

Go 是一个快速增长的开源编程语言，用于构建简单、快速和可靠的软件。点这里看有哪些大公司在使用Go语言来构建他们的服务。

本文提供了所有必要的信息，以帮助开发人员了解使用Go语言开发Web应用程序的最佳选项。。

本文包含了最详细的框架比较，通过尽可能多的角度(人气，社区支持，内置功能等)来比较最知名的几个Web 框架。

Beego: 一个Go语言下开源的，高性能Web框架 

     * https://github.com/astaxie/beego 

     * https://beego.me

Buffalo: 一个Go语言下快速Web开发框架 

     * https://github.com/gobuffalo/buffalo 

     * https://gobuffalo.io

Echo: 一个高性能，极简的Web框架 

     * https://github.com/labstack/echo 

     * https://echo.labstack.com

Gin: 一个Go语言写的HTTP Web框架。它提供了Martini风格的API并有更好的性能。 

     * https://github.com/gin-gonic/gin 

     * https://gin-gonic.github.io/gin

Iris: 目前发展最快的Go Web框架。提供完整的MVC功能并且面向未来。 

     * https://github.com/kataras/iris 

     * https://iris-go.com

Revel: 一个高生产率，全栈Go语言的Web框架。 

     * https://github.com/revel/revel 

     * https://revel.github.io



人气


  
按人气排序(star收藏数)



https://github.com/speedwheel/awesome-go-web-frameworks/blob/master/README.md#popularity



学习曲线


https://github.com/speedwheel/awesome-go-web-frameworks/blob/master/README.md#learning-curve

感谢 astaxie 和 kataras 的精彩工作，同时希望其他的框架能够赶上并提供更多的用例，至少对我来说，如果要我切换到一个新框架，用例是快速掌握更多知识的最丰富的资源。一个用例抵得上千言万语。



核心功能


  
按功能由多到少排序






https://github.com/speedwheel/awesome-go-web-frameworks/blob/master/README.md#core-features


  
Go中最著名的“Web框架”并不是真正的框架，也就是说：Echo、Gin和Bufflo不是真正的(完整功能的)Web框架。但是Go社区的大多数人认为它们是。他们认为它们可以和Iris、Beego或Revel相比较。因此，我们有义务将它们也包括在这个列表中。
  
  
除了Beego和Revel之外，上述所有框架都可以适应任何为net/http创建的中间件。有些框架很容易，有些需要些编码(即使有点痛苦也是一个选择)。




名词解释



路由：命名路径参数和通配符(Router: Named Path Parameters & Wildcard)

你可以注册一个处理器(handler)并对应一个动态路径路由(router)。

下面是命名路径参数的例子： 
~ 

"/user/{username}" matches to "/user/me"， "/user/speedwheel" etc 

~

路径参数 _username_ 的值分别是 _”me”_ 和 _”speedwheel”_。

下面是通配符的例子： 
~ 

"/user/{path *wildcard}" matches to 

"/user/some/path/here"， 

"/user/this/is/a/dynamic/multi/level/path" etc 

~

路径参数 _path_ 的值分别是 _”some/path/here”_ 和 _”this/is/a/dynamic/multi/level/path”_。


  
Iris 也支持一种叫 _macros_ 的功能，可以描述为 _/user/{username:string}_ 或 _/user/{username:int min(1)}_




路由：正则表达式(Router: Regex)

你可以注册一个处理器(handler)并对应一个包含过滤器(filter)的动态路径路由(router)。过滤器会过滤掉一些传给处理器的参数值。

下面是一个例子： 
~ 

"/user/{id ^[0-9]$}" matches to "/user/42" but not to "/user/somestring" 

~ 

路径参数 _id_ 的值是整数 _42_ (而不会是字符串)。



路由：分组(Router: Grouping)

你可以注册通用逻辑或中间件/处理器(middlewar/handler)并对应一组共享相同路径前缀的路由(router)。

下面是一个例子： 
~ 

myGroup := Group("/user"， userAuthenticationMiddleware) 

myGroup.Handle("GET"， "/"， userHandler) 

myGroup.Handle("GET"， "/profile"， userProfileHandler) 

myGroup.Handle("GET"， "/signup"， getUserSignupForm) 

~ 

    * /user 

    * /user/profile 

    * /user/signup

你甚至可以在分组(group)中再创建子分组(subgroup) 
~ 

myGroup.Group("/messages"， optionalUserMessagesMiddleware) 

myGroup.Handle("GET'， "/{id}"， getMessageByID) 

~ 

    * /user/messages/{id}



路由：随意组合以上选项而不用担心冲突(Router: All the above Mixed Without Conflict)

这是一个先进且很有用的功能，我们很多人希望路由或Web框架支持该功能，但目前在Go环境里只有Iris支持。

这意味着像 /{path *wildcard}，/user/{username}， /user/static 和  /user/{path *wildcard} 可以注册在同一个路由里而且可以被正确地映射到静态路径 (/user/static) 或 通配符 (/{path *wildcard})



路由：自定义HTTP错误(Router: Custom HTTP Errors)

你可以注册一个处理器(handler)并对应一个’错误’代码。 HTTP 错误代码是一个 >=400 的状态码，例如 NotFound 404。 

下面是一个例子： 
~ 

OnErrorCode(404， myNotFoundHandler) 

~

上面的大多数Web框架只支持注册 404，405 和 500 错误代码，但是像 Iris，Beego和 Revel 这些提供完整功能的框架支持任何状态代码甚至 任何错误(any error)代码(只有Iris支持 任何错误 )。



100%与 net/http 兼容(100% compatible with net/http)

这意味着： 

    * 框架提供了上下文(context)让你可以直接访问 *http.Request 和  http.ResponseWriter。 

    * 你可以把 net/http 处理器(handler)转化到一个特定框架下的处理器(Handler)。



中间件生态系统(Middleware ecosystem)

你可以不用自己来为每个处理器包装中间件，但是框架提供给你一个完整的引擎来定义流程，无论是全局的或每个路由或每组路由，例如 Use(middleware)， Done(middleware) 等。



Sinatra风格的API(Sinatra-like API)

在运行时注册处理器来处理特定HTTP方法的路由(和路径参数)。

下面是一个例子： 
~ 

.Get or GET("/path"， gethandler) 

.Post or POST("/path"， postHandler) 

.Put or PUT("/path"， putHandler) and etc. 

~



服务器： 自动HTTPS(Server: Automatic HTTPS)

框架的服务器支持注册和自动更新SSL证书来管理SSL/TLS传入连接(https)。最着名的自动HTTPS提供者是letsencrypt。



服务器： 正常关机(Server: Gracefully Shutdown)

当按下 CTRL+C 关闭终端应用程序时，服务器将正常地停止，它会等待一些连接完成它们的工作(在设定的时间内)，或者触发一个自定义的事件来做清理(例如关闭数据库)。



服务器： 多监听器(Server: Multi Listeners)

框架的服务器支持注册自定义 net.Listener 或者可以通过多个 http 服务器和地址来服务web应用。



完全支持HTTP/2(Full HTTP/2)

框架支持HTTP/2，包括https和服务器 Push 功能。



子域(Subdomains)

你可以直接在你的Web应用里按子域(subdomain) 直接注册路由。

secondary 是指框架不支持该功能但是你依然可以通过启用多个http服务器来实现。坏处是主应用程序和子域并不相连而且默认情况下它们并不直接共享逻辑。



会话(Sessions)

http会话被支持并可以在你的特定处理器中使用。

* 一些Web框架支持使用后台数据库来存储会话，以便在服务器重启之间获得持久性。
* Buffalo 使用 gorrila 会话，这比其他的实现要慢一点点。


下面是一个例子： 

~~~ 

func setValue(context http_context){ 

    s := Sessions.New(http_context) 

    s.Set(“key”， “my value”) 

}

func getValue(context http_context){ 

    s := Sessions.New(http_context) 

    myValue := s.Get(“key”) 

}

func logoutHandler(context http_context){ 

    Sessions.Destroy(http_context) 

} 

~~~ 

Wiki: https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#HTTP_session



Websockets

框架支持websocket通信协议。实现是各不相同的。

你应该搜索他们的例子，看看有什么适合你。我的同事尝试了所有框架后告诉我，与其他框架相比，Iris实现了功能更强大且更简单的webosocket连接。

Wiki: https://en.wikipedia.org/wiki/WebSocket



App 内置视图/模板(View/Templates)

通常情况下，你必须将所有模板文件与你的Web应用程序的可执行文件一起打包。应用程序App 内置意味着该框架支持与go-bindata的集成，所以最终的可执行文件包含模板，表示为 []byte。



什么是视图引擎

框架支持模板加载，模板自定义和自带模板并能在一些关键工作上帮助我们。 



视图引擎：STD(View Engine: STD)

框架支持标准 html/template 解析器来加载模板。



视图引擎：Pug(View Engine: Pug)

框架支持 Pug 解析器来加载模板。



视图引擎：Django(View Engine: Django)

框架支持 Django 解析器来加载模板。



视图引擎：Handlebars(View Engine: Handlebars)

框架支持 Handlebars 解析器来加载模板。



视图引擎：Amber(View Engine: Amber)

框架支持 Amber 解析器来加载模板。



渲染器：Markdown， JSON， JSONP， XML…

框架的上下文为你提供了一种轻松地发送和定制各种内容类型的响应结果的简便方法。



MVC

模型-视图-控制器(MVC)是在计算机上实现用户界面的软件架构模式。它将一个给定的应用程序分成三个相互关联的部分。这样做是为了将信息的内部表示与信息呈现给用户并让用户接受的方式分离开来。MVC设计模式分离了这些主要成分并允许高效的代码重用和并行开发。

* Iris支持完整的MVC功能，可以在运行时注册。
* Beego仅支持方法和模型匹配，可以在运行时注册。
* Revel支持方法、路径和模型匹配，只能通过一个生成器注册(一个用于构建Web应用程序的必要软件)。


Wiki: https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller



缓存(Caching)

Web缓存(或HTTP缓存)是一种信息技术，用于临时存储(缓存)Web文档，如HTML页面和图像，以减少服务器延迟。Web缓存系统记录了网络通信，如果满足某些条件，后续请求的结果可以直接取自Web缓存。Web缓存系统既可以指设备，也可以指计算机程序。

Wiki: https://en.wikipedia.org/wiki/Web_cache



文件服务器(File Server)

你可以把一个(物理)目录注册到一个路由表，该路由表会自动将目录下的文件服务给客户程序。 



文件服务器： 内置入APP(File Server: Embedded Into App)

通常你必须将所有静态文件(如资源文件、CSS、JavaScript文件…)和应用程序的可执行文件一起传输。支持此特性的框架使你有机会将所有这些数据嵌入到应用程序中，表示为 []byte，它们的响应时间也更快，因为服务器可以不用在物理位置上查找文件而直接服务。



响应可以在发送之前在生命周期内多次修改(Response can be Modified Many times through lifecycle before sent)

目前仅Iris可以通过http_context内置的 response writer 支持该功能。

当框架支持这一功能时，你可以在发送给客户端之前检索,重置或修改的状态代码、正文和头文件(在基于net/http的Web框架中，默认情况下这是不可能的，因为正文和状态代码在写入后无法检索或更改)。 



Gzip

你可以在路由的处理器里改变响应writer来使用gzip压缩，框架应该设置返回结果的头(header)，并在出现任何错误时重置writer，也应该检查客户端是否支持gzip。


  
gzip是一种文件格式(也可以是一个软件应用)，用于文件的压缩和解压缩软件。 


Wiki: https://en.wikipedia.org/wiki/Gzip



测试框架(Testing Framework)

你可以使用特定的框架测试HTTP，测试框架就是帮助你轻松地编写更好的测试。

下面是一个例子(目前仅Iris支持) 
~ 

func TestAPI(t *testing.T) { 

    app := myIrisApp()  

    tt := httptest.New(t， app) 

    tt.GET("/admin").WithBasicAuth("name"， "pass").Expect(). 

    Status(httptest.StatusOK).Body().Equal("welcome") 

} 

~

myirisapp 返回一个你假定的Web应用程序， 

针对路径 /admin 它有一个GET处理器并有基本的身份验证保护。

上面简单的测试检查 /admin 请求是否返回状态码 Status OK 并验证特定的用户名和密码，最后检查正文内容是 “welcome”。



Typescript Transpiler

Typescript的目标是成为一个ES6超集，除了标准定义的所有新东西，它将添加一个静态类型系统(static type system)。Typescript也有一个转换器(transpiler)将我们的Typescript代码(即6 +类型)转换到ES5或ES3标准上的JavaScript代码，以便在目前的浏览器上运行。



在线编辑器(Online Editor)

有了在线编辑器，你可以快速方便地编译和运行Go代码。



日志系统(Logging System)

自定义日志系统系统可以扩展原始日志包的功能，比如代码配色、格式、日志级别的分隔，不同的登录后台等等。



维护和自动更新(Maintenance & Auto-Updates)

以非侵入性的方式通知用户“即时更新”。 

这篇文章最早发布在：https://medium.com/@MarinescuEdwar1/top-6-web-frameworks-for-go-as-of-2017-23270e059c4b

PS：推荐一个容器技术线上直播，讲师来自腾讯、华为、思科、58同城、蘑菇街、当当等6位一线专家，议题涵盖容器云、微服务、servicemesh等最新实践，欢迎报名参加