When to use autowiring in Spring

Question

I am reading the book Pro Spring 3 . It has a certain paragraph that really confused me. The paragraph is about autowiring in spring. Here is an excerpt:

In most cases, the answer to the question of whether you should use autowiring is definitely “no!” Autowiring can save you time in small applications, but in many cases, it leads to bad practices and is inflexible in large applications. Using byName seems like a good idea, but it may lead you to give your classes artificial property names so that you can take advantage of the autowiring functionality. The whole idea behind Spring is that you can create your classes how you like and have Spring work for you, not the other way around ...

... For any nontrivial application, steer clear of autowiring at all costs.

I have always been using the @Autowired tag in applications I have created. Can someone explain what is wrong with it and what I should use instead?

A mini example on how I handle most things now is:

@Service("snippetService")
public class SnippetService {

    @Autowired
    private TestService testService;

    public Snippet getSnippet() {
        return testService.getSnippet();
    }
}    

Is using autowiring like this "wrong" or am I missing something?

Answer 1

I believe there are two things confused here. What is meant by 'autowiring' in this chapter is marking bean for automated detection and injection of dependencies. This can be achieved through setting of "autowire" bean attribute.

This is in fact opposed to using @Autowired where you explicitely indicate field or setter for dependency injection.

Have a look here: http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/beans.html#beans-factory-autowire .

To explain it, assume you have

public class SnippetService {

    private TestService testService;

    public Snippet getSnippet() {
        return testService.getSnippet();
    }

    public void setTestService(TestService testService) {
      this.testService = testService;
    }
}

If you defined a bean:

<bean class="mypackage.SnippetService" autowire="byType"/>

spring would attempt to inject bean of matching type, TestService in this case, by calling setTestService setter. Even though you did not use @Autowired . This indeed is dangerous since some setters might not be meant to be called by spring.

If you set autowire="no", nothing will be injected unless marked so with @Autowired , @Resource , @Inject .

Answer 2

There's nothing wrong with what you have, especially if you are starting out with one implementation of TestService anyways. As Johan mentions though, it's better to use @javax.annotation.Resource which also allows you to be more specific if you need to (for example using the name or the type attribute).

Answer 3

The only problem I see here is that you are loosing control a little. For example, say you have two or more instances of TestService in your app config and you want to use one of them. Having Autowire makes is trickier than using config XML to inject for you. This is what your book is trying to point ie it becomes difficult/trickier in big application where such needs are more frequent.

If you don't have such situations, I think its fine.

Answer 4

Autowire through XML is completely safe and helpful if you do constructor based autowiring particularly if you make the collaborators private final.

I'm kind shocked the author said that when I did the above on an extremely large spring 2.5 project a couple years ago. (at the time the annotation support was not working in JBoss)