<bean id="boy" class="com.dueeast.a_ioc.Boy" scope="prototype">

  </bean>

<bean id="girl" class="com.dueeast.a_ioc.Girl">

<property name="boy">

<ref bean="boy"/>

</property>

</bean>

前提是在com.dueeast.a_ioc.Girl 中，有对com.dueeast.a_ioc.Boy这个类的set方法↓

public class Girl {

Boy boy;

public void setBoy(Boy boy) {

this.boy = boy;

}

public void kiss(){

boy.display();

System.out.println("kiss");

}

}

就可以这样使用了↓

public class App {

public static void main(String[] args) {

BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\10.7MyEclipseSpace\\BlogTest\\src\\beans.xml"));

Girl girl = (Girl) ac.getBean("girl");

girl.kiss();

}

}

以上是DI依赖注入的简单演示

-----------------------------------------------------------------------------------------------------------------------

在楼上代码中，下面这一句实例化了Spring的容器。

BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\10.7MyEclipseSpace\\BlogTest\\src\\beans.xml"));

实例化Spring容器一共有四种方式↓

（1）加载一个spring容器

ApplicationContext ac = new ClassPathXmlApplicationContext("容器全路径");

（2）加载多个spring容器

ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"容器全路径"});

（3）从外部文件系统加载容器

ApplicationContext ac = new FileSystemXmlApplicationContext("容器在本地磁盘的绝对路径");

（4）使用BeanFactory的用法

BeanFactory ac = new XmlBeanFactory(new FileSystemResource("容器在本地磁盘的绝对路径"));

项目中最常用是使用ApplicationContext和ClassPathXmlApplicationContext，一般不使用BeanFactory

ApplicationContext是对BeanFactory扩展，提供了更多功能

1、国际化处理

2、事件传递

3、Bean自动装配

4、各种不同应用层的Context实现

创建对象的作用于模式：

单例模式singleton(默认值) 

l 如果是单例的话，将spring中bean元素节点的scope设置成singleton，加载spring容器的时候，就会加载对应的构造方法，此时构造方法只执行1次，表示单例

l 在spring容器中配置：lazy-init="false"（默认值）；表示只要加载spring容器，此时就会立即加载构造对象的方法。

l 在spring容器中配置：lazy-init="true"；表示只有调用对应对象的时候，才会初始化对应的构造方法。

l 如果在spring容器中的beans节点配置default-lazy-init="false"（默认值），对全局所有的bean都有效

多例模式prototype（整合由于struts2是多例，在spring容器创建Action对象的时候，将其设置多例）

l 如果是单例的话，将spring中bean元素节点的scope设置成prototype，加载spring容器的时候，不会加载执行对应对象的构造方法，此时只有调用对应对象的时候，才会执行对应的构造方法，执行多次，表示多例

l 多例中不会存在lazy-init属性，因为没有意义

* request每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境（一个系统request.setAttribute () ）

* session同一个HTTP Session 共享一个Bean，不同Session使用不同Bean，仅适用于WebApplicationContext 环境（一个系统session.setAttribute()）

* global session一般用于Porlet应用环境，该作用域仅适用于WebApplicationContext 环境（多个系统共享一个session）

------------------------------------------------------------------------------------------

依赖注入详解

1、在类中的属性需要设置set方法(用以下javabean演示，set方法因过多而省略)

private Integer id;

private String name;

private Person person;

private List<Object> list;

private Object[] arrays;

private Set<Object> set;

private Map<String, Object> map;

private Properties properties;

//spring整合hibernate的时候，都可以在容器中使用Properties集合完成对hibernate的操作

private List<Object> listnull = new ArrayList<Object>();

2、在spring的容器中定义：

<bean id="person" class="h_setXml.Person" p:pid="30" p:pname="酸菜"></bean>

<bean id="userService" class="h_setXml.UserServiceImpl">

<!-- 1:配置bean的简单属性，基本数据类型和String。 -->

<property name="id" value=http://www.mamicode.com/"10"></property>

<property name="name" value=http://www.mamicode.com/"翠花"></property>

<!-- 

2:注入对象，引用其它bean（外部bean）

结论：项目开发时都会使用外部注入，因为由外部创建对象，容器中的其他对象都可以调用

如果是内部调用，只能在当前bean中才能使用

-->

<property name="person" ref="person"></property> 

<!-- 2:注入对象，内部bean 

<property name="person">

<bean class="cn.itcast.h_setXml.Person"></bean>

</property>-->

<!-- 3:测试p空间，为对象中的属性赋值 -->

<!-- 4:注入集合，A、装配List和数组(通用): -->

<property name="list">

<list>

<value>list001</value>

<value>list002</value>

<ref bean="person"/>

</list>

</property>

<property name="arrays">

<array>

<value>array001</value>

<value>array002</value>

<ref bean="person"/>

</array>

</property>

<!-- 4:注入集合， B、 装配set： -->

<property name="set">

<set>

<value>set001</value>

<value>set002</value>

<ref bean="person"/>

</set>

</property>

<!-- 4:注入集合，装配集合 C、 装配map： -->

<property name="map">

<map>

<entry key="key001">

<value>mapValue001</value>

</entry>

<entry key="key002">

<value>mapValue002</value>

</entry>

<entry key="key003">

<ref bean="person"/>

</entry>

</map>

</property>

<!-- 5:注入集合，D、装配Properties：值不可以是对象 -->

<property name="properties">

<props>

<prop key="prop001">propValue001</prop>

<prop key="prop002">propValue002</prop>

</props>

</property>

<!-- 6:设置空值 -->

<property name="listnull">

<null/>

</property>

</bean>

3、注入构造器并在类中使用构造器

在spring容器中定义：

<bean id="userService" class="i_constructorXml.UserServiceImpl">

<!-- 

constructor-arg：构造器函数注入的方式

  * index:构造器方法中参数的位置，0表示第1个位置

  * type:表示构造器方法中参数的类型，类型可以写成java的类型

  * 要求：

  1：按照位置注入：如果使用参数的位置注入，需要注入的值要符合构造方法参数的类型

  2：按照参数类型注入：根据构造函数参数的位置不同，可能会注入到不同的构造方法

<!-- 结论：当使用构造器函数的时候，可以使用即按照类型指定，同时也按照参数的位置指定 -->

<constructor-arg type="java.lang.String" index="1">

<value>1</value>

</constructor-arg>

<constructor-arg type="java.lang.String" index="0">

<value>翠花</value>

</constructor-arg>

</bean>

在类中使用构造函数，注入参数的值

public UserServiceImpl(String name,Integer id){

System.out.println("先String再Integer");

this.id = id;

this.name = name;

}

public UserServiceImpl(Integer id,String name){

System.out.println("先Integer再String");

this.id = id;

this.name = name;

}

public UserServiceImpl(String name,String education){

System.out.println("先String再String");

this.name = name;

this.education = education;

}