Spring IoC控制反转

创建Spring项目的步骤

1.新建 java project
2.导入jar:
必须的jar:
1)spring的核心：spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)日志：commons-logging.jar
可选的：
1)日志的实现：log4j.jar
2)单元测试：junit.jar
3.定义接口和实现类（可没有接口）：和没有使用框架一样定义
4.定义spring的配置文件(myobject.txt)
1）加入约束文件spring-beans.xsd
2）声明bean对象。 bean对象就是java对象
bean:在spring中把java对象称为bean.
5.定义测试类，在代码中使用spring
创建接口ApplicationContext，表示spring框架
实体类不适合交由Spring容器创建，通常用来保存数据库中的数据，常常变化

applicationContext.xml文件的三个位置以及三种创建容器的方式

xml文件和src是同级目录

String configLocation = "applicationContext.xml";
ApplicationContext cxt = new ClassPathXmlApplicationContext(configLocation);
SomeService service = (SomeService) cxt.getBean("service");
service.doService();

xml文件建立在项目的根目录下

String configLocation = "applicationContext.xml";
ApplicationContext cxt = new FileSystemXmlApplicationContext(configLocation);
SomeService service = (SomeService) cxt.getBean("service");
service.doService();

xml文件建立在磁盘的目录上

String configLocation = "E:/applicationContext.xml";
ApplicationContext cxt = new FileSystemXmlApplicationContext(configLocation);
SomeService service = (SomeService) cxt.getBean("service");
service.doService();

Bean的装配

Bean 的装配，即 Bean 对象的创建。容器根据代码要求创建 Bean 对象后再传递给代码的过程，称为 Bean 的装配，在创建spring容器对象的时候，会创建spring配置文件中的所有对象

默认装配方式

代码通过 getBean()方式从容器获取指定的 Bean 实例，容器首先会调用 Bean 类的无参构造器，如果没有无参构造器，会发生异常

Bean的作用域

当通过 Spring 容器创建一个 Bean 实例时，不仅可以完成 Bean 的实例化，还可以通过scope 属性，为 Bean 指定特定的作用域。Spring 支持 5 种作用域。
（1）singleton：单态模式。即在整个 Spring 容器中，使用 singleton 定义的 Bean 将是单例的，只有一个实例。默认为单态的。
单例作用域：存在范围是和容器对象一样
*单例作用域的对象创建时间？在创建容器对象时，会创建好所有的单例对象。
* 创建好的对象放入到Spring的Map中。
* 优点：获取对象的速度快。
* 缺点：占内存。
（2）prototype：原型模式。即每次使用 getBean 方法获取的同一个的实例都是一个新的实例。
原型作用域的对象在什么时候创建的？
* 在执行getBean()方法的时候才创建对象， 原型作用域是把对象的创建
* 时间延迟了，延迟到使用对象的时候
* 优点：不占内存
* 缺点：获取对象的速度慢

 <!-- 指定bean对象的作用域：作用域指对象的存在范围和可见性。
1.singleton:单例，在spring容器中对象只有一个，默认值。
        如何指定单例：
<bean id="xx" class="yyy" scope="singleton"/>

2.prototype:原型,每次使用getBean()都获取到一个新的对象
      如何指定原型：
<bean id="xx" class="yyy" scope="prototype"/>
 -->

定制 Bean 的生命始末

可以为 Bean 定制初始化后的生命行为，也可以为 Bean 定制销毁前的生命行为

<!-- 定义bean的生命始末方法：自定义方法参与到spring创建和销毁对象的过程中。
1）在java类中定义方法， 方法的原型： public void 方法名自定义的(无参数){ 。。。}
2）在定义bean对象的时候，告诉spring两个方法的存在
<bean id="xx" class="yyy" init-method="bean的初始化的方法名"
destory-method="bean销毁之前执行的方法名" >
初始化和销毁两个方法之间没有依赖关系，需要哪一个就用哪一个
-->

注意，若要看到 Bean 的 destroy-method 的执行结果，需要满足两个条件：
（1）Bean 为 singleton，即单例
（2）要确保容器关闭。接口 ApplicationContext 没有 close()方法，但其实现类有。所以，可以将 ApplicationContext 强转为其实现类对象，或直接创建的就是实现类对象

基于XML的DI

bean 实例在调用无参构造器创建了空值对象后，就要对 bean 对象的属性进行初始化。
初始化是由容器自动完成的，称为注入。
根据注入方式的不同，常用的有两类：设值注入、构造注入。
设置注入分为了两步：调用无参构造创建对象，通过反射调用set方法赋值； 构造注入只需要一步：调用构造方法，创建对象的同时赋值，也就是说，在设值注入时，需要含有无参的构造方法，而在构造注入时，需要有有带参数的构造方法，不需要含有无参构造方法

设值注入

<!-- 设值注入：调用类中的set方法完成属性赋值
1） 简单类型：spring中把String和java基本数据类型，称为简单类型。
      简单类型的设值注入：
<bean id="xxx" class="yyy">
<property name="属性名" value="简单类型的属性值"/>
<property name="属性名" value="简单类型的属性值"/>
...
</bean>

2）引用类型的设值注入
      语法1：使用ref作为属性
<bean id="xxx" class="yyy">
<property name="属性名" ref="bean的id"/>
</bean>

     语法2：使用ref作为子标签
<bean id="xx" class="yyy">
<property name="属性名">
 <ref bean="bean的id"/>
</property>
</bean>
-->

构造注入

构造注入：spring调用类的有参数构造方法，在构造方法中给属性赋值。
语法：使用表示构造方法的参数。
一个构造方法的参数对应一个标签
有三种方式：
使用name属性
使用index属性
省略index属性

给具有集性质的属性赋值
什么类型的属性，就用什么类型的子标签，
集合中是简单类型就用value， 是对象类型就用ref

 <bean id="myCollections" class="com.bjpowernode.ba04.MyCollections">
        <!-- Array<String> -->
     	<property name="mystr">
     		<array>
     			<value>大兴区</value>
     			<value>朝阳区</value>
     		</array>
     	</property>
     	
     	<!-- Set<String> -->
     	<property name="myset">
     		<set>
     			<value>北京</value>
     			<value>上海</value>
     			<value>杭州</value>
     		</set>
     	</property>
     	
     	<!-- List<Student> -->
     	<property name="mylist">
     		<list>
     			<ref bean="myStudent"/>
     			<ref bean="myStudent1"/>
     			<ref bean="myStudent2"/>
     		</list>
     	</property>
     	
     	<!-- Map<String,Integer> -->
     	<property name="mymap">
     		<map>
     			<entry key="weight" value="80" /> <!-- key-value -->
     			<entry key="height" value="180" />
     		</map>
     	</property>
     	
     	<!-- Properties -->
     	<property name="myprop">
     		<props>
     			<prop key="tel">010-14678979</prop> <!-- key-value -->
     			<prop key="phone">1234578978</prop>
     		</props>
     	</property>
     	
     	<!-- List<Map<String,String>> -->
     	<property name="mylistmap">
     		<list>
     			<map> <!-- 0 -->
     				<entry key="weight" value="80kg" />
     				<entry key="height" value="180cm" />
     			</map>
     			
     			<map> <!-- 1 -->
     				<entry key="tel" value="1534879" />
     				<entry key="phone" value="1649879" />
     			</map>
     		</list>
     	
     	</property>
     </bean>
     
     
     <!-- 构造注入， 使用name属性-->
     <bean id="myStudent" class="com.bjpowernode.ba04.Student">
     	 <constructor-arg name="myage" value="22" />
     	 <constructor-arg name="myname" value="张三" />
     	 <constructor-arg name="myXueXiao" ref="mySchool" />
     </bean>
    
    
    <!-- 构造注入，使用index属性 -->
    <bean id="myStudent1" class="com.bjpowernode.ba04.Student">
    	 <constructor-arg index="1" value="26" />
    	 <constructor-arg index="0" value="李四" />
    	 <constructor-arg index="2" ref="mySchool" />
    </bean>
     
    <!-- 构造注入，省略index -->
    <bean id="myStudent2" class="com.bjpowernode.ba04.Student">
    	 <constructor-arg  value="周丽" />
    	 <constructor-arg  value="20" />
    	 <constructor-arg  ref="mySchool" />
    </bean>
     
     <bean id="mySchool" class="com.bjpowernode.ba04.School">
     	<property name="name" value="清华大学" />
     	<property name="address" value="北京的海淀区" />
     </bean>