Advertisement

---

Top

< Prev

Next >

In this tutorial, we will explain how to access a collection of objects stored in Map Collection, using the Spring Expression Language(SpEL) of Spring Framework. Before that we are also going to explain how to configure a collection of objects stored within a Map collection using the <map> tag of Spring Framework within its configuration XML file.

Creating the Java class - Company

We are going to create a java class named Company within the decodejava package and this class contains a String property named name and a Map collection consisting of multiple <key-value> pair of an Integer value(Employee ID) as a Key and its associated Employee object as its value.

Besides this, we are also going to define a couple of getter and setter methods within this class to set the Map collection and the String property.

package decodejava;

import java.util.Map;

public class Company 
{
 public String name;
 public Map<Integer,Employee> employees;
 
 
public String getName() 
{
	return name;
}
public void setName(String name) 
{
	this.name = name;
}


public Map<Integer,Employee> getEmployees()
{
	return employees;
}

public void setEmployees(Map<Integer,Employee> employees)
{
	this.employees = employees;
}

}

Creating a Java Class - Employee

Next, we are going to add another Java class named Employee and it is going to contain a String property and a primitive int property.

The properties will be assigned a value by the Spring Container, when the Employee bean is created by it using the configuration xml file(to be created in the upcoming section).

package decodejava;

public class Employee 
{
	public String name;
	public int telNo;
	
	
	public String getName() 
	{
		return name;
	}
	
	
	public void setName(String name) 
	{
		this.name = name;
	}
	
	
	public int getTelNo() 
	{
		return telNo;
	}
	
	
	public void setTelNo(int telNo) 
	{
		this.telNo = telNo;
	}
	
}

Advertisement

Adding the Utility class that calls the Spring API

Next, we are going to create another class named - Utility, which is a simple java class.

Utility.java

package decodejava;

import java.util.ArrayList;
import java.util.Map;
import java.util.Set;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class Utility {

	public static void main(String[] args) 
	{
		ApplicationContext context = new FileSystemXmlApplicationContext("classpath:config.beans.xml");
		Company company = context.getBean(Company.class);
		
		
		StandardEvaluationContext  stContext  = new StandardEvaluationContext(company);
		SpelExpressionParser parser = new SpelExpressionParser();
		
		Map<Integer,Employee> map = (Map<Integer,Employee>)parser.parseRaw("employees.?[key == 2]").getValue(stContext);
		
		Set<Map.Entry<Integer,Employee>> set = map.entrySet();
		
		for(Map.Entry<Integer,Employee> employee : set)
		{
			System.out.println("Employee ID : " + employee.getKey());
			System.out.println("Employee Name : " + employee.getValue().getName());
			System.out.println("Employee Tel No : " + employee.getValue().getTelNo());	
		}
			
	}
}

The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext, which loads the configuration xml file - config.beans.xml and does the following -

• Eventually, using the bean of Company class, this class calls the method of Employee class methods - getName() and getTelNo() by extracting each Employee bean from Map collection.

The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext, which loads the configuration xml file - config.beans.xml and does the following -

• Creates the Company bean and initiates it with a value by calling its setter methods i.e. setName() and setEmployees(Map<Integer,Employee> employees)



• Creates a Map collection of three Employee beans and initiate their values by calling its setter methods i.e. setName() and setTelNo() for each of these Employee beans.



• This Map collection consisting of multiple <key-value> pair of an Integer and an Employee bean is injected into Company bean.



• Accesses the Company bean specified in the configuration file by calling the getBean() method of ApplicationContext container.



• Using the StandardEvaluationContext class to evaluate the object of Company class, which is passed to its constructor.



• Using the SpelExpressionParse class to parse a String expression, which is passed to its method parseRaw(). This String expression starts with a question mark(?), followed by a boolean condition within a square bracket.

The String expression "employees.?[key == 2]" is parsed and returns a Map object containing the an Employee object with key equals to "2".


• Eventually, we have used for-each loop to cycle through the Map collection returned by parseRaw() method and have called the methods of Employee class - getName() and getTelNo().

Adding a configuration file

Next, we are going to add a configuration file to our project. This configuration document is an Extensible Markup Language(XML) file, ending with .xml extension and we are going to name file as config.beans.xml.

In this file, we have configured a Company bean with a unique id and it contains a collection of Employee beans.


config.beans.xml

<?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:util="springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/context/spring-context.xsd
       ">
           
<bean id="CompanyBean" class="decodejava.Company">
<property name="employees">
	<map>
			<entry key="1" value-ref="Employee1"></entry>
			<entry key="2" value-ref="Employee2"></entry>
			<entry key="3" value-ref="Employee3"></entry>
	</map>
</property>
</bean>

<bean class="decodejava.Employee" id="Employee1">
			<property name="name" value="Emp1"></property>
			<property name="telNo" value="111111"></property>
</bean>

<bean class="decodejava.Employee" id="Employee2">
			<property name="name" value="Emp2"></property>
			<property name="telNo" value="222222"></property>
</bean>

<bean class="decodejava.Employee" id="Employee3">
			<property name="name" value="Emp3"></property>
			<property name="telNo" value="333333"></property>
</bean>

</beans>

This mapping document has a parent <beans> tag as the root element and its individual child elements, each with a <bean> tag, containing all the attributes such as -

• The id attribute within the <bean> element defines a unique id associated with the bean.
• The class attribute within the <bean> element defines the name of the class of this bean.



The property child element in <bean> tag refers to a property within the Employee class.
• The name child attribute refers to the name of a property in the Employee class i.e. name or telNo.
• The value child attribute refers to the value of this property.



The <map> child tag element in <property> tag is used to configure a Map collection property containing an Integer and an Employee object in Company class.

Advertisement

Directory Structure of Project

The picture above depicts how and where to arrange classes and interfaces comprising this Spring Project, in a specific directory structure.

Project Folder - SpELWithMap is the name of our Project and it is a top-level directory.

This project folder contains a package of our project i.e. decodejava containing three classes -
• A POJO class named Company.java.
• Another POJO class named Employee.java.
• A class that calls the Spring Framework into action i.e. Utility.java.



• Besides this, the project folder also contains a configuration file i.e. config.beans.xml, used to configure the beans of classes in the project.
  
  
• The project folder also contains all the needed Spring JARs present in the libs folder of Spring Framework installation.

Execution

Finally, after executing Utility class, you will get the following output within the Console window. This output shown below, shows how the Utility class has used the ApplicationContext container of Spring Framework to load the configuration xml file - config.beans.xml, access the beans specified in it, instantiate the Company class and Employee class, by calling their respective setter methods.

This class has used StandardEvaluationContext class to evaluate the object of Company class and have used the SpelExpressionParse class to parse a String expression which returns a Map object containing the Employee object with their key value equals to "2" and have finally called the methods getName() and getTelNo() on these objects.

Aug 21, 2018 5:35:42 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@626b2d4a: startup date [Tue Aug 21 17:35:42 2018]; root of context hierarchy
Aug 21, 2018 5:35:42 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Employee ID : 2
Employee Name : Emp2
Employee Tel No : 222222

This concludes configuring a Map collection with the Spring Framework and access it using Spring Expression Language(SpEL). In the next article, we are going to show you how to access a Arrays collection using Spring Expression Language(SpEL)

Please share this article -

< Prev

Next >

< SpEL with Array

SpEL with XML >

Advertisement