Spring Boot - Internationalisation

L'internationalisation est un processus qui rend votre application adaptable à différentes langues et régions sans modifications techniques du code source. En d'autres termes, l'internationalisation est une préparation à la localisation.

Dans ce chapitre, nous allons apprendre en détail comment implémenter l'internationalisation dans Spring Boot.

Dépendances

Nous avons besoin des dépendances Spring Boot Starter Web et Spring Boot Starter Thymeleaf pour développer une application Web dans 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

Nous devons déterminer les paramètres régionaux par défaut de votre application. Nous devons ajouter le bean LocaleResolver dans notre application Spring Boot.

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

LocaleChangeInterceptor

LocaleChangeInterceptor est utilisé pour modifier le nouveau Locale en fonction de la valeur du paramètre de langue ajouté à une demande.

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

Pour prendre cet effet, nous devons ajouter le LocaleChangeInterceptor dans l'intercepteur de registre de l'application. La classe de configuration doit étendre la classe WebMvcConfigurerAdapter et remplacer la méthode addInterceptors ().

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

Sources de messages

L'application Spring Boot prend par défaut les sources de messages de src/main/resourcesdossier sous le chemin de classe. Le nom du fichier de messages de paramètres régionaux par défaut doit êtremessage.properties et les fichiers pour chaque locale doivent être nommés comme messages_XX.properties. Le «XX» représente le code régional.

Toutes les propriétés du message doivent être utilisées comme valeurs de paire de clés. Si aucune propriété n'est trouvée dans les paramètres régionaux, l'application utilise la propriété par défaut du fichier messages.properties.

Les messages.properties par défaut seront comme indiqué -

welcome.text=Hi Welcome to Everyone

La langue française messages_fr.properties sera comme indiqué -

welcome.text=Salut Bienvenue à tous

Note - Le fichier source des messages doit être enregistré au format de fichier «UTF-8».

Fichier HTML

Dans le fichier HTML, utilisez la syntaxe #{key} pour afficher les messages du fichier de propriétés.

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

Le code complet est donné ci-dessous

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')
}

Le fichier principal de classe d'application Spring Boot est donné ci-dessous -

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);
   }
}

Le fichier de classe de contrôleur est donné ci-dessous -

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";
   }
}

Classe de configuration pour prendre en charge l'internationalisation

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());
   }
}

Les sources de message - messages.properties sont comme indiqué -

welcome.text = Hi Welcome to Everyone

Les sources de message - message_fr.properties sont comme indiqué -

welcome.text = Salut Bienvenue à tous

Le fichier HTML locale.html doit être placé sous le répertoire templates sur le chemin de classe comme indiqué -

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

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande comme indiqué -

java –jar <JARFILE>

Vous constaterez que l'application a démarré sur le port Tomcat 8080.

Cliquez maintenant sur l'URL http://localhost:8080/locale dans votre navigateur Web et vous pouvez voir la sortie suivante -

L'URL http://localhost:8080/locale?language=fr vous donnera la sortie comme indiqué -