Einführung in Java

1. Übersicht

Der Zweck dieses Intro-Tutorials ist es, das Play Framework zu erkunden und herauszufinden, wie wir damit eine Webanwendung erstellen können.

Play ist ein hochproduktives Webanwendungsframework für Programmiersprachen, dessen Code auf der JVM kompiliert und ausgeführt wird, hauptsächlich Java und Scala. Es integriert die Komponenten und APIs, die wir für die moderne Entwicklung von Webanwendungen benötigen.

2. Spielen Sie das Framework-Setup

Gehen wir zur offiziellen Seite des Play Frameworks und laden die neueste Version der Distribution herunter. Zum Zeitpunkt dieses Tutorials ist die neueste Version 2.7.

Wir werden den Zip-Ordner des Play Java Hello World-Tutorials herunterladen und die Datei an einem geeigneten Ort entpacken. Im Stammverzeichnis dieses Ordners finden Sie eine ausführbare sbt- Datei, mit der wir die Anwendung ausführen können. Alternativ können wir sbt von ihrer offiziellen Seite installieren .

Gehen Sie wie folgt vor, um sbt aus dem heruntergeladenen Ordner zu verwenden:

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

Beachten Sie, dass wir ein Skript im aktuellen Verzeichnis ausführen, daher die Verwendung der ./- Syntax.

Wenn wir sbt installieren , können wir es stattdessen verwenden:

cd /path/to/folder/ sbt run

Nachdem Sie diesen Befehl ausgeführt haben, wird eine Anweisung mit dem Titel "(Server gestartet, verwenden Sie die Eingabetaste, um anzuhalten und zur Konsole zurückzukehren ...)" angezeigt. Dies bedeutet, dass unsere Anwendung fertig ist. Daher können wir jetzt zu // localhost: 9000 gehen, wo uns eine Play Welcome-Seite angezeigt wird:

3. Anatomie der Spielanwendungen

In diesem Abschnitt erfahren Sie besser, wie eine Play-Anwendung aufgebaut ist und wofür die einzelnen Dateien und Verzeichnisse in dieser Struktur verwendet werden.

Wenn Sie sich sofort zu einem einfachen Beispiel herausfordern möchten, fahren Sie mit dem nächsten Abschnitt fort.

Dies sind die Dateien und Ordner, die wir in einer typischen Play Framework-Anwendung finden:

├── 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. Das App- Verzeichnis

Dieses Verzeichnis enthält Java-Quellcode, Webvorlagen und Quellen kompilierter Assets - im Grunde alle Quellen und alle ausführbaren Ressourcen.

Das App- Verzeichnis enthält einige wichtige Unterverzeichnisse, von denen jedes einen Teil des MVC-Architekturmusters enthält:

  • Modelle - Dies ist die Anwendungsgeschäftsschicht. Die Dateien in diesem Paket werden wahrscheinlich unsere Datenbanktabellen modellieren und uns den Zugriff auf die Persistenzschicht ermöglichen
  • Ansichten - In diesem Ordner sind alle HTML-Vorlagen enthalten, die im Browser gerendert werden können
  • Controller - ein Unterverzeichnis, in dem wir unsere Controller haben. Controller sind Java-Quelldateien, die Aktionen enthalten, die für jeden API-Aufruf ausgeführt werden müssen. Aktionen sind öffentliche Methoden, die HTTP-Anforderungen verarbeiten und Ergebnisse zurückgeben, die denen von HTTP-Antworten entsprechen
  • Assets - Ein Unterverzeichnis, das kompilierte Assets wie CSS und Javascript enthält. Die oben genannten Namenskonventionen sind flexibel. Wir können unsere Pakete erstellen, z. B. ein App / Utils- Paket. Wir können auch die Paketnamen- App / com / baeldung / controller anpassen

Es enthält auch optionale Dateien und Verzeichnisse, die von der jeweiligen Anwendung benötigt werden.

3.2. Das öffentliche Verzeichnis

Im öffentlichen Verzeichnis gespeicherte Ressourcen sind statische Assets, die direkt vom Webserver bereitgestellt werden.

Dieses Verzeichnis enthält normalerweise drei Unterverzeichnisse für Bilder, CSS- und JavaScript-Dateien. Es wird empfohlen, die Asset-Dateien so zu organisieren, dass sie in allen Play-Anwendungen konsistent sind.

3.3. Das conf- Verzeichnis

Das Verzeichnis conf enthält Anwendungskonfigurationsdateien. In der application.conf werden die meisten Konfigurationseigenschaften für die Play-Anwendung abgelegt. Wir definieren Endpunkte für die App in Routen .

Wenn die Anwendung zusätzliche Konfigurationsdateien benötigt, sollten diese in dieses Verzeichnis gestellt werden.

3.4. Das lib- Verzeichnis

Das lib- Verzeichnis ist optional und enthält nicht verwaltete Bibliotheksabhängigkeiten. Wenn wir Gläser haben, die nicht im Build-System angegeben sind, legen wir sie in diesem Verzeichnis ab. Sie werden automatisch zum Anwendungsklassenpfad hinzugefügt.

3.5. Die build.sbt- Datei

Die Datei build.sbt ist das Anwendungserstellungsskript. Hier listen wir die zum Ausführen der Anwendung erforderlichen Abhängigkeiten auf, z. B. Test- und Persistenzbibliotheken.

3.6. Das Projekt Verzeichnis

Alle Dateien, die den Erstellungsprozess basierend auf SBT konfigurieren, befinden sich im Projektverzeichnis .

3.7. Das Zielverzeichnis

Dieses Verzeichnis enthält alle vom Build-System generierten Dateien, z. B. alle .class- Dateien.

Nachdem wir die Verzeichnisstruktur für das gerade heruntergeladene Play Framework Hello World-Beispiel gesehen und untersucht haben, können wir nun anhand eines Beispiels die Grundlagen des Frameworks durchgehen.

4. Einfaches Beispiel

In diesem Abschnitt erstellen wir ein sehr einfaches Beispiel für eine Webanwendung. Wir werden diese Anwendung verwenden, um uns mit den Grundlagen des Play-Frameworks vertraut zu machen.

Anstatt ein Beispielprojekt herunterzuladen und daraus aufzubauen , sehen wir uns eine andere Möglichkeit an, wie wir mit dem Befehl sbt new eine Play Framework-Anwendung erstellen können .

Öffnen Sie eine Eingabeaufforderung, navigieren Sie zu dem Speicherort Ihrer Wahl und führen Sie den folgenden Befehl aus:

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.

Passen wir die Antwort für die Aktion HomeController.customContentType an text / html an :

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

Dieses Muster erstreckt sich über alle Arten von Inhaltstypen. Abhängig vom Format der Daten, die wir an die ok- Hilfsmethode übergeben, können wir text / html durch text / plain oder application / json ersetzen .

Wir können etwas Ähnliches tun, um Header zu setzen:

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

7. Fazit

In diesem Artikel haben wir die Grundlagen des Play Frameworks untersucht. Mit Play konnten wir auch eine grundlegende Java-Webanwendung erstellen.

Wie üblich ist der Quellcode für dieses Tutorial auf GitHub verfügbar.