By Version

Motor de plantillas Qute

Qute is a templating engine designed specifically to meet the Quarkus needs. The usage of reflection is minimized to reduce the size of native images. The API combines both the imperative and the non-blocking reactive style of coding. In the development mode, all files located in src/main/resources/templates are watched for changes and modifications are immediately visible. Furthermore, we try to detect most of the template problems at build time. In this guide, you will learn how to easily render templates in your application.

Solución

Recomendamos que siga las instrucciones de las siguientes secciones y cree la aplicación paso a paso. Sin embargo, también puede ir directamente al ejemplo completo.

Clone el repositorio Git: git clone -b 3.8 https://github.com/quarkusio/quarkus-quickstarts.git o descargue un archivo.

La solución se encuentra en el qute-quickstart directorio.

Hello World with Jakarta REST

If you want to use Qute in your Jakarta REST application, you need to add an extension first:

either quarkus-resteasy-reactive-qute if you are using RESTEasy Reactive:

pom.xml

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-reactive-qute</artifactId>
</dependency>

build.gradle

implementation("io.quarkus:quarkus-resteasy-reactive-qute")

or quarkus-resteasy-qute if you are using RESTEasy Classic:

pom.xml

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-qute</artifactId>
</dependency>

build.gradle

implementation("io.quarkus:quarkus-resteasy-qute")

Empezaremos con una plantilla muy sencilla:

hello.txt

Hello {name}! (1)

1	`{name}` es una expresión de valor que se evalúa cuando se renderiza la plantilla.

By default, all files located in the src/main/resources/templates directory and its subdirectories are registered as templates. Templates are validated during startup and watched for changes in the development mode.

Ahora vamos a inyectar la plantilla "compilada" en la clase de recursos.

HelloResource.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import io.quarkus.qute.TemplateInstance;
import io.quarkus.qute.Template;

@Path("hello")
public class HelloResource {

    @Inject
    Template hello; (1)

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public TemplateInstance get(@QueryParam("name") String name) {
        return hello.data("name", name); (2) (3)
    }
}

1	Si no se proporciona el calificador `@Location`, se utiliza el nombre del campo para localizar la plantilla. En este caso particular, estamos inyectando una plantilla con la ruta `templates/hello.txt`.
2	`Template.data()` devuelve una nueva instancia de plantilla que se puede personalizar antes de que se active el renderizado real. En este caso, ponemos el valor del nombre bajo la clave `name`. El mapa de datos es accesible durante el renderizado.
3	Note that we don’t trigger the rendering - this is done automatically by a special `ContainerResponseFilter` implementation.

Si su aplicación se está ejecutando, puede solicitar el punto final:

$ curl -w "\n" http://localhost:8080/hello?name=Martin
Hello Martin!

Plantillas con seguridad de tipos

Hay una forma alternativa de declarar sus plantillas en su código Java, que se basa en la siguiente convención:

Organise your template files in the /src/main/resources/templates directory, by grouping them into one directory per resource class. So, if your ItemResource class references two templates hello and goodbye, place them at /src/main/resources/templates/ItemResource/hello.txt and /src/main/resources/templates/ItemResource/goodbye.txt. Grouping templates per resource class makes it easier to navigate to them.
En cada una de sus clases de recursos, declare una clase @CheckedTemplate static class Template {} dentro de su clase de recursos.
Declare un public static native TemplateInstance method(); por archivo de plantilla para su recurso.
Utilice esos métodos estáticos para construir sus instancias de plantilla.

Este es el ejemplo anterior, reescrito con este estilo:

Empezaremos con una plantilla muy sencilla:

HelloResource/hello.txt

Hello {name}! (1)

1	`{name}` es una expresión de valor que se evalúa cuando se renderiza la plantilla.

Now let’s declare and use those templates in the resource class.

HelloResource.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import io.quarkus.qute.TemplateInstance;
import io.quarkus.qute.CheckedTemplate;

@Path("hello")
public class HelloResource {

    @CheckedTemplate
    public static class Templates {
        public static native TemplateInstance hello(String name); (1)
    }

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public TemplateInstance get(@QueryParam("name") String name) {
        return Templates.hello(name); (2)
    }
}

1	Esto declara una plantilla con la ruta `templates/HelloResource/hello`.
2	`Templates.hello()` returns a new template instance that is returned from the resource method. Note that we don’t trigger the rendering - this is done automatically by a special `ContainerResponseFilter` implementation.

Una vez que haya declarado una clase @CheckedTemplate, comprobaremos que todos sus métodos apuntan a plantillas existentes, así que si intenta utilizar una plantilla de su código Java y se olvidó de añadirla, se lo haremos saber en el momento de la compilación :)

Tenga en cuenta que este estilo de declaración le permite referenciar plantillas declaradas en otros recursos también:

HelloResource.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import io.quarkus.qute.TemplateInstance;

@Path("goodbye")
public class GoodbyeResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public TemplateInstance get(@QueryParam("name") String name) {
        return HelloResource.Templates.hello(name);
    }
}

Plantillas de nivel superior con seguridad de tipos

Naturalmente, si desea declarar plantillas en el nivel superior, directamente en /src/main/resources/templates/hello.txt, por ejemplo, puede declararlas en una clase de nivel superior (no anidada) Templates:

HelloResource.java

package org.acme.quarkus.sample;

import io.quarkus.qute.TemplateInstance;
import io.quarkus.qute.Template;
import io.quarkus.qute.CheckedTemplate;

@CheckedTemplate
public class Templates {
    public static native TemplateInstance hello(String name); (1)
}

1	Esto declara una plantilla con la ruta `templates/hello`.

Declaraciones de parámetros de plantillas

Si declara una declaración de parámetro en una plantilla, Qute intenta validar todas las expresiones que hacen referencia a este parámetro y si se encuentra una expresión incorrecta la compilación falla.

Supongamos que tenemos una clase simple como esta:

Item.java

public class Item {
    public String name;
    public BigDecimal price;
}

Y nos gustaría renderizar una página HTML simple que contenga el nombre del artículo y el precio.

Empecemos de nuevo con la plantilla:

ItemResource/item.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>{item.name}</title> (1)
</head>
<body>
    <h1>{item.name}</h1>
    <div>Price: {item.price}</div> (2)
</body>
</html>

1	Esta expresión está validada. Intente cambiar la expresión a `{item.nonSense}` y la compilación debería fallar.
2	Esto también se valida.

Por último, vamos a crear una clase de recursos con plantillas con seguridad de tipos:

ItemResource.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import io.quarkus.qute.TemplateInstance;
import io.quarkus.qute.Template;
import io.quarkus.qute.CheckedTemplate;

@Path("item")
public class ItemResource {

    @CheckedTemplate
    public static class Templates {
        public static native TemplateInstance item(Item item); (1)
    }

    @GET
    @Path("{id}")
    @Produces(MediaType.TEXT_HTML)
    public TemplateInstance get(@PathParam("id") Integer id) {
        return Templates.item(service.findItem(id)); (2)
    }
}

1	Declare un método que nos da un `TemplateInstance` para `templates/ItemResource/item.html` y declare su parámetro `Item item` para que podamos validar la plantilla.
2	Haga que el objeto `Item` sea accesible en la plantilla.

When the --parameters compiler argument is enabled, RESTEasy Reactive may infer the parameter names from the method argument names, making the @PathParam("id") annotation optional in this case.

Declaración de parámetros de la plantilla dentro de la propia plantilla

Alternativamente, puede declarar los parámetros de la plantilla en el propio archivo de la plantilla.

Empecemos de nuevo con la plantilla:

item.html

{@org.acme.Item item} (1)
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>{item.name}</title> (2)
</head>
<body>
    <h1>{item.name}</h1>
    <div>Price: {item.price}</div>
</body>
</html>

1	Declaración opcional del parámetro. Qute intenta validar todas las expresiones que hacen referencia al parámetro `item`.
2	Esta expresión está validada. Intente cambiar la expresión a `{item.nonSense}` y la compilación debería fallar.

Por último, vamos a crear una clase de recursos.

ItemResource.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import io.quarkus.qute.TemplateInstance;
import io.quarkus.qute.Template;

@Path("item")
public class ItemResource {

    @Inject
    ItemService service;

    @Inject
    Template item; (1)

    @GET
    @Path("{id}")
    @Produces(MediaType.TEXT_HTML)
    public TemplateInstance get(Integer id) {
        return item.data("item", service.findItem(id)); (2)
    }
}

1	Inyecte la plantilla con la ruta `templates/item.html`.
2	Haga que el objeto `Item` sea accesible en la plantilla.

Métodos de extensión de plantillas

Los métodos de extensión de plantillas se utilizan para ampliar el conjunto de propiedades accesibles de los objetos de datos.

Sometimes, you’re not in control of the classes that you want to use in your template, and you cannot add methods to them. Template extension methods allows you to declare new method for those classes that will be available from your templates just as if they belonged to the target class.

Sigamos ampliando nuestra página HTML simple que contiene el nombre del artículo, el precio y añadamos un precio con descuento. El precio con descuento a veces se denomina "propiedad computada". Implementaremos un método de extensión de plantilla para renderizar esta propiedad fácilmente. Actualicemos nuestra plantilla:

HelloResource/item.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>{item.name}</title>
</head>
<body>
    <h1>{item.name}</h1>
    <div>Price: {item.price}</div>
    {#if item.price > 100} (1)
    <div>Discounted Price: {item.discountedPrice}</div> (2)
    {/if}
</body>
</html>

1	`if` es una sección de flujo de control básico.
2	Esta expresión también se valida contra la clase `Item` y, obviamente, no hay tal propiedad declarada. Sin embargo, hay un método de extensión de plantilla declarado en la clase `TemplateExtensions` - véase más abajo.

Por último, vamos a crear una clase en la que pondremos todos nuestros métodos de extensión:

TemplateExtensions.java

package org.acme.quarkus.sample;

import io.quarkus.qute.TemplateExtension;

@TemplateExtension
public class TemplateExtensions {

    public static BigDecimal discountedPrice(Item item) { (1)
        return item.price.multiply(new BigDecimal("0.9"));
    }
}

1	Se puede utilizar un método de extensión de plantilla estática para añadir "propiedades computadas" a una clase de datos. La clase del primer parámetro se utiliza para hacer coincidir el objeto base y el nombre del método se utiliza para hacer coincidir el nombre de la propiedad.

Puede colocar métodos de extensión de plantillas en cada clase si los anota con @TemplateExtension, pero le aconsejamos que los mantenga agrupados por tipo de destino o en una única clase TemplateExtensions por convención.

Renderizado de informes periódicos

Templating engine could be also very useful when rendering periodic reports. You’ll need to add the quarkus-scheduler and quarkus-qute extensions first. In your pom.xml file, add:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-qute</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-scheduler</artifactId>
</dependency>

Supongamos que tenemos un bean SampleService cuyo método get() devuelve una lista de muestras.

Sample.java

public class Sample {
    public boolean valid;
    public String name;
    public String data;
}

La plantilla es simple:

report.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Report {now}</title>
</head>
<body>
    <h1>Report {now}</h1>
    {#for sample in samples} (1)
      <h2>{sample.name ?: 'Unknown'}</h2> (2)
      <p>
      {#if sample.valid}
        {sample.data}
      {#else}
        <strong>Invalid sample found</strong>.
      {/if}
      </p>
    {/for}
</body>
</html>

1	La sección de bucle permite iterar sobre iterables, mapas y flujos.
2	Esta expresión de valor está utilizando el operador elvis - si el nombre es nulo se utiliza el valor por defecto.

ReportGenerator.java

package org.acme.quarkus.sample;

import jakarta.inject.Inject;

import io.quarkus.qute.Template;
import io.quarkus.qute.Location;
import io.quarkus.scheduler.Scheduled;

public class ReportGenerator {

    @Inject
    SampleService service;

    @Location("reports/v1/report_01") (1)
    Template report;

    @Scheduled(cron="0 30 * * * ?") (2)
    void generate() {
        String result = report
            .data("samples", service.get())
            .data("now", java.time.LocalDateTime.now())
            .render(); (3)
        // Write the result somewhere...
    }
}

1	En este caso, utilizamos el calificador `@Location` para especificar la ruta de la plantilla: `templates/reports/v1/report_01.html`.
2	Utilice la anotación `@Scheduled` para indicar a Quarkus que ejecute este método cada media hora. Para más información, consulte la guía del Programador.
3	El método `TemplateInstance.render()` desencadena la renderización. Tenga en cuenta que este método bloquea el hilo actual.

Guía de referencia Qute

Para saber más sobre Qute, consulte la guía de referencia de Qute.

Referencia de configuración de Qute

Propiedad de configuración fijada en tiempo de compilación - Todas las demás propiedades de configuración son anulables en tiempo de ejecución

Configuration property	Tipo	Por defecto
`quarkus.qute.suffixes` The list of suffixes used when attempting to locate a template file. By default, `engine.getTemplate("foo")` would result in several lookups: `foo`, `foo.html`, `foo.txt`, etc. Environment variable: `QUARKUS_QUTE_SUFFIXES` Show more	list of string	`qute.html,qute.txt,html,txt`
`quarkus.qute.type-check-excludes` The list of exclude rules used to intentionally ignore some parts of an expression when performing type-safe validation. An element value must have at least two parts separated by dot. The last part is used to match the property/method name. The prepended parts are used to match the class name. The value `` can be used to match any name. Examples: `org.acme.Foo.name` - exclude the property/method `name` on the `org.acme.Foo` class `org.acme.Foo.` - exclude any property/method on the `org.acme.Foo` class `*.age` - exclude the property/method `age` on any class Environment variable: `QUARKUS_QUTE_TYPE_CHECK_EXCLUDES` Show more	list of string
`quarkus.qute.template-path-exclude` This regular expression is used to exclude template files from the `templates` directory. Excluded templates are neither parsed nor validated during build and are not available at runtime. The matched input is the file path relative from the `templates` directory and the `/` is used as a path separator. By default, the hidden files are excluded. The name of a hidden file starts with a dot. Environment variable: `QUARKUS_QUTE_TEMPLATE_PATH_EXCLUDE` Show more	Pattern	`^\..\|.\/\..*$`
`quarkus.qute.iteration-metadata-prefix` The prefix is used to access the iteration metadata inside a loop section. A valid prefix consists of alphanumeric characters and underscores. Three special constants can be used: `<alias_>` - the alias of an iterated element suffixed with an underscore is used, e.g. `item_hasNext` and `it_count` `<alias?>` - the alias of an iterated element suffixed with a question mark is used, e.g. `item?hasNext` and `it?count` `<none>` - no prefix is used, e.g. `hasNext` and `count` By default, the `<alias_>` constant is set. Environment variable: `QUARKUS_QUTE_ITERATION_METADATA_PREFIX` Show more	string	`<alias_>`
`quarkus.qute.escape-content-types` The list of content types for which the `'`, `"`, `<`, `>` and `&` characters are escaped if a template variant is set. Environment variable: `QUARKUS_QUTE_ESCAPE_CONTENT_TYPES` Show more	list of string	`text/html,text/xml,application/xml,application/xhtml+xml`
`quarkus.qute.default-charset` The default charset of the templates files. Environment variable: `QUARKUS_QUTE_DEFAULT_CHARSET` Show more	Charset	`UTF-8`
`quarkus.qute.dev-mode.no-restart-templates` By default, a template modification results in an application restart that triggers build-time validations. This regular expression can be used to specify the templates for which the application is not restarted. I.e. the templates are reloaded and only runtime validations are performed. The matched input is the template path that starts with a template root, and the `/` is used as a path separator. For example, `templates/foo.html`. Environment variable: `QUARKUS_QUTE_DEV_MODE_NO_RESTART_TEMPLATES` Show more	Pattern
`quarkus.qute.property-not-found-strategy` The strategy used when a standalone expression evaluates to a "not found" value at runtime and the `quarkus.qute.strict-rendering` config property is set to `false` This strategy is never used when evaluating section parameters, e.g. `{#if foo.name}`. In such case, it’s the responsibility of the section to handle this situation appropriately. By default, the `NOT_FOUND` constant is written to the output. However, in the development mode the `PropertyNotFoundStrategy#THROW_EXCEPTION` is used by default, i.e. when the strategy is not specified. Environment variable: `QUARKUS_QUTE_PROPERTY_NOT_FOUND_STRATEGY` Show more	`default`Output the `NOT_FOUND` constant., `noop`No operation - no output., `throw-exception`Throw a `TemplateException`., `output-original`Output the original expression string, e.g. `{foo.name}`.
`quarkus.qute.remove-standalone-lines` Specify whether the parser should remove standalone lines from the output. A standalone line is a line that contains at least one section tag, parameter declaration, or comment but no expression and no non-whitespace character. Environment variable: `QUARKUS_QUTE_REMOVE_STANDALONE_LINES` Show more	boolean	`true`
`quarkus.qute.strict-rendering` If set to `true` then any expression that is evaluated to a `Results.NotFound` value will always result in a `TemplateException` and the rendering is aborted. Note that the `quarkus.qute.property-not-found-strategy` config property is completely ignored if strict rendering is enabled. Environment variable: `QUARKUS_QUTE_STRICT_RENDERING` Show more	boolean	`true`
`quarkus.qute.timeout` The global rendering timeout in milliseconds. It is used if no `timeout` template instance attribute is set. Environment variable: `QUARKUS_QUTE_TIMEOUT` Show more	long	`10000`
`quarkus.qute.use-async-timeout` If set to `true` then the timeout should also be used for asynchronous rendering methods, such as `TemplateInstance#createUni()` and `TemplateInstance#renderAsync()`. Environment variable: `QUARKUS_QUTE_USE_ASYNC_TIMEOUT` Show more	boolean	`true`
`quarkus.qute.content-types` The additional map of suffixes to content types. This map is used when working with template variants. By default, the `java.net.URLConnection#getFileNameMap()` is used to determine the content type of a template file. Environment variable: `QUARKUS_QUTE_CONTENT_TYPES` Show more	`Map<String,String>`

Configuration property

Tipo

Por defecto

quarkus.qute.suffixes

The list of suffixes used when attempting to locate a template file.

By default, engine.getTemplate("foo") would result in several lookups: foo, foo.html, foo.txt, etc.

Environment variable: QUARKUS_QUTE_SUFFIXES

list of string

qute.html,qute.txt,html,txt

quarkus.qute.type-check-excludes

The list of exclude rules used to intentionally ignore some parts of an expression when performing type-safe validation.

An element value must have at least two parts separated by dot. The last part is used to match the property/method name. The prepended parts are used to match the class name. The value * can be used to match any name.

Examples:

org.acme.Foo.name - exclude the property/method name on the org.acme.Foo class
org.acme.Foo.* - exclude any property/method on the org.acme.Foo class
*.age - exclude the property/method age on any class

Environment variable: QUARKUS_QUTE_TYPE_CHECK_EXCLUDES

list of string

quarkus.qute.template-path-exclude

This regular expression is used to exclude template files from the templates directory. Excluded templates are neither parsed nor validated during build and are not available at runtime.

The matched input is the file path relative from the templates directory and the / is used as a path separator.

By default, the hidden files are excluded. The name of a hidden file starts with a dot.

Environment variable: QUARKUS_QUTE_TEMPLATE_PATH_EXCLUDE

Pattern

^\..|.\/\..*$

quarkus.qute.iteration-metadata-prefix

The prefix is used to access the iteration metadata inside a loop section.

A valid prefix consists of alphanumeric characters and underscores. Three special constants can be used:

<alias_> - the alias of an iterated element suffixed with an underscore is used, e.g. item_hasNext and it_count
<alias?> - the alias of an iterated element suffixed with a question mark is used, e.g. item?hasNext and it?count
<none> - no prefix is used, e.g. hasNext and count By default, the <alias_> constant is set.

Environment variable: QUARKUS_QUTE_ITERATION_METADATA_PREFIX

string

<alias_>

quarkus.qute.escape-content-types

The list of content types for which the ', ", <, > and & characters are escaped if a template variant is set.

Environment variable: QUARKUS_QUTE_ESCAPE_CONTENT_TYPES

list of string

text/html,text/xml,application/xml,application/xhtml+xml

quarkus.qute.default-charset

The default charset of the templates files.

Environment variable: QUARKUS_QUTE_DEFAULT_CHARSET

Charset

UTF-8

quarkus.qute.dev-mode.no-restart-templates

By default, a template modification results in an application restart that triggers build-time validations.

This regular expression can be used to specify the templates for which the application is not restarted. I.e. the templates are reloaded and only runtime validations are performed.

The matched input is the template path that starts with a template root, and the / is used as a path separator. For example, templates/foo.html.

Environment variable: QUARKUS_QUTE_DEV_MODE_NO_RESTART_TEMPLATES

Pattern

quarkus.qute.property-not-found-strategy

The strategy used when a standalone expression evaluates to a "not found" value at runtime and the quarkus.qute.strict-rendering config property is set to false

This strategy is never used when evaluating section parameters, e.g. {#if foo.name}. In such case, it’s the responsibility of the section to handle this situation appropriately.

By default, the NOT_FOUND constant is written to the output. However, in the development mode the PropertyNotFoundStrategy#THROW_EXCEPTION is used by default, i.e. when the strategy is not specified.

Environment variable: QUARKUS_QUTE_PROPERTY_NOT_FOUND_STRATEGY

defaultOutput the NOT_FOUND constant., noopNo operation - no output., throw-exceptionThrow a TemplateException., output-originalOutput the original expression string, e.g. {foo.name}.

quarkus.qute.remove-standalone-lines

Specify whether the parser should remove standalone lines from the output. A standalone line is a line that contains at least one section tag, parameter declaration, or comment but no expression and no non-whitespace character.

Environment variable: QUARKUS_QUTE_REMOVE_STANDALONE_LINES

boolean

true

quarkus.qute.strict-rendering

If set to true then any expression that is evaluated to a Results.NotFound value will always result in a TemplateException and the rendering is aborted.

Note that the quarkus.qute.property-not-found-strategy config property is completely ignored if strict rendering is enabled.

Environment variable: QUARKUS_QUTE_STRICT_RENDERING

boolean

true

quarkus.qute.timeout

The global rendering timeout in milliseconds. It is used if no timeout template instance attribute is set.

Environment variable: QUARKUS_QUTE_TIMEOUT

long

10000

quarkus.qute.use-async-timeout

If set to true then the timeout should also be used for asynchronous rendering methods, such as TemplateInstance#createUni() and TemplateInstance#renderAsync().

Environment variable: QUARKUS_QUTE_USE_ASYNC_TIMEOUT

boolean

true

quarkus.qute.content-types

The additional map of suffixes to content types. This map is used when working with template variants. By default, the java.net.URLConnection#getFileNameMap() is used to determine the content type of a template file.

Environment variable: QUARKUS_QUTE_CONTENT_TYPES

Map<String,String>

Solución
Hello World with Jakarta REST
Plantillas con seguridad de tipos
- Plantillas de nivel superior con seguridad de tipos
Declaraciones de parámetros de plantillas
- Declaración de parámetros de la plantilla dentro de la propia plantilla
Métodos de extensión de plantillas
Renderizado de informes periódicos
Guía de referencia Qute
Referencia de configuración de Qute

Motor de plantillas Qute

Solución

Hello World with Jakarta REST

Plantillas con seguridad de tipos

Plantillas de nivel superior con seguridad de tipos

Declaraciones de parámetros de plantillas

Declaración de parámetros de la plantilla dentro de la propia plantilla

Métodos de extensión de plantillas

Renderizado de informes periódicos

Guía de referencia Qute

Referencia de configuración de Qute

Related content

On the same extensions

On the same topics