Introduction à Jooby

1. Vue d'ensemble

Jooby est un framework micro web évolutif et rapide construit sur lesNIO web servers les plus utilisés. Il est très simple et modulaire, clairement conçu pour l’architecture Web moderne. Il prend également en charge lesJavascript etKotlin.

Par défaut,Jooby est fourni avec un excellent support pourNetty, Jetty, and Undertow.

Dans cet article, nous allons découvrir la structure globale du projetJooby et comment créer une application Web simple à l'aide deJooby.

2. Architecture d'application

Une structure d'application simple deJooby ressemblera ci-dessous:

├── 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

Le point à noter ici est que dans le répertoirepublic, nous pouvons mettre des fichiers statiques comme css / js / html etc. Dans le répertoireconf, nous pouvons mettre n'importe quel fichier de configuration dont une application a besoin commelogback.xml ouapplication.conf etc.

3. Dépendance Maven

Nous pouvons créer une simple applicationJooby en ajoutant la dépendance suivante dans nospom.xml:


    org.jooby
    jooby-netty
    1.1.3

Si nous voulons choisirJetty ouUndertow, nous pouvons utiliser la dépendance suivante:


    org.jooby
    jooby-jetty
    1.1.3


    org.jooby
    jooby-undertow
    1.1.3

Vous pouvez vérifier la dernière version du projetJooby dans lesCentral Maven Repository.

Jooby also has a dedicated Maven archetype. Nous pouvons l'utiliser pour créer un exemple de projet avec toutes les dépendances nécessaires pré-construites.

Nous pouvons utiliser le script suivant pour générer le projet exemple:

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

4. Création d'une application

4.1. Lancement du serveur

Pour démarrer le serveur intégré, nous devons utiliser l'extrait de code suivant:

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

Une fois démarré, le serveur fonctionnera surdefault port8080.

Nous pouvons également configurer le serveur principal avec un port personnalisé et un port personnaliséHTTPS:

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

4.2. Implémentation du routeur

Il est très facile de créer un routeur basé sur un chemin enJooby. Par exemple, nous pouvons créer un routeur pour le chemin «/login» de la manière suivante:

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

De la même manière, si nous voulons gérer d'autres méthodesHTTP comme POST, PUT, etc., nous pouvons utiliser l'extrait de code ci-dessous:

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

Ici, nous récupérons le jeton de nom de paramètre de requête à partir de la requête. Par défaut, tous les paramètres de requête sont convertis en type de donnéesJooby´sMutant. En fonction des attentes, nous pouvons le convertir en n’importe quel type de données primitif pris en charge.

Nous pouvons vérifier n'importe quel paramètre url de la manière suivante:

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

Nous pouvons utiliser l'un des éléments ci-dessus. Il est également possible de rechercher des paramètres commençant par un contenu fixe. Par exemple, nous pouvons trouver un paramètre d’URL commençant par ‘uid:' de la manière suivante:

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

4.3. Implémentation du contrôleur de modèle MVC

Pour une application d'entreprise,Jooby est livré avec une API MVC, un peu comme n'importe quel autre framework MVC comme Spring MVC.

Par exemple, nous pouvons gérer un chemin appelé «/hello»:

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

De la même manière, nous pouvons créer un gestionnaire pour gérer d'autres méthodes HTTP avec@POST, @PUT, @DELETE, etc. annotation.

4.4. Gestion du contenu statique

Pour servir tout contenu statique tel que HTML, Javascript, CSS, image, etc., nous devons placer ces fichiers dans le répertoirepublic.

Une fois placé, à partir du routeur, nous pouvons mapper n’importe quelle URL sur ces ressources:

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

4.5. Formulaire de traitement

L'interface deJooby’sRequest gère par défaut tout objet de formulaire sans utiliser de conversion de type manuel.

Supposons que nous devions soumettre les détails des employés via un formulaire. Dans un premier temps, nous devons créer un objet beanEmployee que nous utiliserons pour contenir les données:

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

    // standard constructors, getters and setters
}

Maintenant, nous devons créer une page pour créer le formulaire:

Ensuite, nous allons créer un gestionnaire de publication pour traiter ce formulaire et récupérer les données envoyées:

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

Le point à noter ici est que nous devons déclarer le formulaireenctype commeapplication/x-www-form-urlencoded pour prendre en charge la liaison de formulaire dynamique.

ParRequest.file(String filename), nous pouvons récupérer le fichier téléchargé:

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

4.6. Implémentation d'un filtre

Out of the box, Jooby offre la flexibilité de définir des filtres globaux ainsi que les filtres basés sur les chemins.

La mise en œuvre du filtre dansJooby est un peu délicate depuiswe need to configure the URL path twice, once for the filter and once again for the handler.

Par exemple, si nous devons implémenter un filtre pour un chemin d’URL appelé ‘/filter',, nous devons implémenter le filtre dans ce chemin de manière explicite:

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

La syntaxe est très similaire au filtreServlet. Il est possible de restreindre la demande et de renvoyer la réponse dans le filtre lui-même en appelant la méthodeResponse.send(Result result).

Une fois le filtre implémenté, nous devons implémenter le gestionnaire de requêtes:

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

4.7. Session

Jooby est fourni avec deux types d'implémentation de session; en mémoire et à base de cookies.

La mise en œuvre de la gestion de session en mémoire est assez simple. Nous avons la possibilité de choisir l'un des magasins de session à haut débit disponibles avecJooby commeEhCache, Guava, HazleCast, Cassandra, Couchbase, Redis, MongoDB, etMemcached.

Par exemple, pour implémenter un stockage de session basé sur Redis, nous devons ajouter la dépendance Maven suivante:


    org.jooby
    jooby-jedis
    1.1.3

Maintenant, nous pouvons utiliser l’extrait de code ci-dessous pour activer la gestion de session:

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

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

Le point à noter ici est que nous pouvons configurer l'url deRedis comme propriété‘db' dans leapplication.conf.

Pour activer la gestion de session basée sur les cookies, nous devons déclarercookieSession(). If cookie based approach is selected, we must need to declare application.secret property in the application.conf file. Étant donné que chaque cookie sera signé sera signé avec cette clé secrète, il est toujours conseillé d'utiliser un long fragment de chaîne aléatoire comme clé secrète. **

Dans l'approche en mémoire et basée sur les cookies, nous devons déclarer le paramètre de configuration nécessaire dans le fichierapplication.conf, sinon l'application lancera unIllegalStateException au démarrage.

5. Essai

Tester un itinéraire MVC est en effet facile car un itinéraire est lié à une stratégie pour une classe. Cela facilite l'exécution de tests unitaires sur tous les itinéraires.

Par exemple, nous pouvons rapidement créer un scénario de test pour l’URL par défaut:

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");
    }
}

Il faut noter ici que l'utilisation de l'annotation@ClassRule ne créera qu'une seule instance du serveur pour tous les cas de test. Si nous avons besoin de construire des instances séparées des serveurs pour chaque cas de test, nous devons utiliser l'annotation@Rule sans le modificateur statique.

Nous pouvons également utiliserJooby’s MockRouter pour tester le chemin de la même manière:

@Test
public void given_defaultUrl_with_mockrouter_expect_fixedString()
  throws Throwable {

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

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

6. Conclusion

Dans ce tutoriel, nous avons exploré le projetJooby et ses fonctionnalités essentielles.

Comme toujours, le code source complet est disponibleover on GitHub.

TOC

Introduction à Jooby