JAVA EE: TreeMap

Showing posts with label TreeMap. Show all posts

Friday, 10 August 2018

How to create a concrete Map collection class (HashMap and TreeMap) using mapFactoryBean in Spring

Master Spring & Java Development!

Subscribe to Ram N Java for clean, beginner-friendly coding guides!

Overview: Configuring Concrete Maps with MapFactoryBean

In the Spring Framework, injecting collections such as Map is a common task. By default, Spring instantiates standard map implementations when using built-in XML collection tags. However, when your application requires a specific concrete collection class—such as a HashMap, sorted TreeMap, or concurrent map—Spring's MapFactoryBean provides precise control over the exact map type instantiated and populated in the container.

In this guide, you will learn how to configure MapFactoryBean to create concrete Map collections like HashMap and TreeMap, populate them with key-value pairs, and inject them into your Spring beans.

Understanding MapFactoryBean

MapFactoryBean is a built-in Spring helper class that creates concrete map instances with customized behavior:

Target Concrete Class: Allows you to define the exact implementation class via the targetMapClass property (e.g., java.util.HashMap or java.util.TreeMap).
Pre-Populated Key-Value Pairs: Accepts source map entries through its sourceMap property and copies them into the newly instantiated target map.
Sorted and Ordered Maps: When configuring a TreeMap, keys are automatically maintained in natural sorted order, making it ideal for ordered lookups.
Reusable Map Beans: Produces a standalone bean that can be injected into multiple collaborator beans across your Spring context.

Step-by-Step Implementation

Declare MapFactoryBean in XML: Configure the bean using org.springframework.beans.factory.config.MapFactoryBean.
Specify the Target Map Class: Set targetMapClass to your chosen map implementation:
<property name="targetMapClass" value="java.util.TreeMap"/>
Populate Source Map Entries: Add key-value entries inside the sourceMap property:
<property name="sourceMap"> <map> <entry key="India" value="New Delhi"/> <entry key="USA" value="Washington D.C."/> </map> </property>
Inject into Target Bean: Reference the created map bean in your dependent class using the standard ref attribute.

Recommended Next Videos from Ram N Java

Click here to watch on Youtube:
https://www.youtube.com/watch?v=_gUjDJ0WQVU&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

How to create a concrete Map collection class (HashMap and TreeMap) using mapFactoryBean in Spring

pom.xml

<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%20http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ram.core</groupId>

    <artifactId>SpringDemo</artifactId>

    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>SpringDemo</name>

    <url>http://maven.apache.org</url>

    <properties>

        <spring.version>5.0.2.RELEASE</spring.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <!-- Spring 5 dependencies -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

    </dependencies>

</project>

FruitShop.java

package com.ram.core;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class FruitShop

{

    private String shopName;

    private Map<Integer, String> mapOfAvailableFruits;

    public String getShopName()

    {

        return shopName;

    }

    public void setShopName(String shopName)

    {

        this.shopName = shopName;

    }

    public Map<Integer, String> getMapOfAvailableFruits()

    {

        return mapOfAvailableFruits;

    }

    public void setMapOfAvailableFruits(

            Map<Integer, String> mapOfAvailableFruits)

    {

        this.mapOfAvailableFruits = mapOfAvailableFruits;

    }

    public void displayFruitShopInfo()

    {

        System.out.println("FruitShop [shopName=" + shopName

                + ", mapOfAvailableFruits=" + mapOfAvailableFruits + "]");

        System.out.println("Fruit ShopName = " + shopName);

        Set<Entry<Integer, String>> set = mapOfAvailableFruits.entrySet();

        Iterator<Entry<Integer, String>> itr = set.iterator();

        while (itr.hasNext())

        {

            Entry<Integer, String> entry = itr.next();

            System.out.println("Fruit Id = " + entry.getKey()

                    + ", Fruit Name = " + entry.getValue());

        }

    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

    xmlns:util="http://www.springframework.org/schema/util"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

    http://www.springframework.org/schema/util

    http://www.springframework.org/schema/util/spring-util-4.3.xsd">

    <bean id="fruitShop" class="com.ram.core.FruitShop">

        <property name="shopName" value="Fruit Mart"></property>

        <property name="mapOfAvailableFruits">

            <bean class="org.springframework.beans.factory.config.MapFactoryBean">

                <property name="targetMapClass">

                    <value>java.util.HashMap</value>

                </property>

                <property name="sourceMap">

                    <map>

                        <entry key="1" value="Apple"></entry>

                        <entry key="2" value="Grapes"></entry>

                    </map>

                </property>             

            </bean>

        </property>

    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        System.out.println("---------------------------------------");

        FruitShop fruitShop = (FruitShop) context.getBean("fruitShop");

        System.out.println(

                "Got fruitShop object from the ApplicationContext(Spring Container)");

        fruitShop.displayFruitShopInfo();

    }

}

Output

Jul 31, 2018 9:22:25 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Tue Jul 31 09:22:25 IST 2018]; root of context hierarchy

Jul 31, 2018 9:22:25 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

---------------------------------------

Got fruitShop object from the ApplicationContext(Spring Container)

FruitShop [shopName=Fruit Mart, mapOfAvailableFruits={1=Apple, 2=Grapes}]

Fruit ShopName = Fruit Mart

Fruit Id = 1, Fruit Name = Apple

Fruit Id = 2, Fruit Name = Grapes

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_MapFactoryBean.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_MapFactoryBean

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/463ef0439e374e3884b06b8ead881ecf3ac4364f/Spring_2018/SpringDemo_MapFactoryBean/?at=master

See also:

All JavaEE Videos Playlist

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

How to create a concrete Map collection class (HashMap and TreeMap) using util:map in Spring

Master Spring & Java Development!

Subscribe to Ram N Java for clean, beginner-friendly coding guides!

🔔 Subscribe to Ram N Java

Overview: Concrete Map Collections with util:map in Spring

In the Spring Framework, managing collections inside XML configuration can sometimes become verbose when using standard bean definitions. The Spring util schema offers concise, dedicated XML tags to declare collection beans directly. With the <util:map> element, you can easily instantiate concrete map implementations such as java.util.HashMap or java.util.TreeMap as standalone beans.

In this guide, you will learn how to declare concrete Map collection beans using the util:map namespace, configure their implementation classes, and inject them cleanly into your Spring beans.

Why Use <util:map> in Spring?

The util:map tag simplifies collection bean configuration with several benefits:

Clean & Concise XML: Eliminates boilerplate MapFactoryBean declarations by providing a dedicated, expressive schema element.
Concrete Class Customization: Use the map-class attribute to specify concrete collection types such as java.util.HashMap, java.util.LinkedHashMap, or java.util.TreeMap.
Standalone Reusable Bean: Defines a map bean with its own id, allowing it to be shared and injected across multiple collaborating beans.
Sorting & Ordering: Specifying java.util.TreeMap guarantees that keys are kept in their natural sorted order.

Step-by-Step Configuration

Declare the Util Namespace: Add the util schema definition to your Spring XML configuration:
xmlns:util="http://www.springframework.org/schema/util"
Define the Map with util:map: Set the desired concrete class via map-class and add key-value entries:
<util:map id="countryCapitals" map-class="java.util.TreeMap"> <entry key="India" value="New Delhi"/> <entry key="USA" value="Washington D.C."/> </util:map>
Inject the Map into Target Bean: Reference the map bean in your target bean definition:
<bean id="countryService" class="com.example.CountryService"> <property name="capitals" ref="countryCapitals"/> </bean>