Spring Boot - Internationalisierung

Die Internationalisierung ist ein Prozess, mit dem Ihre Anwendung an verschiedene Sprachen und Regionen angepasst werden kann, ohne dass technische Änderungen am Quellcode vorgenommen werden müssen. Mit anderen Worten, Internationalisierung ist eine Bereitschaft zur Lokalisierung.

In diesem Kapitel erfahren Sie ausführlich, wie Sie die Internationalisierung in Spring Boot implementieren.

Abhängigkeiten

Wir benötigen die Abhängigkeiten Spring Boot Starter Web und Spring Boot Starter Thymeleaf, um eine Webanwendung in Spring Boot zu entwickeln.

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

Wir müssen das Standardgebietsschema Ihrer Anwendung bestimmen. Wir müssen die LocaleResolver-Bean in unserer Spring Boot-Anwendung hinzufügen.

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

LocaleChangeInterceptor

LocaleChangeInterceptor wird verwendet, um das neue Gebietsschema basierend auf dem Wert des Sprachparameters zu ändern, der einer Anforderung hinzugefügt wurde.

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

Um diesen Effekt zu erzielen, müssen wir den LocaleChangeInterceptor zum Registrierungs-Interceptor der Anwendung hinzufügen. Die Konfigurationsklasse sollte die WebMvcConfigurerAdapter-Klasse erweitern und die Methode addInterceptors () überschreiben.

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

Nachrichtenquellen

Die Spring Boot-Anwendung übernimmt standardmäßig die Nachrichtenquellen src/main/resourcesOrdner unter dem Klassenpfad. Der Standardname für das Gebietsschema der Nachrichtendatei sollte lautenmessage.properties und Dateien für jedes Gebietsschema sollten den Namen haben messages_XX.properties. Das "XX" steht für den Gebietsschema-Code.

Alle Nachrichteneigenschaften sollten als Schlüsselpaarwerte verwendet werden. Wenn im Gebietsschema keine Eigenschaften gefunden werden, verwendet die Anwendung die Standardeigenschaft aus der Datei messages.properties.

Die Standardnachrichten.Eigenschaften sind wie folgt:

welcome.text=Hi Welcome to Everyone

Die französische Sprache messages_fr.properties wird wie folgt angezeigt:

welcome.text=Salut Bienvenue à tous

Note - Die Nachrichtenquelldatei sollte im Dateiformat „UTF-8“ gespeichert werden.

HTML-Datei

Verwenden Sie in der HTML-Datei die Syntax #{key} um die Nachrichten aus der Eigenschaftendatei anzuzeigen.

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

Der vollständige Code ist unten angegeben

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

Die Hauptdatei der Spring Boot-Anwendungsklasse ist unten angegeben:

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

Die Controller-Klassendatei ist unten angegeben -

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

Konfigurationsklasse zur Unterstützung der Internationalisierung

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

Die Nachrichtenquellen - messages.properties sind wie gezeigt -

welcome.text = Hi Welcome to Everyone

Die Nachrichtenquellen - message_fr.properties sind wie gezeigt -

welcome.text = Salut Bienvenue à tous

Die HTML-Datei locale.html sollte wie gezeigt unter dem Vorlagenverzeichnis im Klassenpfad abgelegt werden.

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

Sie können eine ausführbare JAR-Datei erstellen und die Spring-Boot-Anwendung mit den folgenden Maven- oder Gradle-Befehlen ausführen:

Verwenden Sie für Maven den folgenden Befehl: