Einführung in Jooby

1. Überblick

Jooby ist ein skalierbares und schnelles Micro-Web-Framework, das auf den am häufigsten verwendetenNIO web servers aufbaut. Es ist sehr einfach und modular aufgebaut und klar auf die moderne Webarchitektur abgestimmt. Es wird auchJavascript undKotlin unterstützt.

Standardmäßig bietetJooby eine hervorragende Unterstützung fürNetty, Jetty, and Undertow.

In diesem Artikel erfahren Sie mehr über die gesamte Projektstruktur vonJoobyund wie Sie eine einfache Webanwendung mitJoobyerstellen.

2. Anwendungsarchitektur

Eine einfacheJooby-Anwendungsstruktur sieht wie folgt aus:

├── public
|   └── welcome.html
├── conf
|   ├── application.conf
|   └── logback.xml
└── src
|   ├── main
|   |   └── java
|   |       └── com
|   |           └── example
|   |               └── jooby
|   |                   └── App.java
|   └── test
|       └── java
|           └── com
|               └── example
|                   └── jooby
|                       └── AppTest.java
├── pom.xml

Hierbei ist zu beachten, dass wir im Verzeichnispublictatische Dateien wie css / js / html usw. ablegen können. Im Verzeichnisconf können wir jede Konfigurationsdatei ablegen, die eine Anwendung benötigt, z. B.logback.xml oderapplication.conf usw.

3. Maven-Abhängigkeit

Wir können eine einfacheJooby-Anwendung erstellen, indem wir unserenpom.xml: die folgende Abhängigkeit hinzufügen


    org.jooby
    jooby-netty
    1.1.3

Wenn wirJetty oderUndertow wählen möchten, können wir die folgende Abhängigkeit verwenden:


    org.jooby
    jooby-jetty
    1.1.3


    org.jooby
    jooby-undertow
    1.1.3

Sie können die neueste Version desJooby-Projekts inCentral Maven Repository überprüfen.

Jooby also has a dedicated Maven archetype. Wir können damit ein Beispielprojekt mit allen erforderlichen Abhängigkeiten erstellen.

Wir können das folgende Skript verwenden, um das Beispielprojekt zu generieren:

mvn archetype:generate -B -DgroupId=com.example.jooby -DartifactId=jooby
-Dversion=1.0 -DarchetypeArtifactId=jooby-archetype
-DarchetypeGroupId=org.jooby -DarchetypeVersion=1.1.3

4. Erstellen einer Anwendung

4.1. Server starten

Um den eingebetteten Server zu starten, müssen wir den folgenden Codeausschnitt verwenden:

public class App extends Jooby {
    public static void main(String[] args) {
        run(App::new, args);
    }
}

Nach dem Start läuft der Server aufdefault port8080.

Wir können den Back-End-Server auch mit einem benutzerdefinierten Port und einem benutzerdefiniertenHTTPS-Port konfigurieren:

{
    port( 8081 );
    securePort( 8443 );
}

4.2. Router implementieren

Es ist sehr einfach, einen pfadbasierten Router inJooby zu erstellen. Zum Beispiel können wir einen Router für den Pfad '/login' auf folgende Weise erstellen:

{
    get( "/login", () -> "Hello from example");
}

In ähnlicher Weise können wir, wenn wir andereHTTP-Methoden wie POST, PUT usw. behandeln möchten, das folgende Codefragment verwenden:

{
    post( "/save", req -> {
        Mutant token = req.param( "token" );
        return token.intValue();
    });
}

Hier rufen wir das Anforderungsparameter-Namenstoken aus der Anforderung ab. Standardmäßig werden alle Anforderungsparameter in den DatentypMutantvonJooby umgewandelt. Basierend auf der Erwartung können wir es in jeden unterstützten primitiven Datentyp konvertieren.

Wir können jeden URL-Parameter folgendermaßen überprüfen:

{
    get( "/user/{id}", req -> "Hello user : " + req.param("id").value() );
    get( "/user/:id", req -> "Hello user: " + req.param("id").value() );
}

Wir können eines der oben genannten verwenden. Es ist auch möglich, Parameter zu finden, die mit einem festen Inhalt beginnen. Zum Beispiel können wir einen URL-Parameter finden, der mit 'uid:' beginnt, und zwar auf folgende Weise:

{
    get( "/uid:{id}", req -> "Hello User with id : uid" +
        req.param("id").value());
}

4.3. MVC Pattern Controller implementieren

Für eine Unternehmensanwendung wirdJooby mit einer MVC-API geliefert, ähnlich wie bei allen anderen MVC-Frameworks wie Spring MVC.

Zum Beispiel können wir einen Pfad namens "/hello" behandeln:

@Path("/hello")
public class GetController {
    @GET
    public String hello() {
        return "Hello example";
    }
}

Sehr ähnlich können wir einen Handler erstellen, der andere HTTP-Methoden mit@POST, @PUT, @DELETE usw. verarbeitet. Anmerkung.

4.4. Umgang mit statischen Inhalten

Um statische Inhalte wie HTML, Javascript, CSS, Bild usw. bereitzustellen, müssen wir diese Datei im Verzeichnispublicablegen.

Einmal platziert, können wir vom Router aus jede URL diesen Ressourcen zuordnen:

{
    assets( "/employee" , "form.html" );
}

4.5. Formular bearbeiten

Die Schnittstelle vonJooby’sRequestverarbeitet standardmäßig jedes Formularobjekt ohne manuelle Typumwandlung.

Nehmen wir an, wir müssen Mitarbeiterdaten über ein Formular übermitteln. Im ersten Schritt müssen wir einEmployee-Bean-Objekt erstellen, mit dem wir die Daten speichern:

public class Employee {
    String id;
    String name;
    String email;

    // standard constructors, getters and setters
}

Jetzt müssen wir eine Seite erstellen, um das Formular zu erstellen:

Als Nächstes erstellen wir einen Post-Handler, um dieses Formular zu adressieren und die übermittelten Daten abzurufen:

post( "/submitForm", req -> {
    Employee employee = req.params(Employee.class);
    // ...
    return "empoyee data saved successfullly";
});

Hierbei ist zu beachten, dass das Formularenctype alsapplication/x-www-form-urlencoded deklariert werden muss, um die dynamische Formularbindung zu unterstützen.

MitRequest.file(String filename) können wir die hochgeladene Datei abrufen:

post( "/upload", req -> {
    Upload upload = req.file("file");
    // ...
    upload.close();
});

4.6. Filter implementieren

Standardmäßig bietet, Jooby die Flexibilität, globale Filter sowie pfadbasierte Filter zu definieren.

Das Implementieren eines Filters inJooby ist seitwe need to configure the URL path twice, once for the filter and once again for the handler. etwas schwierig

Wenn wir beispielsweise einen Filter für einen URL-Pfad mit dem Namen "/filter'," implementieren müssen, müssen wir den Filter explizit in diesem Pfad implementieren:

get( "/filter", ( req, resp, chain ) -> {
    // ...
    chain.next( req, resp );
});

Die Syntax ist dem Filter vonServletehr ähnlich. Sie können die Anforderung einschränken und die Antwort im Filter selbst zurücksenden, indem Sie die MethodeResponse.send(Result result)aufrufen.

Sobald der Filter implementiert ist, müssen wir den Request-Handler implementieren:

get("/filter", (req, resp) -> {
    resp.send("filter response");
});

4.7. Session

Jooby wird mit zwei Arten der Sitzungsimplementierung geliefert. In-Memory und Cookie-basiert.

Das Implementieren der In-Memory-Sitzungsverwaltung ist recht einfach. Wir haben die Möglichkeit, einen der mitJooby verfügbaren Session-Stores mit hohem Durchsatz wieEhCache, Guava, HazleCast, Cassandra, Couchbase, Redis, MongoDB, undMemcached. auszuwählen

Um beispielsweise einen Redis-basierten Sitzungsspeicher zu implementieren, müssen wir folgende Maven-Abhängigkeit hinzufügen:


    org.jooby
    jooby-jedis
    1.1.3

Jetzt können wir das folgende Code-Snippet verwenden, um die Sitzungsverwaltung zu aktivieren:

{
    use(new Redis());
    session(RedisSessionStore.class);

    get( "/session" , req -> {
        Session session = req.session();
        session.set("token", "value");
        return session.get("token").value();
    });
}

Hierbei ist zu beachten, dass wir die URL vonRedisals Eigenschaft von‘db' inapplication.conf konfigurieren können.

Um die Cookie-basierte Sitzungsverwaltung zu aktivieren, müssen wircookieSession() deklarieren. If cookie based approach is selected, we must need to declare application.secret property in the application.conf file. Da jedes Cookie signiert wird, wird es mit diesem geheimen Schlüssel signiert. Es ist immer ratsam, ein langes zufälliges Zeichenfolgenfragment als geheimen Schlüssel zu verwenden. **

Sowohl im speicherinternen als auch im Cookie-basierten Ansatz müssen wir den erforderlichen Konfigurationsparameter in der Dateiapplication.confdeklarieren, da die Anwendung sonst beim Start einIllegalStateException auslöst.

5. Testen

Das Testen der MVC-Route ist in der Tat einfach, da eine Route an eine Strategie für eine Klasse gebunden ist. Dies macht es einfach, Komponententests für alle Routen durchzuführen.

Zum Beispiel können wir schnell einen Testfall für die Standard-URL erstellen:

public class AppTest {

    @ClassRule
    public static JoobyRule app = new JoobyRule(new App());

    @Test
    public void given_defaultUrl_expect_fixedString() {

        get("/").then().assertThat().body(equalTo("Hello World!"))
          .statusCode(200).contentType("text/html;charset=UTF-8");
    }
}

Hierbei ist zu beachten, dass bei Verwendung der Annotation von@ClassRulenur eine Instanz des Servers für alle Testfälle erstellt wird. Wenn wir für jeden Testfall separate Instanzen der Server erstellen müssen, müssen wir die Annotation@Ruleohne den statischen Modifikator verwenden.

Wir können auchJooby’s MockRouter verwenden, um den Pfad auf die gleiche Weise zu testen:

@Test
public void given_defaultUrl_with_mockrouter_expect_fixedString()
  throws Throwable {

    String result = new MockRouter(new App()).get("/");

    assertEquals("Hello World!", result);
}

6. Fazit

In diesem Tutorial haben wir dasJooby-Projekt und seine wesentlichen Funktionen untersucht.

Wie immer ist der vollständige Quellcodeover on GitHub verfügbar.

TOC

Einführung in Jooby