今天在研究rails3发错误电子信的时候无意中发现了强大的rack middleware,一开始还不知道,后来才发现了它强大的功能。先看看rack吧:(以下也是来自网络)
Rack:
Rack是什么?Rack提供了用ruby开发web应用的一个接口。比如Rails框架,就是由rack承担着跟web服务器之间的交互。简而言 之,Rack已经成为ruby开发web应用程序的一个规范,它统一了web服务器和web框架之间的交互接口。它所支持的web服务器和web框架已经 非常之多:http://rack.rubyforge.org/doc/ 。
Rack的规范非常简单,就是一个call方法:http://rack.rubyforge.org/doc/SPEC.html 。接受一个environment,然后返回status,header和body。这不就是http的全部么?
Middleware
A Middleware is a simple class instance that has two methods (at least), initialize
and call
. It is used to alter(改变) a HTTP request to and the response from your main Rack-compliant(兼容 ) web application. It is a form of proxy but with code rather than separate software. A set of middleware and their respective endpoints are known as a Stack.(一个 中间件及 各自 的端点 设置 被称为 堆栈。 )
What is an Endpoint?
An Endpoint is again a simple ruby class that only responds to call
. Thus it is so similar to a middleware that in fact a class can be one and the same thing, if it wants to return a response instead of letting it cascade through to the main endpoint.
Almost the simplest middleware possible is the following:
class SimpleMiddleware
def initialize(app, options={})
@app = app
@options = options
end
def call(env)
# downward logic
status, headers, response = @app.call(env)
# upward logic
[status, headers, response]
end
end
Firstly, the initialize
method, which accepts two arguments. The first is a rack endpoint, and the second is some options that will be required later for some logic.
The other important feature is the call
method, which accepts a hash of environment variables sent from the middleware further out. It also returns an array consisting of three things: the status, a hash of headers and a response body.
Middleware Stack是如何工作的?
As an example, here is a basic (imaginary) middleware stack:
# Top of the chain: the Listening Server
use SecondSimpleMiddleware # Inherits from SimpleMiddleware
use SimpleMiddleware
run ActionController::Routing::Routes
# Bottom of the chain: Your App
When a HTTP request comes in from a client, the server call
s SecondSimpleMiddleware, which executes its downward logic, then call
s SimpleMiddleware. SimpleMiddleware in turn executes it’s own downward logic, and call
s ActionController::Routing::Routes, which executes your applications logic.
Cleverly, ActionController::Routing::Routes returns an array containing 3 important elements. The first is the http status, as an integer. The second is a hash of headers to send back in the response. The last is the response body, which should respond to each
.
This array gets returned to SimpleMiddleware, which performs its upward logic before returning an array in the exact same format to SecondSimpleMiddleware. Then SecondSimpleMiddleware performs its upward logic, before returning an array of the exact same format back to the listening server, which formats it as a HTTP Response and sends it to the client.
class EarlyResponderMiddleware
def initialize(app, options={})
@app = app
@options = options
end
def call(env)
if env['path'] == "/foo"
body = "Not Found"
[404, {"Content-Length"=> body.length}, body]
else
@app.call(env)
end
end
end
And the following is what would happen if the path matched “/foo”:
Implementation
The beauty of this implementation is that middlewares can be added, moved and removed from this stack at will, without any other middlewares giving a damn. The exact implementation has been made so simple yet clever that an endpoint actually looks exactly the same as an endpoint with a middleware in front of it.
The following is the build_app
method I mentioned earlier, which Rack calls to construct its app
object to hand to a server.
def build_app(app)
middleware[options[:environment]].reverse_each do |middleware|
middleware = middleware.call(self) if middleware.respond_to?(:call)
next unless middleware
klass = middleware.shift
app = klass.new(app, *middleware)
end
app
end
In Rails 3, the default middleware stack is:
use ActionDispatch::Static # only development # part two
use Rack::Lock
use ActiveSupport::Cache::Strategy::LocalCache
use Rack::Runtime
use Rails::Rack::Logger # part three
use ActionDispatch::ShowExceptions
use ActionDispatch::RemoteIp
use Rack::Sendfile
use ActionDispatch::Callbacks # part four
use ActiveRecord::ConnectionAdapters::ConnectionManagement
use ActiveRecord::QueryCache
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore # part five
use ActionDispatch::Flash
use ActionDispatch::ParamsParser
use Rack::MethodOverride
use ActionDispatch::Head
run Test::Application.routes # part six
This stack is very easy to alter using the config.middleware methods. They allow you to insert middleware anywhere in the stack. More information can be found in the “Rails on Rack” Rails Guide . You’ll also find a lot more API centric information about middleware in that article, whereas my articles are looking more at the implementation.
Rack Middleware
为什么不可以在Rack和web framework之间做些事情呢?于是Rack middleware发展起来了。Rack中间件其实就是一些遵循Rack规范的应用。为什么要发展出Rack middleware?因为很多事情在这里做起来就非常方便,其实就是AOP的方式(你也可以把它理解成filter)。
看一下众多的middlewares:http://wiki.github.com/rack/rack/list-of-middleware 。或者在你的最新(2.3)rails应用下敲下命令行:rake middleware。
关联:http://andyhu1007.iteye.com/blog/537610
Configuring Middleware Stack
Rails provides a simple configuration interface config.middleware for adding, removing and modifying the middlewares in the middleware stack via environment.rb or the environment specific configuration file environments/<environment>.rb .
Adding a Middleware
You can add a new middleware to the middleware stack using any of the following methods:
- config.middleware.use(new_middleware, args) – Adds the new middleware at the bottom of the middleware stack.
- config.middleware.insert_before(existing_middleware, new_middleware, args) – Adds the new middleware before the specified existing middleware in the middleware stack.
- config.middleware.insert_after(existing_middleware, new_middleware, args) – Adds the new middleware after the specified existing middleware in the middleware stack.
Example:
# config/environment.rb
# Push Rack::BounceFavicon at the bottom
config.middleware.use Rack::BounceFavicon
# Add Lifo::Cache after ActiveRecord::QueryCache.
# Pass { :page_cache => false } argument to Lifo::Cache.
config.middleware.insert_after ActiveRecord::QueryCache, Lifo::Cache, :page_cache => false
Swapping a Middleware
You can swap an existing middleware in the middleware stack using config.middleware.swap .
Example:
# config/environment.rb
# Replace ActionController::Failsafe with Lifo::Failsafe
config.middleware.swap ActionController::Failsafe, Lifo::Failsafe
Middleware Stack is an Array
The middleware stack behaves just like a normal Array . You can use any Array methods to insert, reorder, or remove items from the stack. Methods described in the section above are just convenience methods.
For example, the following removes the middleware matching the supplied class name:
config.middleware.delete(middleware)
Internal Middleware Stack
Much of Action Controller’s functionality is implemented as Middlewares. The following table explains the purpose of each of them:
Middleware | Purpose |
---|---|
Rack::Lock | Sets env["rack.multithread"] flag to true and wraps the application within a Mutex. |
ActionController::Failsafe | Returns HTTP Status 500 to the client if an exception gets raised while dispatching. |
ActiveRecord::QueryCache | Enable the Active Record query cache. |
ActionController::Session::CookieStore | Uses the cookie based session store. |
ActionController::Session::MemCacheStore | Uses the memcached based session store. |
ActiveRecord::SessionStore | Uses the database based session store. |
Rack::MethodOverride | Sets HTTP method based on _method parameter or env["HTTP_X_HTTP_METHOD_OVERRIDE"] . |
Rack::Head | Discards the response body if the client sends a HEAD request. |