Introduction à jouer en Java

1. Vue d'ensemble

Le but de ce didacticiel d'introduction est d'explorer le framework Play et de comprendre comment nous pouvons créer une application Web avec.

Play est un framework d'application Web à haute productivité pour les langages de programmation dont le code est compilé et exécuté sur la JVM, principalement Java et Scala. Il intègre les composants et les API dont nous avons besoin pour le développement d'applications Web modernes.

2. Configuration de Play Framework

Rendons-nous sur la page officielle du framework Play et téléchargeons la dernière version de la distribution. Au moment de ce tutoriel, la dernière est la version 2.7.

Nous téléchargerons le dossier zip du didacticiel Play Java Hello World et décompresserons le fichier dans un emplacement pratique. À la racine de ce dossier, nous trouverons un exécutable sbt que nous pouvons utiliser pour exécuter l'application. Alternativement, nous pouvons installer sbt depuis leur page officielle.

Pour utiliser sbt à partir du dossier téléchargé, procédons comme suit:

cd /path/to/folder/ ./sbt run

Notez que nous exécutons un script dans le répertoire courant, d'où l'utilisation de la syntaxe ./ .

Si nous installons sbt, nous pouvons l'utiliser à la place:

cd /path/to/folder/ sbt run

Après avoir exécuté cette commande, nous verrons une instruction qui dit «(Le serveur a démarré, utilisez Entrée pour arrêter et revenir à la console…)». Cela signifie que notre application est prête, nous pouvons donc maintenant nous diriger vers // localhost: 9000 où nous serons présentés avec une page de bienvenue de lecture:

3. Anatomie des applications Play

Dans cette section, nous allons mieux comprendre comment une application Play est structurée et à quoi sert chaque fichier et répertoire de cette structure.

Si vous souhaitez vous mettre tout de suite au défi avec un exemple simple, passez à la section suivante.

Voici les fichiers et dossiers que nous trouvons dans une application Play Framework classique:

├── app → Application sources │   ├── assets → Compiled Asset sources │   │   ├── javascripts → Typically Coffee Script sources │   │   └── stylesheets → Typically LESS CSS sources │   ├── controllers → Application controllers │   ├── models → Application business layer │   └── views → Templates ├── build.sbt → Application build script ├── conf → Configurations files and other non-compiled resources (on classpath) │   ├── application.conf → Main configuration file │   └── routes → Routes definition ├── dist → Arbitrary files to be included in your projects distribution ├── lib → Unmanaged libraries dependencies ├── logs → Logs folder │   └── application.log → Default log file ├── project → sbt configuration files │   ├── build.properties → Marker for sbt project │   └── plugins.sbt → sbt plugins including the declaration for Play itself ├── public → Public assets │   ├── images → Image files │   ├── javascripts → Javascript files │   └── stylesheets → CSS files ├── target → Generated files │   ├── resolution-cache → Information about dependencies │   ├── scala-2.11 │   │   ├── api → Generated API docs │   │   ├── classes → Compiled class files │   │   ├── routes → Sources generated from routes │   │   └── twirl → Sources generated from templates │   ├── universal → Application packaging │   └── web → Compiled web assets └── test → source folder for unit or functional tests 

3.1. Le répertoire des applications

Ce répertoire contient le code source Java, les modèles Web et les sources des ressources compilées - essentiellement toutes les sources et toutes les ressources exécutables.

Le répertoire de l' application contient des sous-répertoires importants, chacun contenant une partie du modèle architectural MVC:

  • modèles - c'est la couche métier de l'application, les fichiers de ce package modéliseront probablement nos tables de base de données et nous permettront d'accéder à la couche de persistance
  • vues - tous les modèles HTML qui peuvent être rendus dans le navigateur sont contenus dans ce dossier
  • contrôleurs - un sous-répertoire dans lequel nous avons nos contrôleurs. Les contrôleurs sont des fichiers source Java contenant des actions à exécuter pour chaque appel d'API. Les actions sont des méthodes publiques qui traitent les requêtes HTTP et renvoient les mêmes résultats que les réponses HTTP
  • assets - un sous-répertoire qui contient des actifs compilés tels que CSS et javascript. Les conventions de dénomination ci-dessus sont flexibles, nous pouvons créer nos packages, par exemple un package app / utils . Nous pouvons également personnaliser l' application de nom de package / com / baeldung / controllers

Il contient également des fichiers et répertoires facultatifs selon les besoins de l'application particulière.

3.2. L' annuaire public

Les ressources stockées dans l' annuaire public sont des actifs statiques qui sont servis directement par le serveur Web.

Ce répertoire contient généralement trois sous-répertoires pour les fichiers images, CSS et JavaScript. Il est recommandé d'organiser les fichiers d'actifs comme celui-ci par souci de cohérence dans toutes les applications Play.

3.3. Le répertoire conf

Le répertoire conf contient les fichiers de configuration de l'application. Le fichier application.conf est l'endroit où nous mettrons la plupart des propriétés de configuration de l'application Play. Nous définirons des points de terminaison pour l'application dans les routes .

Si l'application a besoin de fichiers de configuration supplémentaires, ils doivent être placés dans ce répertoire.

3.4. Le répertoire lib

Le répertoire lib est facultatif et contient des dépendances de bibliothèque non gérées. Si nous avons des fichiers JAR qui ne sont pas spécifiés dans le système de construction, nous les mettons dans ce répertoire. Ils seront ajoutés automatiquement au chemin de classe de l'application.

3.5. Le fichier build.sbt

Le fichier build.sbt est le script de création de l'application. C'est ici que nous listons les dépendances nécessaires pour exécuter l'application, telles que les bibliothèques de test et de persistance.

3.6. Le répertoire du projet

Tous les fichiers qui configurent le processus de construction basé sur SBT se trouvent dans le répertoire du projet .

3.7. Le répertoire cible

Ce répertoire contient tous les fichiers générés par le système de construction - par exemple, tous les fichiers .class .

Après avoir vu et exploré la structure de répertoires de l'exemple Play Framework Hello World que nous venons de télécharger, nous pouvons maintenant passer en revue les principes de base du framework à l'aide d'un exemple.

4. Exemple simple

Dans cette section, nous allons créer un exemple très basique d'application Web. Nous utiliserons cette application pour nous familiariser avec les principes de base du framework Play.

Au lieu de télécharger un exemple de projet et de le construire à partir de celui-ci, voyons une autre façon de créer une application Play Framework, en utilisant la commande sbt new .

Ouvrons une invite de commande, accédez à l'emplacement de votre choix et exécutons la commande suivante:

sbt new playframework/play-java-seed.g8

For this one, we'll need to have installed sbt already as explained in Section 2.

The above command will prompt us for a name for the project first. Next, it will ask for the domain (in reverse, as is the package naming convention in Java) that will be used for the packages. We press Enter without typing a name if we want to keep the defaults which are given in square brackets.

The application generated with this command has the same structure as the one generated earlier. We can, therefore, proceed to run the application as we did previously:

cd /path/to/folder/ sbt run

The above command, after completion of execution, will spawn a server on port number 9000 to expose our API, which we can access through //localhost:9000. We should see the message “Welcome to Play” in the browser.

Our new API has two endpoints that we can now try out in turn from the browser. The first one – which we have just loaded – is the root endpoint, which loads an index page with the “Welcome to Play!” message.

The second one, at //localhost:9000/assets, is meant for downloading files from the server by adding a file name to the path. We can test this endpoint by getting the favicon.png file, which was downloaded with the application, at //localhost:9000/assets/images/favicon.png.

5. Actions and Controllers

A Java method inside a controller class that processes request parameters and produces a result to be sent to the client is called an action.

A controller is a Java class that extends play.mvc.Controller that logically groups together actions that may be related to results they produce for the client.

Let's now head over to app-parent-dir/app/controllers and pay attention to HomeController.java.

The HomeController‘s index action returns a web page with a simple welcome message:

public Result index() { return ok(views.html.index.render()); }

This web page is the default index template in the views package:

@main("Welcome to Play") {  }

As shown above, the index page calls the main template. The main template then handles the rendering of the page header and body tags. It takes two arguments: a String for the title of the page and an Html object to insert into the body of the page.

@(title: String)(content: Html)    @* Here's where we render the page title `String`. *@ @title     @* And here's where we render the `Html` object containing * the page content. *@ @content   

Let's change the text in the index file a little:

@main("Welcome to Baeldung") {  }

Reloading the browser will give us a bold heading:

Welcome to Play Framework Tutorial on Baeldung!

We can do away with the template completely by removing the render directive in the index() method of the HomeController so that we can return plain text or HTML text directly:

public Result index() { return ok("REST API with Play by Baeldung"); }

After editing the code, as shown above, we'll have only the text in the browser. This will just be plain text without any HTML or styling:

REST API with Play by Baeldung

We could just as well output HTML by wrapping the text in the header tags and then passing the HTML text to the Html.apply method. Feel free to play around with it.

Let's add a /baeldung/html endpoint in routes:

GET /baeldung/html controllers.HomeController.applyHtml

Now let's create the controller that handles requests on this endpoint:

public Result applyHtml() { return ok(Html.apply("")); }

When we visit //localhost:9000/baeldung/html we'll see the above text formatted in HTML.

We've manipulated our response by customizing the response type. We'll look into this feature in more detail in a later section.

We have also seen two other important features of the Play Framework.

First, reloading the browser reflects the most recent version of our code; that's because our code changes are compiled on the fly.

Secondly, Play provides us with helper methods for standard HTTP responses in the play.mvc.Results class. An example is the ok() method, which returns an OK HTTP 200 response alongside the response body we pass to it as a parameter. We've already used the method displaying text in the browser.

There are more helper methods such as notFound() and badRequest() in the Results class.

6. Manipulating Results

We have been benefiting from Play's content negotiation feature without even realizing it. Play automatically infers response content type from the response body. This is why we have been able to return the text in the ok method:

return ok("text to display");

And then Play would automatically set the Content-Type header to text/plain. Although this works in most cases, we can take over control and customize the content type header.

Nous allons personnaliser la réponse pour HomeController.customContentType action text / html :

public Result customContentType() { return ok("This is some text content").as("text/html"); }

Ce modèle recoupe toutes sortes de types de contenu. Selon le format des données que nous transmettons à la méthode d'assistance ok , nous pouvons remplacer text / html par text / plain ou application / json .

Nous pouvons faire quelque chose de similaire pour définir les en-têtes:

public Result setHeaders() { return ok("This is some text content") .as("text/html") .withHeader("Header-Key", "Some value"); }

7. Conclusion

Dans cet article, nous avons exploré les bases du Play Framework. Nous avons également pu créer une application Web Java de base à l'aide de Play.

Comme d'habitude, le code source de ce tutoriel est disponible à l'adresse over sur GitHub.