JAVA EE: Type Ambiguity

Showing posts with label Type Ambiguity. Show all posts

Sunday, 15 July 2018

What is Constructor injection type ambiguities in Spring?

Enjoying This Tutorial?

Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

Introduction

Constructor-based dependency injection is one of the most reliable ways to achieve bean immutability in the Spring Framework. However, when a class has multiple overloaded constructors with similar argument counts (such as constructors accepting int vs. String), Spring's IoC container can encounter type ambiguity when parsing XML configuration values.

Why Does Constructor Ambiguity Occur?

XML String Default: In XML files, all values specified inside <constructor-arg value="..."/> are treated as strings by default.
Constructor Overloading Conflicts: If a class defines both Employee(String, String) and Employee(String, int), Spring may not know which constructor to invoke without explicit type guidance.
Unexpected Constructor Selection: Without explicit disambiguation, Spring may invoke the wrong constructor based on order of appearance or default type conversion rules.

How to Resolve Constructor Type Ambiguities

Spring provides clear mechanisms within the <constructor-arg> tag to resolve ambiguities: type and index.

1. The Java Class with Overloaded Constructors

package com.ram.model;

public class Employee {
    private String name;
    private int age;

    public Employee(String name, String age) {
        System.out.println("Invoked (String, String) constructor");
        this.name = name;
        this.age = Integer.parseInt(age);
    }

    public Employee(String name, int age) {
        System.out.println("Invoked (String, int) constructor");
        this.name = name;
        this.age = age;
    }
}

2. Explicit Disambiguation Using type and index in XML

Use the type attribute to specify the exact target type (e.g., int vs java.lang.String) and index to enforce argument positioning:

<!-- Disambiguating explicitly using type and index attributes -->
<bean id="employee" class="com.ram.model.Employee">
    <constructor-arg index="0" type="java.lang.String" value="Ram" />
    <constructor-arg index="1" type="int" value="30" />
</bean>

3. Loading the ApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Employee emp = (Employee) context.getBean("employee");
System.out.println("Employee loaded successfully!");

Key Takeaway

Specifying the type and index attributes on <constructor-arg> removes all guesswork for Spring's IoC container, preventing constructor resolution errors and ensuring that the exact target constructor is called every time.

Recommended Constructor & Dependency Injection Tutorials from Ram N Java

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

Click the below Image to Enlarge:

What is Constructor injection type ambiguities 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>

Employee.java

package com.ram.core.model;

public class Employee

{

    private String name;

    private String address;

    private int age;

    public Employee(String name, String address, int age)

    {

        this.name = name;

        this.address = address;

        this.age = age;

    }

    public Employee(String name, int age, String address)

    {

        this.name = name;

        this.age = age;

        this.address = address;

    }

    @Override

    public String toString()

    {

        return "Employee [name=" + name + ", address=" + address + ", age="

                + age + "]";

    }

}

applicationContext.xml

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

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

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

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

    <bean id="employee" class="com.ram.core.model.Employee">

        <constructor-arg type="java.lang.String">

            <value>Peter</value>

        </constructor-arg>

        <constructor-arg type="int">

            <value>32</value>

        </constructor-arg>

        <constructor-arg type="java.lang.String">

            <value>1888</value>

        </constructor-arg>

    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.core.model.Employee;

public class App

{ 

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

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

        Employee employee = (Employee) context.getBean("employee");

        System.out.println(

                "Got employee object from the ApplicationContext(Spring container)");

        System.out.println(employee);

    }

}

Output

Jun 26, 2018 9:13:32 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Tue Jun 26 09:13:32 IST 2018]; root of context hierarchy

Jun 26, 2018 9:13:32 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

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

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

Got employee object from the ApplicationContext(Spring container)

Employee [name=Peter, address=1888, age=32]