[转载]Spring Annotation Based Configuration
2014-02-12 09:22
381 查看
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.
</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.
@Required
return age; }
@Required
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:
}
Following is the content of the MainApp.java file:package com.tutorialspoint;
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">
<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"-->
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:
Next, you can try above example after removing comment from 'age' property as follows:
Now above example will produce following result:
Here is the content of TextEditor.java file:
@Autowired
} }
Following is the content of another dependent class file SpellChecker.java:package com.tutorialspoint;
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;
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:
@Autowired with (required=false) option
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"
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
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.
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> |
Name : Zara Age : 11
Spring @Autowired Annotation
@Autowired on Setter Methods ExampleHere 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> |
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
ExampleHere 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) { |
}
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> |
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(); |
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.
相关文章推荐
- [Spring]Annotation-based container configuration_AnotationBasis_02
- [转载]Spring Java Based Configuration
- [Spring]Annotation-based container configuration_AnotationBasis_01
- [Spring]Annotation-based container configuration_AnotationBasis_03 --JSR 330 Standard Annotations
- 第一篇:Configuration-basic 之Spring对注解的处理【AnnotationConfigApplicationContext 】深度剖析
- spring boot Configuration Annotation Proessor not found in classpath
- spring boot Configuration Annotation Proessor not found in classpath
- Spring @Configuration用annotation装配spring
- Spring @Configuration用annotation装配spring
- Spring AOP Advices - After returning advice example - xml based configuration
- spring(四)之基于注解(Annotation-based)的配置.md
- Spring AOP Advices - After throwing advice example - xml based configuration
- Spring @Configuration用annotation装配spring
- Spring 3 Java Based Configuration with @Value
- 详解 Spring 3.0 基于 Annotation 的依赖注入实现--转载
- spring boot Configuration Annotation Proessor not found in classpath
- Spring AOP Advices - Around advice example - xml based configuration
- 【spring】 <tx:annotation-driven /> 的理解 【转载的】
- 【SpringBoot】Spring Boot Configuration Annotation Processor not found in classpath
- Spring AOP Advices - Before advice example - xml based configuration - See more at: http://www.java2