Skip to content

5. Internacionalización

Una aplicación internacionalizada muestra su texto en el idioma del usuario. El caso de estudio está en francés e inglés. El principio es simple: las vistas ya no contienen texto, sino claves ([MENU.HOME]), y un diccionario para cada idioma asocia un texto a cada clave. El idioma seleccionado se almacena en una cookie.

[Spring] tiene su propio sistema de traducción: la interfaz [MessageSource], cuya implementación estándar lee archivos como [messages_fr.properties], [messages_en.properties]... Conservaremos la interfaz, ya que [Spring] y [Thymeleaf] la usan para traducir, pero la implementaremos nosotros mismos, con una pequeña clase que lee diccionarios JSON: son los mismos archivos que los de las versiones [ASP.NET Core MVC] y [NestJS] del caso de estudio, y su formato se puede leer y escribir sin herramientas especiales. En cambio, dejaremos que [Spring MVC] se encargue de la selección del idioma en cada solicitud: este es el papel de su resolvedor de idioma ([LocaleResolver]), que vimos en el Ejemplo 16.

5.1. Ejemplo 22: Una aplicación bilingüe

22-i18n/
├── src/main/java/example22/
│   ├── config/
│   │   └── WebConfig.java
│   ├── controllers/
│   │   ├── LanguageController.java
│   │   └── PagesController.java
│   ├── translation/
│   │   ├── Formats.java
│   │   └── Translator.java
│   └── Example22Application.java
├── src/main/resources/
│   ├── i18n/
│   │   ├── en.json
│   │   └── fr.json
│   ├── static/css/
│   │   └── styles.css
│   ├── templates/
│   │   ├── fragments/
│   │   │   └── navbar.html
│   │   ├── pages/
│   │   │   ├── home.html
│   │   │   └── products.html
│   │   └── layout.html
│   └── application.properties
└── pom.xml

Los archivos [pom.xml] (el starter [Thymeleaf]), [application.properties] (puerto 5000), [Example22Application.java] (la clase de inicio) y [styles.css] son los mismos que los de los ejemplos anteriores.

5.1.1. Los diccionarios

El archivo [src/main/resources/i18n/fr.json]:

{
  "MENU": {
    "HOME": "Accueil",
    "PRODUCTS": "Produits"
  },
  "HOME": {
    "TITLE": "Bienvenue",
    "HELLO": "Bonjour {name} !",
    "DATE": "Nous sommes le {date}."
  },
  "PRODUCTS": {
    "TITLE": "Nos produits",
    "NAME": "Produit",
    "PRICE": "Prix",
    "COUNT": "{n} produit(s) au catalogue."
  }
}

El archivo [src/main/resources/i18n/en.json]:

{
  "MENU": {
    "HOME": "Home",
    "PRODUCTS": "Products"
  },
  "HOME": {
    "TITLE": "Welcome",
    "HELLO": "Hello {name}!",
    "DATE": "Today is {date}."
  },
  "PRODUCTS": {
    "TITLE": "Our products",
    "NAME": "Product",
    "PRICE": "Price",
    "COUNT": "{n} product(s) in the catalogue."
  }
}
  • Un diccionario es un archivo JSON, organizado por página o por tema: la clave [HOME.HELLO] hace referencia al texto [HELLO] de la sección [HOME];
  • Línea 8: un texto puede contener parámetros, encerrados entre llaves, que se reemplazan durante la traducción. El orden de las palabras varía de un idioma a otro: por eso un texto no se crea simplemente concatenando segmentos traducidos.

Los diccionarios se colocan en [src/main/resources]: [Maven] copia esta carpeta en [target/classes], junto con las clases compiladas. Por lo tanto, forman parte de la classpath: el conjunto de carpetas y archivos comprimidos donde [Java] busca las clases y los recursos de la aplicación: ahí es donde el programa los leerá, sin importar desde qué carpeta se inicie.

5.1.2. El servicio de traducción

El archivo [translation/Translator.java], en dos partes. La primera parte lee los diccionarios y traduce:

package example22.translation;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.springframework.context.MessageSource;
import org.springframework.context.MessageSourceResolvable;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;

import tools.jackson.databind.JsonNode;
import tools.jackson.databind.ObjectMapper;

// el servicio de traducción: los diccionarios JSON, leídos UNA SOLA VEZ al iniciar.
// Implementa la interfaz MessageSource de Spring y se llama [messageSource]:
// Spring lo usa entonces para TODAS las traducciones, y Thymeleaf para las
// expresiones #{...} de las vistas.
@Component("messageSource")
public class Translator implements MessageSource {

    public static final List<String> LANGUAGES = List.of("fr", "en");
    public static final String DEFAULT_LANGUAGE = "en";

    // {name}: un parámetro en un texto
    private static final Pattern PARAMETER = Pattern.compile("\\{(\\w+)\\}");

    // idioma -> (clave completa "HOME.HELLO" -> texto)
    private final Map<String, Map<String, String>> dictionaries = new HashMap<>();

    public Translator() throws IOException {
        ObjectMapper json = new ObjectMapper();
        for (String language : LANGUAGES) {
            // los diccionarios están en src/main/resources/i18n, por lo tanto en el classpath
            try (InputStream stream = new ClassPathResource("i18n/" + language + ".json").getInputStream()) {
                Map<String, String> dictionary = new HashMap<>();
                flatten(json.readTree(stream), "", dictionary);
                dictionaries.put(language, dictionary);
            }
        }
    }

    // el idioma soportado más cercano a [locale]: "fr_FR" -> "fr"; "de" -> "en"
    public static String language(Locale locale) {
        String language = locale == null ? "" : locale.getLanguage();
        return LANGUAGES.contains(language) ? language : DEFAULT_LANGUAGE;
    }

    // translate("HOME.HELLO", ["name", "Marie"], en) -> "Hello Marie!"
    // Los parámetros se pasan como pares (nombre, valor).
    public String translate(String key, Object[] parameters, Locale locale) {
        if (key == null || key.isEmpty()) {
            return "";
        }
        // una clave ausente muestra la propia clave: un olvido es visible en pantalla
        String text = dictionaries.get(language(locale)).getOrDefault(key, key);
        if (parameters == null || parameters.length == 0) {
            return text;
        }
        Map<String, String> values = new HashMap<>();
        for (int i = 0; i + 1 < parameters.length; i += 2) {
            values.put(String.valueOf(parameters[i]), String.valueOf(parameters[i + 1]));
        }
        // cada {name} se reemplaza por el valor del parámetro del mismo nombre
        Matcher m = PARAMETER.matcher(text);
        return m.replaceAll(r -> Matcher.quoteReplacement(values.getOrDefault(r.group(1), r.group())));
    }

    // { "MENU": { "HOME": "Home" } } -> { "MENU.HOME": "Home" }
    private static void flatten(JsonNode node, String prefix, Map<String, String> result) {
        for (Map.Entry<String, JsonNode> property : node.properties()) {
            String key = prefix.isEmpty() ? property.getKey() : prefix + "." + property.getKey();
            if (property.getValue().isObject()) {
                flatten(property.getValue(), key, result);
            } else {
                result.put(key, property.getValue().asString());
            }
        }
    }

Analicemos este código:

  • líneas 24–25: el servicio es un bean (anotado con [@Component]) y, por lo tanto, un singleton: los archivos se leen una sola vez, al iniciar. Implementa la interfaz [MessageSource] de [Spring] y se llama [messageSource], como lo especifica la anotación. Este nombre no se elige al azar: es con este nombre que [Spring] busca el servicio de traducción de la aplicación. [Spring Boot], que crea uno de forma predeterminada (leería los archivos [messages*.properties]), se abstiene de hacerlo en cuanto existe un bean con ese nombre;
  • líneas 27–28: los idiomas admitidos y el idioma predeterminado. [List.of] crea una lista de solo lectura;
  • línea 31: la expresión regular [\{(\w+)\}] (una llave de apertura, uno o más caracteres de palabra, capturados, una llave de cierre), que identifica los parámetros en un texto. En una cadena [Java], la barra invertida se escribe como [\\]. [Pattern.compile] la analiza una sola vez;
  • línea 34: para cada idioma, un diccionario [Java] ([Map]) que asocia cada clave completa ([HOME.HELLO]) con su texto;
  • líneas 36–46: el constructor lee los archivos JSON. [ClassPathResource] hace referencia a un archivo de la classpath (vea más arriba). La instrucción [try (...)] (conocida como instrucción “try-with-resources”) cierra automáticamente el flujo abierto entre sus paréntesis al final del bloque, incluso si se produce un error. El objeto [ObjectMapper] de la biblioteca [Jackson] (la que [Spring] usa para JSON) analiza el texto y lo convierte en un árbol de nodos [JsonNode];
  • líneas 49–52: el idioma admitido más cercano a un idioma dado. Un objeto [Locale] de tipo [Java] denota un idioma, posiblemente especificado por un país ([fr], [en_US]...); [getLanguage()] proporciona su código de dos letras. Un idioma no admitido ([de]) devuelve el idioma predeterminado;
  • líneas 56–72: la traducción. La clave se busca en el diccionario del idioma solicitado; si no se encuentra, se muestra la propia clave ([getOrDefault]): una omisión es inmediatamente visible en la pantalla;
  • líneas 65–68: los parámetros se almacenan en un arreglo [Object[]], como pares (nombre, valor): [["name", "Marie"]]. El bucle los organiza en un diccionario [name -> value]. Veremos por qué se eligió este formato algo inusual;
  • líneas 70–71: [replaceAll] reemplaza cada parámetro [{name}] que se encuentra en el texto por el resultado de la lambda: el valor del parámetro con el mismo nombre ([r.group(1)] es la parte capturada entre paréntesis), o el parámetro mismo, sin cambios, si no tiene valor ([r.group()] es el texto completo encontrado). [Matcher.quoteReplacement] protege los caracteres [$] y [\] que un valor podría contener, y que de otro modo tienen un significado especial para [replaceAll];
  • Líneas 75–84: el método “aplana” el JSON: el objeto ["HOME": { "HELLO": "..." }] produce la clave [HOME.HELLO]. Se llama a sí mismo (método recursivo) para recorrer objetos anidados. [properties()] devuelve los pares (nombre, valor) de un objeto JSON; [asString()] devuelve el valor de un texto.

La segunda parte implementa la interfaz [MessageSource]:

    // la interfaz MessageSource

    @Override
    public String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
        return translate(code, args, locale);
    }

    @Override
    public String getMessage(String code, Object[] args, Locale locale) {
        return translate(code, args, locale);
    }

    // un mensaje descrito por varios códigos posibles (los errores de validación):
    // gana el primer código presente en el diccionario
    @Override
    public String getMessage(MessageSourceResolvable message, Locale locale) {
        Map<String, String> dictionary = dictionaries.get(language(locale));
        String[] codes = message.getCodes() == null ? new String[0] : message.getCodes();
        for (String code : codes) {
            if (dictionary.containsKey(code)) {
                return translate(code, message.getArguments(), locale);
            }
        }
        String defaultText = message.getDefaultMessage();
        return defaultText != null ? defaultText : (codes.length > 0 ? codes[0] : "");
    }
}
  • líneas 3–11: los dos métodos que traducen un código (una clave) y sus argumentos a un idioma dado; llaman a [translate]. La anotación [@Override] indica al compilador que verifique que, efectivamente, se sobrescribe un método de la interfaz;
  • líneas 15–26: el tercer método recibe un objeto [MessageSourceResolvable], que describe un mensaje mediante varios códigos posibles, desde el más específico hasta el más general. Así es como [Spring] describe los errores de validación (vea el Ejemplo 19): una restricción [@NotBlank] en el campo [name] de un objeto [person] produce los códigos [NotBlank.person.name], [NotBlank.name], [NotBlank]... Tiene prioridad el primer código presente en el diccionario; si no hay ninguno, se devuelve el mensaje predeterminado o el primer código. El caso de estudio usa esto para traducir sus mensajes de error.

En [Spring], el formato habitual de los parámetros de un mensaje es posicional: [Hello {0}!], donde el primer argumento reemplaza a [{0}]. Preferimos los parámetros con nombre, que son más legibles en un diccionario ([Hello {name}!]) e idénticos a los de otras versiones del caso de estudio. Sin embargo, la interfaz [MessageSource] solo pasa un arreglo de argumentos; de ahí la convención de pares (nombre, valor).

5.1.3. Traducción en las vistas

En una vista [Thymeleaf], la expresión [#{KEY}], introducida simplemente por el arreglo del Ejemplo 14, es la traducción de la clave [KEY] al idioma de la solicitud: [Thymeleaf] llama al bean [messageSource], es decir, a nuestro [Translator]. Los argumentos se pasan entre paréntesis: [#{HOME.HELLO('name', ${name})}] llama a [getMessage("HOME.HELLO", ["name", "Marie"], language)]. No es necesario escribir ninguna clase del lado de la vista: esta es la ventaja de haber implementado la interfaz de [Spring].

Quedan las fechas y los montos, que no se traducen pero sí se formatean según el idioma. El archivo [translation/Formats.java]:

package example22.translation;

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Currency;

import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Component;

// fechas y montos, formateados en el idioma de la solicitud (vea el ejemplo 16)
@Component("formats")
public class Formats {

    // una fecha en palabras completas
    public String longDate(LocalDate date) {
        return date.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(LocaleContextHolder.getLocale()));
    }

    // un monto en euros
    public String money(BigDecimal amount) {
        NumberFormat format = NumberFormat.getCurrencyInstance(LocaleContextHolder.getLocale());
        format.setCurrency(Currency.getInstance("EUR"));
        return format.format(amount);
    }
}

Esta es, más o menos, la clase del Ejemplo 16:

  • línea 14: un bean llamado [formats], al que las vistas hacen referencia como [${@formats.longDate(...)}];
  • líneas 19 y 24: [LocaleContextHolder.getLocale()] especifica el idioma de la solicitud actual. Veremos quién lo establece;
  • línea 19: una fecha en formato largo ([FormatStyle.FULL]), en ese idioma;
  • líneas 24–26: un monto, en el formato monetario de ese idioma, en euros sin importar el idioma.

5.1.4. Selección del idioma

El archivo [config/WebConfig.java]:

package example22.config;

import java.time.Duration;
import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.i18n.CookieLocaleResolver;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

// la configuración de Spring MVC, complementada
@Configuration
public class WebConfig implements WebMvcConfigurer {

    // Bootstrap, compartido por los ejemplos: la carpeta examples/common/bootstrap
    // se sirve bajo la URL /bootstrap/...
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/bootstrap/**")
                // "file:": una carpeta del disco, relativa a la carpeta actual. Dos
                // intentos: iniciado desde la carpeta del ejemplo, o desde [examples]
                .addResourceLocations("file:../common/bootstrap/", "file:common/bootstrap/");
    }

    // el idioma de cada solicitud: el de la cookie [language], inglés en caso contrario.
    // El bean debe llamarse [localeResolver]: con ese nombre lo busca Spring.
    @Bean
    public LocaleResolver localeResolver() {
        CookieLocaleResolver resolver = new CookieLocaleResolver("language");
        resolver.setDefaultLocale(Locale.ENGLISH);
        resolver.setCookieMaxAge(Duration.ofDays(365));
        resolver.setCookieHttpOnly(true);
        resolver.setCookieSameSite("Lax");
        return resolver;
    }
}

Analicemos este código:

  • Líneas 19–25: los archivos de [Bootstrap], como en los ejemplos anteriores;
  • Líneas 29–37: el bean [localeResolver] (que es el nombre con el que [Spring MVC] lo busca) establece el idioma de cada solicitud. Al comienzo de cada solicitud, [Spring MVC] le pide el idioma y lo almacena en [LocaleContextHolder] durante toda la solicitud: los métodos de [Formats], las expresiones [#{...}] de [Thymeleaf] y la variable [#locale] en las vistas lo recuperan de ahí;
  • línea 31: un [CookieLocaleResolver], proporcionado por [Spring], lee el idioma de una cookie, aquí llamada [language]. La cookie contiene el código del idioma ([en]);
  • línea 32: sin cookie, el idioma es el inglés. Observe que el idioma del navegador (encabezado [Accept-Language]) se ignora entonces: el usuario elige el idioma con los botones FR / EN;
  • Líneas 33–35: las características de la cookie que [CookieLocaleResolver] escribirá cuando se cambie el idioma: una duración de un año; [HttpOnly] (el [JavaScript] de la página no puede leerla); [SameSite=Lax] (no se envía en solicitudes POST provenientes de otros sitios).

El archivo [controllers/LanguageController.java]:

package example22.controllers;

import java.net.URI;
import java.util.Locale;

import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.LocaleResolver;

import example22.translation.Translator;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@Controller
public class LanguageController {

    private final LocaleResolver localeResolver;

    public LanguageController(LocaleResolver localeResolver) {
        this.localeResolver = localeResolver;
    }

    // GET /language/fr: guarda la elección en una cookie y luego vuelve a la página anterior
    @GetMapping("/language/{language}")
    public String change(@PathVariable String language, HttpServletRequest request, HttpServletResponse response) {
        if (!Translator.LANGUAGES.contains(language)) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND);
        }
        // el LocaleResolver escribe él mismo su cookie (nombre, valor, duración...)
        localeResolver.setLocale(request, response, Locale.forLanguageTag(language));
        return "redirect:" + originPage(request);
    }

    // la página de la que venimos (encabezado Referer), de la cual conservamos solo la ruta:
    // redirigir a una dirección completa tomada de la solicitud permitiría
    // enviar al usuario a otro sitio (vulnerabilidad de "open redirect")
    private static String originPage(HttpServletRequest request) {
        String referer = request.getHeader("Referer");
        try {
            URI url = URI.create(referer);
            String path = url.getRawPath();
            // "//site.com/..." sería entendida por el navegador como una dirección
            // en OTRO sitio: también se rechaza
            if (path == null || !path.startsWith("/") || path.startsWith("//")) {
                return "/";
            }
            return url.getRawQuery() == null ? path : path + "?" + url.getRawQuery();
        } catch (RuntimeException e) {
            // sin encabezado Referer (NullPointerException), o una dirección inválida
            return "/";
        }
    }
}

Analicemos este código:

  • líneas 20–24: el controlador recibe [LocaleResolver] mediante inyección de dependencias;
  • líneas 27–35: [GET /language/fr] almacena la selección en una cookie y luego redirige a la página de la que venía el usuario. Un idioma desconocido provoca un error 404 ([ResponseStatusException], vea el Ejemplo 21);
  • línea 33: no creamos la cookie nosotros mismos; en su lugar, le pedimos a [LocaleResolver] que cambie el idioma, y este escribe la cookie con el nombre y las características especificados en [WebConfig]. [Locale.forLanguageTag("en")] crea el objeto [Locale] para el inglés;
  • línea 34: [redirect:] solicita una redirección (vea el ejemplo 04);
  • líneas 40–55: la página de origen la indica el encabezado [Referer], que el navegador agrega cuando se hace clic en un enlace. Conservamos solo la ruta y los parámetros ([getRawPath], [getRawQuery]: tal como aparecen en la dirección, sin decodificar). Redirigir a una URL completa tomada de la solicitud permitiría que un sitio malicioso cree un enlace que, tras pasar por nuestro sitio, envíe al usuario al sitio malicioso (una vulnerabilidad conocida como [open redirect]);
  • líneas 45–49: una ruta que comienza con dos barras también se rechaza: el navegador interpretaría [//pirate.example/trap] como la dirección [http://pirate.example/trap], en otro sitio;
  • líneas 51–54: sin el encabezado [Referer], [URI.create(null)] lanza una [NullPointerException]; una dirección no válida, una [IllegalArgumentException]. Ambas derivan de [RuntimeException]: esto lo lleva de vuelta a la página de inicio.

5.1.5. Las vistas

El archivo [templates/layout.html]:

<!doctype html>
<!--#locale: el idioma de la solicitud; su código de dos letras: #locale.language-->
<html xmlns:th="http://www.thymeleaf.org" th:lang="${#locale.language}" th:fragment="page(title, content)">
<head>
  <meta charset="utf-8">
  <!--el título es una CLAVE, proporcionada por la página, traducida por el diseño-->
  <title th:text="#{${title}}">Title</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3">
    <nav th:replace="~{fragments/navbar :: navbar}"></nav>
    <main th:replace="${content}"></main>
  </div>
</body>
</html>
  • Línea 3: la plantilla (vea el Ejemplo 15) es un fragmento con dos parámetros: el título de la página y su contenido. El atributo [lang] de la página refleja el idioma seleccionado (útil para lectores de pantalla y correctores ortográficos): [#locale] es el idioma de la solicitud, y [#locale.language] es su código de dos letras;
  • línea 7: el título de la página es una clave, proporcionada por la página y traducida por la plantilla: en [#{${title}}], la clave misma es el resultado de una expresión;
  • línea 13: la barra de navegación, un fragmento de otro archivo.

El archivo [templates/fragments/navbar.html]:

<nav class="navbar navbar-expand bg-light rounded mb-3 px-3" th:fragment="navbar">
  <div class="navbar-nav me-auto">
    <!--#{KEY}: la traducción de una clave, en el idioma de la solicitud-->
    <a class="nav-link" href="/" th:text="#{MENU.HOME}">Home</a>
    <a class="nav-link" href="/products" th:text="#{MENU.PRODUCTS}">Products</a>
  </div>
  <!--el idioma actual se resalta-->
  <div class="btn-group btn-group-sm" th:with="language=${#locale.language}">
    <a class="btn" th:classappend="${language == 'fr'} ? 'btn-primary' : 'btn-outline-primary'" href="/language/fr">FR</a>
    <a class="btn" th:classappend="${language == 'en'} ? 'btn-primary' : 'btn-outline-primary'" href="/language/en">EN</a>
  </div>
</nav>
  • Líneas 4–5: dos textos traducidos. El texto escrito dentro de la etiqueta ([Home]) solo se muestra si el archivo se abre directamente en un navegador; [Thymeleaf] lo reemplaza por la traducción;
  • línea 8: [th:with] define una variable local, [language], que puede utilizarse dentro de la etiqueta y de sus etiquetas hijas;
  • Líneas 9-10: dos enlaces (cambiar el idioma no modifica ningún dato de la aplicación: basta con un GET), con el idioma actual resaltado: [th:classappend] agrega una clase CSS a las de la etiqueta.

El archivo [templates/pages/home.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('HOME.TITLE', ~{::main})}">
<body>
<main>
  <h1 th:text="#{HOME.TITLE}">Welcome</h1>
  <!--un parámetro: el par (nombre del parámetro, valor)-->
  <p th:text="#{HOME.HELLO('name', ${name})}">Hello Marie!</p>
  <!--la fecha, formateada primero, luego pasada como parámetro [date]-->
  <p th:text="#{HOME.DATE('date', ${@formats.longDate(today)})}">Today is...</p>
</main>
</body>
</html>
  • línea 2: la página invoca la plantilla, usando la clave para su título y su contenido (la etiqueta [main]);
  • línea 7: un parámetro, pasado como un par (nombre, valor);
  • línea 9: la fecha se formatea primero con el bean [formats] y luego se pasa como el parámetro [date] al mensaje.

El archivo [templates/pages/products.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('PRODUCTS.TITLE', ~{::main})}">
<body>
<main>
  <h1 th:text="#{PRODUCTS.TITLE}">Our products</h1>
  <table class="table table-sm w-auto">
    <thead><tr><th th:text="#{PRODUCTS.NAME}">Product</th><th class="text-end" th:text="#{PRODUCTS.PRICE}">Price</th></tr></thead>
    <tbody>
      <tr th:each="product : ${products}">
        <td th:text="${product.name}">Keyboard</td>
        <td class="text-end" th:text="${@formats.money(product.price)}">€25.00</td>
      </tr>
    </tbody>
  </table>
  <p th:text="#{PRODUCTS.COUNT('n', ${#lists.size(products)})}">3 product(s) in the catalogue.</p>
</main>
</body>
</html>
  • línea 11: el importe, formateado según el idioma;
  • línea 15: un parámetro numérico: [#lists.size] indica el tamaño de la lista; [Translator] convierte el valor en una cadena ([String.valueOf]).

El archivo [controllers/PagesController.java]:

package example22.controllers;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

// las acciones no saben nada del idioma: proporcionan datos,
// las vistas los traducen y formatean
@Controller
public class PagesController {

    public record Product(String name, BigDecimal price) {
    }

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("name", "Marie");
        model.addAttribute("today", LocalDate.of(2026, 9, 23));
        return "pages/home";
    }

    @GetMapping("/products")
    public String products(Model model) {
        model.addAttribute("products", List.of(
                new Product("Keyboard", new BigDecimal("25")),
                new Product("Mouse", new BigDecimal("12.5")),
                new Product("Screen", new BigDecimal("1149"))));
        return "pages/products";
    }
}

Las acciones no dependen del idioma: proporcionan los datos, mientras que las vistas los traducen y formatean. El precio es un [BigDecimal], y el tipo [Java] para números decimales exactos es adecuado para importes monetarios (línea 16). La fecha de la página de inicio es una fecha fija, el 23 de septiembre de 2026 (línea 22), y no la fecha actual: por lo tanto, los resultados que se muestran a continuación no dependen del día en que se ejecute el ejemplo.

5.1.6. Ejecución

En inglés (todavía sin cookie), en la URL http://localhost:5000/ y http://localhost:5000/products:

Image

Image

Un clic en un botón de idioma (aquí EN), simulado con [curl] (la opción [-H] agrega el encabezado [Referer] que el navegador habría enviado):

curl -i -H "Referer: http://localhost:5000/products" http://localhost:5000/language/en
1
2
3
4
HTTP/1.1 302
Set-Cookie: language=en; Path=/; Max-Age=31536000; Expires=Sat, 25 Sep 2027 16:49:23 GMT; HttpOnly; SameSite=Lax
Location: http://localhost:5000/products
Content-Length: 0

[CookieLocaleResolver] establece la cookie [language], con el valor [en], con las características solicitadas ([Max-Age] y [Expires] especifican ambas la duración, para navegadores antiguos y recientes, respectivamente). La redirección regresa a la página original ([Tomcat]; el servidor ha expandido la ruta [/products] a una dirección completa). Un clic en FR funciona de la misma manera (cookie [language=fr]): las páginas ahora están en francés:

Image

Image

Las fechas y los importes siguieron el cambio: “mercredi 23 septembre 2026”, “1 149,00 €”.

Un sitio malicioso que intente aprovechar nuestra redirección solo vería una página de nuestro sitio:

curl -i -H "Referer: https://pirate.example/trap?x=1" http://localhost:5000/language/fr
curl -i -H "Referer: https://pirate.example//pirate.example/trap" http://localhost:5000/language/fr
1
2
3
4
5
6
7
8
9
HTTP/1.1 302
Set-Cookie: language=fr; Path=/; Max-Age=31536000; Expires=Sat, 25 Sep 2027 16:49:24 GMT; HttpOnly; SameSite=Lax
Location: http://localhost:5000/trap?x=1
Content-Length: 0

HTTP/1.1 302
Set-Cookie: language=fr; Path=/; Max-Age=31536000; Expires=Sat, 25 Sep 2027 16:49:24 GMT; HttpOnly; SameSite=Lax
Location: http://localhost:5000/
Content-Length: 0

Un idioma no admitido:

curl -i http://localhost:5000/language/de
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"timestamp":"2026-09-25T16:49:23.993Z","status":404,"error":"Not Found","message":"404 NOT_FOUND","path":"/language/de"}

La respuesta de error predeterminada de [Spring Boot]: JSON para [curl], una página HTML para un navegador. El capítulo 7 muestra cómo reemplazarla por una página propia.

Por último, recuerde que una cookie está bajo el control del cliente. Una cookie [language=de] creada manualmente es aceptada por [CookieLocaleResolver]: el texto sigue en inglés (el idioma predeterminado de [Translator]), pero la fecha se formatea en alemán:

curl -b "language=de" http://localhost:5000/
1
2
3
<html lang="de">
  <p>Hello Marie!</p>
  <p>Today is Mittwoch, 23. September 2026.</p>

(solo se muestran tres líneas de la página). No tiene mayor importancia: el usuario solo se engaña a sí mismo.

El caso de estudio procede exactamente de esta manera, con diccionarios más completos ([i18n/fr.json] y [i18n/en.json]): el mismo bean [messageSource], el mismo [CookieLocaleResolver], el mismo controlador [/language/{language}]. La única diferencia es que los mensajes de error generados por las capas de negocio y web también son claves, traducidas en el último momento por la vista.