spring 三种注入方式
2017-04-12 15:58
218 查看
[align=left][/align]spring 的三种注入方式
//引用:http://yujing-yu.iteye.com/blog/1595617
--------------------------------------------------------------------------------
1. 接口注入( 不推荐 )
2. getter , setter 方式注入( 比较常用 )
3. 构造器注入( 死的应用 )
--------------------------------------------------------------------------------
关于 getter 和 setter 方式的注入
· autowire="defualt"
· autowire=“byName”
· autowire="bytype"
详细解析注入方式
例如:有如下两个类需要注入
第一个类:
Java代码
1. package org.jia;
2.
3. public class Order {
4. private String orderNum;
5. @SuppressWarnings ( "unused" )
6. private OrderItem orderitem;
7.
8. public OrderItem getOrderitem() {
9. return orderitem;
10. }
11.
12. public void setOrderitem(OrderItem orderitem) {
13. this .orderitem = orderitem;
14. }
15.
16. public String getOrderNum() {
17. return orderNum;
18. }
19.
20. public void setOrderNum(String orderNum) {
21. this .orderNum = orderNum;
22. }
23. }
第二个类:
Java代码
1. package org.jia;
2.
3. public class OrderItem {
4. private String orderdec;
5.
6. public String getOrderdec() {
7. return orderdec;
8. }
9.
10. public void setOrderdec(String orderdec) {
11. this .orderdec = orderdec;
12. }
13. }
常用getter&&setter方式介绍
方式第一种注入:
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3.
4. < beans >
5. < bean id = "orderItem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" >
9. <!-----注入变量 名字必须与类中的名字一样------->
10. < property name = "orderNum" value = "order000007" > </ property >
11. < !--注入对象 名字为orderitem,所属的类的应用id为orderItem-- >
12. < property name = "orderitem" ref = "orderItem" > </ property >
13.
14. --> </ bean >
15. </ beans >
方式第二种注入: byName
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. <!--此时的id就必须与Order.java中所定义的OrderItem的对象名称一样了,不然就会找不到-->
5. < bean id = "orderitem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" < span style = "color: #ff0000;" > autowire = "byName" </ span > >
9. < property name = "orderNum" value = "order000007" > </ property >
10. </ bean >
11. </ beans >
方式第三种注入: byType
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. <!--按照byType注入则就与id没有关系,可以随便定义id !!!但是不能出现多个此类的id-->
5. < bean id = "orderitdfadafaem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" < span style = "color: #ff0000;" > autowire = "byType" </ span > >
9. < property name = "orderNum" value = "order000007" > </ property >
10. </ bean >
11. </ beans >
autowire="constructor"
需要在 Order.java 中加入一个构造器
Java代码
1. public Order(OrderItem item )
2. {
3. orderitem = item;
4. }
XML配置文件
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. < bean id = "orderItem" class = "org.jia.OrderItem" >
5. < property name = "orderdec" value = "item00001" > </ property >
6. </ bean >
7. < bean id = "order" class = "org.jia.Order" autowire = "constructor" >
8. < property name = "orderNum" value = "order000007" > </ property >
9. </ bean >
10. </ beans >
三种注入方式比较
接口注入:
接口注入模式因为具备侵入性,它要求组件必须与特定的接口相关联,因此并不被看好,实际使用有限。
Setter 注入:
对于习惯了传统 javabean 开发的程序员,通过 setter 方法设定依赖关系更加直观。
如果依赖关系较为复杂,那么构造子注入模式的构造函数也会相当庞大,而此时设值注入模式则更为简洁。
如果用到了第三方类库,可能要求我们的组件提供一个默认的构造函数,此时构造子注入模式也不适用。
构造器注入:
在构造期间完成一个完整的、合法的对象。
所有依赖关系在构造函数中集中呈现。
依赖关系在构造时由容器一次性设定,组件被创建之后一直处于相对“不变”的稳定状态。
只有组件的创建者关心其内部依赖关系,对调用者而言,该依赖关系处于“黑盒”之中。
总结
Spring使用注入方式,为什么使用注入方式,这系列问题实际归结起来就是一句话,Spring的注入和IoC (本人关于IoC的阐述)反转控制是一回事。
理论上:第三种注入方式(构造函数注入)在符合java使用原则上更加合理,第二种注入方式(setter注入)作为补充。
实际上:我个人认为第二种注入方式(setter注入)可以取得更加直观的效果,在使用工作上有不可比拟的优势,所以setter注入依赖关系应用更加广泛。
//引用:http://yujing-yu.iteye.com/blog/1595617
--------------------------------------------------------------------------------
1. 接口注入( 不推荐 )
2. getter , setter 方式注入( 比较常用 )
3. 构造器注入( 死的应用 )
--------------------------------------------------------------------------------
关于 getter 和 setter 方式的注入
· autowire="defualt"
· autowire=“byName”
· autowire="bytype"
详细解析注入方式
例如:有如下两个类需要注入
第一个类:
Java代码
1. package org.jia;
2.
3. public class Order {
4. private String orderNum;
5. @SuppressWarnings ( "unused" )
6. private OrderItem orderitem;
7.
8. public OrderItem getOrderitem() {
9. return orderitem;
10. }
11.
12. public void setOrderitem(OrderItem orderitem) {
13. this .orderitem = orderitem;
14. }
15.
16. public String getOrderNum() {
17. return orderNum;
18. }
19.
20. public void setOrderNum(String orderNum) {
21. this .orderNum = orderNum;
22. }
23. }
第二个类:
Java代码
1. package org.jia;
2.
3. public class OrderItem {
4. private String orderdec;
5.
6. public String getOrderdec() {
7. return orderdec;
8. }
9.
10. public void setOrderdec(String orderdec) {
11. this .orderdec = orderdec;
12. }
13. }
常用getter&&setter方式介绍
方式第一种注入:
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3.
4. < beans >
5. < bean id = "orderItem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" >
9. <!-----注入变量 名字必须与类中的名字一样------->
10. < property name = "orderNum" value = "order000007" > </ property >
11. < !--注入对象 名字为orderitem,所属的类的应用id为orderItem-- >
12. < property name = "orderitem" ref = "orderItem" > </ property >
13.
14. --> </ bean >
15. </ beans >
方式第二种注入: byName
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. <!--此时的id就必须与Order.java中所定义的OrderItem的对象名称一样了,不然就会找不到-->
5. < bean id = "orderitem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" < span style = "color: #ff0000;" > autowire = "byName" </ span > >
9. < property name = "orderNum" value = "order000007" > </ property >
10. </ bean >
11. </ beans >
方式第三种注入: byType
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. <!--按照byType注入则就与id没有关系,可以随便定义id !!!但是不能出现多个此类的id-->
5. < bean id = "orderitdfadafaem" class = "org.jia.OrderItem" >
6. < property name = "orderdec" value = "item00001" > </ property >
7. </ bean >
8. < bean id = "order" class = "org.jia.Order" < span style = "color: #ff0000;" > autowire = "byType" </ span > >
9. < property name = "orderNum" value = "order000007" > </ property >
10. </ bean >
11. </ beans >
autowire="constructor"
需要在 Order.java 中加入一个构造器
Java代码
1. public Order(OrderItem item )
2. {
3. orderitem = item;
4. }
XML配置文件
Html代码
1. <? xml version = "1.0" encoding = "UTF-8" ?>
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4. < bean id = "orderItem" class = "org.jia.OrderItem" >
5. < property name = "orderdec" value = "item00001" > </ property >
6. </ bean >
7. < bean id = "order" class = "org.jia.Order" autowire = "constructor" >
8. < property name = "orderNum" value = "order000007" > </ property >
9. </ bean >
10. </ beans >
三种注入方式比较
接口注入:
接口注入模式因为具备侵入性,它要求组件必须与特定的接口相关联,因此并不被看好,实际使用有限。
Setter 注入:
对于习惯了传统 javabean 开发的程序员,通过 setter 方法设定依赖关系更加直观。
如果依赖关系较为复杂,那么构造子注入模式的构造函数也会相当庞大,而此时设值注入模式则更为简洁。
如果用到了第三方类库,可能要求我们的组件提供一个默认的构造函数,此时构造子注入模式也不适用。
构造器注入:
在构造期间完成一个完整的、合法的对象。
所有依赖关系在构造函数中集中呈现。
依赖关系在构造时由容器一次性设定,组件被创建之后一直处于相对“不变”的稳定状态。
只有组件的创建者关心其内部依赖关系,对调用者而言,该依赖关系处于“黑盒”之中。
总结
Spring使用注入方式,为什么使用注入方式,这系列问题实际归结起来就是一句话,Spring的注入和IoC (本人关于IoC的阐述)反转控制是一回事。
理论上:第三种注入方式(构造函数注入)在符合java使用原则上更加合理,第二种注入方式(setter注入)作为补充。
实际上:我个人认为第二种注入方式(setter注入)可以取得更加直观的效果,在使用工作上有不可比拟的优势,所以setter注入依赖关系应用更加广泛。
相关文章推荐
- Spring IOC三种注入方式比较
- Spring的三种注入方式
- Spring依赖注入的三种方式
- Spring IOC三种注入方式(接口注入、setter注入、构造器注入)(摘抄)
- Spring的三种注入方式都是什么?如何选用?
- Spring的三种注入方式
- Spring IOC三种注入方式比较
- Spring依赖注入的三种方式
- Spring依赖注入的三种方式
- spring的三种注入方式:
- Spring中注入的三种方式
- Spring的三种注入方式?
- spring Ioc 依赖注入的三种方式:构造函数注入、setter方法注入和接口注入
- Spring中接口注入的三种方式
- spring的三种注入方式
- Spring中注入的三种方式
- Spring的注入方式(三种)
- Spring的注入方式(三种)
- Spring中接口注入的三种方式
- Spring 三种注入方式