Spring

Spring是什么?

是一个开源的、用于简化企业级应用开发的应用开发框架。
a.简化开发:
Spring框架对很多常用的api做了简化，比如，使用Spring jdbc
(Spring jdbc是Spring框架中的一个模块)访问数据库，不再需要
考虑如何获取连接、关闭连接、处理异常等等。

b.提高了系统的维护性:
Spring容器(Spring框架中的一个模块)帮我们创建对象、并且管理
对象之间依赖关系。这样一来，对象之间的耦合性大大降低，提高
了系统的维护性。

c.可以集成其它的框架:
Spring框架提供了集成其它常用框架的功能，比如，要使用
任务调度功能、就可以将Quartz和Spring进行集成。

Spring容器

(1)什么是Spring容器?

Spring容器(Spring框架中的一个模块)帮我们创建对象、并且管理 对象之间依赖关系。

(2)如何启动Spring容器?

**step1.导包。**

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>3.2.8.RELEASE</version>
</dependency>

step2.添加Spring配置文件。

配置文件用来告诉容器，如何创建对象、如何建立对象之间的依赖关系等等。

step3.启动容器。

  /*
     * 启动Spring容器。
     * ApplicationContext是一个接口，定义了Spring
     * 容器的基本功能。
     * ClassPathXmlApplicationContext是一个实现了
     * ApplicationContext接口的类，该类会依据类路径
     * 来查找Spring配置文件，然后启动容器。
     */
    ApplicationContext ac = 
        new ClassPathXmlApplicationContext(
                "applicationContext.xml");
    System.out.println("ac:"  + ac);

(3)创建对象

1)方式一 使用无参构造器。

**step1.**为类添加无参构造器(或者缺省构造器)。

**step2.**在配置文件当中，使用bean元素进行配置。

<!-- 
    使用无参构造器创建对象。
    其中,id属性值要求唯一,class属性要写类的完整的名字。
 -->

**step3.**启动Spring容器，调用容器提供的getBean方法来获得
对象。

Student stu = ac.getBean("stu1",Student.class);

2)方式二 使用静态工厂方法。

<!--
    使用静态工厂方法来创建对象 。
    factory-method属性用来指定静态方法名，
    容器会调用该类的静态方法来创建对象。
    以下配置，容器会调用Calendar.getInstance()
    方法，该方法会返回一个对象。
 -->
<bean id="cal1" class="java.util.Calendar" 
factory-method="getInstance"/>

3)方式三 使用实例工厂方法。

<!-- 
    使用实例工厂方法来创建对象。
    factory-bean属性值是一个bean的id,
    factory-method属性指定方法名。
    以下配置，容器会调用id为cal1的bean的
    getTime方法。
    注：
        bean指的是由容器所管理的对象。
 -->
<bean id="time1" factory-bean="cal1" 
factory-method="getTime"/>

(4)作用域
容器默认情况下，对于某个bean元素，只会创建一个实例。
可以修改bean的作用域，将作用域设置为"prototype"，容器 就会创建多个实例。

<!-- 
        scope属性用来设置bean的作用域。
        缺省值是"singleton",只会创建一个实例；
        如果值为"prototype",则会创建多个实例(每调用一次
        getBean方法，就会创建一个)。

        singleton:单例。
        prototype:原型。
-->
<bean id="sb1" class="basic.ScopeBean" 
scope="prototype"/>

(5)生命周期
容器在创建好相应的对象之后，会调用该对象的初始化方法， 在销毁该对象之前，会调用该对象的销毁方法。
可以使用init-method属性和destroy-method属性来指定 初始化方法和销毁方法的名称。

  <!-- 
        scope属性用来设置bean的作用域。
        缺省值是"singleton",只会创建一个实例；
        如果值为"prototype",则会创建多个实例(每调用一次
        getBean方法，就会创建一个)。

        singleton:单例。
        prototype:原型。
     -->
    <bean id="sb1" class="basic.ScopeBean" 
    scope="prototype"/>

    <!--
        init-method属性用于指定初始化方法名。
        destroy-method属性用于指定销毁方法名。
        注：
            容器在删除对象之前，会先调用该对象的
            销毁方法。 
            只有作用域为singleton的bean,销毁方法
            才会执行。
     -->
    <bean id="ms1" class="basic.MessageService" 
    init-method="init" destroy-method="destroy"
    scope="singleton"/>

(6)延迟加载
默认情况下，容器启动之后，会将所有作用域为"singleton"的 bean实例化。
可以将lazy-init属性值设置为true,容器启动之后，不再创建这些 实例了(只有调用了getBean方法才会创建)。

<!-- 
    lazy-init属性用来设置是否延迟加载，
    如果值为true，表示延迟加载。
 -->

<bean id="lb1" class="basic.LazyBean" 
lazy-init="true"/>

IOC和DI

(1)什么是IOC(Inversion Of Control 控制反转)?

对象之间的依赖关系应该由容器来建立。

(2)什么是DI(Dependency Injection 依赖注入)?

容器可以通过调用set方法或者构造器来建立对象之间的依赖关系。
注：
IOC是目标，DI是手段。

(3)使用set方法来建立依赖关系。

  <!-- 
        配置set方法注入。
        property元素的name属性用于指定set方法名
        (首字母大写，前面添加set),ref属性用于
        指定被注入的bean的id。
     -->
    <bean id="a1" class="ioc.A">
        <property name="b" ref="b1"/>
    </bean>

(4)使用构造器来注入

   <bean id="wt1" class="ioc.Waiter"/>
    <!-- 
        配置构造器注入。
        constructor-arg的index属性用来指定参数的下标,
        ref属性用来指定被注入的bean的id。
     -->
    <bean id="rest1" class="ioc.Restaurant">
        <constructor-arg index="0" ref="wt1"/>
    </bean>

(5)自动装配

a.自动装配指的是，容器按照某种规则，自动建立对象之间的依赖关系。
即不用明确指定被注入的bean的id。
容器底层仍然需要调用set方法或者构造器来完成依赖关系的建立。

b.容器默认情况下，是不会自动装配的。

  <bean id="eg1" class="autowire.Enginee"/>
    <!-- 
        autowire属性用于指定自动装配的方式，有三个值:
        byName: 
            容器以属性名作为bean的id来查找对应的
            bean，找到之后，调用set方法来完成注入。
            注：
                如果找不到对应的bean,则不注入。
        byType:
            容器以属性类型作为bean的类型来查找对应的
            bean,找到之后，调用set方法来完成注入。
            注：
                如果找不到对应的bean,则不注入。
                如果找到多个，则会出错。
        constructor:
            类似byType,只不过调用构造器来完成注入。
     -->
    <bean id="car" class="autowire.Car" 
    autowire="byType"/>

(6)注入基本类型的值

    <!-- 
        注入基本类型的值(包括String)，使用
        value属性。
     -->
<bean id="v
b1" class="value.ValueBean">
        <property name="name" value="花花"/>
        <property name="age" value="20"/>
    </bean>

(7)注入集合类型的值

  <bean id="vb1" class="value.ValueBean">
        <property name="name" value="鲁班"/>
        <property name="age" value="20"/>
        <property name="interest">
            <list>
                <value>钓鱼</value>
                <value>做饭</value>
                <value>游泳</value>
                <value>看电视</value>
            </list>
        </property>
        <property name="city">
            <set>
                <value>北京</value>
                <value>洛阳</value>
                <value>南京</value>
            </set>
        </property>
        <property name="score">
            <map>
                <entry key="english" value="60"/>
                <entry key="math" value="1"/>
            </map>
        </property>
        <property name="db">
            <props>
                <prop key="username">Tom</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>

若list中装的是对象,<ref  bean=“该对象的id”/>

(8)引用的方式注入集合类型的值

 <util:list id="interestBean">
        <value>抽烟</value>
        <value>喝酒</value>
        <value>烫头</value>
    </util:list> 
    <util:set id="cityBean">
        <value>长沙</value>
        <value>岳阳</value>
        <value>华容</value>
    </util:set>
    <util:map id="scoreBean">
        <entry key="english" value="90"/>
        <entry key="math" value="80"/>
    </util:map>
    <util:properties id="dbBean">
        <prop key="username">Sally</prop>
        <prop key="password">test</prop>
    </util:properties>
    <bean id="vb2" class="value.ValueBean">
        <property name="interest" 
        ref="interestBean"/>
        <property name="city"
        ref="cityBean"/>
        <property name="score"
        ref="scoreBean"/>
        <property name="db"
        ref="dbBean"/>
    </bean>

(9)读取properties文件的内容

 <!-- 
        读取.properties文件的内容。
        location属性指定properties文件的位置，
        容器会读取指定文件的内容，然后将这些内容添加到了
        Properties对象里面。
     -->
     <util:properties id="config" 
     location="classpath:config.properties"/>

(10)Spring表达式