Spring Framework的基本認(rèn)識(shí)

一. spring(春天)的簡(jiǎn)介

Spring Framework 是一個(gè)開(kāi)源的Java／Java EE全功能棧（full-stack）的應(yīng)用程序框架.最初由Rod Johnson和Juergen Hoeller等開(kāi)發(fā)。Spring Framework提供了一個(gè)簡(jiǎn)易的開(kāi)發(fā)方式，這種開(kāi)發(fā)方式允青，將避
免那些可能致使底層代碼變得繁雜混亂的大量的屬性文件和幫助類(lèi),是一個(gè)輕量級(jí)的Java開(kāi)發(fā)框架.
    spring為了解決企業(yè)應(yīng)用開(kāi)發(fā)的復(fù)雜性而創(chuàng)建的农渊。框架的主要優(yōu)勢(shì)之一
    就是其分層架構(gòu)，分層架構(gòu)允許使用者選擇使用哪一個(gè)組件，同時(shí)為
     J2EE 應(yīng)用程序開(kāi)發(fā)提供集成的框架。
    * Spring使用基本的JavaBean來(lái)完成以前只可能由EJB完成的事情剥懒。然而，Spring的用途不僅限于服務(wù)器端的開(kāi)發(fā)合敦。從簡(jiǎn)單性初橘、可測(cè)試性和松耦合的角度而言，任何Java應(yīng)用都可以   從Spring中受益充岛。
    * Spring的核心是控制反轉(zhuǎn)（IoC）和面向切面（AOP）保檐。
    
    * EE開(kāi)發(fā)分成三層結(jié)構(gòu)
        * WEB層(view)   -- Spring MVC
        * 業(yè)務(wù)層(service)   -- Bean管理:(IOC)
        * 持久層(dao)   -- Spring的JDBC模板.ORM模板用于整合其他的持久層框架

        
  Spring框架，可以解決對(duì)象創(chuàng)建以及對(duì)象之間依賴(lài)關(guān)系的一種框架崔梗。且可以和其他框架一起使用夜只；Spring與Struts,  Spring與hibernate(起到整合（粘合）作用的一個(gè)框架)
  
Spring提供了一站式解決方案：
    1） Spring Core  spring的核心功能： IOC容器, 解決對(duì)象創(chuàng)建及依賴(lài)關(guān)系
    2） Spring Web  Spring對(duì)web模塊的支持。
                        -→ 可以與struts整合,讓struts的action創(chuàng)建交給spring
                        -→ spring mvc模式
    3） Spring DAO  Spring 對(duì)jdbc操作的支持  【JdbcTemplate模板工具類(lèi)】
    4） Spring ORM  spring對(duì)orm的支持： 
                        → 既可以與hibernate整合蒜魄，【session】
                        → 也可以使用spring的對(duì)hibernate操作的封裝
    5）Spring AOP  切面編程
    6）SpringEE   spring 對(duì)javaEE其他模塊的支持

1.1 spring的特點(diǎn)

    * 方便解耦扔亥，簡(jiǎn)化開(kāi)發(fā)
        * Spring就是一個(gè)大工廠场躯，可以將所有對(duì)象創(chuàng)建和依賴(lài)關(guān)系維護(hù)，交給Spring管理
    * AOP編程的支持
        * Spring提供面向切面編程旅挤，可以方便的實(shí)現(xiàn)對(duì)程序進(jìn)行權(quán)限攔截踢关、運(yùn)行監(jiān)控等功能
    * 聲明式事務(wù)的支持
        * 只需要通過(guò)配置就可以完成對(duì)事務(wù)的管理，而無(wú)需手動(dòng)編程
    * 方便程序的測(cè)試
        * Spring對(duì)Junit4支持谦铃，可以通過(guò)注解方便的測(cè)試Spring程序
    * 方便集成各種優(yōu)秀框架
        * Spring不排斥各種優(yōu)秀的開(kāi)源框架耘成，其內(nèi)部提供了對(duì)各種優(yōu)秀框架（如：Struts2、Hibernate驹闰、MyBatis、Quartz等）的直接支持
    * 降低JavaEE API的使用難度
        * Spring 對(duì)JavaEE開(kāi)發(fā)中非常難用的一些API（JDBC撒会、JavaMail嘹朗、遠(yuǎn)程調(diào)用等），都提供了封裝诵肛，使這些API應(yīng)用難度大大降低

二. spring兩個(gè)重要概念:IOC容器和AOP概念的理解.

2.1 IOC容器:inverse of control,控制翻轉(zhuǎn),意思是將對(duì)象的創(chuàng)建權(quán)限反轉(zhuǎn)給SpringＲ倥唷！我們代碼中不再像原來(lái)那樣使用new關(guān)鍵字創(chuàng)建對(duì)象

* 使用IOC可以解決的程序耦合性高的問(wèn)題.

下面通過(guò)代碼來(lái)理解IOC容器:

2.2 創(chuàng)建web工程,結(jié)構(gòu)如下

01文件結(jié)構(gòu).png

每個(gè)類(lèi)的關(guān)鍵代碼:

接口就一個(gè)相同的簡(jiǎn)單方法

public void save();

實(shí)現(xiàn)類(lèi)的代碼:

UserDao.class

public class UserDao implements IUserDao{

   @Override
   public void save() {
       // TODO Auto-generated method stub
       System.out.println("保存用戶(hù)成功");
   }
   

UserService.class

public class UserService implements IUserService{
   
   private IUserDao userDao;
   
   @Override
   public void save() {
       // TODO Auto-generated method stub
       /*
        * 不使用IOC容器的寫(xiě)法
        * /
       userDao = new UserDao();
       userDao.save();
       
   }

UserAction.class

public class UserAction implements IUserAction{

   private IUserService userService;
       
   @Override
   public void save() {
       // TODO Auto-generated method stub
       /*
        * 不使用IOC容器的寫(xiě)法
        * */
       userService = new UserService();
       userService.save();
   }
   
   
   public static void main(String[] args) {
       /*
        * 不使用IOC容器的寫(xiě)法
        * /
       IUserAction userAction = new UserAction();
       userAction.save();
   }
   
}   

運(yùn)行工程,console打印輸出:保存用戶(hù)成功

這是傳統(tǒng)的編碼方式,每個(gè)類(lèi)的成員變量到需要相應(yīng)的new,創(chuàng)建出來(lái),耦合性比較強(qiáng).

2.2 使用IOC容器管理對(duì)象的創(chuàng)建.

2.2.1:在原來(lái)的工程上添加spring-core的六個(gè)jar包,并且在src目錄下創(chuàng)建applicationContext.xml文件,jar包add to buil path;

02文件結(jié)構(gòu).png

主要類(lèi)添加set方法:

UserDao.class

public class UserDao implements IUserDao{

   @Override
   public void save() {
       // TODO Auto-generated method stub
       System.out.println("保存用戶(hù)成功");
   }
}

UserService.class

public class UserService implements IUserService{
   
   private IUserDao userDao;
   public void setUserDao(IUserDao userDao) {
       this.userDao = userDao;
   }

   @Override
   public void save() {
       // TODO Auto-generated method stub
       /*
        * 不使用IOC容器的寫(xiě)法
       userDao = new UserDao();
       userDao.save();
       */
       userDao.save();
   }

}

UserAction.class

public class UserAction implements IUserAction{

   private IUserService userService;
   public void setUserService(IUserService userService) {
       this.userService = userService;
   }
   
   @Override
   public void save() {
       // TODO Auto-generated method stub
       /*
        * 不使用IOC容器的寫(xiě)法
       userService = new UserService();
       userService.save();
       */
       
       userService.save();
   }
   
   public static void main(String[] args) {
       /*
        * 不使用IOC容器的寫(xiě)法
       IUserAction userAction = new UserAction();
       userAction.save();
       */
       
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       IUserAction action = (UserAction)ac.getBean("userAction");
       action.save();
   }
}

在applicationContext.xml文件添加bean約束和節(jié)點(diǎn)

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
       
       
    <bean id="userDao" class="com.it.dao.UserDao"></bean>
    <bean id="userService" class="com.it.service.UserService">
       <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userAction" class="com.it.action.UserAction" scope="prototype">
       <property name="userService" ref="userService"></property>
    </bean>
       
</beans>

運(yùn)行工程,console打印輸出:保存用戶(hù)成功.

我們發(fā)現(xiàn),只需要通過(guò)在XML文件中進(jìn)行配置,對(duì)象的創(chuàng)建就交給了spring的IOC容器.我們的代碼就不再需要new 關(guān)鍵字進(jìn)行創(chuàng)建,直接getBean("id")進(jìn)行獲取;這就是IOC的基本體現(xiàn).

引出了另外一個(gè)概念:

• 依賴(lài)注入怔檩， dependency injection 處理對(duì)象的依賴(lài)關(guān)系
• 和控制反轉(zhuǎn)的區(qū)別：

   控制反轉(zhuǎn): 解決對(duì)象創(chuàng)建的問(wèn)題 【對(duì)象創(chuàng)建交給別人】
   依賴(lài)注入: 在創(chuàng)建完對(duì)象后褪秀， 對(duì)象的關(guān)系的處理就是依賴(lài)注入 【通過(guò)set方法依賴(lài)注入】

8.3 IOC容器獲取的兩種方式

8.3.1 創(chuàng)建User類(lèi)

User.java

public class User {

    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    
    public User() {
        // TODO Auto-generated constructor stub
        super();
        this.id = 22;
        this.name = "Jack";
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.id +"->"+this.name;
    }

}

IOC容器獲取方式一:

    @Test
    public void testIOC1() {
        //1.把對(duì)象的創(chuàng)建交給IOC容器
        //這種加載方式會(huì)采用懶加載,調(diào)用getBean的時(shí)候才創(chuàng)建
        ClassPathResource resource = new ClassPathResource("applicationContext.xml");
        
        //2.創(chuàng)建容器對(duì)象(Bean工廠),IOC容器=工廠類(lèi)+applicationContext.xml
        BeanFactory factory = new XmlBeanFactory(resource);
        User user = (User) factory.getBean("user");
        System.out.println(user);
    }

方式二:

//2.直接得到IOC容器(方便,常用)
        @Test
        public void testIOC2() {
            ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
            User user = (User) ac.getBean("user");
            System.out.println(user);
        }

要記得在applicationContext.xml配置user的bean節(jié)點(diǎn).

8.3.2 IOC容器創(chuàng)建對(duì)象：

                創(chuàng)建對(duì)象, 有幾種方式：
                1） 調(diào)用無(wú)參數(shù)構(gòu)造器
                2） 帶參數(shù)構(gòu)造器
                3） 工廠創(chuàng)建對(duì)象
                        工廠類(lèi)，靜態(tài)方法創(chuàng)建對(duì)象
                        工廠類(lèi)薛训，非靜態(tài)方法創(chuàng)建對(duì)象

測(cè)試幾種創(chuàng)建方式:

配置applicationContext.xml,添加bean節(jié)點(diǎn)

 <!--1. 默認(rèn)無(wú)參數(shù)構(gòu)造函數(shù) -->
        <bean id="user" class="com.it.entity.User"></bean>
        
        <!-- 2.帶參數(shù)構(gòu)造器 -->
        <bean id="user2" class="com.it.entity.User">
            <constructor-arg index="0" value="33"></constructor-arg>
            <constructor-arg index="1" value="Rose" type="java.lang.String"></constructor-arg>
        </bean>
        
        <!-- 3.引用參數(shù) -->
        
        <bean id="name" class="java.lang.String">
            <constructor-arg value="Roses"></constructor-arg>
        </bean>
        
        <bean id="user3" class="com.it.entity.User">
            <constructor-arg index="0" value="44"></constructor-arg>
            <constructor-arg index="1" ref="name"></constructor-arg>
        </bean>
        
        <!-- 4.工廠類(lèi)創(chuàng)建對(duì)象 -->
        
        <!-- 先創(chuàng)建工程 -->
        <bean id="factory" class="com.it.dependency.ObjectFacctory"></bean>
        
        <!-- 4.1工廠類(lèi),實(shí)例方法 -->
        <!-- factory實(shí)例方法創(chuàng)建user對(duì)象 -->
        <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
        
        <!-- 4.2工廠類(lèi)靜態(tài)方法 -->
        <bean id="user5" class="com.it.dependency.ObjectFacctory" factory-method="getStaticInstance"></bean>

創(chuàng)建對(duì)象工廠類(lèi)ObjectFactory.java

package com.it.dependency;
import com.it.entity.*;

public class ObjectFacctory {

    //工廠類(lèi)創(chuàng)建對(duì)象
    
    //實(shí)例方法創(chuàng)建對(duì)象
    private User getInstance(){
        return new User(100, "Jack");
        
    }
    
    //靜態(tài)方法創(chuàng)建對(duì)象
    private static User getStaticInstance(){
        return new User(102, "Jack2");
        
    }
}

測(cè)試類(lèi)App.java,關(guān)鍵代碼

ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        @Test
        public void testIOCCreateObject() {
            //調(diào)用默認(rèn)參數(shù)構(gòu)造器
            User user = (User) ac.getBean("user");
            System.out.println(user);
        }
        
        @Test
        public void testIOCCreateObject1() {
            
            //帶參數(shù)構(gòu)造器
            User user = (User) ac.getBean("user2");
            System.out.println(user);
        }
        
        @Test
        public void testIOCCreateObject2() {
            
            //調(diào)用引用參數(shù)
            User user = (User) ac.getBean("user3");
            System.out.println(user);
        }
        
        @Test
        public void testIOCCreateObject3() {
            //調(diào)用工廠類(lèi)實(shí)例方法
            User user = (User) ac.getBean("user4");
            System.out.println(user);
            
        }
        
        @Test
        public void testIOCCreateObject4() {
            //調(diào)用工廠類(lèi)靜態(tài)方法
            User user = (User) ac.getBean("user5");
            System.out.println(user);
            
        }

8.4 Spring框架的屬性注入:對(duì)象依賴(lài)關(guān)系

對(duì)于類(lèi)成員變量媒吗，常用的注入方式有兩種
    * 構(gòu)造函數(shù)注入
    * 屬性setter方法注入(常用)
    * p名稱(chēng)空間
     * 自動(dòng)裝配(了解)
     * 注解(重點(diǎn))

8.4.1構(gòu)造函數(shù)注入

        <bean id="user2" class="com.it.entity.User">
            <constructor-arg index="0" value="33"></constructor-arg>
            <constructor-arg index="1" value="Rose" type="java.lang.String"></constructor-arg>
        </bean>

8.4.2 Set方法注入,需要注入的類(lèi)要提供set方法

   <!-- set方法注入值 -->
     <bean id="userDao" class="com.it.dao.UserDao"></bean>
     <bean id="userService" class="com.it.service.UserService">
        <property name="userDao" ref="userDao"></property>
     </bean>
     
     <bean id="userAction" class="com.it.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
     </bean>

8.4.3 內(nèi)部bean

<!-- 內(nèi)部bean賦值 -->
     <bean id="userAction" class="com.it.action.UserAction" scope="prototype">
        <property name="userService">
            <bean id="userService" class="com.it.service.UserService">
                <property name="userDao">
                    <bean class="com.it.dao.UserDao"></bean>
                </property>
            </bean>
        </property>
     </bean>

8.4.4 p命名空間

頂部的約束要添加,更改為

<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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
     <!-- 
        給對(duì)象屬性注入值：
            # p 名稱(chēng)空間給對(duì)象的屬性注入值
             (spring3.0以上版本才支持)
     -->
     <bean id="userDao" class="com.it.dao.UserDao"></bean>
     
     <bean id="userService" class="com.it.service.UserService" p:userDao-ref="userDao"></bean>
     
     <bean id="userAction" class="com.it.action.UserAction" p:userService-ref="userService"></bean>
    
    
    <!-- 傳統(tǒng)的注入： 
     <bean id="user" class="cn.it.entity.User" >
        <property name="name" value="xxx"></property>
     </bean>
    -->
    <!-- p名稱(chēng)空間優(yōu)化后 -->
    <bean id="user6" class="com.it.entity.User" p:name="Jack0001"></bean>   
        
</beans>

8.4.5 自動(dòng)裝配

根據(jù)名稱(chēng)自動(dòng)裝配：autowire="byName"
自動(dòng)去IOC容器中找與屬性名同名的引用的對(duì)象，并自動(dòng)注入;
? 根據(jù)類(lèi)型自動(dòng)裝配：autowire="byType"
必須確保改類(lèi)型在IOC容器中只有一個(gè)對(duì)象乙埃；否則報(bào)錯(cuò)闸英。

    <bean id="userDao" class="com.it.dao.UserDao"></bean>   
    <bean id="userService" class="com.it.service.UserService" autowire="byName"></bean>
    <!-- 根據(jù)“名稱(chēng)”自動(dòng)裝配： userAction注入的屬性，會(huì)去ioc容器中自動(dòng)查找與屬性同名的對(duì)象 -->
    <bean id="userAction" class="com.it.action.UserAction" autowire="byName"></bean>

也可以定義到全局介袜， 這樣就不用每個(gè)bean節(jié)點(diǎn)都去寫(xiě)autowire=”byName”

<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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd"><!-- default-autowire="byName">
       
       <bean id="userDao" class="com.it.dao.UserDao"></bean>   
       <bean id="userService" class="com.it.service.UserService"></bean>
       <!-- 根據(jù)“名稱(chēng)”自動(dòng)裝配： userAction注入的屬性甫何，會(huì)去ioc容器中自動(dòng)查找與屬性同名的對(duì)象 -->
       <bean id="userAction" class="com.it.action.UserAction"></bean>

</beans>

8.4.6 注解方式

注解方式可以簡(jiǎn)化spring的IOC容器的配置!

使用注解步驟：
   1）先引入context名稱(chēng)空間
       xmlns:context="http://www.springframework.org/schema/context"
   2）開(kāi)啟注解掃描
       <context:component-scan base-package="cn.it"></context:component-scan>
   3）使用注解
       通過(guò)注解的方式，把對(duì)象加入ioc容器遇伞。

      創(chuàng)建對(duì)象以及處理對(duì)象依賴(lài)關(guān)系辙喂，相關(guān)的注解：
       @Component   指定把一個(gè)對(duì)象加入IOC容器

   @Repository   作用同@Component； 在持久層使用
   @Service      作用同@Component鸠珠； 在業(yè)務(wù)邏輯層使用
   @Controller    作用同@Component巍耗； 在控制層使用 

   @Resource     屬性注入
   
   屬性注入的注解(說(shuō)明：使用注解注入的方式,可以不用提供set方法)
   * 如果是注入的普通類(lèi)型，可以使用value注解
       * @Value            -- 用于注入普通類(lèi)型

   * 如果注入的是對(duì)象類(lèi)型跳芳，使用如下注解
       * @Autowired        -- 默認(rèn)按類(lèi)型進(jìn)行自動(dòng)裝配
           * 如果想按名稱(chēng)注入
           * @Qualifier    -- 強(qiáng)制使用名稱(chēng)注入

   * @Resource             -- 相當(dāng)于@Autowired和@Qualifier一起使用
       * 強(qiáng)調(diào)：Java提供的注解
       * 屬性使用name屬性

applicationContext.xml

<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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
       
       
      <context:component-scan base-package="com.it"></context:component-scan>
       
</beans>

UserDao.java

package com.it.dao;

import org.springframework.stereotype.Component;

import com.it.interfaces.IUserDao;

@Component(value="userDao")
public class UserDao implements IUserDao{

   @Override
   public void save() {
       // TODO Auto-generated method stub
       System.out.println("保存用戶(hù)成功");
   }
}

UserService.java

package com.it.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import com.it.dao.UserDao;
import com.it.interfaces.IUserDao;
import com.it.interfaces.IUserService;

@Component(value="userService")
public class UserService implements IUserService{
   
   @Resource
   private IUserDao userDao;

   @Override
   public void save() {
       userDao.save();
   }

}

UserAction.java

package com.it.action;

import javax.annotation.Resource;

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

import com.it.interfaces.IUserAction;
import com.it.interfaces.IUserService;
import com.it.service.UserService;

@Component(value="userAction")
public class UserAction implements IUserAction{

   @Resource
   private IUserService userService;
   
   
   @Override
   public void save() {
       // TODO Auto-generated method stub
       userService.save();
   }
   
   
   public static void main(String[] args) {
       
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       IUserAction action = (UserAction)ac.getBean("userAction");
       action.save();
   }

}

運(yùn)行程序,控制臺(tái)會(huì)輸出: 保存用戶(hù)成功

小結(jié):

1） 使用注解芍锦，可以簡(jiǎn)化配置，且可以把對(duì)象加入IOC容器,及處理依賴(lài)關(guān)系(DI)

2） 注解可以和XML配置一起使用飞盆。

8.5 bean管理配置標(biāo)簽屬性值

1. id屬性和name屬性的區(qū)別
    * id        -- Bean起個(gè)名字娄琉，在約束中采用ID的約束次乓，唯一
        * 取值要求：必須以字母開(kāi)始，可以使用字母孽水、數(shù)字票腰、連字符、下劃線(xiàn)女气、句話(huà)杏慰、冒號(hào)  id:不能出現(xiàn)特殊字符

    * name      -- Bean起個(gè)名字，沒(méi)有采用ID的約束（了解）
        * 取值要求：name:出現(xiàn)特殊字符.如果<bean>沒(méi)有id的話(huà) , name可以當(dāng)做id使用
        * Spring框架在整合Struts1的框架的時(shí)候炼鞠，Struts1的框架的訪(fǎng)問(wèn)路徑是以/開(kāi)頭的缘滥，例如：/bookAction

2. class屬性          -- Bean對(duì)象的全路徑
3. scope屬性          -- scope屬性代表Bean的作用范圍
    * singleton         -- 單例（默認(rèn)值）
    * prototype         -- 多例，在Spring框架整合Struts2框架的時(shí)候谒主，Action類(lèi)也需要交給Spring做管理朝扼，配置把Action類(lèi)配置成多例！霎肯！
    * request           -- 應(yīng)用在Web項(xiàng)目中,每次HTTP請(qǐng)求都會(huì)創(chuàng)建一個(gè)新的Bean
    * session           -- 應(yīng)用在Web項(xiàng)目中,同一個(gè)HTTP Session 共享一個(gè)Bean
    * globalsession     -- 應(yīng)用在Web項(xiàng)目中,多服務(wù)器間的session(集群)

4. Bean對(duì)象的創(chuàng)建和銷(xiāo)毀的兩個(gè)屬性配置（了解）
    * 說(shuō)明：Spring初始化bean或銷(xiāo)毀bean時(shí)擎颖，有時(shí)需要作一些處理工作，因此spring可以在創(chuàng)建和拆卸bean的時(shí)候調(diào)用bean的兩個(gè)生命周期方法
    * init-method       -- 當(dāng)bean被載入到容器的時(shí)候調(diào)用init-method屬性指定的方法
    * destroy-method    -- 當(dāng)bean從容器中刪除的時(shí)候調(diào)用destroy-method屬性指定的方法
        * 想查看destroy-method的效果观游，有如下條件
            * scope= singleton有效
            * web容器中會(huì)自動(dòng)調(diào)用搂捧，但是main函數(shù)或測(cè)試用例需要手動(dòng)調(diào)用（需要使用ClassPathXmlApplicationContext的close()方法）

8.7 集合的注入

1. 如果是數(shù)組或者List集合，注入配置文件的方式是一樣的
    <bean id="collectionBean" class="com.it.CollectionBean">
        <property name="arrs">
            <list>
                <value>22</value>
                <value>44</value>
            </list>
        </property>
    </bean>

2. 如果是Set集合懂缕，注入的配置文件方式如下：
    <property name="sets">
        <set>
            <value>哈哈</value>
            <value>呵呵</value>
        </set>
    </property>

3. 如果是Map集合允跑，注入的配置方式如下：
    <property name="map">
        <map>
            <entry key="小明" value="38"/>
            <entry key="小花" value="38"/>
            <entry key="如花" value="29"/>
        </map>
    </property>

4. 如果是properties屬性文件的方式，注入的配置如下：
    <property name="pro">
        <props>
            <prop key="uname">root</prop>
            <prop key="pass">123</prop>
        </props>
    </property>