Spring注解@Component、@Repository、@Service、@Controller区别

Spring注解@Component、@Repository、@Service、@Controller区别

Spring 2.5 中除了提供 @Component 注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service 和 @Controller。在目前的 Spring 版本中，这 3 个注释和 @Component 是等效的，但是从注释类的命名上，很容易看出这 3 个注释分别和持久层、业务层和控制层（Web 层）相对应。虽然目前这 3 个注释和 @Component 相比没有什么新意，但 Spring 将在以后的版本中为它们添加特殊的功能。所以，如果 Web 应用程序采用了经典的三层分层结构的话，最好在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释，而用 @Component 对那些比较中立的类进行注释。在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。 Spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了@Component,@Service,@Controller,@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件时一样的。要使用自动扫描机制，我们需要打开以下配置信息：java代码1. <?xml version="1.0" encoding="UTF-8" ?> <beansxmlns="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/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsd" 2. > 3. 4. <context:component-scan base-package=”com.eric.spring”>5. </beans> 6. 其中base-package为需要扫描的包（含所有子包） @Service用于标注业务层组件，@Controller用于标注控制层组件（如struts中的action）,@Repository用于标注数据访问组件，即DAO组件，而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。7. @Service public class VentorServiceImpl implements iVentorService{ 8. } @Repository public class VentorDaoImpl implements iVentorDao { 9. } getBean的默认名称是类名（头字母小写），如果想自定义，可以@Service(“aaaaa”)这样来指定，这种bean默认是单例的，如果想改变，可以使用@Service(“beanName”)@Scope(“prototype”)来改变。可以使用以下方式指定初始化方法和销毁方法（方法名任意）： @PostConstructpublic void init() { 10. } 11. @PreDestroy public void destory() { 12. }注入方式：把DAO实现类注入到service实现类中，把service的接口(注意不要是service的实现类)注入到action中，注入时不要new 这个注入的类，因为spring会自动注入，如果手动再new的话会出现错误，然后属性加上 @Autowired后不需要getter()和setter()方法，Spring也会自动注入。至于更具体的内容，等对注入的方式更加熟练后会做个完整的例子上来。注解：在 spring的配置文件里面只需要加上<context:annotation-config/>和<context:component-scanbase-package="需要实现注入的类所在包"/>，可以使用base-package="*"表示全部的类。< context:component-scan base-package=”com.eric.spring”>其中base-package为需要扫描的包（含所有子包）在接口前面标上@Autowired和@Qualifier注释使得接口可以被容器注入，当接口存在两个实现类的时候必须指定其中一个来注入，使用实现类首字母小写的字符串来注入，如： @Autowired @Qualifier("chinese") private Man man;否则可以省略，只写@Autowired。 @Service服务层组件，用于标注业务层组件,表示定义一个bean，自动根据bean的类名实例化一个首写字母为小写的bean，例如Chinese实例化为chinese，如果需要自己改名字则:@Service("你自己改的bean名")。 @Controller用于标注控制层组件(如struts中的action) @Repository持久层组件，用于标注数据访问组件，即DAO组件 @Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 @Service public class VentorServiceImpl implements iVentorService { } @Repository public class VentorDaoImpl implements iVentorDao { } getBean 的默认名称是类名（头字母小写），如果想自定义，可以@Service(“aaaaa”) 这样来指定，这种bean默认是单例的，如果想改变，可以使用@Service(“beanName”)@Scope(“prototype”)来改变。可以使用以下方式指定初始化方法和销毁方法（方法名任意）： @PostConstruct public void init() { } @PreDestroy public void destory() { }

BYETHANON2011年 06 月 02 日INJAVA

Spring不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。@Resource装配顺序1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

@Autowired 与@Resource的区别：

1、@Autowired与@Resource都可以用来装配bean.都可以写在字段上,或写在setter方法上。

2、@Autowired默认按类型装配（这个注解是属业spring的），默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，如：@Autowired(required=false)，如果我们想使用名称装配可以结合@Qualifier注解进行使用，如下：

3、@Resource（这个注解属于J2EE的），默认安装名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行安装名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

推荐使用：@Resource注解在字段上，这样就不用写setter方法了，并且这个注解是属于J2EE的，减少了与spring的耦合。这样代码看起就比较优雅。

1. 使用Spring2.5的Autowired实现注释型的IOC

2.

3. 本文地址：http://qzone.QQ.com/blog/55357655-1232078233

4.

5. 使用Spring2.5的新特性——Autowired可以实现快速的自动注入，而无需在xml文档里面添加bean的声明，大大减少了xml文档的维护。（偶喜欢这个功能，因为偶对xml不感冒）。以下是一个例子：

6. 先编写接口Man：

7. publicinterfaceMan{

8. publicStringsayHello();

9. }

10. 然后写Man的实现类Chinese和American：

11. @Service

12. publicclassChineseimplementsMan{

13. publicStringsayHello(){

14. return"IamChinese!";

15. }

16. }

17.

18. @Service

19. publicclassAmericanimplementsMan{

20. publicStringsayHello(){

21. return"IamAmerican!";

22. }

23. }

24.

25. @Service注释表示定义一个bean，自动根据bean的类名实例化一个首写字母为小写的bean，例如Chinese实例化为chinese，American实例化为american，如果需要自己改名字则:@Service("你自己改的bean名")。

26.

27. beans.xml

28. <?xmlversion="1.0"encoding="UTF-8"?>

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

30. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

31. xmlns:context="http://www.springframework.org/schema/context"

32. xsi:schemaLocation="http://www.springframework.org/schema/beans

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

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

35. http://www.springframework.org/schema/context/spring-context-2.5.xsd">

36. <context:annotation-config/>

37. <context:component-scanbase-package="testspring.main"/>

38. </beans>

39. 在spring的配置文件里面只需要加上<context:annotation-config/>和<context:component-scanbase-package="需要实现注入的类所在包"/>，可以使用base-package="*"表示全部的类。

40.

41. 编写主类测试：

42. @Service

43. publicclassMain{

44. @Autowired

45. @Qualifier("chinese")

46. privateManman;

47.

48. publicstaticvoidmain(String[]args){

49. //TODOcodeapplicationlogichere

50. ApplicationContextctx=newClassPathXmlApplicationContext("beans.xml");

51. Mainmain=(Main)ctx.getBean("main");

52. System.out.println(main.getMan().sayHello());

53. }

54.

55. publicMangetMan(){

56. returnman;

57. }

58. }

59.

60. 在Man接口前面标上@Autowired和@Qualifier注释使得Man接口可以被容器注入，当Man接口存在两个实现类的时候必须指定其中一个来注入，使用实现类首字母小写的字符串来注入。否则可以省略，只写@Autowired

61.

62. **********************

63. 使用Spring2.5注释驱动的IoC功能

64. 发表于08-03-0420:38|阅读1285|评分(暂无)

65. 概述

66.

67. 注释配置相对于XML配置具有很多的优势：

68.

69. 它可以充分利用Java的反射机制获取类结构信息，这些信息可以有效减少配置的工作。如使用JPA注释配置ORM映射时，我们就不需要指定PO的属性名、类型等信息，如果关系表字段和PO属性名、类型都一致，您甚至无需编写任务属性映射信息——因为这些信息都可以通过Java反射机制获取。

70. 注释和Java代码位于一个文件中，而XML配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和Java代码放在一起，有助于增强程序的内聚性。而采用独立的XML配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维上的不连贯会降低开发效率。

71. 因此在很多情况下，注释配置比XML配置更受欢迎，注释配置有进一步流行的趋势。Spring2.5的一大增强就是引入了很多注释类，现在您已经可以使用注释配置完成大部分XML配置的功能。在这篇文章里，我们将向您讲述使用注释进行Bean定义和依赖注入的内容。

72.

73.

74. 原来我们是怎么做的

75.

76. 在使用注释配置之前，先来回顾一下传统上是如何配置Bean并完成Bean之间依赖关系的建立。下面是3个类，它们分别是Office、Car和Boss，这3个类需要在Spring容器中配置为Bean：

77.

78. Office仅有一个属性：

79.

80.

81. 清单1.Office.java

82.

83. packagecom.baobaotao;

84. publicclassOffice{

85. privateStringofficeNo=”001”;

86.

87. //省略get/setter

88.

89. @Override

90. publicStringtoString(){

91. return"officeNo:"+officeNo;

92. }

93. }

94.

95.

96.

97. Car拥有两个属性：

98.

99.

100. 清单2.Car.java

101.

102. packagecom.baobaotao;

103.

104. publicclassCar{

105. privateStringbrand;

106. privatedoubleprice;

107.

108. //省略get/setter

109.

110. @Override

111. publicStringtoString(){

112. return"brand:"+brand+","+"price:"+price;

113. }

114. }

115.

116.

117.

118. Boss拥有Office和Car类型的两个属性：

119.

120.

121. 清单3.Boss.java

122.

123. packagecom.baobaotao;

124.

125. publicclassBoss{

126. privateCarcar;

127. privateOfficeoffice;

128.

129. //省略get/setter

130.

131. @Override

132. publicStringtoString(){

133. return"car:"+car+"/n"+"office:"+office;

134. }

135. }

136.

137.

138.

139. 我们在Spring容器中将Office和Car声明为Bean，并注入到BossBean中：下面是使用传统XML完成这个工作的配置文件beans.xml：

140.

141.

142. 清单4.beans.xml将以上三个类配置成Bean

143.

144. <?xmlversion="1.0"encoding="UTF-8"?>

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

146. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

147. xsi:schemaLocation="http://www.springframework.org/schema/beans

148. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

149. <beanid="boss"class="com.baobaotao.Boss">

150. <propertyname="car"ref="car"/>

151. <propertyname="office"ref="office"/>

152. </bean>

153. <beanid="office"class="com.baobaotao.Office">

154. <propertyname="officeNo"value="002"/>

155. </bean>

156. <beanid="car"class="com.baobaotao.Car"scope="singleton">

157. <propertyname="brand"value="红旗CA72"/>

158. <propertyname="price"value="2000"/>

159. </bean>

160. </beans>

161.

162.

163.

164. 当我们运行以下代码时，控制台将正确打出boss的信息：

165.

166.

167. 清单5.测试类：AnnoIoCTest.java

168.

169. importorg.springframework.context.ApplicationContext;

170. importorg.springframework.context.support.ClassPathXmlApplicationContext;

171. publicclassAnnoIoCTest{

172.

173. publicstaticvoidmain(String[]args){

174. String[]locations={"beans.xml"};

175. ApplicationContextctx=

176. newClassPathXmlApplicationContext(locations);

177. Bossboss=(Boss)ctx.getBean("boss");

178. System.out.println(boss);

179. }

180. }

181.

182.

183.

184. 这说明Spring容器已经正确完成了Bean创建和装配的工作。

185.

186.

187. 使用@Autowired注释

188.

189. Spring2.5引入了@Autowired注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。来看一下使用@Autowired进行成员变量自动注入的代码：

190.

191.

192. 清单6.使用@Autowired注释的Boss.java

193.

194. packagecom.baobaotao;

195. importorg.springframework.beans.factory.annotation.Autowired;

196.

197. publicclassBoss{

198.

199. @Autowired

200. privateCarcar;

201.

202. @Autowired

203. privateOfficeoffice;

204.

205. &hellip;

206. }

207.

208.

209.

210. Spring通过一个BeanPostProcessor对@Autowired进行解析，所以要让@Autowired起作用必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessorBean。

211.

212.

213. 清单7.让@Autowired注释工作起来

214.

215. <?xmlversion="1.0"encoding="UTF-8"?>

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

217. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

218. xsi:schemaLocation="http://www.springframework.org/schema/beans

219. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

220.

221. <!--该BeanPostProcessor将自动起作用，对标注@Autowired的Bean进行自动注入-->

222. <beanclass="org.springframework.beans.factory.annotation.

223. AutowiredAnnotationBeanPostProcessor"/>

224.

225. <!--移除bossBean的属性注入配置的信息-->

226. <beanid="boss"class="com.baobaotao.Boss"/>

227.

228. <beanid="office"class="com.baobaotao.Office">

229. <propertyname="officeNo"value="001"/>

230. </bean>

231. <beanid="car"class="com.baobaotao.Car"scope="singleton">

232. <propertyname="brand"value="红旗CA72"/>

233. <propertyname="price"value="2000"/>

234. </bean>

235. </beans>

236.

237.

238.

239. 这样，当Spring容器启动时，AutowiredAnnotationBeanPostProcessor将扫描Spring容器中所有Bean，当发现Bean中拥有@Autowired注释时就找到和其匹配（默认按类型匹配）的Bean，并注入到对应的地方中去。

240.

241. 按照上面的配置，Spring将直接采用Java反射机制对Boss中的car和office这两个私有成员变量进行自动注入。所以对成员变量使用@Autowired后，您大可将它们的setter方法（setCar()和setOffice()）从Boss中删除。

242.

243. 当然，您也可以通过@Autowired对方法或构造函数进行标注，来看下面的代码：

244.

245.

246. 清单8.将@Autowired注释标注在Setter方法上

247.

248. packagecom.baobaotao;

249.

250. publicclassBoss{

251. privateCarcar;

252. privateOfficeoffice;

253.

254. @Autowired

255. publicvoidsetCar(Carcar){

256. this.car=car;

257. }

258.

259. @Autowired

260. publicvoidsetOffice(Officeoffice){

261. this.office=office;

262. }

263. …

264. }

265.

266.

267.

268. 这时，@Autowired将查找被标注的方法的入参类型的Bean，并调用方法自动注入这些Bean。而下面的使用方法则对构造函数进行标注：

269.

270.

271. 清单9.将@Autowired注释标注在构造函数上

272.

273. packagecom.baobaotao;

274.

275. publicclassBoss{

276. privateCarcar;

277. privateOfficeoffice;

278.

279. @Autowired

280. publicBoss(Carcar,Officeoffice){

281. this.car=car;

282. this.office=office;

283. }

284.

285. …

286. }

287.

288.

289.

290. 由于Boss()构造函数有两个入参，分别是car和office，@Autowired将分别寻找和它们类型匹配的Bean，将它们作为Boss(Carcar,Officeoffice)的入参来创建BossBean。

291.

292.

293. 当候选Bean数目不为1时的应对方法

294.

295. 在默认情况下使用@Autowired注释进行自动注入时，Spring容器中匹配的候选Bean数目必须有且仅有一个。当找不到一个匹配的Bean时，Spring容器将抛出BeanCreationException异常，并指出必须至少拥有一个匹配的Bean。我们可以来做一个实验：

296.

297.

298. 清单10.候选Bean数目为0时

299.

300. <?xmlversion="1.0"encoding="UTF-8"?>

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

302. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

303. xsi:schemaLocation="http://www.springframework.org/schema/beans

304. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

305.

306. <beanclass="org.springframework.beans.factory.annotation.

307. AutowiredAnnotationBeanPostProcessor"/>

308.

309. <beanid="boss"class="com.baobaotao.Boss"/>

310.

311. <!--将officeBean注释掉-->

312. <!--<beanid="office"class="com.baobaotao.Office">

313. <propertyname="officeNo"value="001"/>

314. </bean>-->

315.

316. <beanid="car"class="com.baobaotao.Car"scope="singleton">

317. <propertyname="brand"value="红旗CA72"/>

318. <propertyname="price"value="2000"/>

319. </bean>

320. </beans>

321.

322.

323.

324. 由于officeBean被注释掉了，所以Spring容器中将没有类型为Office的Bean了，而Boss的office属性标注了@Autowired，当启动Spring容器时，异常就产生了。

325.

326. 当不能确定Spring容器中一定拥有某个类的Bean时，可以在需要自动注入该类Bean的地方可以使用@Autowired(required=false)，这等于告诉Spring：在找不到匹配Bean时也不报错。来看一下具体的例子：

327.

328.

329. 清单11.使用@Autowired(required=false)

330.

331. packagecom.baobaotao;

332.

333. importorg.springframework.beans.factory.annotation.Autowired;

334. importorg.springframework.beans.factory.annotation.Required;

335.

336. publicclassBoss{

337.

338.