Introduzione a giocare in Java

1. Panoramica

Lo scopo di questo tutorial introduttivo è esplorare il Play Framework e capire come possiamo creare un'applicazione web con esso.

Play è un framework per applicazioni web ad alta produttività per linguaggi di programmazione il cui codice è compilato ed eseguito su JVM, principalmente Java e Scala. Integra i componenti e le API di cui abbiamo bisogno per lo sviluppo di applicazioni web moderne.

2. Riproduci Framework Setup

Andiamo alla pagina ufficiale del framework Play e scarichiamo l'ultima versione della distribuzione. Al momento di questo tutorial, l'ultima è la versione 2.7.

Scaricare la cartella zip del tutorial Play Java Hello World e decomprimere il file in una posizione comoda. Alla radice di questa cartella, troveremo un eseguibile sbt che possiamo usare per eseguire l'applicazione. In alternativa, possiamo installare sbt dalla loro pagina ufficiale.

Per utilizzare sbt dalla cartella scaricata, procedi come segue:

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

Notare che stiamo eseguendo uno script nella directory corrente, da qui l'uso della sintassi ./ .

Se installiamo sbt, possiamo usarlo invece:

cd /path/to/folder/ sbt run

Dopo aver eseguito questo comando, vedremo un'istruzione che dice "(Server avviato, usa Invio per fermarti e tornare alla console ...)". Ciò significa che la nostra applicazione è pronta, quindi ora possiamo andare su // localhost: 9000 dove ci verrà presentata una pagina di benvenuto di Play:

3. Anatomia delle applicazioni di gioco

In questa sezione, avremo una migliore comprensione di come è strutturata un'applicazione Play e per cosa viene utilizzato ogni file e directory in quella struttura.

Se desideri metterti alla prova con un semplice esempio subito, passa alla sezione successiva.

Questi sono i file e le cartelle che troviamo in una tipica applicazione Play Framework:

├── 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. La directory dell'app

Questa directory contiene codice sorgente Java, modelli web e sorgenti di risorse compilate - in pratica, tutte le sorgenti e tutte le risorse eseguibili.

La directory dell'app contiene alcune importanti sottodirectory, ognuna delle quali racchiude una parte del modello architettonico MVC:

  • modelli : questo è il livello aziendale dell'applicazione, i file in questo pacchetto probabilmente modelleranno le nostre tabelle di database e ci consentiranno di accedere al livello di persistenza
  • viste : tutti i modelli HTML che possono essere visualizzati nel browser sono contenuti in questa cartella
  • controllers - una sottodirectory in cui abbiamo i nostri controller. I controller sono file di origine Java che contengono azioni da eseguire per ciascuna chiamata API. Le azioni sono metodi pubblici che elaborano richieste HTTP e restituiscono risultati uguali alle risposte HTTP
  • assets : una sottodirectory che contiene risorse compilate come CSS e javascript. Le convenzioni di denominazione di cui sopra sono flessibili, possiamo creare i nostri pacchetti, ad esempio un pacchetto app / utils . Possiamo anche personalizzare l' app di denominazione dei pacchetti / com / baeldung / controllers

Contiene anche file e directory opzionali secondo le esigenze dell'applicazione specifica.

3.2. La directory pubblica

Le risorse archiviate nella directory pubblica sono risorse statiche servite direttamente dal server Web.

Questa directory di solito ha tre sottodirectory per immagini, file CSS e JavaScript. Si consiglia di organizzare i file delle risorse in questo modo per coerenza in tutte le applicazioni Play.

3.3. La directory conf

La directory conf contiene i file di configurazione dell'applicazione. Il file application.conf è dove metteremo la maggior parte delle proprietà di configurazione per l'applicazione Play. Definiremo gli endpoint per l'app nelle rotte .

Se l'applicazione necessita di file di configurazione aggiuntivi, è necessario inserirli in questa directory.

3.4. La directory lib

La directory lib è facoltativa e contiene dipendenze di librerie non gestite. Se abbiamo dei jar che non sono specificati nel sistema di compilazione, li mettiamo in questa directory. Verranno aggiunti automaticamente al classpath dell'applicazione.

3.5. Il file build.sbt

Il file build.sbt è lo script di compilazione dell'applicazione. Qui è dove vengono elencate le dipendenze necessarie per eseguire l'applicazione, come le librerie di test e persistenza.

3.6. La directory del progetto

Tutti i file che configurano il processo di compilazione basato su SBT si trovano nella directory del progetto .

3.7. La directory di destinazione

Questa directory contiene tutti i file generati dal sistema di compilazione, ad esempio tutti i file .class .

Dopo aver visto ed esplorato la struttura delle directory per l'esempio Hello World di Play Framework che abbiamo appena scaricato, ora possiamo esaminare i fondamenti del framework utilizzando un esempio.

4. Semplice esempio

In questa sezione creeremo un esempio molto semplice di un'applicazione web. Useremo questa applicazione per familiarizzare con i fondamenti del framework Play.

Invece di scaricare un progetto di esempio e costruire da esso, vediamo un altro modo in cui possiamo creare un'applicazione Play Framework, usando il comando sbt new .

Apriamo un prompt dei comandi, andiamo alla nostra posizione preferita ed eseguiamo il seguente comando:

sbt new playframework/play-java-seed.g8

Per questo, avremo bisogno di avere già installato sbt come spiegato nella Sezione 2.

Il comando precedente ci chiederà prima un nome per il progetto. Successivamente, chiederà il dominio (al contrario, come è la convenzione di denominazione dei pacchetti in Java) che verrà utilizzato per i pacchetti. Premiamo Invio senza digitare un nome se vogliamo mantenere i valori predefiniti che sono indicati tra parentesi quadre.

L'applicazione generata con questo comando ha la stessa struttura di quella generata in precedenza. Possiamo, quindi, procedere ad eseguire l'applicazione come abbiamo fatto in precedenza:

cd /path/to/folder/ sbt run

Il comando precedente, dopo il completamento dell'esecuzione, genererà un server sulla porta numero 9000 per esporre la nostra API , a cui possiamo accedere tramite // localhost: 9000 . Dovremmo vedere il messaggio "Welcome to Play" nel browser.

La nostra nuova API ha due endpoint che ora possiamo provare a turno dal browser. Il primo, che abbiamo appena caricato, è l'endpoint root, che carica una pagina di indice con il messaggio "Welcome to Play!" Messaggio.

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.

Cerchiamo di personalizzare la risposta per HomeController.customContentType azione per text / html :

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

Questo modello si adatta a tutti i tipi di tipi di contenuto. A seconda del formato dei dati che passiamo al metodo ok helper, possiamo sostituire text / html con text / plain o application / json .

Possiamo fare qualcosa di simile per impostare le intestazioni:

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

7. Conclusione

In questo articolo, abbiamo esplorato le basi del Play Framework. Siamo anche stati in grado di creare un'applicazione web Java di base utilizzando Play.

Come al solito, il codice sorgente di questo tutorial è disponibile su GitHub.