Spring Boot - Internacionalización

La internacionalización es un proceso que hace que su aplicación se adapte a diferentes idiomas y regiones sin cambios de ingeniería en el código fuente. En sus palabras, la internacionalización es una preparación para la localización.

En este capítulo, aprenderemos en detalle cómo implementar la internacionalización en Spring Boot.

Dependencias

Necesitamos la dependencia Spring Boot Starter Web y Spring Boot Starter Thymeleaf para desarrollar una aplicación web en Spring Boot.

Maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

Necesitamos determinar la configuración regional predeterminada de su aplicación. Necesitamos agregar el bean LocaleResolver en nuestra aplicación Spring Boot.

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

LocaleChangeInterceptor se utiliza para cambiar la nueva configuración regional en función del valor del parámetro de idioma agregado a una solicitud.

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

Para tener este efecto, debemos agregar LocaleChangeInterceptor en el interceptor de registro de la aplicación. La clase de configuración debe extender la clase WebMvcConfigurerAdapter y anular el método addInterceptors ().

@Override
public void addInterceptors(InterceptorRegistry registry) {
   registry.addInterceptor(localeChangeInterceptor());
}

Fuentes de mensajes

La aplicación Spring Boot de forma predeterminada toma las fuentes de mensajes de src/main/resourcescarpeta debajo de la ruta de clase. El nombre del archivo de mensaje de configuración regional predeterminado debe sermessage.properties y los archivos para cada configuración regional deben denominarse como messages_XX.properties. El "XX" representa el código local.

Todas las propiedades del mensaje deben usarse como valores de pares de claves. Si no se encuentran propiedades en el entorno local, la aplicación utiliza la propiedad predeterminada del archivo messages.properties.

Los messages.properties predeterminados serán los siguientes:

welcome.text=Hi Welcome to Everyone

El idioma francés messages_fr.properties será como se muestra:

welcome.text=Salut Bienvenue à tous

Note - El archivo de origen de los mensajes debe guardarse en formato de archivo "UTF-8".

Archivo HTML

En el archivo HTML, use la sintaxis #{key} para mostrar los mensajes del archivo de propiedades.

<h1 th:text = "#{welcome.text}"></h1>

El código completo se da a continuación.

Maven - pom.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradle - build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

El archivo principal de clase de la aplicación Spring Boot se muestra a continuación:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

El archivo de clase del controlador se proporciona a continuación:

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

Clase de configuración para apoyar la internacionalización

package com.tutorialspoint.demo;

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.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

Las fuentes de mensajes - messages.properties es como se muestra -

welcome.text = Hi Welcome to Everyone

Las fuentes de mensajes - message_fr.properties es como se muestra -

welcome.text = Salut Bienvenue à tous

El archivo HTML locale.html debe colocarse en el directorio de plantillas en la ruta de clase como se muestra:

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>Internationalization</title>
   </head>
   <body>
      <h1 th:text = "#{welcome.text}"></h1>
   </body>
</html>

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring boot mediante los siguientes comandos de Maven o Gradle:

Para Maven, use el siguiente comando:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, use el siguiente comando:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando como se muestra:

java –jar <JARFILE>

Verá que la aplicación se ha iniciado en el puerto 8080 de Tomcat.

Ahora presiona la URL http://localhost:8080/locale en su navegador web y puede ver el siguiente resultado:

La URL http://localhost:8080/locale?language=fr le dará la salida como se muestra -