Was ist Rack?
Rack bietet eine minimale Schnittstelle zwischen Webservern, die Ruby- und Ruby-Frameworks unterstützen.
Mit Rack können Sie eine Rack-Anwendung schreiben.
Rack übergibt den Umgebungs-Hash (einen Hash, der in einer HTTP-Anforderung eines Clients enthalten ist und aus CGI-ähnlichen Headern besteht) an Ihre Rack-Anwendung, die die in diesem Hash enthaltenen Elemente verwenden kann, um zu tun, was sie wollen.
Was ist eine Rack-Anwendung?
Um Rack verwenden zu können, müssen Sie eine 'App' bereitstellen - ein Objekt, das auf die #callMethode mit dem Umgebungs-Hash als Parameter reagiert (normalerweise definiert als env). #callmuss ein Array mit genau drei Werten zurückgeben:
- den Statuscode (zB '200'),
- ein Hash von Headern ,
- der Antworttext (der auf die Ruby-Methode reagieren muss
each).
Sie können eine Rack-Anwendung schreiben, die ein solches Array zurückgibt. Diese wird von Rack innerhalb einer Antwort an Ihren Client zurückgesendet (dies ist tatsächlich eine Instanz der Klasse Rack::Response[Klicken, um zu den Dokumenten zu gelangen]).
Eine sehr einfache Rack-Anwendung:
gem install rack- Erstellen Sie eine
config.ruDatei - Rack muss danach suchen.
Wir werden eine winzige Rack-Anwendung erstellen, die eine Antwort (eine Instanz von Rack::Response) zurückgibt , deren Antworttext ein Array ist, das eine Zeichenfolge enthält : "Hello, World!".
Wir werden einen lokalen Server mit dem Befehl starten rackup.
Wenn Sie den entsprechenden Port in unserem Browser besuchen, sehen Sie "Hallo Welt!" im Ansichtsfenster gerendert.
#./message_app.rb
class MessageApp
def call(env)
[200, {}, ['Hello, World!']]
end
end
#./config.ru
require_relative './message_app'
run MessageApp.new
Starten Sie einen lokalen Server mit rackupund besuchen Sie localhost: 9292, und Sie sollten "Hallo Welt!" gerendert.
Dies ist keine umfassende Erklärung, aber im Wesentlichen geschieht hier, dass der Client (der Browser) über Ihren lokalen Server eine HTTP-Anforderung an Rack sendet und Rack instanziiert MessageAppund ausgeführt wird call, wobei der Umgebungs-Hash als Parameter an die Methode übergeben wird ( das envArgument).
Rack verwendet den Rückgabewert (das Array) und erstellt daraus eine Instanz von Rack::Responseund sendet diese an den Client zurück. Der Browser verwendet Magie , um "Hallo Welt!" Zu drucken. auf den Bildschirm.
Übrigens, wenn Sie sehen möchten, wie der Umgebungs-Hash aussieht, legen Sie ihn einfach puts envdarunter def call(env).
Minimal wie es ist, was Sie hier geschrieben haben, ist eine Rack-Anwendung!
Eine Rack-Anwendung mit dem Hash der eingehenden Umgebung interagieren lassen
In unserer kleinen Rack - App können wir mit dem interagieren envHash (siehe hier für mehr über das Umwelt - Hash).
Wir werden die Möglichkeit für den Benutzer implementieren, eine eigene Abfragezeichenfolge in die URL einzugeben. Daher ist diese Zeichenfolge in der HTTP-Anforderung vorhanden, die als Wert in einem der Schlüssel / Wert-Paare des Umgebungs-Hashs gekapselt ist.
Unsere Rack-App greift über den Umgebungs-Hash auf diese Abfragezeichenfolge zu und sendet sie über den Text in der Antwort an den Client (in diesem Fall unseren Browser) zurück.
Aus den Rack-Dokumenten zum Umgebungs-Hash:
"QUERY_STRING: Der Teil der Anforderungs-URL, der auf das? Gefolgt wird, falls vorhanden. Kann leer sein, ist aber immer erforderlich!"
#./message_app.rb
class MessageApp
def call(env)
message = env['QUERY_STRING']
[200, {}, [message]]
end
end
Wenn Sie jetzt rackupbesuchen localhost:9292?hello( ?helloals Abfragezeichenfolge), sollte im Ansichtsfenster "Hallo" angezeigt werden.
Rack-Middleware
Wir werden:
- fügen Sie ein Stück Rack - Middleware in unserem Code - Basis - eine Klasse:
MessageSetter,
- Der Umgebungs-Hash trifft diese Klasse zuerst und wird als Parameter übergeben :
env,
MessageSetterfügt einen 'MESSAGE'Schlüssel in den env-Hash ein, dessen Wert 'Hello, World!'if env['QUERY_STRING']ist , wenn er leer ist; env['QUERY_STRING']wenn nicht,- Endlich wird es zurückkehren
@app.call(env)- @appals nächste App im 'Stack' : MessageApp.
Erstens die "Langhand" -Version:
#./middleware/message_setter.rb
class MessageSetter
def initialize(app)
@app = app
end
def call(env)
if env['QUERY_STRING'].empty?
env['MESSAGE'] = 'Hello, World!'
else
env['MESSAGE'] = env['QUERY_STRING']
end
@app.call(env)
end
end
#./message_app.rb (same as before)
class MessageApp
def call(env)
message = env['QUERY_STRING']
[200, {}, [message]]
end
end
#config.ru
require_relative './message_app'
require_relative './middleware/message_setter'
app = Rack::Builder.new do
use MessageSetter
run MessageApp.new
end
run app
Aus den Rack :: Builder-Dokumenten geht hervor , dass Rack::Builderein kleines DSL implementiert wird , um Rack-Anwendungen iterativ zu erstellen. Dies bedeutet im Grunde, dass Sie einen "Stapel" erstellen können, der aus einem oder mehreren Middlewares und einer "untersten" Anwendung besteht, an die gesendet werden soll. Alle Anfragen, die an Ihre unterste Anwendung weitergeleitet werden, werden zuerst von Ihren Middleware (s) verarbeitet.
#useGibt die Middleware an, die in einem Stapel verwendet werden soll. Es nimmt die Middleware als Argument.
Rack Middleware muss:
- Haben Sie einen Konstruktor, der die nächste Anwendung im Stapel als Parameter verwendet.
- Antworten Sie auf die
callMethode, die den Umgebungs-Hash als Parameter verwendet.
In unserem Fall ist die 'Middleware' MessageSetter, der 'Konstruktor' die MessageSetter- initializeMethode, die 'nächste Anwendung' im Stapel MessageApp.
Also hier, wegen dem , was Rack::Buildertut unter der Haube, das appArgument von MessageSetter‚s - initializeMethode ist MessageApp.
(Machen Sie sich mit dem Kopf vertraut, bevor Sie fortfahren)
Daher gibt jede Middleware den vorhandenen Umgebungs-Hash im Wesentlichen an die nächste Anwendung in der Kette weiter. Sie haben also die Möglichkeit, diesen Umgebungs-Hash in der Middleware zu mutieren, bevor Sie ihn an die nächste Anwendung im Stapel weitergeben.
#runNimmt ein Argument, das ein Objekt ist, das auf #calleine Rack-Antwort (eine Instanz von Rack::Response) reagiert und diese zurückgibt .
Schlussfolgerungen
Mit können Rack::BuilderSie Ketten von Middlewares erstellen, und jede Anforderung an Ihre Anwendung wird von jeder Middleware nacheinander verarbeitet, bevor sie schließlich vom letzten Teil des Stapels (in unserem Fall MessageApp) verarbeitet wird. Dies ist äußerst nützlich, da verschiedene Phasen der Verarbeitung von Anforderungen getrennt werden. In Bezug auf die Trennung von Bedenken könnte es nicht viel sauberer sein!
Sie können eine 'Anforderungspipeline' erstellen, die aus mehreren Middlewares besteht, die sich mit folgenden Dingen befassen:
- Authentifizierung
- Genehmigung
- Caching
- Dekoration
- Leistungs- und Nutzungsüberwachung
- Ausführung (tatsächlich die Anfrage bearbeiten und eine Antwort geben)
(über den Aufzählungspunkten einer anderen Antwort in diesem Thread)
Sie werden dies häufig in professionellen Sinatra-Anwendungen sehen. Sinatra benutzt Rack! Sehen Sie hier für die Definition dessen , was Sinatra IST !
Als letzte Anmerkung config.rukönnen wir in einem Kurzschriftstil geschrieben werden, der genau die gleiche Funktionalität erzeugt (und dies ist, was Sie normalerweise sehen werden):
require_relative './message_app'
require_relative './middleware/message_setter'
use MessageSetter
run MessageApp.new
Um genauer zu zeigen, was MessageAppgerade getan wird, finden Sie hier die 'Langhand'-Version, die explizit zeigt, #calldass eine neue Instanz von Rack::Responsemit den erforderlichen drei Argumenten erstellt wird.
class MessageApp
def call(env)
Rack::Response.new([env['MESSAGE']], 200, {})
end
end
Nützliche Links
