@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;
   }
}

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.

Answer 2

@Autowired is not the same as @Required.

The @Required-Annotation is specialized for telling Spring that this property has to be injected by the information given in the XML-configuration-File and not through annotations. And that doesn't matter when you use the @Autowire-Annotation.

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), but the Annotation on its own doesn't tell to inject the dependency. So it is used to check if it is in the XML-configuration file, but not to inject a dependency. The injection is done because the property is mentioned in the XML-file.

So in the end it tells that the injection has to be done because of a configuration in the XML-File. But again: The annotation doesn't tell that the dependency has to be injected, but that it has to be mentioned in the XML-File - which then lets the dependency be injected.

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.