www.baeldung.com Open in urlscan Pro
2606:4700:3108::ac42:28f8  Public Scan

Form analysis
1 forms found in the DOM

POST https://www.getdrip.com/forms/15866254/submissions

<form method="post" action="https://www.getdrip.com/forms/15866254/submissions"><input type="hidden" value="https://www.getdrip.com/forms/15866254/submissions">
  <div>
    <div style="padding-top: 20px;">
      <input class="input-email" name="fields[email]" id="drip-email" type="email" placeholder="Your Email" value="" label="Email Address">
    </div>
    <div><input name="website" id="website" type="text" placeholder="website" value="" label="Website" style="display:none"></div>
    <div style="padding-top: 20px;"><button type="submit">FOLLOW THE SPRING</button></div>
  </div>
</form>

Text Content

WE VALUE YOUR PRIVACY

We and our partners store and/or access information on a device, such as cookies
and process personal data, such as unique identifiers and standard information
sent by a device for personalised ads and content, ad and content measurement,
and audience insights, as well as to develop and improve products. With your
permission we and our partners may use precise geolocation data and
identification through device scanning. You may click to consent to our and our
partners’ processing as described above. Alternatively you may access more
detailed information and change your preferences before consenting or to refuse
consenting. Please note that some processing of your personal data may not
require your consent, but you have a right to object to such processing. Your
preferences will apply to this website only. You can change your preferences at
any time by returning to this site or visit our privacy policy.
MORE OPTIONSAGREE

 * 
 * 
 * Start Here
 * Courses ▼▲
   
   
    * REST WITH SPRING
      
      The canonical reference for building a production grade API with Spring
   
   
    * LEARN SPRING SECURITY ▼▲
      
      THE unique Spring Security education if you’re working with Java today
      
      
       * LEARN SPRING SECURITY CORE
         
         Focus on the Core of Spring Security 5
      
      
       * LEARN SPRING SECURITY OAUTH
         
         Focus on the new OAuth2 stack in Spring Security 5
   
   
    * LEARN SPRING
      
      From no experience to actually building stuff
   
   
    * LEARN SPRING DATA JPA
      
      The full guide to persistence with Spring Data JPA

 * Guides ▼▲
   
   
    * PERSISTENCE
      
      The Persistence with Spring guides
   
   
    * REST
      
      The guides on building REST APIs with Spring
   
   
    * SECURITY
      
      The Spring Security guides

 * About ▼▲
   
   
    * FULL ARCHIVE
      
      The high level overview of all the articles on the site.
   
   
    * BAELDUNG EBOOKS
      
      Discover all of our eBooks
   
   
    * ABOUT BAELDUNG
      
      About Baeldung.

 * 
 * 




GUIDE TO SPRING @AUTOWIRED



Last updated: September 14, 2023

Written by: baeldung
 * Spring+

 * Spring Core Basics
 * Spring DI

Course – LS (cat=Spring)


GET STARTED WITH SPRING 5 AND SPRING BOOT 2, THROUGH THE REFERENCE LEARN SPRING
COURSE:

>> LEARN SPRING



1. OVERVIEW



Starting with Spring 2.5, the framework introduced annotations-driven Dependency
Injection. The main annotation of this feature is @Autowired. It allows Spring
to resolve and inject collaborating beans into our bean.


FURTHER READING:


SPRING COMPONENT SCANNING

Learn about the mechanism behind Spring component scanning, and how you can
tweak it to your own needs
Read more →


INTRO TO INVERSION OF CONTROL AND DEPENDENCY INJECTION WITH SPRING

A quick introduction to the concepts of Inversion of Control and Dependency
Injection, followed by a simple demonstration using the Spring Framework
Read more →

In this tutorial, we’ll first take a look at how to enable autowiring and
the various ways to autowire beans. Afterward, we’ll talk about resolving bean
conflicts using @Qualifier annotation, as well as potential exception scenarios.


2. ENABLING @AUTOWIRED ANNOTATIONS



The Spring framework enables automatic dependency injection. In other words, by
declaring all the bean dependencies in a Spring configuration file, Spring
container can autowire relationships between collaborating beans. This is called
Spring bean autowiring.

To use Java-based configuration in our application, let’s enable
annotation-driven injection to load our Spring configuration:

@Configuration
@ComponentScan("com.baeldung.autowire.sample")
public class AppConfig {}Copy

Alternatively, the <context:annotation-config> annotation is mainly used to
activate the dependency injection annotations in Spring XML files.



Moreover, Spring Boot introduces the @SpringBootApplication annotation. This
single annotation is equivalent to using @Configuration,
@EnableAutoConfiguration, and @ComponentScan.

Let’s use this annotation in the main class of the application:

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}Copy

As a result, when we run this Spring Boot application, it will automatically
scan the components in the current package and its sub-packages. Thus it will
register them in Spring’s Application Context, and allow us to inject beans
using @Autowired.


3. USING @AUTOWIRED



After enabling annotation injection, we can use autowiring on properties,
setters, and constructors.


3.1. @AUTOWIRED ON PROPERTIES



Let’s see how we can annotate a property using @Autowired. This eliminates the
need for getters and setters.



First, let’s define a fooFormatter bean:

@Component("fooFormatter")
public class FooFormatter {
    public String format() {
        return "foo";
    }
}Copy

Then, we’ll inject this bean into the FooService bean using @Autowired on the
field definition:

@Component
public class FooService {  
    @Autowired
    private FooFormatter fooFormatter;
}Copy

As a result, Spring injects fooFormatter when FooService is created.


3.2. @AUTOWIRED ON SETTERS



Now let’s try adding @Autowired annotation on a setter method.

In the following example, the setter method is called with the instance of
FooFormatter when FooService is created:



public class FooService {
    private FooFormatter fooFormatter;
    @Autowired
    public void setFormatter(FooFormatter fooFormatter) {
        this.fooFormatter = fooFormatter;
    }
}
Copy


3.3. @AUTOWIRED ON CONSTRUCTORS



Finally, let’s use @Autowired on a constructor.

We’ll see that an instance of FooFormatter is injected by Spring as an argument
to the FooService constructor:

public class FooService {
    private FooFormatter fooFormatter;
    @Autowired
    public FooService(FooFormatter fooFormatter) {
        this.fooFormatter = fooFormatter;
    }
}Copy


4. @AUTOWIRED AND OPTIONAL DEPENDENCIES



When a bean is being constructed, the @Autowired dependencies should be
available. Otherwise, if Spring cannot resolve a bean for wiring, it will throw
an exception.

Consequently, it prevents the Spring container from launching successfully with
an exception of the form:

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: 
No qualifying bean of type [com.autowire.sample.FooDAO] found for dependency: 
expected at least 1 bean which qualifies as autowire candidate for this dependency. 
Dependency annotations: 
{@org.springframework.beans.factory.annotation.Autowired(required=true)}Copy

To fix this, we need to declare a bean of the required type:

public class FooService {
    @Autowired(required = false)
    private FooDAO dataAccessor; 
}Copy


5. AUTOWIRE DISAMBIGUATION



By default, Spring resolves @Autowired entries by type. If more than one bean of
the same type is available in the container, the framework will throw a fatal
exception.

To resolve this conflict, we need to tell Spring explicitly which bean we want
to inject.


5.1. AUTOWIRING BY @QUALIFIER



For instance, let’s see how we can use the @Qualifier annotation to indicate the
required bean.



First, we’ll define 2 beans of type Formatter:

@Component("fooFormatter")
public class FooFormatter implements Formatter {
    public String format() {
        return "foo";
    }
}Copy

@Component("barFormatter")
public class BarFormatter implements Formatter {
    public String format() {
        return "bar";
    }
}Copy

Now let’s try to inject a Formatter bean into the FooService class:

public class FooService {
    @Autowired
    private Formatter formatter;
}Copy

In our example, there are two concrete implementations of Formatter available
for the Spring container. As a result, Spring will throw a
NoUniqueBeanDefinitionException exception when constructing the FooService:


Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: 
No qualifying bean of type [com.autowire.sample.Formatter] is defined: 
expected single matching bean but found 2: barFormatter,fooFormatter
Copy

We can avoid this by narrowing the implementation using a @Qualifier annotation:

public class FooService {
    @Autowired
    @Qualifier("fooFormatter")
    private Formatter formatter;
}Copy

When there are multiple beans of the same type, it’s a good idea to use
@Qualifier to avoid ambiguity.

Please note that the value of the @Qualifier annotation matches with the name
declared in the @Component annotation of our FooFormatter implementation.


5.2. AUTOWIRING BY CUSTOM QUALIFIER



Spring also allows us to create our own custom @Qualifier annotation. To do so,
we should provide the @Qualifier annotation with the definition:

@Qualifier
@Target({
  ElementType.FIELD, ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface FormatterType {  
    String value();
}Copy

Then we can use the FormatterType within various implementations to specify a
custom value:



@FormatterType("Foo")
@Component
public class FooFormatter implements Formatter {
    public String format() {
        return "foo";
    }
}Copy

@FormatterType("Bar")
@Component
public class BarFormatter implements Formatter {
    public String format() {
        return "bar";
    }
}Copy

Finally, our custom Qualifier annotation is ready to use for autowiring:

@Component
public class FooService {  
    @Autowired
    @FormatterType("Foo")
    private Formatter formatter;
}
Copy

The value specified in the @Target meta-annotation restricts where to apply the
qualifier, which in our example is fields, methods, types, and parameters.


5.3. AUTOWIRING BY NAME



Spring uses the bean’s name as a default qualifier value. It will inspect the
container and look for a bean with the exact name as the property to autowire
it.

Hence, in our example, Spring matches the fooFormatter property name to the
FooFormatter implementation. Therefore, it injects that specific implementation
when constructing FooService:

public class FooService {
 @Autowired 
private Formatter fooFormatter; 
}Copy


6. CONCLUSION



In this article, we discussed autowiring and the different ways to use it. We
also examined ways to solve two common autowiring exceptions caused by either a
missing bean or an ambiguous bean injection.

The source code of this article is available on the GitHub project.

Course – LS (cat=Spring)


GET STARTED WITH SPRING 5 AND SPRING BOOT 2, THROUGH THE LEARN SPRING COURSE:

>> THE COURSE
res – REST with Spring (eBook) (everywhere)
Learning to build your API
with Spring?
Download the E-book
Comments are closed on this article!

res – REST with Spring (eBook) (everywhere)
Building a REST API with Spring 5?
Download the E-book





COURSES

 * All Courses
 * All Bulk Courses
 * All Bulk Team Courses
 * The Courses Platform

SERIES

 * Java “Back to Basics” Tutorial
 * Jackson JSON Tutorial
 * Apache HttpClient Tutorial
 * REST with Spring Tutorial
 * Spring Persistence Tutorial
 * Security with Spring
 * Spring Reactive Tutorials

ABOUT

 * About Baeldung
 * The Full Archive
 * Editors
 * Jobs
 * Our Partners
 * Partner with Baeldung

 * Terms of Service
 * Privacy Policy
 * Company Info
 * Contact



Follow the Spring Category


Follow the Spring category to get regular info about the new articles and
tutorials we publish here.
FOLLOW THE SPRING