Take the 2-minute tour ×

Annotations becoming popular. Spring-3 supports them. CDI depends on them heavily (I can not use CDI with out of annotations, right?)

My question is why?

I heard several issues:

  1. "It helps get rid of XML". But what is bad about xml? Dependencies are declarative by nature, and XML is very good for declarations (and very bad for imperative programming). With good IDE (like idea) it is very easy to edit and validate xml, is not it?

  2. "In many cases there is only one implementation for each interface". That is not true! Almost all interfaces in my system has mock implementation for tests.

Any other issues?

And now my pluses for XML:

  1. You can inject anything anywhere (not only code that has annotations)

  2. What should I do if I have several implementations of one interface? Use qualifiers? But it forces my class to know what kind of injection it needs. It is not good for design.

XML based DI makes my code clear: each class has no idea about injection, so I can configure it and unit-test it in any way.

What do you think?

share|improve this question
add comment

10 Answers

I can only speak from experience with Guice, but here's my take. The short of it is that annotation-based configuration greatly reduces the amount you have to write to wire an application together and makes it easier to change what depends on what... often without even having to touch the configuration files themselves. It does this by making the most common cases absolutely trivial at the expense of making certain relatively rare cases slightly more difficult to handle.

I think it's a problem to be too dogmatic about having classes have "no idea about injection". There should be no reference to the injection container in the code of a class. I absolutely agree with that. However, we must be clear on one point: annotations are not code. By themselves, they change nothing about how a class behaves... you can still create an instance of a class with annotations as if they were not there at all. So you can stop using a DI container completely and leave the annotations there and there will be no problem whatsoever.

When you choose not to provide metadata hints about injection within a class (i.e. annotations), you are throwing away a valuable source of information on what dependencies that class requires. You are forced to either repeat that information elsewhere (in XML, say) or to rely on unreliable magic like autowiring which can lead to unexpected issues.

To address some of your specific questions:

It helps get rid of XML

Many things are bad about XML configuration.

  • It's terribly verbose.
  • It isn't type-safe without special tools.
  • It mandates the use of string identifiers. Again, not safe without special tool support.
  • Doesn't take any advantage of the features of the language, requiring all kinds of ugly constructs to do what could be done with a simple method in code.

That said, I know a lot of people have been using XML for long enough that they are convinced that it is just fine and I don't really expect to change their minds.

In many cases there is only one implementation for each interface

There is often only one implementation of each interface for a single configuration of an application (e.g. production). The point is that when starting up your application, you typically only need to bind an interface to a single implementation. It may then be used in many other components. With XML configuration, you have to tell every component that uses that interface to use this one particular binding of that interface (or "bean" if you like). With annotation-based configuration, you just declare the binding once and everything else is taken care of automatically. This is very significant, and dramatically reduces the amount of configuration you have to write. It also means that when you add a new dependency to a component, you often don't have to change anything about your configuration at all!

That you have mock implementations of some interface is irrelevant. In unit tests you typically just create the mock and pass it in yourself... it's unrelated to configuration. If you set up a full system for integration tests with certain interfaces using mocks instead... that doesn't change anything. For the integration test run of the system, you're still only using 1 implementation and you only have to configure that once.

XML: You can inject anything anywhere

You can do this easily in Guice and I imagine you can in CDI too. So it's not like you're absolutely prevented from doing this by using an annotation-based configuration system. That said, I'd venture to say that the majority of injected classes in the majority of applications are classes that you can add an @Inject to yourself if it isn't already there. The existence of a lightweight standard Java library for annotations (JSR-330) makes it even easier for more libraries and frameworks to provide components with an @Inject annotated constructor in the future, too.

More than one implementation of an interface

Qualifiers are one solution to this, and in most cases should be just fine. However, in some cases you do want to do something where using a qualifier on a parameter in a particular injected class would not work... often because you want to have multiple instances of that class, each using a different interface implementation or instance. Guice solves this with something called PrivateModules. I don't know what CDI offers in this regard. But again, this is a case that is in the minority and it's not worth making the rest of your configuration suffer for it as long as you can handle it.

share|improve this answer
The only drawback I can figure out about annotations is when you have a library with some classes that MAY use DI, the annotations will drag the spring dependency to that library. If using xml in the application that will use the library, only the application will need to depend on spring. (Suppose we are talking abount spring DI, I believe Guice is no different in this matter). –  Ivaylo Slavov Dec 8 '11 at 10:14
add comment

I have the following principle: configuration-related beans are defined with XML. Everything else - with annotations.

Why? Because you don't want to change configuration in classes. On the other hand, it's much simpler to write @Service and @Inject, in the class that you want to enable.

This does not interfere with testing in any way - annotations are only metadata that is parsed by the container. If you like, you can set different dependencies.

As for CDI - it has an extension for XML configuration, but you are right it uses mainly annotations. That's something I don't particularly like in it though.

share|improve this answer
add comment

In my opinion, this is more a matter of taste.

1) In our project (using Spring 3), we want the XML-configuration files to be just that: configuration. If it doesn't need to be configured (from end-user perspective) or some other issue doesn't force it to be done in xml, don't put the bean-definitions/wirings into the XML-configurations, use @Autowired and such.

2) With Spring, you can use @Qualifier to match a certain implementation of the interface, if multiple exist. Yes, this means you have to name the actual implementations, but I don't mind.

In our case, using XML for handling all the DI would bloat the XML-configuration files a lot, although it could be done in a separate xml-file (or files), so it's not that valid point ;). As I said, it's a matter of taste and I just think it's easier and more clean to handle the injections via annotations (you can see what services/repositories/whatever something uses just by looking at the class instead of going through the XML-file looking for the bean-declaration).

Edit: Here's an opinion about @Autowired vs. XML that I completely agree with: Spring @Autowired usage

share|improve this answer
add comment

"But what is bad about xml?" It's yet another file to manage and yet another place to have to go look for a bug. If your annotations are right next to your code it's much easier to mange and debug.

share|improve this answer
add comment

Also don't forget Spring JavaConfig.

share|improve this answer
It is a viable alternative to annotations in my opinion. But it cannot substitute for XML configuration. –  Stijn Van Bael Feb 15 '11 at 15:58
add comment

I like to keep my code clear, as you pointed. XML feets better, at least for me, in the IOC principle.

The fundamental principle of Dependency Injection for configuration is that application objects should not be responsible for looking up the resources or collaborators they depend on. Instead, an IoC container should configure the objects, externalizing resource lookup from application code into the container. (J2EE Development without EJB - Rod Johnson - page 131)

Again, it just my point of view, no fundamentalism in there :)

EDIT: Some useful discussions out there:

share|improve this answer
annotations are metadata - they do not participate in lookup. The only difference is the location of the metadata. And it does not violate IoC principles. –  Bozho Feb 14 '11 at 17:59
I agree. I didn't want to mean that injection violate the IoC principles. What I tried to point is that keeping the metadata out from classes is more clear for me. –  Aito Feb 14 '11 at 18:19
Personally, I think it's ok to acknowledge the reality that you're using a DI container since you can get of real benefits by doing that and no disadvantages. –  ColinD Feb 14 '11 at 18:33
add comment

In my case the developers writing the application are different that the ones configuring it (different departments, different technologies/languages) and the last group doesn't even has access to the source code (which is the case in many enterprise setups). That makes Guice unusable since I would have to expose source code rather than consuming the xmls configured by the developers implementing the app.

Overall I think it is important to recognize that providing the components and assembling/configuring an application are two different exercises and provide if needed this separation of concerns.

share|improve this answer
It looks like Guice can read configuration files (properties) out of the box: stackoverflow.com/questions/4805874/… –  mjn Feb 25 '11 at 19:14
add comment

I just have a couple of things to add to what's already here.

  • To me, DI configuration is code. I would like to treat it as such, but the very nature of XML prevents this without extra tooling.

  • Spring JavaConfig is a major step forward in this regard, but it still has complications. Component scanning, auto-magic selection of interface implementations, and semantics around CGLIB interception of @Configuration annotated classes make it more complex than it needs to be. But it's still a step forward from XML.

  • The benefit of separating IoC metadata from application objects is overstated, especially with Spring. Perhaps if you confined yourself to the Spring IoC container only, this would be true. But Spring offers a wide application stack built on the IoC container (Security, Web MVC, etc). As soon as you leverage any of that, you're tied to the container anyway.

share|improve this answer
add comment

Like all things, dependency injection should be used in moderation. Moreover, all trappings of the injections should be segregated from the application code and relegated to the code associated with main.

In general applications should have a boundary that separates the abstract application code from the concrete implementation details. All the source code dependencies that cross that boundary should point towards the application. I call the concrete side of that boundary, the main partition, because that's where 'main' (or it's equivalent) should live.

The main partition consists of factory implementations, strategy implementations, etc. And it is on this side of the boundary that the dependency injection framework should do it's work. Then those injected dependencies can be passed across the boundary into the application by normal means. (e.g. as arguments).

The number of injected dependencies should be relatively small. A dozen or less. In which case, the decision between XML or annotations is moot.

share|improve this answer
add comment

XML has the only benefit of a declarative style that is defined clearly separated from the application code itself. That stays independent from DI concerns. The downsides are verbosity, poor re-factoring robustness and a general runtime failure behaviour. There is just a general (XML) tool support with little benefit compared to IDE support for e.g. Java. Besides this XML comes with a performance overhead so it usually is slower than code solutions.

Annoations often said to be more intuitive and robust when re-factoring application code. Also they benefit from a better IDE guidance like guice provides. But they mix application code with DI concerns. An application gets dependent on a framework. Clear separation is almost impossible. Annotations are also limited when describing different injection behaviour at the same place (constructor, field) dependent on other circumstances (e.g. robot legs problem). Moreover they don't allow to treat external classes (library code) like your own source. Therefore they are considered to run faster than XML.

Both techniques have serious downsides. Therefore I recommend to use Silk DI. It is declarative defined in code (great IDE support) but 100% separated from your application code (no framework dependency). It allows to treat all code the same no matter if it is from your source or a external library. Problems like the robot legs problem are easy to solve with usual bindings. Furthermore it has good support to adapt it to your needs.

share|improve this answer
add comment

Your Answer


