[转载]Spring Annotation Based Configuration

Annotation injection is performed before XML injection, thus the latter configuration will override the former for properties wired through both approaches.

Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider to have following configuration file in case you want to use any annotation in your Spring application.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="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/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- bean definitions go here -->

</beans>

Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us see few important annotations to understand how they work:

• @Autowired
• The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties. 

• @Required
• The @Required annotation applies to bean property setter methods.
• @Qualifier

• The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired.

• @JSR-250 Annotations
• Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations. 

Spring @Required Annotation 

Here is the content of Student.java file:

 package com.tutorialspoint;

 import org.springframework.beans.factory.annotation.Required;

 public class Student {
    private Integer age;
    private String name;

@Required

    public void setAge(Integer age) {
       this.age = age;

    }
    public Integer getAge() {

return age; }

@Required

    public void setName(String name) {
       this.name = name;

    }
    public String getName() {

The @Required annotation applies to bean property setter methods and it indicates that the affected bean property must be populated in XML configuration file at configuration time otherwise the container throws a BeanInitializationException exception. Below is an example to show the use of @Required annotation.

Let us have working Eclipse IDE in place and follow the following steps to create a Spring application:

Description

Create a project with a name SpringExample and create a
package com.tutorialspoint under the src folder in the created project.

Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter.

Create Java classes Student and MainApp under the com.tutorialspoint package.

Create Beans configuration file Beans.xml under the src folder.

The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below.

      return name;
   }

}

Following is the content of the MainApp.java file: package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {

ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");

Student student = (Student) context.getBean("student"); System.out.println("Name : " + student.getName() ); System.out.println("Age : " + student.getAge() );

} }

Following is the content of the configuration file Beans.xml: <?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="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/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for student bean -->

<bean id="student" class="com.tutorialspoint.Student"> <property name="name" value="Zara" />

<!-- try without passing age and check the result -->

<!-- property name="age" value="11"-->

   </bean>
</beans>

Once you are done with creating source and bean configuration files, let us run the application. If everything is fine with your application, this will raise BeanInitializationException exception and print the following error along with other log messages:

Property 'age' is required for bean 'student'

Next, you can try above example after removing comment from 'age' property as follows:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="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/schema/context/spring-context-

3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for student bean -->

<bean id="student" class="com.tutorialspoint.Student">

<property name="name" value="Zara" />

<property name="age" value="11"/> </bean>

</beans>

Now above example will produce following result:

Name : Zara
Age : 11

Spring @Autowired Annotation

@Autowired on Setter Methods Example

Here is the content of TextEditor.java file:

package com.tutorialspoint;

import org.springframework.beans.factory.annotation.Autowired;

public class TextEditor {
   private SpellChecker spellChecker;

@Autowired

   public void setSpellChecker( SpellChecker spellChecker ){
      this.spellChecker = spellChecker;

   }
   public SpellChecker getSpellChecker( ) {

      return spellChecker;
   }

   public void spellCheck() {
      spellChecker.checkSpelling();

} }

Following is the content of another dependent class file SpellChecker.java: package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){

System.out.println("Inside SpellChecker constructor." ); }

public void checkSpelling(){ System.out.println("Inside checkSpelling." );

} }

Following is the content of the MainApp.java file: package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {

ApplicationContext context =

new ClassPathXmlApplicationContext("Beans.xml");

TextEditor te = (TextEditor) context.getBean("textEditor");
te.spellCheck();

}
} 

Following is the configuration file Beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="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/schema/context/spring-context- 3.0.xsd">

  <context:annotation-config/>

<!-- Definition for textEditor bean without constructor-arg  -->

<bean id="textEditor" class="com.tutorialspoint.TextEditor"> </bean>

  <!-- Definition for spellChecker bean -->

<bean id="spellChecker"class="com.tutorialspoint.SpellChecker"> </bean>

</beans>

Once you are done with creating source and bean configuration files, let us run the application. If everything is fine with your application, this will print the following message:

Inside SpellChecker constructor.
Inside checkSpelling.

@Autowired with (required=false) option

By default, the @Autowired annotation implies the dependency is required similar to @Required annotation, however, you can turn off the default behavior by using (required=false) option with @Autowired.

The following example will work even if you do not pass any value for age property but still it will

demand for name property. You can try this example yourself because this is similar to @Required annotation example except that only Student.java file has been changed.

package com.tutorialspoint;

import org.springframework.beans.factory.annotation.Autowired;

public class Student {
   private Integer age;
   private String name;

@Autowired(required=false) public void setAge(Integer age) {

   this.age = age;
}

public Integer getAge() {
   return age;

}

@Autowired

public void setName(String name) {
   this.name = name;

}
public String getName() {

   return name;
}

}

Spring @Qualifier Annotation

 

Example 

Here is the content of Student.java file:
package com.tutorialspoint;
public class Student {    private Integer age;    private String name;    public void setAge(Integer age) {       this.age = age;    }    public Integer getAge() { return age; }    public void setName(String name) {

 

      this.name = name;

   }

   public String getName() {

      return name;

} }

Here is the content of Profile.java file: package com.tutorialspoint;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

public class Profile {

   @Autowired

@Qualifier("student1") private Student student;

public Profile(){
System.out.println("Inside Profile constructor." );

}

public void printAge() {
System.out.println("Age : " + student.getAge() );

}

public void printName() {
System.out.println("Name : " + student.getName() );

} }

Following is the content of the MainApp.java file: package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

import

org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {

   public static void main(String[] args) {

ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");

Profile profile = (Profile) context.getBean("profile");

      profile.printAge();

      profile.printName();

   }

}

Consider the example of following configuration file Beans.xml: <?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="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/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for profile bean -->

<bean id="profile" class="com.tutorialspoint.Profile"> </bean>

   <!-- Definition for student1 bean -->

<bean id="student1" class="com.tutorialspoint.Student">

<property name="name" value="Zara" />

<property name="age" value="11"/> </bean>

   <!-- Definition for student2 bean -->

<bean id="student2" class="com.tutorialspoint.Student"> <property name="name" value="Nuha" />
<property name="age" value="2"/>

   </bean>

</beans>

 

Once you are done with creating source and bean configuration files, let us run the application. If everything is fine with your application, this will print the following message:

Inside Profile constructor.

Age : 11

Name : Zara

@Resource Annotation

You can use @Resource annotation on fields or setter methods and it works the same as in Java EE 5. The @Resource annotation takes a 'name' attribute which will be interpreted as the bean name to be injected. You can say, it followsby-nameautowiring semantics as demonstrated in the below example:

package com.tutorialspoint;
import javax.annotation.Resource;

public class TextEditor {
   private SpellChecker spellChecker;

@Resource(name= "spellChecker")
public void setSpellChecker( SpellChecker spellChecker ){

      this.spellChecker = spellChecker;
   }

   public SpellChecker getSpellChecker(){
      return spellChecker;

   }
   public void spellCheck(){

      spellChecker.checkSpelling();

TUTORIALS POINT

Simply Easy Learning Page 78

} }

If no 'name' is specified explicitly, the default name is derived from the field name or setter method. In case of a field, it takes the field name; in case of a setter method, it takes the bean property name.