Since Spring 2.5, one of the most interesting ways of wiring beans in Spring has been to use annotations to automatically wire bean properties. Auto wiring with annotations isn’t much different than using the autowire attribute in XML. But it does allow for more fine-grained auto wiring, where you can selectively annotate certain properties for autowiring.

Annotation wiring isn’t turned on in the Spring container by default. So, before we can use annotation-based autowiring, we’ll need to enable it in our spring configuration. The simplest way to do that is with annotation element from the context Spring’ configuration namespace.

<context:annotation-config/>

Adding the above line would enable the autowiring mechanism in the spring framework. Alternatively, you can include the AutowiredAnnotationBeanPostProcessor to enable the autowiring feature as follows:

<bean class="org.springframework.beans.factory.
   annotation.AutowiredAnnotationBeanPostProcessor"/>

The following is the simplest way to enable:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=http://www.springframework.org/schema/beans
xmlns:xsi=http://www.w3.org/XMLSchema-instance
xmlns:context=http://www.springframework.org/schema/context
xsi:schmeaLocation="

http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schmea/context/spring-context-3.0.xsd”>

<context:annotation-config/>
<context:component-scan base-package="com.java.beat.beans"/>
</beans>

tells the Spring that you intend to use annotation-based wiring in Spring. Once it’s in place you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors.

also read:

• Spring interview questions
• Introduction to Spring framework

elements works by scanning a package and all of its sub-packages, looking for classes that could be automatically registered as beans in the Spring container. The base-package attributes tells the package to start its scan from. @Component annotation used to register classes as beans in a Spring container.

Spring 3.0 support a few different annotations for autowiring.

Spring’s own @Autowired annotation.

• The @Inject annotation from JSR-330.
• The @Resource annotation from JSR-250.

We’ll look at how to use @Autowired first. Then we’ll cover the remaining annotations in other posts.

@Autowired

Marked a bean property with @Autowired will surely push Spring framework to wire it with the targeted one using by Type. What’s especially interesting about @Autowired is that you don’t have to use it with a property declaration or a setter method. You can use it on any method to automatically wire in bean references.

package com.java.beat.beans;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component("holderBean")
public class HolderBean {
     @Autowired
     @Qualifier("wiredBean")
     private WiredBean wiredBean;
     public WiredBean getWiredBean() {
              return wiredBean;
     }
     public void setWiredBean(WiredBean wiredBean) {
              this.wiredBean = wiredBean;
     }
}

package com.java.beat.beans;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component("wiredBean")
@Qualifier("wiredBean")
public class WiredBean {
}

As you can see in the previous example, HolderBean has a reference to WiredBean, autowired using @Autowired annotation. As you can see, @Autowired won’t even thwarted by the private keyword. Even though the wiredBean property is private, it will still be autowired. Is there no limit to @Autowired ’s reach ?

Actually, there are a couple of circumstances that could keep @Autowired from getting its job done. Specifically, there must be exactly one bean that’s applicable for autowiring into the @Autowired property or parameter. If there are no applicable beans or if multiple beans could be autowired, then @Autowired will run into some trouble. Fortunately, there’s a way can we help @Autowired out in those circumstances.

First, let’s look at how to keep @Autowired from failing when there is not a matching bean.

Optional Autowiring

By default, @Autowired has a strong contract, requiring that the thing it annotates is wired. If no bean can be wired into the @Autowired – annotated property or argument, then autowired fails (with a nasty NoSuchBeanDefinitionException). That may be what you want – to have Spring fail early when autowiring goes bad rather than later with NullPointerException.

But it’s also possible that the property being wired is truly optional and a null value is acceptable. In that case, you can configure optional autowiring be setting @Autowired’s required attribute to false.

@Autowired(required=false)
Private WiredBean wiredBean;

Qualifying Ambiguous Dependencies

In the other hand may be the problem’s not a lack of beans for Spring autowiring to choose from. May be it’s an abundance of (or at least two) beans, each of which is qualified to be wired into a property or parameter.

For example, suppose you have two beans that of type WiredBean. In that event, there is no way for @Autowired to choose which one you really want. So instead of guessing, a NoSuchBeanDefinitionException will be thrown and wiring will fail.

To help @Autowired figure out which bean you want, you can accompany it with Spring’s @Qualifier annotation.

@Autowired
@Qualifier("wiredBean")
private WiredBean wiredBean;

• Introduction to Spring Framework
• Introduction to Spring MVC
• What is Spring Expression Language?

New Features in Spring 2.5

• Annotation-driven dependency injection through @Autowired annotation and fine-grained auto wiring control with @Qualifier.

• Support for JSR-250 annotations, including @Resource for dependency injection of a named resource, as well as @PostConstruct and @PreDestroy for life-cycle methods.

• Auto-detection of Spring components that are annotated with @Component.

• An all-new annotation-driven Spring MVC programming model that greatly simplifies Spring web development such as @Controller.

• A new integration test framework that’s based on JUnit 4 and annotations.

Even though annotations were the big story of Spring 2.5, there’s more:

• Full Java 6 and Java EE 5 support, including JDBC 4.0, JTA 1.1, Java Mail 1.4 and JAX-WS2.0.
• A new bean name pointcut expression for weaving aspects into Spring beans by their name.
• Built-in support for AspectJ load-time weaving.
• New XML configuration namespaces, including context namespace for configuring application context details and a jms namespace for configuring message-driven beans.

Once you are looking for all of those features, you may ask yourself about really what the added value of Spring 3.0 is and what the new features that are added in it. Next paragraph will clarify that.

What’s new In Spring 3.0?

Spring 3.0 makes the entire spring code base to take advantage of the Java 5.0 technology. The notable Java 5 features like Generics, Varargs, Annotations and other improvements has been extensively implemented with the Spring 3.0 release. This release is one of the major and important release for Spring 3.0.

With all of good stuff in Spring 2.5, it’s hard to imagine what could possibly follow in Spring 3.0. But with the 3.0 release, Spring one-upped itself with the continuation of annotation-driven theme and several new features:

• Full-scale REST support in Spring MVC, including Spring MVC controllers that respond to REST-style URLs with XML, JSON, RSS or any other appropriate response. REST support in spring is one of the beautiful addition to the spring framework itself. It make life easier for the developers who want to write the RESTful webservices.
• A new expression language that brings Spring dependency injection to a new level by enabling injection of values from a verity of sources, including beans and system properties.
• New annotations for Spring MVC, including @CookieValue and @Request-Header, to pull values from cookies and request headers, respectively.
• A new XML namespace for easing configuration of Spring MVC.
• Support for declarative validation with JSR-303 (Bean Validation) annotations.
• Support for the new JSR-330 dependency injection specification.
• Annotation-oriented declaration of asynchronous and scheduled methods.
• A new annotation-based configuration model that allows for nearly XML-free Spring configuration.
• The Object-to-XML (OXM) mapping functionality from the Spring Web services project has been moved into the core Spring framework.

Just as important as what’s new in Spring 3.0 is what’s not in Spring 3.0. Specifically, starting with Spring 3.0, Java 5 is now required, as Java 1.4 has reached end-of-life and will no longer be supported in Spring. The above list is brief introduction to what are the new features introduced in this release. Going forward, I would write each feature in detail with the appropriate examples. Looking forward to your comments and feedback after reading the article. If you are looking for any specific feature, please post it in the comments section.