Spring的注入方式详解

转载 2012年03月22日 23:08:01
Spring的注入方式详解
Spring有三个注入方式,type1,type2,type3
type1  接口依赖
type2  setter/getter
type3  构造方法
 
type2,type3较用常用
首先来看一下type2

 
type2 setter/getter(引用注入)

例如,存在一个User类和Home类
 
user类里一个userName;一个Home对象的属性.
public class User { 
       private String userName;
    private Home myHome;
       public Home getMyHome() { 
              return myHome;
       }
       public void setMyHome(Home myHome) { 
              this.myHome = myHome;
       }
       public String getUserName() { 
              return userName;
       }
       public void setUserName(String userName) { 
              this.userName = userName;
       }
}
public class Home { 
       private String homeAddr;
       public String getHomeAddr() { 
              return homeAddr;
       }
       public void setHomeAddr(String homeAddr) { 
              this.homeAddr = homeAddr;
       }
}
public class TestMain { 
    public static void main(String[] args) { 
        ApplicationContext context=new FileSystemXmlApplicationContext("test/lyx/applicationContext.xml");
        User user1=(User)context.getBean("user");
    
        System.out.println(“姓名为: ”+user1.getUserName());
        System.out.println(“家庭住址是: ”+user1.getMyHome().getHomeAddr());
 
    }
 
}
将两个bean的注入:(applicationContext.xml配置如下)
       <bean id="home" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>大连</value>
              </property>
       </bean>
 
       <bean id="user" class="test.lyx.User" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="userName">
                     <value>liuyuanxi</value>
              </property>
              <property name="myHome">
              <ref bean="home"/>
              </property>
       </bean>
这里的user bean,引用了home bean,
运行时会打出 
姓名为:liuyuanxi 
家庭住址是:大连
这种方式就是setter/getter方式注入,习惯用JavaBean的人应该很容易理解这种方法,也就是能过<property name="userName">来指定属性. <value>liuyuanxi</value>来指定属性所对应的值.多少个属性就有多少个<property>
这里一个人,和家是两个类,也提到了两个bean之间的引用.也就是user bean给名字赋了值,home bean给地址赋了值.如果在user bean中想引入 home bean中的地址.就用<ref/>不再用<values>
 
 
type3 构造方法注入

这里我们在User里加入一个构造器
public User(Home myHome){ 
this.myHome=myHome;
}
然后 把配置文件改一下:autowire=constructor;
 
       <bean id="home" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>大连</value>
              </property>
       </bean>
 
       <bean id="user" class="test.lyx.User" abstract="false"
              singleton="true" lazy-init="default" autowire=" constructor "
              dependency-check="default">
              <property name="userName">
                     <value>liuyuanxi</value>
              </property>
              <property name="myHome">
              <ref bean="home"/>
              </property>
       </bean>
运行时会打出 
姓名为:liuyuanxi 
家庭住址是:大连
这种方式就是构造器注入
 
我们再来看看spring的绑定
也就是通过bean属性autowire来设置
1.       通过bean属性autowire="byType"的设置可以使用bean在运行时候根据去寻找同类型的已定义属性,如果找不到则处于未绑定状态.(已定义好指在applicationContext.xml中初始化)这里我们把配置文件的 user bean的autowire改成autowire="byType",注意一定要把User的构造器去掉,要不然先找构造器,会出错.这里的home bean是属于,test.lyx.Home类型的,而user bean里有两个属性一个属性已经初始化,而另一个属性Home,就会自动找到.
applicationContext.xml配置如下:
       <bean id="home" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>大连</value>
              </property>
       </bean>
 
       <bean id="user" class="test.lyx.User" abstract="false"
              singleton="true" lazy-init="default" autowire=" byType "
              dependency-check="default">
              <property name="userName">
                     <value>liuyuanxi</value>
              </property>
              <property name="myHome">
              <ref bean="home"/>
              </property>
       </bean>
运行时会打出 
姓名为:liuyuanxi 
家庭住址是:大连
这种方式就是构造器注入
 
但这样的寻找方式有一个弱点,
假如再注入一个Home bean,叫home1,运行时就会找到两个bean,出错.
       <bean id="home1" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>beijing</value>
              </property>
       </bean>
如果我们想解决这种问题也很简单,我们可以把autowire改为,autowire="byName"方式来寻找.
但是这里一定要注意:Home bean的id名,一定要和属性名字一样.这里应该改成,id="myHome"
       <bean id="home1" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>dalian</value>
              </property>
       </bean>
       <bean id="myHome" class="test.lyx.Home" abstract="false"
              singleton="true" lazy-init="default" autowire="default"
              dependency-check="default">
              <property name="homeAddr">
                     <value>北京</value>
              </property>
       </bean>
这样的话
运行时会打出 
姓名为:liuyuanxi 
家庭住址是:北京
而不在是大连了,这种寻找方式就是byName,也就是按属性的名字进行查询.注意:id一定要属性的名字一样.
 
2.我们来比较一个byname和 bytype这两种方式.
byname要比bytype精确些,因为id,是不能重名的.
而且假如存在一这样一种情况,两个user bean,分别为user1,user2,那么user1,user2都可以,打出北京.重用性很好.
到这可能有人会想到.user1,和user2调用的是同一个Home吗.你可以把他们的hashcode();打出来,你会发现地址是一样的,也就是说,是同一个bean.这里是因为singleton="true"的原因,如果你把singleton改成了"false"那就不是一个对象了.
3.如果把autowire=” constructor”也就是构造器注入一定要注意了,他是以byType进行查找,也就是说,Home bean,是不能出现两次,否则就会出错了.
4.如果autowire设置成为autodetect,他会一直找,直到找到一个合适的为止.constructor,bytype,byname的顺序去找.这种方式是不推荐使用的.因为你很难判断出执行的是那个.

Spring-三种依赖注入方式

三种依赖注入方式,即构造方法注入(constructor injection),setter方法注入(setter injection)以及接口注入(interface injection). 构造方...
  • wojiaohuangyu
  • wojiaohuangyu
  • 2016年06月29日 21:48
  • 5685

深入浅出spring IOC中三种依赖注入方式

深入浅出spring IOC中三种依赖注入方式 spring的核心思想是IOC和AOP,IOC-控制反转,是一个重要的面向对象编程的法则来消减计算机程序的耦合问题,控制反转一般分为两种类型,依赖...
  • u011637069
  • u011637069
  • 2016年07月19日 19:53
  • 30259

深刻剖析spring三种注入方式以及使用注解的原理

  概述 注释配置相对于 XML 配置具有很多的优势: 它可以充分利用 Java 的反射机制获取类结构信息,这些信息可以有效减少配置的工作。如使用 JPA 注释配置 ORM 映射时...
  • qq_22075041
  • qq_22075041
  • 2017年05月14日 15:49
  • 1414

spring的五种依赖注入方式

平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程...
  • shadow_zed
  • shadow_zed
  • 2017年05月19日 22:35
  • 2062

Spring四种依赖注入方式

平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程...
  • tolcf
  • tolcf
  • 2014年09月10日 22:23
  • 2329

Spring常用的三种注入方式

Spring通过DI(依赖注入)实现IOC(控制反转),常用的注入方式主要有三种:构造方法注入,setter注入,基于注解的注入。构造方法注入先简单看一下测试项目的结构,用maven构建的,四个包:e...
  • a909301740
  • a909301740
  • 2017年10月28日 21:45
  • 526

Spring两种注入方式的区别

Spring两种注入方式分别是:@Autowired和@Re
  • yinganan90
  • yinganan90
  • 2014年04月23日 11:04
  • 1212

Spring三种注入属性的方式

Spring三种方法注入属性 1.        准备工作: 1)        新建Dao包,Service包 2)        在每个包内新建对应的接口,以及impl包 Us...
  • qq_28174471
  • qq_28174471
  • 2016年09月05日 18:25
  • 1799

spring三种注入方式比较

三种注入方式比较 接口注入: 接口注入模式因为具备侵入性,它要求组件必须与特定的接口相关联,因此并不被看好,实际使用有限。 Setter 注入: 对于习惯了传统 javabean 开发的程序员...
  • xiaolingzinia
  • xiaolingzinia
  • 2013年11月29日 12:23
  • 1320

Spring定义bean的三种方式和自动注入

前言:随着一个项目规模的增大,我们不得不引入许多Java bean对象,而这些对象一般来说是在Spring的配置文件applicationContext.xml中进行配置的,这样就声明了这是一个由Sp...
  • sinat_34596644
  • sinat_34596644
  • 2016年11月08日 10:52
  • 19214
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Spring的注入方式详解
举报原因:
原因补充:

(最多只允许输入30个字)