spring的三种注入方式

最新推荐文章于 2022-10-16 15:53:57 发布
最新推荐文章于 2022-10-16 15:53:57 发布
阅读量1k 收藏
点赞数
分类专栏： Spring综合 系统架构知识 文章标签： spring注入 spring
spring的三种注入方式：

  1. 接口注入（不推荐）
  2. getter，setter方式注入（比较常用）
  3. 构造器注入（死的应用）

关于getter和setter方式的注入：
  •  autowire="defualt"
  •  autowire=“byName”
  •  autowire="bytype" 
例如：
 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     
24 }
25 package org.jia;
26 
27 public class OrderItem {
28     private String orderdec;
29 
30     public String getOrderdec() {
31         return orderdec;
32     }
33 
34     public void setOrderdec(String orderdec) {
35         this.orderdec = orderdec;
36     }
37 }
38

getter&&setter方式第一种注入：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <bean id="orderItem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" >
        <!-----注入变量 名字必须与类中的名字一样------->
        <property name="orderNum" value="order000007"></property>
         <！--注入对象 名字为orderitem，所属的类的应用id为orderItem-->
        <property name="orderitem" ref="orderItem"></property>
    
    --></bean>


</beans>


getter&&setter方式第二种注入： byName

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--此时的id就必须与Order.java中所定义的OrderItem的对象名称一样了，不然就会找不到-->
    <bean id="orderitem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" autowire="byName">
        <property name="orderNum" value="order000007"></property>
    </bean>
</beans>


getter&&setter方式第三种注入：byType

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--按照byType注入则就与id没有关系，可以随便定义id ！！！但是不能出现多个此类的id-->
    <bean id="orderitdfadafaem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" autowire="byType">
        <property name="orderNum" value="order000007"></property>
    </bean>
</beans>


关于构造器的注入：

 autowire="constructor"
需要在Order.java中加入一个构造器
public Order(OrderItem item ){ orderitem = item; }

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="orderItem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" autowire="constructor">
        <property name="orderNum" value="order000007"></property>
    </bean>
</beans>

 

  • 构造器注入
这种方式的注入是指带有参数的构造函数注入，看下面的例子，我创建了两个成员变量SpringDao和User， 
public class SpringAction {   
    //注入对象springDao   
    private SpringDao springDao;   
    private User user;   
       
    public SpringAction(SpringDao springDao,User user){   
        this.springDao = springDao;   
        this.user = user;   
        System.out.println("构造方法调用springDao和user");   
    }   
           
        public void save(){   
        user.setName("卡卡");   
        springDao.save(user);   
    }   
}


在XML文件中同样不用<property>的形式，而是使用<constructor-arg>标签，ref属性同样指向其它<bean>

<!--配置bean,配置后该类由spring管理-->  
    <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
        <!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->  
        <constructor-arg ref="springDao"></constructor-arg>  
        <constructor-arg ref="user"></constructor-arg>  
    </bean>  
        <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>  
         <bean name="user" class="com.bless.springdemo.vo.User"></bean>


解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：

下面是设置index，就是参数位置： 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
        <constructor-arg index="0" ref="springDao"></constructor-arg>  
        <constructor-arg index="1" ref="user"></constructor-arg>  
    </bean>


另一种是设置参数类型：

<constructor-arg type="java.lang.String" ref=""/>  

 

  • 静态工厂的方法注入
静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过spring注入的形式获取：
Java代码 复制代码  收藏代码
  1. package com.bless.springdemo.factory;   
  2.   
  3. import com.bless.springdemo.dao.FactoryDao;   
  4. import com.bless.springdemo.dao.impl.FactoryDaoImpl;   
  5. import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;   
  6.   
  7. public class DaoFactory {   
  8.     //静态工厂   
  9.     public static final FactoryDao getStaticFactoryDaoImpl(){   
  10.         return new StaticFacotryDaoImpl();   
  11.     }   
  12. }  
package com.bless.springdemo.factory;

import com.bless.springdemo.dao.FactoryDao;
import com.bless.springdemo.dao.impl.FactoryDaoImpl;
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;

public class DaoFactory {
	//静态工厂
	public static final FactoryDao getStaticFactoryDaoImpl(){
		return new StaticFacotryDaoImpl();
	}
}

同样看关键类，这里我需要注入一个FactoryDao对象，这里看起来跟第一种注入一模一样，但是看随后的xml会发现有很大差别:
Java代码 复制代码  收藏代码
  1.  public class SpringAction {   
  2.         //注入对象   
  3.     private FactoryDao staticFactoryDao;   
  4.        
  5.     public void staticFactoryOk(){   
  6.         staticFactoryDao.saveFactory();   
  7.     }   
  8.     //注入对象的set方法   
  9.     public void setStaticFactoryDao(FactoryDao staticFactoryDao) {   
  10.         this.staticFactoryDao = staticFactoryDao;   
  11.     }   
  12. }  
 public class SpringAction {
        //注入对象
	private FactoryDao staticFactoryDao;
	
	public void staticFactoryOk(){
		staticFactoryDao.saveFactory();
	}
	//注入对象的set方法
	public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
		this.staticFactoryDao = staticFactoryDao;
	}
}
 
Spring的IOC配置文件，注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类，而是指向静态工厂 DaoFactory，并且配置 factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法：
Xml代码 复制代码  收藏代码
  1. <!--配置bean,配置后该类由spring管理-->  
  2.     <bean name="springAction" class="com.bless.springdemo.action.SpringAction" >  
  3.         <!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)-->  
  4.         <property name="staticFactoryDao" ref="staticFactoryDao"></property>  
  5.                 </property>  
  6.     </bean>  
  7.     <!--(3)此处获取对象的方式是从工厂类中获取静态方法-->  
  8.     <bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>  
  9.       
 


  • 实例工厂的方法注入
实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法：
Java代码
public class DaoFactory {   
  1.     //实例工厂   
  2.     public FactoryDao getFactoryDaoImpl(){   
  3.         return new FactoryDaoImpl();   
  4.     }   
  5. }  
public class DaoFactory {
	//实例工厂
	public FactoryDao getFactoryDaoImpl(){
		return new FactoryDaoImpl();
	}
}

那么下面这个类没什么说的，跟前面也很相似，但是我们需要通过实例工厂类创建FactoryDao对象：
Java代码
public class SpringAction {   
  1.     //注入对象   
  2.     private FactoryDao factoryDao;   
  3.        
  4.     public void factoryOk(){   
  5.         factoryDao.saveFactory();   
  6.     }   
  7.   
  8.     public void setFactoryDao(FactoryDao factoryDao) {   
  9.         this.factoryDao = factoryDao;   
  10.     }   
  11. }  
public class SpringAction {
	//注入对象
	private FactoryDao factoryDao;
	
	public void factoryOk(){
		factoryDao.saveFactory();
	}

	public void setFactoryDao(FactoryDao factoryDao) {
		this.factoryDao = factoryDao;
	}
}
 
最后看spring配置文件：
Xml代码
  1. <!--配置bean,配置后该类由spring管理-->  
  2.     <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
  3.         <!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)-->  
  4.         <property name="factoryDao" ref="factoryDao"></property>  
  5.     </bean>  
  6.        
  7.     <!--(4)此处获取对象的方式是从工厂类中获取实例方法-->  
  8.     <bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>  
  9.     <bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>  
 

  • 总结
Spring IOC注入方式用得最多的是(1)(2)种，多谢多练就会非常熟练。
        另外注意：通过Spring创建的对象默认是单例的，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：
Java代码
  1. <bean name="..." class="..." scope="prototype">  


 

南北雪树
关注
专栏目录
Spring三种注入方式（三）
07-30
本篇主要介绍Spring中的三种注入方式，包括构造器注入、设值注入和接口注入。 **一、构造器注入** 构造器注入是通过构造函数来传递依赖对象的一种方式。当类有多个构造函数时，Spring会使用带有最多参数的构造函数...
Field injection is not recommended（Spring团队不推荐使用Field注入）
热门推荐
编程火箭车（Coding Rocket）专注编程领域
02-23 5万+
在使用 IDEA 开发 SpringBoot 项目时，在 Controller 类中使用注解 @Autowired 注入一个依赖出现了警告提示。这是怎么回事？（在之前使用 MyEclipse 开发时通常直接使用 @Autowired 进行注入，当时并没有觉得有什么问题。）
spring定义和装配bean
前端蜗牛君
12-19 600
手动定义和装配Bean 在项目的根目录中新建一个名叫bean.xml的xml文件，内容如下： beans> bean id="car" class="org.zdk.springProj1.BMW" /> bean id="tom" class="org.zdk.springProj1.Person"> constructor-arg value="To
Spring框架学习（4）IOC容器 Bean格式
寒潭清
09-21 265
XML格式 无论是BeanFactory还是ApplicationContext都使用统一的XML格式 beans的XML说明 所有Spring容器加载XML配置文件头部说明，都需要以下DOCTYPE声明 基于DTD声明 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.org/dtd/spring-beans.
Spring的XML解析中关于DTD的路径问题-
xumingrencai
06-28 346
在Spring中最简单的一个xml如下： &lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&gt; &lt;beans&gt;
Spring中配置id或name相同的Bean可能引发的问题及解决方案
chengwei0708的博客
08-14 1145
一、背景 如果再xml中配置了相同的<Bean>的ID或name可能会造成一些问题，今天我们来探讨一下并解决。 二、问题 1、在同一个xml中配置了相同的bean的id。EX: <?xml version="1.0" encoding="UTF-8"?> &...
Spring三种注入方式（一）
07-30
本篇主要介绍Spring中的三种注入方式，包括构造器注入、设值注入和接口注入。 首先，我们来看构造器注入。构造器注入是在创建对象时，通过构造器传递依赖对象。这种方式强制了对象在创建时就必须提供所有必要的依赖...
Spring三种注入方式（二）
03-20
本篇主要介绍Spring中的三种注入方式，着重讲解在"Spring三种注入方式（二）"中的内容。我们将深入探讨setter注入，这是Spring中最常见的注入方式之一。 ### 一、setter注入 setter注入是通过Spring容器调用对象的...
Spring Bean三种注入方式详解
08-28
Spring Bean三种注入方式详解 在 Spring 框架中，Bean 的依赖注入是通过容器来管理和提供的。依赖注入有三种方式：使用属性的 setter 方法注入、使用构造器注入和使用 Filed 注入。 使用属性的 setter 方法注入 ...
Spring的三种注入方式
01-20
　2、getter，setter方式注入（比较常用） 　3、构造器注入（死的应用） 　关于getter和setter方式的注入 1.autowire=defualt 2.autowire=“byName”  3.autowire=bytype   　详细解析注入方式 　例如...
@Autowired依赖注入为啥不推荐了
zzming2012的专栏
05-26 2908
这几天更新升级了一下java编码神器IDEA，升级完进行日常开发，可能是以前用的IDEA版本比较老旧，升级之后发现之前的日常写法有了个warning提醒。来看图： 如上图，这就奇怪了，我们经常写的业务层就是service接口层和对应的实现类层进行属性注入的时候都是采用注解进行注入的。这也是springIOC给提供的比较方便的地方。我使用IDEA提供的自动修复提示修复了之后变成采用构造函数的形式进行注入了。 但是多年面向Spring开发的经验告诉我，使用@Autowired注解进行依赖注入，肯定是没有问题
Spring 注入方式
Imzhipo的博客
03-15 7529
Spring 注入方式有三中 1.setter注入 2.构造器注入 3.基于注解的注入 1.setter注入 在InjectionServiceImple 中有 变量 injectionDao 并有其的set方法 还有一点需要注意：如果通过set方法注入属性，那么spring会通过默认的空参构造方法来实例化对象，所以如果在类中写了一个带有参数的构造方法，一定要把空参数的构造方法写上，否则spring没有办法实例化对象，导致报错。 2.构造器注入 注意：配置文件中的nam.
Bean的四种注入方式
weixin_45907591的博客
04-05 1万+
1.set方法注入 2.构造器注入 3.静态工厂注入 4.实例工厂注入 我使用下面两个类来进行注入的演示，这两个类分别是User和Car类： Car类： public class Car { // 只包含基本数据类型的属性 private int speed; private double price; public Car() { } public Car(int speed, double price) { this.speed
Spring 自动生成getter和setter方法 tostring方法
趣学程序
01-07 3668
添加maven依赖 dependency> groupId>org.projectlombokgroupId> artifactId>lombokartifactId> version>1.16.18version> scope>providedscope> dependency> 在需要生成getter和setter的类上添加@Data注解 im
springIoC三种实现之getter和setter方式
我是jjking`
11-26 592
getter和setter方式 注意事项： 有私有属性的实现类中必须有getter和setter方法 applicationContext.xml文件中的bean属性配置为property 实体类 public class Grade { private int grade; public Grade() { } public Grade...
spring加载beans找不到声明
佳颖的专栏
05-03 2万+
【转】Spring启动异常: cvc-elt.1: Cannot find the declaration of element 'beans' 今天把在线聊天室代码改了下, 想启动应用测试. 结果抛出一大堆异常: -------------------------------------------------------- org.springframework.beans.fa
spring配置文件注意事项
hu_shengyang的专栏
04-21 1211
<br /> <br /><?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/
Spring中自动注入的两种方式
weixin_44362089的博客
10-16 5310
Spring自动注入的两种方法的详细介绍和案例。byName自动注入，byType自动注入
spring的ioc三种注入方式
最新发布
09-18
Spring的IOC(Inversion of Control)有三种注入方式，分别是构造函数注入、setter注入和接口注入。构造函数注入是通过构造函数来注入依赖对象，可以保证对象的完整性，并且所有依赖项都必须在构造函数中设置。setter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值