Close

Spring - Dependency injection in @Bean method parameters

[Last Updated: Dec 8, 2020]

In a @Configuration class, the methods annotated with @Bean may depend on other beans to initialize themselves. Other beans should be annotated with @Bean as well to be registered with the Spring container.

Spring provides a mechanism where we can pass such bean dependencies with @Bean method parameters. They are injected by the framework just like a arbitrary method's dependencies are resolved

There are following scenarios:



  1. Injecting by type:

    If there's only one bean instance available to be injected to the injection target point then it will be injected successfully by type.


  2. Injecting by name:

    If there are more than one instance of the same type available for a target injection point then there's a conflict (ambiguity). Spring doesn't know which particular instance to be injected in that case. If the name of parameter is same as bean's definition method (the method annotated with @Bean) name then the dependency is resolved by name.

    The bean's definition method can provide a different name than the method name by using @Bean(name = ...), the injection point method's parameter name should match in that case as well.


  3. Injecting by bean's name with matching @Qualifier:

    If there's an ambiguity then it can also be resolved if the injection point method parameter add a @Qualifier annotation with matching target bean's name.


  4. Injecting by matching @Qualifiers

    Ambiguity can also be resolve by using @Qualifier on the both sides. This is important when a bean provider method has already indented to be exposed as a @Qualifier per business logic sense, so that a particular bean's implementation can be changed without updating all injection points.



Examples


Bean classes

package com.logicbig.example;

public class BeanA {
}

package com.logicbig.example;

public class BeanB {
  private BeanA beanA;

  BeanB (BeanA beanA) {
      this.beanA = beanA;
  }

  public BeanA getBeanA () {
      return beanA;
  }
}

package com.logicbig.example;

public class BeanC {
}

Injecting by type

package com.logicbig.example;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class InjectParameterByType {

    public static void main (String[] args) {
        AnnotationConfigApplicationContext context =
                            new AnnotationConfigApplicationContext(
                                                Config.class);
        BeanB beanB = context.getBean(BeanB.class);
        System.out.println("In the main method: " + beanB.getBeanA());
    }

    @Configuration
    public static class Config {

        @Bean
        public BeanA bean1 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean1: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanB bean2 (BeanA theBean) {
            BeanB beanB = new BeanB(theBean);
            System.out.println("method bean2: beanB created = " + beanB +
                                "\n with constructor param BeanA = " + theBean);

            return beanB;
        }
    }
}

Output

method bean1: beanA created = com.logicbig.example.BeanA@22dcf4fa
method bean2: beanB created = com.logicbig.example.BeanB@ad19da9
 with constructor param BeanA = com.logicbig.example.BeanA@22dcf4fa
In the main method: com.logicbig.example.BeanA@22dcf4fa

Injecting by default bean names

package com.logicbig.example;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class InjectParameterByName {

    public static void main (String[] args) {
        AnnotationConfigApplicationContext context =
                            new AnnotationConfigApplicationContext(
                                                Config.class);
        BeanB beanB = context.getBean(BeanB.class);
        System.out.println("In the main method: " + beanB.getBeanA());
    }

    @Configuration
    public static class Config {

        @Bean
        public BeanA bean1 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean1: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanA bean2 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean2: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanB bean3 (BeanA bean1) {
            BeanB beanB = new BeanB(bean1);
            System.out.println("method bean3: beanB created = " + beanB +
                                "\n with constructor param BeanA: " + bean1);

            return beanB;
        }
    }
}

Output

method bean1: beanA created = com.logicbig.example.BeanA@595532b
method bean2: beanA created = com.logicbig.example.BeanA@1592340b
method bean3: beanB created = com.logicbig.example.BeanB@131f2c23
 with constructor param BeanA: com.logicbig.example.BeanA@595532b
In the main method: com.logicbig.example.BeanA@595532b

Injecting by using @Qualifier at both places

package com.logicbig.example;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class InjectParameterByQualifier {

    public static void main (String[] args) {
        AnnotationConfigApplicationContext context =
                            new AnnotationConfigApplicationContext(
                                                Config.class);
        BeanB beanB = context.getBean(BeanB.class);
        System.out.println("In the main method: " + beanB.getBeanA());
    }

    @Configuration
    public static class Config {

        @Bean
        public BeanA bean1 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean1: beanA created = " + beanA);
            return beanA;
        }

        @Qualifier("myBean")
        @Bean
        public BeanA bean2 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean2: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanB bean3 (@Qualifier("myBean") BeanA theBean) {
            BeanB beanB = new BeanB(theBean);
            System.out.println("method bean3: beanB created = " + beanB +
                                "\n with constructor param BeanA = " + theBean);

            return beanB;
        }
    }
}

Output

method bean1: beanA created = com.logicbig.example.BeanA@334b9848
method bean2: beanA created = com.logicbig.example.BeanA@e0c33ff
method bean3: beanB created = com.logicbig.example.BeanB@1a69c4d3
 with constructor param BeanA = com.logicbig.example.BeanA@e0c33ff
In the main method: com.logicbig.example.BeanA@e0c33ff

Injecting by using @Qualifier at injection point only

package com.logicbig.example;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class InjectParameterByQualifier2 {

    public static void main (String[] args) {
        AnnotationConfigApplicationContext context =
                            new AnnotationConfigApplicationContext(
                                                Config.class);
        BeanB beanB = context.getBean(BeanB.class);
        System.out.println("In the main method: " + beanB.getBeanA());
    }

    @Configuration
    public static class Config {

        @Bean
        public BeanA bean1 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean1: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanA bean2 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean2: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanB bean3 (@Qualifier("bean2") BeanA theBean) {
            BeanB beanB = new BeanB(theBean);
            System.out.println("method bean3: beanB created = " + beanB +
                                "\n with constructor param BeanA = " + theBean);

            return beanB;
        }
    }
}

Output

method bean1: beanA created = com.logicbig.example.BeanA@7df9cdea
method bean2: beanA created = com.logicbig.example.BeanA@729f4474
method bean3: beanB created = com.logicbig.example.BeanB@2bb1c183
 with constructor param BeanA = com.logicbig.example.BeanA@729f4474
In the main method: com.logicbig.example.BeanA@729f4474

Injecting multiple beans using @Qualifier

package com.logicbig.example;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class InjectParameterByQualifier3 {

    public static void main (String[] args) {
        AnnotationConfigApplicationContext context =
                            new AnnotationConfigApplicationContext(
                                                Config.class);
        BeanB beanB = context.getBean(BeanB.class);
        System.out.println("In the main method: " + beanB.getBeanA());
    }

    @Configuration
    public static class Config {

        @Bean
        public BeanA bean1 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean1: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        @Qualifier("myBean")
        public BeanA bean2 () {
            BeanA beanA = new BeanA();
            System.out.println("method bean2: beanA created = " + beanA);
            return beanA;
        }

        @Bean
        public BeanC bean3 () {
            BeanC beanC = new BeanC();
            System.out.println("method bean3: beanC created = " + beanC);
            return beanC;
        }

        @Bean
        @Qualifier("myBean2")
        public BeanC bean4 () {
            BeanC beanC = new BeanC();
            System.out.println("method bean4: beanC created = " + beanC);
            return beanC;
        }

        @Bean
        public BeanB bean5 (@Qualifier("myBean") BeanA theBean,
                            @Qualifier("myBean2") BeanC theBean2) {
            BeanB beanB = new BeanB(theBean);
            System.out.println("method bean5: beanB created = " + beanB +
                                "\n with constructor param of type BeanA= " + theBean);
            System.out.println("method bean5: theBean2 instance (can also be in as constructor " +
                                "arg or some " +
                                "other way): " + theBean2);

            return beanB;
        }
    }
}

Output

method bean4: beanC created = com.logicbig.example.BeanC@440a5936
method bean3: beanC created = com.logicbig.example.BeanC@6bce6f30
method bean1: beanA created = com.logicbig.example.BeanA@32208ffa
method bean2: beanA created = com.logicbig.example.BeanA@fd85dc7
method bean5: beanB created = com.logicbig.example.BeanB@8558531
 with constructor param of type BeanA= com.logicbig.example.BeanA@fd85dc7
method bean5: theBean2 instance (can also be in as constructor arg or some other way): com.logicbig.example.BeanC@440a5936
In the main method: com.logicbig.example.BeanA@fd85dc7

Example Project

Dependencies and Technologies Used:

  • Spring Context 4.3.2.RELEASE: Spring Context.
  • JDK 1.8
  • Maven 3.0.4
Spring - The @Bean methods and their inter-dependencies. Select All Download
  • bean-method-parameters
    • src
      • main
        • java
          • com
            • logicbig
              • example
                • InjectParameterByName.java

    See Also