[JAVA] Erste Schritte mit Ratpack (4) -Routing & Static Content

Ratpack Einführungsserie

  1. Einführung in Ratpack (1) - Was ist Ratpack
  2. Einführung in Ratpack (2) --Architecture
  3. Einführung in Ratpack (3) - Hallo Weltdetails
  4. Einführung in Ratpack (4) - Routing & statischer Inhalt
  5. Einführung in Ratpack (5) --Json & Registry
  6. Einführung in Ratpack (6) --Promise
  7. Einführung in Ratpack (7) - Guice & Spring
  8. Einführung in Ratpack (8) - Sitzung
  9. Einführung in Ratpack (9) - Thymeleaf

Routing

Wie oben erwähnt, erfolgt das Routing durch Schreiben eines Handlers, der jedem Pfad in der Klasse "Chain" zugeordnet ist. Die offizielle Dokumentation finden Sie in Chain's Javadoc. Wenn Sie sie hier nicht erklären können, lesen Sie dies bitte. ..

Jede Methode zum Hinzufügen eines Handlers

Die grundlegendste Methode in "Chain" ist "all (Handler)", was angibt, dass alle Anforderungen von diesem Handler verarbeitet werden. Jede der anderen Methoden ist eigentlich nur eine bequeme Methode mit "Bedingungen zum Akzeptieren von Anforderungen", die dieser Methode hinzugefügt wurden. Intern wird jede statische Dienstprogrammmethode von "Handlern" verarbeitet, indem der übergebene "Handler" umbrochen wird.

Diejenigen, die "Class " als Argument anstelle der "Handler" -Instanz selbst verwenden, verwenden diese Klasse aus der "Registry" des Kontexts. Es scheint nicht viel zu sein, aber es funktioniert großartig, wenn es mit einem DI-Container wie Guice kombiniert wird.

Im Folgenden werde ich die wichtigsten Methoden erläutern (alle sind aufgrund der großen Menge unmöglich).

Methode Die Bedingung, unter der der Handler aufgerufen wird
all(Handler) Sie müssen
files() Siehe unten
onlyIf(Predicate<Context>, Handler) PredicateAbertrueWann
when(boolean/Predicate, Action<Chain>) Boolescher Wert oderPredicateAbertrueWann,Action<Chain>Delegiert
prefix(String, Action<Chain>) Wenn der Pfad mit der angegebenen Zeichenfolge beginntDurch relativen Pfad aufgelöstAction<Chain>Delegiert
path(Handler) Wenn die Anforderung mit dem angegebenen Pfad übereinstimmt
get(String, Handler) Wenn der angegebene Pfad übereinstimmt und die GET-Methode aufgerufen wird
post(String, Handler) Wenn der angegebene Pfad übereinstimmt und die POST-Methode aufgerufen wird
patch(String, Handler) Wenn der angegebene Pfad übereinstimmt und die PATCH-Methode aufgerufen wird
put(String, Handler) Wenn der angegebene Pfad übereinstimmt und die PUT-Methode aufgerufen wird
delete(String, Handler) Wenn der angegebene Pfad übereinstimmt und die DELETE-Methode aufgerufen wird
chain.prefix( "hoge", innerChain -> {
    innerChain.get( "piyo", handler );  // /hoge/piyo
} );

Darüber hinaus bietet "Context" praktische Methoden mit den Namen "byMethod ()" und "byContent", mit denen Sie Zweige ideologisch beschreiben können.

//Pfad"hoge"Verzweigen Sie mit GET und POST, wenn Sie dazu aufgefordert werden
chain.path( "hoge", ctx -> {
    ctx.byMethod( m -> {
        m.get( iCtx -> iCtx.render( "get" ) );
        m.post( iCtx -> iCtx.render( "post" ) );
    } );
} );
// "hoge"Von der Anfrage`Accept`Verzweigen Sie nach dem Wert des Headers
chain.path( "hoge", ctx -> ctx.byContent( accept -> {
    accept.json( iCtx -> iCtx.render("json") );
    accept.xml( iCtx -> iCtx.render( "xml" ) );
    accept.noMatch( iCtx -> iCtx.render( "no match" ) );
} ) );

Der Variablenname ist hier übrigens fest geschrieben, kann aber auch in der Methodenkette beschrieben werden.

Pfad wörtlich

Sie können Literale wie reguläre Ausdrücke für die im Pfad angegebene Zeichenfolge verwenden und Pfadparameter festlegen.

Art Syntax Beispiel
wörtlich foo "foo"
Literal für reguläre Ausdrücke ::<<regex>> "foo/::\d+"
Optionales Pfad-Token :<<token-name>>? "foo/:val?"
Erforderliches Pfad-Token :<<token-name>> "foo/:val"
Optionales Pfad-Token für reguläre Ausdrücke :<<token-name>>?:<<regex>> "foo/:val?:\d+"
Erforderliches Pfad-Token für reguläre Ausdrücke :<<token-name>>:<<regex>> "foo/:val:\d+"

(Übersetzt aus Javadoc)

Pfadparameter können über die PathTokens-Klasse abgerufen werden, die mit Context.getPathToken () abgerufen werden kann.

chain.get( "hoge/:name", ctx -> ctx.render( "name: " + ctx.getPathTokens().get( "name" ) ) );
chain.get( "piyo/:id:\\d+", ctx -> ctx.render( "id: " + ctx.getPathTokens().asLong( "id" ) ) );
Pfad Ergebnis
/hoge 404
/hoge/John "name: John"
/piyo/hoge 404
/piyo/123 "id: 123"

Verhalten von "Kontext"

Die Context-Klasse ist eine Klasse, die Informationen darüber enthält, wie eine einzelne Anforderung aufgerufen wird. Wie wir in Hello World gesehen haben, ist "Handler" ein Lambda-Ausdruck, der "Context" empfängt. Daher ist der Verarbeitungsfluss Kontext empfangen-> Verschiedene Verarbeitungen durchführen-> Context.render () aufrufen, um eine Antwort zu erstellen Es wird in Form von sein.

Parameter abfragen

Dies ist der Teil nach ? Der URL. Sie können es als Map von getRequest (). GetQueryParams () erhalten.

Pfadparameter

Wie oben erwähnt, verwenden Sie "getPathToken ()".

FORM-Parameter

Formularparameter, die von HTTP-Tags "

" usw. gesendet werden, werden über die Klasse "Form" mit der Methode "parse ()" abgerufen.

chain.path( "hoge", ctx -> ctx.parse( Form.class ).then( form -> {
    ctx.render( "Received: " + form.entrySet() );
} ) );

parse () wird später beschrieben.

Text anfordern

Sie können es von getRequest (). GetBody () erhalten. Hierbei ist zu beachten, dass die Methode "getBody ()" nicht den Inhalt des Körpers zurückgibt, sondern das "Versprechen" des Körpers. Wie man "Versprechen" benutzt, wird in einem zukünftigen Beitrag erklärt.

Header

Holen Sie es sich über die Klasse "Header", die Sie über "Header (CharSequence)" oder "getRequest ()" erhalten können. GetHeaders () ".

Plätzchen

Sie können es mit Request.getCookies () erhalten.

Gibt eine Antwort zurück

Um die Antwort festzulegen, rufen Sie die Klasse "Response" von "getResponse ()" ab und legen Sie sie in dieser Instanz fest. Die eigentliche Übertragung erfolgt mit "Context.render (Object)" oder "Response.send ()".

Statuscode

Sie kann mit der Methode "status (int)" angegeben werden.

Plätzchen

Die Cookie-Klasse wird durch Aufrufen der cookie () -Methode erstellt. Es ist nicht erforderlich, das zurückgegebene "Cookie" -Objekt zu dem von der "getCookies ()" - Methode zurückgegebenen Satz hinzuzufügen.

Header

Sie können einen variablen Satz von Headern mit Response.getHeaders () erhalten. Komfortmethoden wie "contentType ()" sind ebenfalls verfügbar.

Context.redirect(String) 302 Erzeugt eine Umleitung und wechselt zum angegebenen Pfad.

Context.clientError(int) Es wird verwendet, wenn Sie einen Fehler in der Statuscode 400-Serie generieren möchten. Für 404 wird die Convenience-Methode "notFound ()" bereitgestellt.

Context.render(Object) Dies ist die grundlegendste Methode, die eine Antwort zurückgibt.

BaseDir

Um statische Dateien bereitzustellen, bietet Ratpack einen Mechanismus namens "BaseDir".

Zuerst müssen Sie den BaseDir-Pfad auf ServerConfig setzen. Sie können normalerweise einen JDK-Pfad erstellen, es gibt jedoch eine BaseDir.find () -Methode zum Laden von Ressourcen aus dem Klassenladeprogramm. Es gibt auch eine praktische Methode namens "ServerConfigBuilder.findBaseDir ()". find () sucht im angegebenen Pfad nach einer leeren Datei namens .ratpack. Wenn es gefunden wird, wird statischer Inhalt unter Verwendung dieses Pfads als interner Referenzpfad bereitgestellt. Als Nächstes müssen wir einen Handler erstellen, der die Datei von BaseDir aus bereitstellt. Die Methode Chain.files () sendet den Inhalt der Datei als Antwort, wenn eine Anforderung vom oben festgelegten BaseDir an die als relativer Pfad aufgelöste URL vorliegt.

Dies ist ein konkretes Beispiel. Erstellen Sie hier einen Ordner mit dem Namen "public" in der Ressource und setzen Sie ihn auf BaseDir.

Erstellen Sie Folgendes als Ressource. resources/public/.ratpack resources/public/index.html

Path baseDir = BaseDir.find( "public/.ratpack" );

ServerConfig config = ServerConfig.builder()
                                  .baseDir( baseDir )
                                  .development( true ).build();

Action<Chain> handlers = chain -> {
    chain.files();
};

RatpackServer.start( server -> server
        .serverConfig( config )
        .handlers( handlers ) );

Wenn Sie "http: // localhost: 5050 / index.html" besuchen, sollte der Inhalt der von Ihnen erstellten HTML-Datei angezeigt werden.

Wenn Sie die Datei an Ihren eigenen Pfad binden möchten, übergeben Sie "Pfad" an die Methode "Context.render ()". Sie können die Methode "Context.file ()" verwenden, um die Datei von BaseDir abzurufen.

Versuchen Sie, den Handler im obigen Beispiel wie folgt zu ändern:

Action<Chain> handlers = chain -> {
    chain.files();
    chain.get( "hoge", ctx -> ctx.render( ctx.file( "index.html" ) ) );
};

Wenn Sie auf "http: // localhost: 5050 / hoge" zugreifen, wird der Inhalt von "index.html" angezeigt.

Recommended Posts

Erste Schritte mit Ratpack (4) -Routing & Static Content
Erste Schritte mit Ruby
Erste Schritte mit Swift
Erste Schritte mit Doma-Transaktionen
Erste Schritte mit der Verarbeitung von Doma-Annotationen
Erste Schritte mit Java Collection
Erste Schritte mit JSP & Servlet
Erste Schritte mit Java Basics
Erste Schritte mit Spring Boot
Erste Schritte mit Ruby-Modulen
Erste Schritte mit Java_Kapitel 5_Praktische Übungen 5_4
[Google Cloud] Erste Schritte mit Docker
Erste Schritte mit Docker mit VS-Code
Erste Schritte mit dem Doma-Criteria API Cheet Sheet
Erste Schritte mit Ruby für Java-Ingenieure
Erste Schritte mit Docker für Mac (Installation)
Einführung in den Parametrisierungstest in JUnit
Einführung in Java ab 0 Teil 1
Beginnen Sie mit der Funktionsweise von JVM GC
Erste Schritte mit dem Language Server Protocol mit LSP4J
Erste Schritte mit dem Erstellen von Ressourcenpaketen mit ListResoueceBundle
Erste Schritte mit Java_Kapitel 8_Über "Instanzen" und "Klassen"
Erste Schritte mit der Doma-Projektion mit der Criteira-API
Erste Schritte mit Java 1 Ähnliche Dinge zusammenstellen
Erste Schritte mit Kotlin zum Senden an Java-Entwickler
Erste Schritte mit Doma-Using Joins mit der Criteira-API
Erste Schritte mit Doma-Einführung in die Kriterien-API
Ich habe versucht, mit Gradle auf Heroku zu beginnen
Erste Schritte mit Java-Programmen mit Visual Studio Code
Erste Schritte mit älteren Java-Ingenieuren (Stream + Lambda)
Beginnen Sie mit Gradle
Erste Schritte mit Reactive Streams und der JDK 9 Flow API
Erste Schritte mit der Git Hub Container Registry anstelle von Docker Hub