• Skip to primary navigation
  • Skip to content
  • Skip to primary sidebar
  • Skip to footer
  • Core Java
  • Design Patterns
  • JSP
  • Servlets
  • Building Tools
  • jQuery
  • Spring
  • Hibernate
  • Mongo DB
  • More
    • HTML
    • SCJP
    • AJAX
    • UML
    • Struts
    • J2EE
    • Testing
    • Angular JS

J2EE Reference

  • Home
  • About Us
    • Java Learning Centers
  • Contact Us

Using MessageSource in Spring

July 8, 2015 By j2eereference Leave a Comment

Using MessageSource in Spring

Messaging support and Internationalization is provided by Spring ApplicationContext and this is one of the advantages of using Application Context over BeanFactory. If we have different messages that need to be displayed in application UI and we would not want those messages to be inside the code, we keep those messages in properties file and then refer to these texts inside the properties file. Spring provides support for this. We can have a properties file which consolidates all the key and value pairs and then we specify the key in our application to refer to that text which is assigned to that key in the properties file.  Let us see how we can use this support for Messages in Spring.

mymessages.properties

1
greeting=Hello!

We have the message ‘Hello!’  saved inside a properties file and we have given it  a key of ‘greeting’. We will use this key-value pair and print ‘Hello!’ message in our program.

The first thing we need to have in order to have Messaging Support enabled is to have a message source bean defined in the application.

 spring.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="UTF-8"?>  
 
<beans  
    xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd">  
  
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>mymessages</value>
</list>
</property>
</bean>
<context:annotation-config/>
<context:component-scan base-package="com.j2eereference.spring"></context:component-scan>
</beans>

The bean added to support the message service the bean with id=”messageSource” and the class ‘ResourceBundleMessageSource’ (give the fully qualified name as mentioned in spring.xml). This class is provided by Spring. It helps us pick messages from properties file. This bean needs some more configuration – we need to tell the bean where the properties file is. To do that, we have added a property tag with name ‘basenames’ and within which we define the list of properties file names(without .properties extension). We have only one properties file in our example. If there are multiple properties files, we can list out all the properties file over here. This is what The messageSource is going to look at when it has to pull up messages.

MessageSourceDemo.java

1
2
3
4
5
6
7
8
9
10
11
12
package com.j2eereference.spring;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MessageSourceDemo{
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
System.out.println(context.getMessage("greeting",null,"Default Greeting", null));
}
}

Output:

Hello!

The ‘context’ object has a method called getMessage(). There are different signatures for this method. Lets look into the one that is used here. It takes four parameters –
First parameter – the name of the property that we need to retrieve from the properties file. ‘greeting’ in this example.
Second parameter – A string of object in case the message takes in some parameters. We will look at parameter messages later. Since we don’t have parameter in our message and it is a simple text, we will keep it null.
Third Parameter – The default message that it needs to return in case it does not find a message that we are looking for.’Default Greeting’ in our example. This message will be shown if a corresponding message for the ‘greeting’ key is not found in any of the properties files.
Fourth parameter – the locale for which we are going to get the message. We will keep it null for now and explain it later.

Injecting MessageSource into a bean:

Here lets understand how to inject the MessageSource into a bean with the below example

mymessages.properties

1
greeting=Hello Good morning !

spring.xml

XHTML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?xml version="1.0" encoding="UTF-8"?>  
 
<beans  
    xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd">  
<bean id="Greetings" class="com.j2eereference.spring.messageSource.Greetings" >
<property name="messageSrc" ref="messageSource"/>
</bean>
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>mymessages</value>
</list>
</property>
</bean>
<context:annotation-config/>
<context:component-scan base-package="com.j2eereference.spring"></context:component-scan>
</beans>

 

Greetings.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.j2eereference.spring.messageSource;
 
import org.springframework.context.MessageSource;
 
public class Greetings {
MessageSource messageSrc;
 
public MessageSource getMessageSrc() {
return messageSrc;
}
 
public void setMessageSrc(MessageSource messageSrc) {
this.messageSrc = messageSrc;
}
public void display()
{
System.out.println(this.messageSrc.getMessage("greeting", null,"Default Greeting", null));
}
 
}

MessageSourceDemo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.j2eereference.spring.messageSource;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MessageSourceDemo {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Greetings greetings= (Greetings)context.getBean("Greetings");
greetings.display();
}
}

Output:

1
Hello Good morning !

Using placeholder in MessageSource:

This is fine but how do we replace the sysout that prints the branch information, using message source? As mentioned earlier, the second parameter of the getMesssage() is a string object that in case the message takes in some parameters. Now lets add one more entry in the properties file to print the branch information using message source.

mymessages.properties

1
bank.information=HDFC Branch code : {0} and Address : {1}

MessageSourceDemo.java

1
2
3
4
5
6
7
8
9
10
11
12
package com.j2eereference.spring.messageSource;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MessageSourceDemo {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
System.out.println(context.getMessage("bank.information",new Object[]{"0001","Bangalore , India"},"Default Greeting", null));
}
}

Output:

1
Branch code :0001 and Address : Bangalore , India

Here the message is picked up from the properties file and it also does the parameter substitution.

Related Posts

  • Spring dependency injection with Java configuration
  • What is Spring Boot?
  • @import annotation in Spring
  • Configuring Spring Lifecycle Callbacks with java
  • Configuring Spring Bean Scope with java
  • Spring configuration using java
  • @Required annotation in spring
  • Event handling in Spring
  • Component annotation in spring
  • Spring JSR-250 Annotations

Filed Under: Spring

Reader Interactions

Leave a Reply Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Primary Sidebar

FOLLOW US ONLINE

  • View J2eereference-166104970118637’s profile on Facebook
  • View j2eereference’s profile on Twitter
  • View j2eereference’s profile on LinkedIn

Subscribe by email

Recent posts

  • Java Buzzwords
  • Anonymous Inner Class in Java
  • Network Programming – java.net Package
  • Java Regular Expressions
  • Method Local Inner Class in Java
  • URL Processing in Java
  • Iterator Design Pattern Implementation using Java
  • Strategy Design Pattern Implementation using Java
  • Decorator Design Pattern
  • Adapter Design Pattern Implementation using Java
  • JSF Composite Components
  • JSF UI Components
  • What is JavaServer Faces (JSF)?
  • GOF Design Patterns
  • History and Need for Design Patterns

Footer

Core Java
Design Patterns
JSP
Servlets
HTML
Building Tools
AJAX
SCJP
jQuery
Testing
Spring
UML
Struts
Java Centers
Java Training
Home
About Us
Contact Us
Copyright © j2eereference.com. All right reserved.