[原創]java WEB學習筆記98：Spring學習---Spring Bean配置及相關細節：如何在配置bean，Spring容器（BeanFactory,ApplicationContext），

本博客的目的：①總結本身的學習過程，至關於學習筆記 ②將本身的經驗分享給你們，相互學習，互相交流，不可商用

內容不免出現問題，歡迎指正，交流，探討，能夠留言，也能夠經過如下方式聯繫。

本人互聯網技術愛好者，互聯網技術發燒友

微博：伊直都在0221

QQ：951226918

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

1.在 Spring 的 IOC 容器裏配置 Bean

 　　1）在 xml 文件中經過 bean 節點來配置 bean

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6 
 7     <!-- 配置bean -->
 8     
 9     <!--配置bean 10  class: bean 的全類名，經過反射的方式在IOC 容器中建立bean ，因此要求Bean 中必須有無參數的構造器 11  id:標示容器中的bean，id惟一 12      -->
13     
14     <bean id="helloWord" class="com.jason.spring.beans.HelloWord">
15         <property name="name" value="Spring"></property>
16         
17     </bean>
18 
19 </beans>

 

　　

 

2.Spring 容器

　　

　　1）在 Spring IOC 容器讀取 Bean 配置建立 Bean 實例以前, 必須對它進行實例化. 只有在容器實例化後, 才能夠從 IOC 容器裏獲取 Bean 實例並使用.

　　2）Spring 提供了兩種類型的 IOC 容器實現. 

　　　　① BeanFactory: IOC 容器的基本實現.

　　　　② ApplicationContext: 提供了更多的高級特性. 是 BeanFactory 的子接口

　　　　③ BeanFactory 是 Spring 框架的基礎設施，面向 Spring 自己；ApplicationContext 面向使用 Spring 框架的開發者，幾乎全部的應用場合都直接使用 ApplicationContext 而非底層的 BeanFactory

　　　　④不管使用何種方式, 配置文件時相同的.

　　3）ApplicationContext 接口

　　　　①  ApplicationContext 的主要實現類：

　　　　　　> ClassPathXmlApplicationContext：從 類路徑下加載配置文件

　　　　　　> FileSystemXmlApplicationContext: 從文件系統中加載配置文件

　　　　②  ConfigurableApplicationContext 擴展於 ApplicationContext，新增長兩個主要方法：refresh() 和 close()， 讓 ApplicationContext 具備啓動、刷新和關閉上下文的能力

　　　　　③  ApplicationContext 在初始化上下文時就實例化全部單例的 Bean。

　　　  ④  WebApplicationContext 是專門爲 WEB 應用而準備的，它容許從相對於 WEB 根目錄的路徑中完成初始化工做

 

3.從 IOC 容器中獲取 Bean(ApplicationContext API)

　　　

　　1）getBean(String) :經過bean中的id 獲取容器中的一個實例  推薦

　　2）getBean(Class<T>):經過實例的類型從容器中獲取一個實例

 

4.依賴注入的方式(屬性注入方式)

　　1）屬性注入

　　　　① 屬性注入即經過 setter 方法注入Bean 的屬性值或依賴的對象

　　　　② 屬性注入使用 <property> 元素, 使用 name 屬性指定 Bean 的屬性名稱，value 屬性或 <value> 子節點指定屬性值

　　　　③ 屬性注入是實際應用中最經常使用的注入方式

1 <bean id="helloWord" class="com.jason.spring.beans.HelloWord">
2         <property name="name" value="Spring"></property>
3     </bean>

 

　　2）構造器注入

　　　　① 經過構造方法注入Bean 的屬性值或依賴的對象，它保證了 Bean 實例在實例化後就可使用。

　　　　② 構造器注入在 <constructor-arg> 元素裏聲明屬性, <constructor-arg> 中沒有 name 屬性

　　　　

 1 <!-- 經過構造方法來配置bean 的屬性 -->
 2     <bean id="car" class="com.jason.spring.beans.Car">
 3         <constructor-arg value="Audi" index="0"></constructor-arg>
 4         <constructor-arg value="xian" index="1"></constructor-arg>
 5         <constructor-arg value="50" index="2" type="int"></constructor-arg>
 6     </bean>
 7     
 8     <!-- 使用構造器注入屬性值能夠指定參數的位置和參數的類型! 以區分重載的構造器 -->
 9     <bean id="car2" class="com.jason.spring.beans.Car">
10         <constructor-arg value="Audi" type="java.lang.String"></constructor-arg>
11         <constructor-arg value="xian" type="java.lang.String"></constructor-arg>
12         <constructor-arg value="50" type="double"></constructor-arg>
13     </bean>

 

 

　　

　　3）工廠方法注入（不多使用，不推薦）

 

5.屬性配置細節

　　1）字面值：可用字符串表示的值，能夠經過 <value> 元素標籤或 value 屬性進行注入

　　2）基本數據類型及其封裝類、String 等類型均可以採起字面值注入的方式

<constructor-arg type="double">
            <value>50</value>
        </constructor-arg>

 

　

　　3）若字面值中包含特殊字符，可使用 <![CDATA[]]> 把字面值包裹起來

1 <constructor-arg type="java.lang.String">
2             <value><![CDATA[<XIAN>]]></value>
3         </constructor-arg>

 

 

　　 4）引用其它 Bean

　　　　① 組成應用程序的 Bean 常常須要相互協做以完成應用程序的功能. 要使 Bean 可以相互訪問, 就必須在 Bean 配置文件中指定對 Bean 的引用

　　　　② 在 Bean 的配置文件中, 能夠經過 <ref> 元素或 ref  屬性爲 Bean 的屬性或構造器參數指定對 Bean 的引用

　　　　

 1 <!-- 引用其餘bean-->
 2     <bean id="person" class="com.jason.spring.beans.Person">
 3         <property name="name" value="Jason"></property>
 4         <property name="age" value="24"></property>
 5         <property name="car" ref="car2"></property>
 6         
 7         <!-- <property name="car">  8  <ref bean="car2"/>  9  </property> -->
10     </bean>

 

 

　　       ③ 也能夠在屬性或構造器裏包含 Bean 的聲明, 這樣的 Bean 稱爲內部 Bean

　　　　　　>當 Bean 實例僅僅給一個特定的屬性使用時, 能夠將其聲明爲內部 Bean. 內部 Bean 聲明直接包含在 <property> 或 <constructor-arg> 元素裏, 不須要設置任何 id 或 name 屬性

　　　　　　>內部 Bean 不能使用在任何其餘地方

 1 <!-- 引用其餘bean-->
 2     <bean id="person" class="com.jason.spring.beans.Person">
 3         <property name="name" value="Jason"></property>
 4         <property name="age" value="24"></property>
 5     
 6         <!-- 內部bean, 不能被外部使用，只能在內部使用-->
 7         <property name="car">
 8             <bean class="com.jason.spring.beans.Car">
 9                 <constructor-arg value="Ford"></constructor-arg>
10                 <constructor-arg value="changan"></constructor-arg>
11                 <constructor-arg value="20" type="double"></constructor-arg>
12  
13             </bean>
14         </property>
15     </bean>

 　　　　

　　　　④ 可使用專用的 <null/> 元素標籤爲 Bean 的字符串或其它對象類型的屬性注入 null 值

1 <bean id="person2" class="com.jason.spring.beans.Person">
2         <constructor-arg value="jason"></constructor-arg>
3         <constructor-arg value="25"></constructor-arg>
4       <constructor-arg><null/></constructor-arg>
5     </bean>

 

 

　　　 ⑤ 和 Struts、Hiberante 等框架同樣，Spring 支持級聯屬性的配置：爲級聯屬性賦值， 注意:屬性須要先初始化後才能夠爲級聯屬性賦值，不然有異常，

1 <bean id="person2" class="com.jason.spring.beans.Person">
2         <constructor-arg value="jason"></constructor-arg>
3         <constructor-arg value="25"></constructor-arg>
4         <constructor-arg ref="car"></constructor-arg> 5 <property name="car.brand" value="xxxxxx"></property>
6     </bean>
7     

 

 

　　　　⑥ 集合屬性（list,map,properties）

　　　　>在 Spring中能夠經過一組內置的 xml 標籤(例如: <list>, <set> 或 <map>) 來配置集合屬性.

　　　　>配置 java.util.List 類型的屬性, 須要指定 <list> 標籤, 在標籤裏包含一些元素. 這些標籤能夠經過 <value> 指定簡單的常量值,

　　　　　　　　 經過 <ref> 指定對其餘 Bean 的引用. 經過<bean> 指定內置 Bean 定義. 經過 <null/> 指定空元素. 甚至能夠內嵌其餘集合.

　　　　>數組的定義和 List 同樣, 都使用 <list>

　　　　>配置 java.util.Set 須要使用 <set> 標籤, 定義元素的方法與 List 同樣.

 

 

 1 <!-- 測試如何配置集合屬性 -->
 2     
 3     <bean id="person3" class="com.jason.spring.collection.Person">
 4         <property name="name" value="Mike"></property>
 5         <property name="age" value="30"></property>
 6         <property name="cars">
 7             <list>
 8                 <ref bean="car"/>
 9                 <ref bean="car2"/>
10             </list>
11         </property>
12     </bean>

 

 

 

　　    

1 public class Person { 2 
3     private String name; 4     private int age; 5 
6     private List<Car> cars; 7 
8 ///
9 }

 

 

 

　　　> Java.util.Map 經過 <map> 標籤訂義, <map> 標籤裏可使用多個 <entry> 做爲子標籤. 每一個條目包含一個鍵和一個值. 

　　　> 必須在 <key> 標籤裏定義鍵

 

　　　> 由於鍵和值的類型沒有限制, 因此能夠自由地爲它們指定 <value>, <ref>, <bean> 或 <null> 元素.

　　　> 能夠將 Map 的鍵和值做爲 <entry> 的屬性定義: 簡單常量使用 key 和 value 來定義; Bean 引用經過 key-ref 和 value-ref 屬性定義

 1 <bean id="person4" class="com.jason.spring.collection.Person2">
 2         <property name="name" value="jason"></property>
 3         <property name="age" value="50"></property>
 4         <property name="cars">
 5             <map>
 6                 <entry key="AA" value-ref="car"></entry>
 7                 <entry key="BB" value-ref="car2"></entry>
 8             </map>
 9         </property>
10     </bean>

 

1 public class Person2 { 2 
3     private String name; 4     private int age; 5 
6     private Map<String, Car> cars; 7 
8 ///
9 }

 

　　　　

　　　> 使用 <props> 定義 java.util.Properties, 該標籤使用多個 <prop> 做爲子標籤. 每一個 <prop> 標籤必須定義 key 屬性.

 1 <!-- 配置properties屬性值 -->
 2     <bean id="dataSource" class="com.jason.spring.collection.DataSource">
 3         <property name="properties">
 4         <!-- 使用props 和 prop 子節點來爲Properties 屬性賦值 -->
 5             <props>
 6                 <prop key="user">root</prop>
 7                 <prop key="password">1234</prop>
 8                 <prop key="jdbcUrl">jdbc:mysql:///test</prop>
 9                 <prop key="driverClass">com.myql.jdbc.Driver</prop>
10             </props>
11         </property>
12     </bean>

 

 1 package com.jason.spring.collection;  2 
 3 import java.util.Properties;  4 
 5 public class DataSource {  6 
 7     private Properties properties;  8 
 9     public Properties getProperties() { 10         return properties; 11  } 12 
13     public void setProperties(Properties properties) { 14         this.properties = properties; 15  } 16 
17  @Override 18     public String toString() { 19         return "DataSource [properties=" + properties + "]"; 20  } 21     
22     
23 }

 

 　　

　　注意：當多個對象同時引用同一個集合的時候。如何讓集合提升重用性？

　　解決方法：使用 utility scheme 定義集合

　　>  使用基本的集合標籤訂義集合時, 不能將集合做爲獨立的 Bean 定義, 致使其餘 Bean 沒法引用該集合, 因此沒法在不一樣 Bean 之間共享集合.

　　>  可使用 util schema 裏的集合標籤訂義獨立的集合 Bean. 須要注意的是, 必須在 <beans> 根元素裏添加 util schema 定義

 1 <!-- 配置單例的集合bean，以供多個bean 進行引用，須要導入util 命名空間 -->
 2     <util:list id="cars">
 3         <ref bean="car"/>
 4         <ref bean="car2"/>
 5     </util:list>
 6     
 7     <bean id="person5" class="com.jason.spring.collection.Person">
 8         <property name="name" value="jason"></property>
 9         <property name="age" value="30"></property>
10         <property name="cars" ref="cars"></property>
11     </bean>

 

 

 

　　⑦ 經過p命名空間，簡化爲bean的屬性的賦值過程

 

1 <!-- 經過p 命名空間爲bean 的屬性賦值，首先導入p命名空間，簡化配置方式 -->
2     <bean id="person6" class="com.jason.spring.collection.Person" p:age="30" p:name="jason" p:cars-ref="cars"></bean>