【Spring】IOC容器之bean之间的关系

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

本文主要讲了Spring中Bean之间的关系，分为继承、依赖和引用三个类型。文章中都分别有例子和用法分析。

一、继承Bean配置

  • Spring允许继承bean的配置 ，被继承的bean称为父bean，继承这个父Bean的Bean称为子Bean
  • 子Bean从父Bean中继承配置，包括Bean的属性配置
  • 子Bean也可以 覆盖 从父Bean继承过来的配置
  • 父Bean可以作为配置模版，也可以作为Bean实例， 若只想把父Bean作为模版，可以配置<bean>的abstract属性为true ，这样Spring将不会实例化这个Bean
  • 并不是<bean>元素里的所有属性都会被继承 。比如：autowire，abstract等。
  • 也 可以忽略父Bean的class属性 ，让子Bean指定自己的类，而共享相同的属性配置，但此时 abstract必须设为true

使用案例：

定义House.java:

package com.mucfc;

public class House {
	private String houseSize;
	private String housePosition;
	private String housePrice;
	public String getHouseSize() {
		return houseSize;
	}
	public void setHouseSize(String houseSize) {
		this.houseSize = houseSize;
	}
	public String getHousePosition() {
		return housePosition;
	}
	public void setHousePosition(String housePosition) {
		this.housePosition = housePosition;
	}
	public String getHousePrice() {
		return housePrice;
	}
	public void setHousePrice(String housePrice) {
		this.housePrice = housePrice;
	}
	public String toString(){
		return "房子大小："+houseSize+" 房子位置："+housePosition+" 房子价格："+housePrice;
	}
}

如果多个bean存在相同的配置信息，Spring允许我们定义一个父，子将自动继承父的配置信息。

     <!-- 定义抽象bean -->
     <bean id="abstracthouse" class="com.mucfc.House" p:houseSize="150坪"
        p:housePosition="科苑花园" p:housePrice="15万"/>
     <!-- 继承于abstracthouse -->
      <bean id="house2" parent="abstracthouse" p:housePosition="汇景苑"/>
      <!-- 继承于abstracthouse -->
      <bean id="house3" parent="abstracthouse" p:housePrice="8万"/>

使用：

		House house5=applicationContext.getBean("house2",House.class);
		House house6=applicationContext.getBean("house3",House.class);
		System.out.println(house5);
		System.out.println(house6);

输出结果：

房子大小：150坪 房子位置：汇景苑 房子价格：15万
房子大小：150坪 房子位置：科苑花园 房子价格：8万

house1跟house2都继承自abstracthouse,Spring会将父bean的配置信息传递给子bean，如果子bean提供了父bean已有的配置信息，那么子bean的会覆盖父bean的.

父bean的功能主要是为了简化子bean的配置，所以一般声明为abstract=“true”，表示这个不实例化为一个对应的Bean，如果用户不指定该属性为true，那么IOC容器会实例化一个名叫abstractcar的Bean。

二、依赖Bean配置

  • Spring允许用户通过depends-on属性设定Bean前置依赖的Bean ，前置依赖的Bean会在本Bean实例化之前创建好
  • 如果前置依赖于多个Bean，则可以通过逗号，空格或的方式配置Bean的名称

depends-on:

depends-on属性可以用于当前bean初始化之前显式地强制一个或多个bean被初始化。下面的例子中使用了depends-on属性来指定一个bean的依赖。

    <bean id="buyHouser" class="com.mucfc.depend.BuyHouser" />
    <bean id="HouseAgent" class="com.mucfc.depend.HouseAgent" depends-on="buyHouser" />

若需要表达对多个bean的依赖，可以在‘depends-on‘中将指定的多个bean名字用分隔符进行分隔，分隔符可以是逗号、空格及分号等。下面的

 <bean id="HouseAgent" class="com.mucfc.depend.HouseAgent" init-method="initHouseAgent" depends-on="buyHouser,sellHouser" />

例子中使用了‘depends-on‘来表达对多个bean的依赖。
延迟初始化bean;

在XML配置文件中，延迟初始化将通过<bean/>元素中的lazy-init属性来进行控制。例如：

    <bean id="buyHouser" class="com.mucfc.depend.BuyHouser" lazy-init="true"/>
    <bean id="sellHouser" class="com.mucfc.depend.SellHouser" />

当ApplicationContext实现加载上述配置时，设置为lazy的bean-buyHouser将不会在ApplicationContext启动时提前被实例化，而not.lazy--sellHouser却会被提前实例化。

       需要说明的是，如果一个bean被设置为延迟初始化，而另一个非延迟初始化的singleton bean依赖于它，那么当ApplicationContext提前实例化singleton bean时，它必须也确保所有上述singleton 依赖bean也被预先初始化，当然也包括设置为延迟实例化的bean。因此，如果Ioc容器在启动的时候创建了那些设置为延迟实例化的bean的实例，你也不要觉得奇怪，因为那些延迟初始化的bean可能在配置的某个地方被注入到了一个非延迟初始化singleton bean里面。

使用范例：
1.买房人BuyHouser.java

package com.mucfc.depend;

public class BuyHouser {
private String name;

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}
public void initBuyHouser(){
	System.out.println("初始化了BuyHouser");
	}
}

2、卖房人SellHouser.java

package com.mucfc.depend;

public class SellHouser {
	private String name;
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public void initSellHouser (){
		System.out.println("初始化了SellHouser ");
		}
}

3、房屋中介HouseAgent.java

package com.mucfc.depend;

public class HouseAgent {
private BuyHouser buyHouser;
private SellHouser sellHouser;
public BuyHouser getBuyHouser() {
	return buyHouser;
}
public void setBuyHouser(BuyHouser buyHouser) {
	this.buyHouser = buyHouser;
}
public SellHouser getSellHouser() {
	return sellHouser;
}
public void setSellHouser(SellHouser sellHouser) {
	this.sellHouser = sellHouser;
}
public void initHouseAgent(){
	System.out.println("初始化了HouseAgent");
	}
}

4、beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">

    <bean id="houseAgent" class="com.mucfc.depend.HouseAgent" init-method="initHouseAgent" depends-on="buyHouser,sellHouser" />
    <bean id="buyHouser" class="com.mucfc.depend.BuyHouser" init-method="initBuyHouser" lazy-init="true"/>
    <bean id="sellHouser" class="com.mucfc.depend.SellHouser" init-method="initSellHouser" lazy-init="true"/> 

</beans>

5、测试

package com.mucfc.depend;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {
		 ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");

	}

}

结果：

注意，这里我将BuyHouser和SellHouser都设置成lazy-init="true",但是由于房屋中介HouseAgent依赖到它们两个，所以你你加载这个beans.xml文件时，还是会先把BuyHouser和SellHouser实例化。

三、引用Bean配置

代码结构：
可写成

<bean id="houseAgent1" class="com.mucfc.depend.HouseAgent" p:buyHouser="buyHouser" p:sellHouser="sellHouser"/>
   <bean id="houseAgent2" class="com.mucfc.depend.HouseAgent" p:buyHouser-ref="buyHouser" p:sellHouser-ref="sellHouser"/>

或写成

  <bean id = "houseAgent3" class = "com.mucfc.depend.HouseAgent" >
        <property name="buyHouser">
            <ref bean="buyHouser"/>
        </property>
        <property name="sellHouser">
            <ref local="sellHouser"/>
        </property>
    </bean>

<ref local="xx"/>
        用"local"属性指定目标其实是指向同一文件内对应"id"属性值为此"local"值的索引"local"属性的值必须和目标bean的id属性相同。如果同一文件内没有匹配的元素，xml解析器将提示错误。同样，如果目标在同一XML文件内，使用"local"变量是最好的选择(为了尽可能早地知道错误)
<ref bean="xx"/>
        用"bean"属性指定目标bean是最常规的形式，这允许创建索引到任何同一个容器内的bean(无论是否在同一XML文件中)或者父级的容器内的bean。"bean"属性的值可以和目标bean的"id"属性相同，也可以和目标bean的"name"属性内的一个值相同

1 、用 local 属性指定目标 bean 可以利用 xml 解析器的能力在同一个 XML配置文件中验证 xml id 引用,没有匹配的元素,xml 解析器就会产生一个 error, 所以如果引用的 bean 在同一个 XML配置 文件中 , 那么用 local 形式是最好的选择 .
2 、可以这么说,<ref bean> 是寻找所有 XML配置文件中的 bean; <ref local> 是寻找本 xml 文件中的 bean.
3 、<ref> 提供了如下几方面的属性 :
1)bean: 在当前 Spring XML 配置文件中，或者在同一 BeanFactory(ApplicationContext) 中的其他 JavaBean 中寻找引入的BEAN.
2)local: 仅在当前 Spring XML 配置文件中寻找引入的BEAN.
如果借助于 Spring IDE, 则在编译期可以对其依赖的 JavaBean 进行验证。基于 local 方式，开发者能够使用到 XML 本身提供的优势，而进行验证。 3)parent: 用于指定其依赖的父 JavaBean 定义。

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

时间： 2024-08-08 07:09:44

【Spring】IOC容器之bean之间的关系的相关文章

3.spring：自动装配/Bean之间的关系/作用域/外部文件/spel/

1.自动装配/手动装配 xml配置文件里的bean自动装配 Spring IOC 容器里可以自动的装配Bean,需要做的仅仅是在<bean>的autowire属性里面指定自动装配模式 ->byType(根据类型自动进行装配):若IOC容器里需要有多个与目标Bean类型一样的Bean,在这种情况子下,Spring无法判定那个Bean合适,所以不能执行自动装配 ->byName(根据名称自动装配):必须将目标Bean的名称和属性名设置完全相同, ->constuuctor(通过是

Spring学习记录(四)---bean之间的关系：继承、依赖

     继承 这里说的继承和java的继承是不一样的,不是父类子类.但思想很相似,是父bean和子bean 1.父bean是一个实例时.它本身是一个完整的bean 2.父bean是模板,抽象bean,不能被实例化,只是来被继承. 当遇到一个类要实例化出很多相似的bean对象时,如下,看起来是不是很不简洁 1 <bean id="address1" class="com.guigu.spring.autowire.Address" 2 p:city="

Spring学习--Bean 之间的关系

Bean 之间的关系:继承.依赖. Bean 继承: Spring 允许继承 bean 的配置 , 被继承的 bean 称为父 bean , 继承这个父 bean 的 bean 称为子 bean. 子 bean 从父 bean 中继承配置 , 包括 bean 的属性配置. 子 bean 也可以覆盖从父 bean 继承过来的配置. 父 bean 可以作为配置模板 , 也可以作为 bean 实例.若只想把父 bean 作为模板 , 可以设置 <bean> 的 abstract 属性为 true ,

Spring Bean之间的关系

bean之间的关系:继承和依赖继承bean的配置 Spring允许继承bean的配置,被继承的bean称为父bean,继承这个父bean的bean称为子bean 子bean从父bean中继承配置,包括bean的属性配置 子bean也可以覆盖从父bean继承过来的配置 父bean可以作为配置模版,也可以作为bean实例,若只想把父bean作为模板,可以设置<bean>的abstract属性为true,这样Spring将不会实例化这个bean 并不是<bean>元素里的所有属性都会被继

Spring初学之bean之间的关系和bean的作用域

一.bean之间的关系 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.o

介绍 Spring IoC 容器和 bean

简介 本章涵盖了 Spring Framework实现控制翻转 (IoC) 的原则. IoC 有时也被称为依赖注入 (DI).这是一个对象定义他们依赖的过程,其中对象之间的相关性,也就是说,它们一起工作,只能通过构造函数参数,参数工厂方法或设置在其构造后的对象实例或者是从一个工厂方法返回的对象实例的属性上.容器在创建的 bean 注入这些依赖.这个过程是根本的反转,因此称为控制反转(IoC),bean 本身通过直接构造类,或作为 Service Locator(服务定位器)模式的机制,来控制其依

Bean之间的关系

Bean之间的关系:继承:依赖 [继承Bean的配置] 1.Spring允许继承bean的配置,被继承的bean称为父bean.继承这个父bean的Bean称为子bean. 2.子Bean从父Bean中继承配置,包括Bean的属性配置. 3.子Bean也可以覆盖从父Bean继承过来的配置. /spring-1/src/beans-relation.xml: 1 <bean id="address" class="com.hk.beans.autowire.Address

Spring框架参考手册翻译——第三部分 核心技术 6.1 Spring IoC容器和bean的介绍

第三部分 核心技术 这部分参考文档涵盖的这些技术是Spring Framework绝对重要的. 其中最重要的要数Spring框架的控制反转(IoC)容器.深入剖析Spring框架IoC容器之后,紧接着要介绍的是Spring面向切面编程(AOP)技术.Spring框架拥有自己的AOP框架,从概念上很容易理解,并且成功地解决了AOP在Java企业级编程中80%的痛点需求. 还提供了Spring与AspectJ(目前在功能上最丰富,在Java企业领域最成熟的AOP实现)的集成. 第六章,IoC容器 第

峰Spring4学习（5）bean之间的关系和bean的作用范围

一.bean之间的关系: 1)继承: People.java实体类: package com.cy.entity; public class People { private int id; private String name; private int age; private String className; public int getId() { return id; } public void setId(int id) { this.id = id; } public Strin