Spring架构中的注释功能

如何使用Spring架构中的注释功能——基础篇

在传统Spring架构中配置POJOs的基本操作有两种：装配和依赖注入。下面的例子中装配了两个POJO，同时指定了两个对象之间的依赖关系。

例1：实现一个简单类（Main.java）

Java代码

1. package test;   
2.   
3. import org.springframework.context.ApplicationContext;   

package test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Main {private BasicService service;public BasicService getService() {return service;}public void setService(BasicService service) {this.service = service;}public void print() {service.print();}public static void main(String[] args) {String[] locations = { "beans.xml" };ApplicationContext ctx =new ClassPathXmlApplicationContext(locations);Main main = (Main)ctx.getBean("main");main.print();}}

 例2：基本服务类（BasicService.java）

Java代码

1. package test;   
2.   
3. public class BasicService {   
4.   
5.     public void print() {   
6.         System.out.println("success");   
7.     }   
8. }  

package test;public class BasicService {public void print() {System.out.println("success");}}

 例3：在配置文件中的声明（beans.xml）

Java代码

1. "1.0" encoding="UTF-8" ?>   
2. "http://www.w3.org/2001/XMLSchema-instance"  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">   
5.   
6.     "main" class="test.Main">   
7.         "service">   
8.             "service" />   
9.            
10.        
11.     "service" class="test.BasicService">   
12.   

例4：注释版Main.java

Java代码

1. package test;   
2.   
3. import org.springframework.beans.factory.annotation.Autowired;   

package test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springframework.stereotype.Component;@Componentpublic class Main {@Autowiredprivate BasicService service;public void print() {service.print();}public static void main(String[] args) {String[] locations = { "beans.xml" };ApplicationContext ctx =new ClassPathXmlApplicationContext(locations);Main main = (Main) ctx.getBean("main");main.print();}}

 例5：注释版BasicService.java

Java代码

1. package test;   
2.   
3. import org.springframework.stereotype.Component;   
4.   
5. @Component("service")   
6. public class BasicService {   
7.   
8.     public void print() {   
9.         System.out.println("success");   
10.     }   
11. }  

package test;import org.springframework.stereotype.Component;@Component("service")public class BasicService {public void print() {System.out.println("success");}}

 例6：注释版beans.xml

Java代码

1. "1.0" encoding="UTF-8" ?>   
2. "http://www.w3.org/2001/XMLSchema-instance"  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     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">   
6.   
7.     package="test">   
8.        
9.   

@Component

所有的Spring注释中最重要的莫过于@Component，其作用就是在Spring容器中装配一个POJO对象。@Component作用于类声明之前，其用法有两种：

@Component
@Component(“Spring容器内的对象名”)

第一种注释方法会在Spring容器中实例化一个以类名的首字母为小写命名的POJO对象。如例4中对Main类的注释将会在Spring容器中实例化一个名为main的POJO对象：

Java代码

1. package test;   
2. ...   
3.   
4. @Component  

package test;...@Componentpublic class Main {...public static void main(String[] args) {String[] locations = { "beans.xml" };ApplicationContext ctx =new ClassPathXmlApplicationContext(locations);Main main = (Main)ctx.getBean("main");main.print();}}

 当然，如果不满意类名首字母小写的命名规则，第二种注释方法允许我们自定义POJO的名称。如例5中对BasicService的注释：

Java代码

1. package test;   
2. ...   
3.   
4. @Component("service")   
5. public class BasicService {   
6.     ...   
7. }  

package test;...@Component("service")public class BasicService {...}

@Scope(“singleton”)
@Scope(“prototype”)

我们可以用下面的例子测试prototype或singleton形态的POJOs：

Java代码

1. package test;   
2.   
3. import org.springframework.context.ApplicationContext;   
4. import org.springframework.context.annotation.Scope;   
5. import org.springframework.context.support.ClassPathXmlApplicationContext;   
6. import org.springframework.stereotype.Component;   
7.   
8. @Component  
9. @Scope("prototype")   
10. public class Main {   
11.   
12.     public void print() {   
13.         System.out.println(toString());   
14.     }   
15.   
16.     public static void main(String[] args) {   
17.   
18.         String[] locations = { "beans.xml" };   
19.         ApplicationContext ctx =   
20.             new ClassPathXmlApplicationContext(locations);   
21.   
22.         Main main1 = (Main) ctx.getBean("main");   
23.         main1.print();   
24.   
25.         Main main2 = (Main) ctx.getBean("main");   
26.         main2.print();   
27.   
28.         System.out.println(main1 != main2);   
29.     }   
30. }  

package test;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Scope;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springframework.stereotype.Component;@Component@Scope("prototype")public class Main {public void print() {System.out.println(toString());}public static void main(String[] args) {String[] locations = { "beans.xml" };ApplicationContext ctx =new ClassPathXmlApplicationContext(locations);Main main1 = (Main) ctx.getBean("main");main1.print();Main main2 = (Main) ctx.getBean("main");main2.print();System.out.println(main1 != main2);}}

@Autowired

与@Component对应，@Autowired用于Spring容器中POJOs之间的依赖注入操作，使用该注释的最大好处是不必提供传统JavaBeans的setter方法。如例4与例1相比，私有的成员变量service没有提供settter方法，仅靠@Autowired就可以注入与之对应的service对象。@Autowired作用于类的成员变量、类的setter方法或类的构造函数。其用法有以下两种：

@Autowired
@Autowired(required = false)

独立的@Autowired以byType方式进行依赖注入。如例4中对service成员变量的注释：

Java代码

1. package test;   
2. ...   
3.   
4. @Component  
5. public class Main {   
6.   
7.     @Autowired  
8.     private BasicService service;   
9.   
10.     ...   
11. }  

package test;...@Componentpublic class Main {@Autowiredprivate BasicService service;...}

 只要在Spring容器中存在一个（只有一个）类型为test.BasicService的POJO时，byType方式就可以正确注入。否则将抛出异常，如果不希望强制注入不存在的对象，可以使用第二种方式进行注释。如：

Java代码

1. package test;   
2. ...   
3.   
4. @Component  
5. public class Main {   
6.   
7.     @Autowired(required = false)   
8.     private BasicService service;   
9.   
10.     ...   
11. }  

package test;...@Componentpublic class Main {@Autowired(required = false)private BasicService service;...}

@Autowired与@Qualifier配合使用时将会以byName方式进行依赖注入。以byName方式进行依赖注入正是为了避免相同类型的不同POJOs在注入时发生冲突。@Qualifier作用于类的成员变量、类的setter方法中的参数或类的构造函数中的参数，@Qualifier的用法如下：

@Qualifier(“Spring容器内的对象名”)

如将例4的内容修改一下。如下例：

Java代码

1. package test;   
2. ...   
3.   
4. @Component  
5. public class Main {   
6.   
7.     private BasicService service;   
8.   
9.     @Autowired  
10.     public Main(@Qualifier("basicService")BasicService service) {   
11.         this.service = service;   
12.     }   
13.   
14.     ...   
15. }  

package test;...@Componentpublic class Main {private BasicService service;@Autowiredpublic Main(@Qualifier("basicService")BasicService service) {this.service = service;}...}

...@Componentpublic class Main {private BasicService service;@Autowiredpublic Main(@Qualifier("basicService")BasicService service) {this.service = service;}...}

package test;...@Componentpublic class Main {private BasicService service;@Autowiredpublic Main(@Qualifier("basicService")BasicService service) {this.service = service;}...}