__CONFIG_colors_palette__{"active_palette":0,"config":{"colors":{"40f3f":{"name":"Main Accent","parent":-1}},"gradients":[]},"palettes":[{"name":"Default","value":{"colors":{"40f3f":{"val":"var(--tcb-color-0)"}},"gradients":[]},"original":{"colors":{"40f3f":{"val":"rgb(127, 215, 132)","hsl":{"h":123,"s":0.52,"l":0.67,"a":1}}},"gradients":[]}}]}__CONFIG_colors_palette__

__CONFIG_colors_palette__{"active_palette":0,"config":{"colors":{"40f3f":{"name":"Main Accent","parent":-1}},"gradients":[]},"palettes":[{"name":"Default","value":{"colors":{"40f3f":{"val":"var(--tcb-color-0)"}},"gradients":[]},"original":{"colors":{"40f3f":{"val":"rgb(127, 215, 132)","hsl":{"h":123,"s":0.52,"l":0.67,"a":1}}},"gradients":[]}}]}__CONFIG_colors_palette__
Table of Contents

Spring autowired feature enables injection of the object dependency implicitly. In this article, we will cover different features and techniques for the bean autowiring provided by Spring Framework.

 

Introduction

Spring Framework (2.5) introduced the @Autowired annotation for Dependency Injection. In this article, we will learn how to enable Spring bean autowiring feature and the different techniques to inject bean dependencies in our code base.

 

1. Enabling @Autowired Annotations

To enable Spring based injection, we need to pass certain information to the underlying Spring IoC container to detect all components. This can be achieved with the help of AnnotationConfigApplicationContext and @ComponentScan annotation. For Java based configuration

@Configuration
@ComponentScan("com.java.web")
public class WebConfig {
// ...
}

The XML configuration equivalent

<?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:p="http://www.springframework.org/schema/p"
    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
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.example.web"/>
    <!-- ... -->
</beans>

 

2. Using @Autowired Annotations

Spring Framework provided the following type of bean autowiring.

  • Setter-based autowiring.
  • Constructor based bean wiring.
  • Field or property based autowiring.

 

2.1 @Autowired by Setter

Setter method based annotation allow @Autowired annotation on the setter method. Spring IoC container will call the setter method when the give instance created by Spring.

public class CustomerService {
   
 private ModelMapper modelMapper;

 @Autowired
 public void setModelMapper(ModelMapper modelMapper) {
    this.modelMapper = modelMapper;
 }
}

 

2.2 @Autowired by Constructor

public class CustomerService {

  private ModelMapper modelMapper;

  @Autowired
  public CustomerService(ModelMapper modelMapper) {
     this.modelMapper = modelMapper;
  }
}

 

2.3 @Autowired by Properties

The annotation used directly on properties, eliminating the need for getter and setters.

public class CustomerService {
    @Autowired
    private ModelMapper modelMapper;
}

 

3. @Autowired as Optional

The @Autowired dependency is required by default. This means before injecting the dependency, the dependency being injected should be available.

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

Spring throw NoSuchBeanDefinitionException exception if the required dependency is not available with the container. We can change this behavior by passing false for the required flag.

@Autowired(required =false )
private ModelMapper modelMapper;

 

4. The Qualifier Annotation.

By default, the @Autowired resolve dependencies by type. This works fine until we have only one bean with the same type. Spring framework will throw an exception if more than one bean with the same type is available with the container. The @Autowired annotation will not work in this case, @Qualifier annotation is used for these use case. Let’s take this example

@Service("userServiceImpl")
public class UserServiceImpl implements UserService {
    @Override
    public void enableUser() { }
}
@Service("defaultUserService")
public class DefaultUserService implements UserService {

  @Override
  public void enableUser() {}
}
public class OrderFacade {
  
  @Autowired
  private UserService userService;
}

If we run this code, we may see the following exception on application startup

Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: 
Error creating bean with name 'orderController': Unsatisfied dependency expressed through field 'orderFacade'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: 
Error creating bean with name 'orderFacade': Unsatisfied dependency expressed through field 'userService'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: 
No qualifying bean of type 'com.javadevjournal.rest.service.UserService' available: expected single matching bean but found 2: defaultUserService,userServiceImpl

 

4.1. Autowiring by @Qualifier

The @Qualifier annotation should be used to show Spring about the type of bean injection requested.

public class OrderFacade {

  @Qualifier("userServiceImpl")
  @Autowired
  private UserService userService;
}

The @Qualifier annotation works by matching the name defined with @Service annotation.

 

4.2. Autowired by Name

Spring framework uses bean name as the default qualifier value. Let’s change the code to understand it more clearly.

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void enableUser() { }
}
@Service("defaultUserService")
public class DefaultUserService implements UserService {

  @Override
  public void enableUser() {}
}
public class OrderFacade {
  
  @Autowired
  private UserService userService;
}

Spring framework will inject bean of type UserServiceImpl as bean name matches with the definition.

 

Summary

In this article, we discussed Spring autowired and bean autowiring. We covered different bean injection techniques [email protected] annotation. In the last section, we discussed why to use @Qualifier annotation in your application.

0 0 vote
Article Rating

Related Posts

Java Development Journal


Hello!! Welcome to the Java Development Journal. We love to share our knowledge with our readers and love to build a thriving community.

Subscribe
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

1 Comment
Oldest
Newest Most Voted
Inline Feedbacks
View all comments
{"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}
1
0
Would love your thoughts, please comment.x
()
x