@Autowired vs @Required on setter

Question

I'm curious to know what's the difference between code like this:

class MyClass {
   @Autowired
   MyService myService;
}

and code like this:

class MyClass {
   MyService myService;

   @Required
   public void setMyService(MyService val) {
       this.myService = val;
   }
}

Forked

Answer 1

@Autowired annotation is used when you want to autowire a bean. @Autowired is not limited to setter. It can be used with a constructor and a field as well. If you use @Autowired annotation on a field, that field will be autowired with bean having matching data type.

@Required checks if a particular property has been set or not. If a field has been annotated with @Required annotation and that field is not set, you will get org.springframework.beans.factory.BeanInitializationException.

Refer:

Spring @Autowired usage

Recommended usage of Spring's @Required annotation

Edit: As pointed by @kryger: field annotated with @Autowired is effectively also @Required (unless you explicitly set its parameter required to false). eg:

@Autowired(required=false)
private ObjectType objectType;

For a field that has been annotated @Autowired, if bean with matching data type in not available, org.springframework.beans.factory.BeanCreationException is thrown.

Orthoepy

Does @Required need dependency to be fulfilled at configuration time? – Winterize

@Winterize - By configuration time, if you mean start up time, then yes, @ Required needs to fulfilled at startup. @ Request will be check while creating your Bean i.e when Spring context is initialized. If you mean by compile time, then no. It all happens at context initialization time. Note that, specifying <context:component-scan/> in you configuration tells Spring to check for @ Required annotation. Also check RequiredAnnotationBeanPostProcessorhttps://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/factory/annotation/RequiredAnnotationBeanPostProcessor.html – Orthoepy

@kryger Are you shure? I don't think that with the Autowire-annotation you cannot make shure that the dependency is injected due to the XML-file of the ApplicationContext. – Moskva

@Autowire has a "required" attribute, but this required attribute doesn't throw any exception if the bean is not available in the application context rather it simply neglects the bean – Quincunx

@Quincunx The application context won't throw an exception if the bean is not available only if the parameter 'required' is set to false, otherwise, the app will throw an exception. – Orthoepy

@Orthoepy its my bad, i missed it. Thanks for correcting me. – Quincunx

Answer 2

@Autowired is not the same as @Required.

The @Autowire-Annotation (as in your code-example), tells the ApplicationContext (a.k.a the Spring-IoC-Containter) to inject the desired dependency. (No matter how, if its by using annotations or the XML-File of the ApplicationContext).

The @Required-Annotation, tells the ApplicationContext that this property has to be mentioned in the XML-file (The XML-File of the ApplicationContext), which than leds to the dependency being injected by using the XML-File (or to an expection of course). But the Annotation on its own doesn't tell to inject the dependency! The injection is done because the property is mentioned in the XML-file. That's good to know, you may need it.

With mentioning the property in a XML-File I mean such a configuration for instance:

<bean id="MyClass" class="com.myclasses.common.MyClass">
     <property name="someProperty" value="ValueThatHasToBeInjected" />
</bean>

So why should I use it over the @Autowired-Annotation?

You should use it when the dependency has to be injected by the information in the XML-configuration file.

Can you give me an example?

Well, there is already a very good example on this website. where this is also explained.

Moskva

Answer 3

@watchme @Required -annotation tells to the container that this property needs to be initialized as part of configuration, it can be initialized either through xml configuration or through @Autowired annotation or through java bean creation.

1. xml example:

   public class SimpleMovieLister 
   { 
    private MovieFinder movieFinder;
   
    @Required
    public void setMovieFinder(MovieFinder movieFinder)
    {
       this.movieFinder = movieFinder;
    }
   }
   
   <beans ...>
   <bean id = "movieFinder" class = "com.test.MovieFinder">
   
   <bean id = "simpleMovieLister" class = "com.test.SimpleMovieLister">
    <property name = "movieFinder" value = "movieFinder" />
   

1. through @Autowire

   public class SimpleMovieLister 
   { 
     @Autowired 
     @Required
     private MovieFinder movieFinder;
   }
   
   

Here truly speaking we don't need @Required as it @Autowired default is Required.

3. thru @Bean

   public class SimpleMovieLister 
   { 
     private MovieFinder movieFinder;
   
     @Required
     public void setMovieFinder(MovieFinder movieFinder)
     {
        this.movieFinder = movieFinder;
     }
   }
   
   
   public class AppConfig {
   
   @Bean
   public SimpleMovieLister getSimpleMovieLister()
   {
      SimpleMovieLister simpleMovieLister = new SimpleMovieLister();
      simpleMovieLister.setMovieFinder(new MoveFinder());
   }
   }
   
   
   
   

Neap