Introducción a jugar en Java

1. Información general

El propósito de este tutorial de introducción es explorar Play Framework y descubrir cómo podemos crear una aplicación web con él.

Play es un marco de aplicaciones web de alta productividad para lenguajes de programación cuyo código se compila y ejecuta en la JVM, principalmente Java y Scala. Integra los componentes y las API que necesitamos para el desarrollo de aplicaciones web modernas.

2. Configuración de Play Framework

Vayamos a la página oficial del marco de Play y descarguemos la última versión de la distribución. En el momento de este tutorial, la última es la versión 2.7.

Descargaremos la carpeta zip del tutorial Play Java Hello World y descomprimiremos el archivo en una ubicación conveniente. En la raíz de esta carpeta, encontraremos un ejecutable sbt que podemos usar para ejecutar la aplicación. Alternativamente, podemos instalar sbt desde su página oficial.

Para usar sbt de la carpeta descargada, hagamos lo siguiente:

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

Tenga en cuenta que estamos ejecutando un script en el directorio actual, de ahí el uso de la sintaxis ./ .

Si instalamos sbt, podemos usarlo en su lugar:

cd /path/to/folder/ sbt run

Después de ejecutar este comando, veremos una declaración que dice “(Servidor iniciado, use Enter para detener y volver a la consola…)”. Esto significa que nuestra aplicación está lista, por lo que ahora podemos ir a // localhost: 9000 donde se nos presentará una página de bienvenida de Play:

3. Anatomía de las aplicaciones de juego

En esta sección, comprenderemos mejor cómo está estructurada una aplicación Play y para qué se utiliza cada archivo y directorio en esa estructura.

Si desea desafiarse a sí mismo con un ejemplo simple de inmediato, pase a la siguiente sección.

Estos son los archivos y carpetas que encontramos en una aplicación típica de 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. El directorio de aplicaciones

Este directorio contiene código fuente de Java, plantillas web y fuentes de activos compilados, básicamente, todas las fuentes y todos los recursos ejecutables.

El directorio de la aplicación contiene algunos subdirectorios importantes, cada uno de los cuales empaqueta una parte del patrón arquitectónico MVC:

  • modelos : esta es la capa empresarial de la aplicación, los archivos de este paquete probablemente modelarán nuestras tablas de base de datos y nos permitirán acceder a la capa de persistencia
  • vistas : todas las plantillas HTML que se pueden representar en el navegador están incluidas en esta carpeta
  • controladores : un subdirectorio en el que tenemos nuestros controladores. Los controladores son archivos fuente de Java que contienen acciones que se ejecutarán para cada llamada a la API. Las acciones son métodos públicos que procesan las solicitudes HTTP y devuelven los mismos resultados que las respuestas HTTP.
  • assets : un subdirectorio que contiene recursos compilados como CSS y javascript. Las convenciones de nomenclatura anteriores son flexibles, podemos crear nuestros paquetes, por ejemplo, un paquete de aplicaciones / utils . También podemos personalizar la aplicación de nombres de paquetes / com / baeldung / controllers

También contiene archivos y directorios opcionales según lo necesite la aplicación en particular.

3.2. El directorio público

Los recursos almacenados en el directorio público son activos estáticos que son servidos directamente por el servidor web.

Este directorio generalmente tiene tres subdirectorios para imágenes, CSS y archivos JavaScript. Se recomienda que organicemos los archivos de activos de esta manera para mantener la coherencia en todas las aplicaciones de Play.

3.3. El directorio conf

El directorio conf contiene archivos de configuración de la aplicación. El application.conf es donde vamos a poner la mayor parte de las propiedades de configuración para la aplicación de reproducción. Definiremos puntos finales para la aplicación en rutas .

Si la aplicación necesita archivos de configuración adicionales, deben colocarse en este directorio.

3.4. El directorio lib

El directorio lib es opcional y contiene dependencias de bibliotecas no administradas. Si tenemos archivos jar que no están especificados en el sistema de compilación, los colocamos en este directorio. Se agregarán automáticamente a la ruta de clases de la aplicación.

3.5. El archivo build.sbt

El archivo build.sbt es el script de creación de la aplicación. Aquí es donde enumeramos las dependencias necesarias para ejecutar la aplicación, como las bibliotecas de prueba y persistencia.

3.6. El directorio del proyecto

Todos los archivos que configuran el proceso de construcción basado en SBT se encuentran en el directorio del proyecto .

3.7. El directorio de destino

Este directorio contiene todos los archivos generados por el sistema de compilación, por ejemplo, todos los archivos .class .

Habiendo visto y explorado la estructura de directorios para el ejemplo de Hello World de Play Framework que acabamos de descargar, ahora podemos revisar los fundamentos del framework usando un ejemplo.

4. Ejemplo simple

En esta sección, crearemos un ejemplo muy básico de una aplicación web. Usaremos esta aplicación para familiarizarnos con los fundamentos del marco de Play.

En lugar de descargar un proyecto de ejemplo y construirlo a partir de él, veamos otra forma en que podemos crear una aplicación Play Framework, usando el comando sbt new .

Abramos un símbolo del sistema, naveguemos a la ubicación que elijamos y ejecutemos el siguiente comando:

sbt new playframework/play-java-seed.g8

Para este, necesitaremos haber instalado sbt como se explica en la Sección 2.

El comando anterior nos pedirá primero un nombre para el proyecto. A continuación, pedirá el dominio (a la inversa, como es la convención de nomenclatura de paquetes en Java) que se utilizará para los paquetes. Presionamos Enter sin escribir un nombre si queremos mantener los valores predeterminados que se dan entre corchetes.

La aplicación generada con este comando tiene la misma estructura que la generada anteriormente. Podemos, por tanto, proceder a ejecutar la aplicación como hicimos anteriormente:

cd /path/to/folder/ sbt run

El comando anterior, después de completar la ejecución, generará un servidor en el puerto número 9000 para exponer nuestra API , a la que podemos acceder a través de // localhost: 9000 . Deberíamos ver el mensaje "Bienvenido a jugar" en el navegador.

Nuestra nueva API tiene dos puntos finales que ahora podemos probar a su vez desde el navegador. El primero, que acabamos de cargar, es el extremo raíz, que carga una página de índice con el mensaje "¡Bienvenido a jugar!" mensaje.

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.

Vamos a personalizar la respuesta de HomeController.customContentType acción para text / html :

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

Este patrón atraviesa todo tipo de contenido. Dependiendo del formato de los datos que pasemos al método ok helper, podemos reemplazar text / html por text / plain o application / json .

Podemos hacer algo similar para establecer encabezados:

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

7. Conclusión

En este artículo, hemos explorado los conceptos básicos de Play Framework. También pudimos crear una aplicación web Java básica usando Play.

Como de costumbre, el código fuente de este tutorial está disponible en GitHub.