1 Spring 框架搭建

Spring Jar包地址 http://repo.springsource.org/libs-release-local/org/springframework/spring/
以Spring4为例，下载后，有如下结构：

* docs : API 和开发规范 . 
* libs : jar 包和源码 . 
* schema : 约束 .

Spring框架如图所示，我们使用其核心包 Core Container

核心包如下

lib
    |--com.springsource.org.apache.commons.logging-1.1.1.jar  "Log
    |--com.springsource.org.apache.log4j-1.2.15.jar  "Log
    |--spring-beans-4.2.4.RELEASE.jar  "Beans
    |--spring-context-4.2.4.RELEASE.jar    "Context
    |--spring-core-4.2.4.RELEASE.jar    "Core
    |--spring-expression-4.2.4.RELEASE.jar    "SpEL

Eclipse中建立Java Web项目，点击Finish后，将相关Jar包复制到lib目录下

创建bean class，添加元素并生成set/get方法

public class User {

    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

在src下创建applicationContext.xml文件，可以先为其添加约束

在文件中，引入bean，指定class位置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://www.springframework.org/schema/beans" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">

    <bean  name="user" class="com.ibso.bean.User" ></bean>  
</beans>

创建测试类，test注解通过ctrl + 1引入junit包，运行测试

public class Demo { 
    @Test
    public void fun1(){
        //1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 向容器"要"user对象
        User u = (User) ac.getBean("user");
        //3 打印user对象
        System.out.println(u);      
    }
    
}

2 Spring 思想

IOC和 DI:

IOC:控制反转 ,将对象的创建权交给了Spring.
DI (Dependency Injection): 依赖注入，需要有IOC的环境，Spring 创建这个类的过程中，Spring将类的依赖的属性设置进去.

Spring 的工厂 (容器 ):

ApplicationContext:
下面有两个实现类
ClassPathXmlApplicationContext:加载类路径下 Spring 的配置文件 .
FileSystemXmlApplicationContext :加载本地磁盘路径下 Spring 的配置文件 .
ApplicationContext :在加载 applicationContext.xml (容器启动 )时候就会创建 .
BeanFactory :是在 getBean 的时候才会生成类实例 .

3 Spring配置详解

3.1 Bean元素

3.1.1 Bean元素属性

Bean元素:使用该元素描述需要spring容器管理的对象
<bean name="user" class="com.ibso.bean.User" ></bean>
class属性:被管理对象的完整类名.
name属性:给被管理的对象起个名字.获得对象时根据该名称获得对象，可以重复.可以使用特殊字符.
id属性: 与name属性一模一样，名称不可重复.不能使用特殊字符.
结论: 尽量使用name属性.

3.1.2 对象创建方式

1 空参创建
<bean name="user" class="cn.itcast.bean.User"></bean>
2 静态工厂创建：调用UserFactory的createUser方法创建名为user2的对象放入容器
<bean name="user2" class="cn.itcast.b_create.UserFactory" factory-method="createUser" ></bean>
3 实例工厂创建：调用UserFactory对象的createUser2方法创建名为user3的对象放入容器，实例工厂类userFactory也需要加入到bean

    <bean  name="user3" 
        factory-bean="userFactory"
        factory-method="createUser2" ></bean>
        
    <bean  name="userFactory" 
        class="cn.itcast.b_create.UserFactory"   ></bean>

3.1.3 Scope属性:Bean的作用范围

Scope属性有如下

* singleton : 默认值，单例. 
* prototype : 多例.
* request : WEB项目中,Spring 创建一个 Bean 的对象 ,将对象存入到 request 域中 . 
* session : WEB项目中,Spring 创建一个 Bean 的对象 ,将对象存入到 session 域中 . 
* globalSession : WEB项目中,应用在Porlet环境.如果没有Porlet环境那么 globalSession相当于session.

<bean name="user" class="com.ibso.bean.User" scope="prototype"></bean>

3.1.4 Bean的生命周期配置

通过配置<bean>标签上的init-method作为Bean的初始化时候执行方法，
配置destroy-method作为Bean的销毁时候执行方法。
销毁方法想要执行，需是单例创建的Bean而且在工厂关闭的时候，Bean才会被销毁.
<bean name="user" class="cn.itcast.bean.User" init-method="init" destroy-method="destory" ></bean>
在user class中添加相应的方法

    public void init(){
        System.out.println("我是初始化方法!");
    }
    public void destory(){
        System.out.println("我是销毁方法!");
    }

3.1.5 分模块配置

在xml文件中引入配置<import resource="com/ibso/b_create/applicationContext.xml"/>
有两种配置方式

1 :创建工厂的时候加载多个配置文件 : ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml"); 
2 :在一个配置文件中包含另： <import resource="com/ibso/b_create/applicationContext.xml"/>

3.2 属性注入

3.2.1 Set注入

值类型注入: 为name属性注入value
引用类型注入：name属性注入ref 的bean对象

    <!-- set方式注入: -->
    <bean  name="user" class="cn.itcast.bean.User" >
        <!--值类型注入: 为User对象中名为name的属性注入tom作为值 -->
        <property name="name" value="tom" ></property>
        <property name="age"  value="18" ></property>
        <!-- 引用类型注入: 为car属性注入下方配置的car对象 -->
        <property name="car"  ref="car" ></property>
    </bean>
    <!-- 将car对象配置到容器中 -->
    <bean name="car" class="cn.itcast.bean.Car" >
        <property name="name" value="兰博基尼" ></property>
        <property name="color" value="黄色" ></property>
    </bean>

3.2.2 构造方法注入

构造方法注入将调用User类的构造方法，参数位置可以用index标识，存在多个构造方法不同参数类型时，用type来标识

<bean name="user2" class="cn.itcast.bean.User" >
    <!-- name属性: 构造函数的参数名 -->
    <!-- index属性: 构造函数的参数索引 -->
    <!-- type属性: 构造函数的参数类型-->
    <constructor-arg name="name" index="0" type="java.lang.Integer" value="999"  ></constructor-arg>
    <constructor-arg name="car" ref="car" index="1" ></constructor-arg>
</bean>

    public User(String name, Car car) {
        System.out.println("User(String name, Car car)!!");
        this.name = name;
        this.car = car;
    }
    
    public User(Car car,String name) {
        System.out.println("User(Car car,String name)!!");
        this.name = name;
        this.car = car;
    }
    
    public User(Integer name, Car car) {
        System.out.println("User(Integer name, Car car)!!");
        this.name = name+"";
        this.car = car;
    }

3.2.3 p名称空间注入

走set方法
1.导入P名称空间 xmlns:p="http://www.springframework.org/schema/p"
2.使用p:属性完成注入

<!-- p名称空间注入, 走set方法
    1.导入P名称空间  xmlns:p="http://www.springframework.org/schema/p"
    2.使用p:属性完成注入
        |-值类型: p:属性名="值"
        |-对象类型: p:属性名-ref="bean名称"  -->
    <bean  name="user3" class="cn.itcast.bean.User" p:name="jack" p:age="20" p:car-ref="car"  >
    </bean>

3.2.4 spel注入

spel注入: spring Expression Language sping表达式语言
通过#{user.name}取user对象的name值，#{user3.age}取user3对象的age值，注入到user4

<bean  name="user4" class="cn.itcast.bean.User" >
        <property name="name" value="#{user.name}" ></property>
        <property name="age" value="#{user3.age}" ></property>
        <property name="car" ref="car" ></property>
</bean>

<property name ="price" value ="#{80}" />将80注入到price属性

3.2.5 复杂类型注入

当bean中有复杂对象时，

public class CollectionBean {
    private Object[] arr;//数组类型注入
    private List list;//list/set 类型注入
    private Map map;//map类型注入
    private Properties prop;//properties类型注入

通过以下方式注入

<bean name="cb" class="cn.itcast.c_injection.CollectionBean" >
    <!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 
    <property name="arr" value="tom" ></property>
    -->
    <!-- array注入,多个元素注入 -->
    <property name="arr">
        <array>
            <value>tom</value>
            <value>jerry</value>
            <ref bean="user4" />
        </array>
    </property>
    
    <!-- 如果List中只准备注入一个值(对象),直接使用value|ref即可 
    <property name="list" value="jack" ></property>-->
    <property name="list"  >
        <list>
            <value>jack</value>
            <value>rose</value>
            <ref bean="user3" />
        </list>
    </property>
    <!-- map类型注入 -->
    <property name="map"  >
        <map>
            <entry key="url" value="jdbc:mysql:///crm" ></entry>
            <entry key="user" value-ref="user4"  ></entry>
            <entry key-ref="user3" value-ref="user2"  ></entry>
        </map> 
    </property>
    <!-- prperties 类型注入 -->
    <property name="prop"  >
        <props>
            <prop key="driverClass">com.jdbc.mysql.Driver</prop>
            <prop key="userName">root</prop>
            <prop key="password">1234</prop>
        </props>
    </property>
</bean>