Internationalization of RESTful Services

In this section, we will discuss the Internationalization of the RESTful Web Services.

Internationalization

Internationalization is the process of designing web applications or services in such a way that it can provide support for various countries, various languages automatically without making the changes in the application. It is also known as I18N because the word internationalization has total 18 characters starting from I to N.

Localization is performed by adding locale-specific components such as translated text, data describing locale-specific behavior, etc. It supports full integration into the classes and packages that provide language-or-culture-dependent functionality.

Java provides the foundation for internationalization for desktop and server applications. There are following important internationalized areas of functionality.

36.9M

662

Prime Ministers of India | List of Prime Minister of India (1947-2020)

Text Representation: Java is based on the Unicode character set, and several libraries implement the Unicode standard.
Locale identification and localization: Locale in Java are identifiers that can be used to request locale-specific behavior in different areas of functionality. Localization is supported by ResourceBundle class. The class provides access to local specific objects, including strings.
Date and time handling: Java provides various calendars. It supports conversion to and from calendar independent Date objects. Java supports all the time zones in the world.
Text processing: It includes character analysis, case mapping, string comparison, breaking text into words, formatting numbers, dates, and time values into strings or parsing them back from strings. Most of these functions are locale-dependent.
Character encoding: It supports converting text between Unicode and other character encodings when reading incoming text from the streams or writing outgoing text to the streams.

We need to configure two things to make the service internationalized.

LocaleResolver
ResourceBundleMessageSource

Default Locale is Locale.US. If somebody does not specify the location, it returns the default locale. We also need to customize the ResourceBundle. It has a list of properties that are to be internationalized. We will store the properties in ResourceBundle. ResourceBundleMessageSource is a Spring MVC concept for handling properties. After that, we will use MessageSource, and a header called Accept-Language.

Let's configure the internationalization.

Step 1: Open RestfulWebServicesApplication.java file.

Step 2: Configure a Bean for default locale.

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

Note: Import import org.springframework.web.servlet.LocaleResolver package while importing LocaleResolver.

Step 3: Now, we will store properties in a specific file called messages.properties.

Right-click on src/main/resources folder -> New -> File -> Provide the file name: messages.properties. It contains the default locale message.

messages.properties

good.morning.message=Good Morning

Step 4: Create another property file with the name messages_fr.properties for French locale. It contains a message for the French locale.

messages_fr.properties

good.morning.message=Bonjour

Step 5: Read properties and customize them based on the input accept header. Open the RestfulWebServicesApplication.java and configure another Bean for ResourceBundle.

//configuring ResourceBundle
@Bean
public ResourceBundleMessageSource bundleMessageSource()
{
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
return messageSource;
}

RestfulWebServicesApplication.java

package com.javatpoint.server.main;
import java.util.Locale;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;
@SpringBootApplication
public class RestfulWebServicesApplication
{
public static void main(String[] args)
{
SpringApplication.run(RestfulWebServicesApplication.class, args);
}
//configuring default locale
@Bean
public LocaleResolver localeResolver()
{
SessionLocaleResolver localeResolver = new SessionLocaleResolver();
localeResolver.setDefaultLocale(Locale.US);
return localeResolver;
}
//configuring ResourceBundle
@Bean
public ResourceBundleMessageSource messageSource()
{
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
return messageSource;
}
}

Step 6: Update the service to use these sources. Open the HelloWorldController.java and autowired the MessageSource.

@Autowired
private MessageSource messageSource;

HelloWorldController.java

package com.javatpoint.server.main.helloworld;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
import java.util.Locale;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Configuration;
@Configuration
//Controller
@RestController
public class HelloWorldController
{
@Autowired
private MessageSource messageSource;
//using get method and hello-world URI
@GetMapping(path="/hello-world")
public String helloWorld()
{
return "Hello World";
}
@GetMapping(path="/hello-world-bean")
//method- which returns "Hello World"
public HelloWorldBean helloWorldBean()
{
return new HelloWorldBean("Hello World");//constructor of HelloWorldBean
}
//passing a path variable
//hello-world/path-variable/javatpoint
@GetMapping(path="/hello-world/path-variable/{name}")
public HelloWorldBean helloWorldPathVariable(@PathVariable String name)
{
return new HelloWorldBean(String.format("Hello World, %s",name)); //%s replace the name
}
//internationalization
@GetMapping(path="/hello-world-internationalized")
public String helloWorldInternationalized(@RequestHeader(name="Accept-Language", required=false) Locale locale)
{
return messageSource.getMessage("good.morning.message", null, locale);
}
}

Step 7: Open the REST client Postman and perform the following changes:

Select the GET request.
Type the URI http://localhost:8080/hello-world-internationalized
Click on Headers tab and type:

Internationalization of RESTful Services

Click on the Send button.

It returns the US locale message Good Morning.

Now we change the RequestHeader us to fr and send a GET request again.

It returns the French locale message Bonjour.

Again, change the RequestHeader fr to other RequestHeader, say nl. It returns the default locale (US) message Good Morning.

Let's create a property file message_nl.properties for RequestHeader nl. It contains a message Goede Morgen in the Dutch language.

messages_nl.properties

good.morning.message=Goede Morgen

Again send a GET request that returns the message, Goede Morgen.

Simplify the Internationalization

Now we will simplify the implementation of internationalization, which we have done above. In the previous implementation, we have accepted locale (a RequestHeader) as a parameter to the REST controller method. If we add this to every method that has to be internationalized, it will increase the cost. Spring provides an alternative way to get it from the LocaleContextHolder.

Let's implement the LocaleContextHolder instead of RequestHeader.

Step 1: Open the HelloWorldController.java and change the return type of the helloWorldInternationalized() method.

return messageSource.getMessage("good.morning.message", null, LocaleContextHolder.getLocale());

HelloWorldController.java

package com.javatpoint.server.main.helloworld;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
import java.util.Locale;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.i18n.LocaleContextHolder;
@Configuration
//Controller
@RestController
public class HelloWorldController
{
@Autowired
private MessageSource messageSource;
//using get method and hello-world URI
@GetMapping(path="/hello-world")
public String helloWorld()
{
return "Hello World";
}
@GetMapping(path="/hello-world-bean")
//method- which returns "Hello World"
public HelloWorldBean helloWorldBean()
{
return new HelloWorldBean("Hello World");//constructor of HelloWorldBean
}
//passing a path variable
//hello-world/path-variable/javatpoint
@GetMapping(path="/hello-world/path-variable/{name}")
public HelloWorldBean helloWorldPathVariable(@PathVariable String name)
{
return new HelloWorldBean(String.format("Hello World, %s",name)); //%s replace the name
}
//internationalization
@GetMapping(path="/hello-world-internationalized")
public String helloWorldInternationalized(@RequestHeader(name="Accept-Language", required=false) Locale locale)
{
return messageSource.getMessage("good.morning.message", null, LocaleContextHolder.getLocale());
}
}

Step 2: Open RestfulWebServicesApplication.java and change SessionLocaleResolver to AcceptHeaderLocaleResolver. LocaleResolver implementation uses the primary locale specified in the "accept-language" header of the HTTP request (locale send by the client browser).

RestfulWebServicesApplication.java

package com.javatpoint.server.main;
import java.util.Locale;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;
@SpringBootApplication
public class RestfulWebServicesApplication
{
public static void main(String[] args)
{
SpringApplication.run(RestfulWebServicesApplication.class, args);
}
//configuring default locale
@Bean
public LocaleResolver localeResolver()
{
AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
localeResolver.setDefaultLocale(Locale.US);
return localeResolver;
}
//configuring ResourceBundle
@Bean
public ResourceBundleMessageSource messageSource()
{
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
return messageSource;
}
}

The advantage of AcceptHeaderLocaleResolver is that we do not require to configure request header as a parameter in every controller method.

Step 3: Open the REST client Postman and send a GET request by setting the key as Accept-Language and value as fr. It returns the message Bonjour.

Now uncheck the RequestHeader, change the value fr to en. It returns the default locale (US) message Good Morning.

Step 4: Move to RestfulWebServicesApplication.java. Remove the ResourceBundleMessageSource() method and configure it in the application.properties file.

Step 5: Open application.properties file and configure the message basename instead of creating a separate bean in RestfulWebServicesApplication.java.

Nguyễn Giang

Sunday, May 29, 2022

Internationalization of RESTful Services