1.IOC和DI概述
IOC(Inversion of Control)：其思想是反轉資源獲取的方向. 傳統的資源查找方式要求組件向容器發起請求查找資源. 作為回應, 容器適時的返回資源. 而應用了 IOC 之后, 則是容器主動地將資源推送給它所管理的組件, 組件所要做的僅是選擇一種合適的方式來接受資源. 這種行為也被稱為查找的被動形式。
DI(Dependency Injection) — IOC 的另一種表述方式：即組件以一些預先定義好的方式(例如: setter 方法)接受來自如容器的資源注入. 相對於 IOC 而言，這種表述更直接。
2.Bean的配置方式
Bean 的配置方式：通過全類名（反射）、通過工廠方法（靜態工廠方法 & 實例工廠方法）、FactoryBean。
2.1 Spring通過全類名（反射）配置Bean特點：
1. 基於xml文件的方式，
2. 通過全類名反射，
3. 依靠IOC容器，
4. 依賴注入的方式：屬性注入，構造器注入
基於xml文件的方式配置Bean
<bean id="helloworld" class="com.java.spring.HelloWorld"> <property name="name" value="koala"></property> </bean>
id:Bean的名稱，在IOC容器中必須是惟一的。
2.2通過工廠方法配置Bean
2.2.1 通過調用靜態工廠配置Bean
調用靜態工廠方法創建 Bean是將對象創建的過程封裝到靜態方法中. 當客戶端需要對象時, 只需要簡單地調用靜態方法, 而不用關心創建對象的細節.
要聲明通過靜態方法創建的 Bean, 需要在 Bean 的 class 屬性里指定擁有該工廠的方法的類, 同時在 factory-method 屬性里指定工廠方法的名稱. 最后, 使用 <constrctor-arg> 元素為該方法傳遞方法參數.
示例代碼：
Car.java
package com.java.spring.factory;
public class Car {
private String brand;
private double price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Car(String brand, double price) {
super();
this.brand = brand;
this.price = price;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", price=" + price + "]";
}
}
StaticCarFactory.java
package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class StaticCarFactory {
private static Map<String,Car> cars=new HashMap<String,Car>();
static{
cars.put("audi",new Car("audi",300000.00));
cars.put("ford",new Car("ford",400000.00));
}
//靜態工廠方法
public static Car getCar(String name){
return cars.get(name);
}
}
在beans-factory.xml中進行配置：
<bean id="car1" class="com.java.spring.factory.StaticCarFactory" factory-method="getCar"> <constructor-arg value="audi"></constructor-arg> </bean>
主方法中進行實例化Bean：
package com.java.spring.factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-factory.xml");
Car car1=(Car) ctx.getBean("car1");
System.out.println(car1);
}
}
運行后輸出：
Car [brand=audi, price=300000.0]
靜態工廠方法就是直接調用一個類的靜態方法就能返回Bean的實例，上面代碼中根據靜態工廠方法public static Car getCar(String name)來配置Bean實例。
2.2.2 通過調用實例工廠方法創建 Bean
實例工廠方法: 將對象的創建過程封裝到另外一個對象實例的方法里. 當客戶端需要請求對象時, 只需要簡單的調用該實例方法而不需要關心對象的創建細節.
要聲明通過實例工廠方法創建的 Bean：
- 在 bean 的 factory-bean 屬性里指定擁有該工廠方法的 Bean；
- 在 factory-method 屬性里指定該工廠方法的名稱；
- 使用 construtor-arg 元素為工廠方法傳遞方法參數；
InstanceCarFactory.java
package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class InstanceCarFactory {
private static Map<String,Car> cars=null;
public InstanceCarFactory() {
cars=new HashMap<String,Car>();
cars.put("Audi",new Car("Audi",300000.00));
cars.put("Ford",new Car("Ford",400000.00));
}
public Car getCar(String brand){
return cars.get(brand);
}
}
在beans-factory.xml中進行配置：
//配置工廠的實例
<bean id="carFactory" class="com.java.spring.factory.InstanceCarFactory"></bean>
//通過實例工廠方法來配置bean <bean id="car2" factory-bean="carFactory" factory-method="getCar"> <constructor-arg value="Ford"></constructor-arg> </bean>
2.3 實現 FactoryBean 接口在 Spring IOC 容器中配置 Bean
Spring 中有兩種類型的 Bean, 一種是普通Bean, 另一種是工廠Bean, 即FactoryBean. 工廠 Bean 跟普通Bean不同, 其返回的對象不是指定類的一個實例, 其返回的是該工廠 Bean 的 getObject 方法所返回的對象。
package com.java.spring.FactoryBean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean{
private String brand;
public void setBrand(String brand){
this.brand=brand;
}
@Override
//FactoryBean返回的實例
public Car getObject() throws Exception {
return new Car(brand,500000.00);
}
@Override
//FactoryBean返回的實例是否為單例
public boolean isSingleton() {
return false;
}
@Override
//FactoryBean返回的類型
public Class getObjectType() {
return Car.class;
}
}
在beans-factory.xml中進行配置：
<bean id="car3" class="com.java.spring.FactoryBean.CarFactoryBean"> <property name="brand" value="BWM"></property> </bean>
在主方法中實例化：
Object car3= ctx.getBean("car3");
3.獲取Bean
Spring提供的最常用的IOC容器實現是ApplicationContext，ApplicationContext的主要實現類ClassPathXmlApplicationContext從類路徑下加載配置文件。
創建Spring的IOC對象：
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
從IOC容器中獲取Bean：調用ApplicationContext的getBean()方法。
HelloWorld helloWorld=(HelloWorld) ctx.getBean("helloworld");
4.Spring依賴注入的方式
4.1 屬性注入
屬性注入即通過 setter 方法注入Bean 的屬性值或依賴的對象。使用 <property> 元素, 使用 name 屬性指定 Bean 的屬性名稱，value 屬性或 <value> 子節點指定屬性值，是最常用的注入方式。
例如：
<bean id="helloworld" class="com.java.spring.HelloWorld"> <property name="name" value="koala"></property> </bean>
4.2 構造方法注入
通過構造方法注入Bean 的屬性值或依賴的對象，它保證了 Bean 實例在實例化后就可以使用。構造器注入在 <constructor-arg> 元素里聲明屬性, <constructor-arg> 中沒有 name 屬性。
Car.java
package com.java.spring;
public class Car {
private String brand;
private String corp;
private double price;
private int maxSpeed;
public Car(String brand, String corp, double price) {
super();
this.brand = brand;
this.corp = corp;
this.price = price;
}
public Car(String brand, String corp, int maxSpeed) {
super();
this.brand = brand;
this.corp = corp;
this.maxSpeed = maxSpeed;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price + ", maxSpeed=" + maxSpeed + "]";
}
}
4.2.1 按索引匹配入參
在XML中設置：
<bean id="car" class="com.java.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="上海" index="1"></constructor-arg> <constructor-arg value="500000.0000" index="2"></constructor-arg> </bean>
主方法中獲取Bean實例：
package com.java.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.創建spring的IOC對象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.從IOC容器中獲取bean實例
Car car=(Car) ctx.getBean("car");
System.out.println(car);
}
}
運行后輸出：
Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0]
4.2.2 按類型匹配入參
在XML中設置：
<bean id="car2" class="com.java.spring.Car"> <constructor-arg value="Audi" type="String"></constructor-arg> <constructor-arg value="長春一汽" type="String"></constructor-arg> <constructor-arg value="240" type="int"></constructor-arg> </bean>
也可以使用<value></value>子節點進行賦值:
<bean id="car2" class="com.java.spring.Car"> <constructor-arg value="Audi" type="String"></constructor-arg> <constructor-arg value="長春一汽" type="String"></constructor-arg> <constructor-arg type="int"> <value>240</value> </constructor-arg> </bean>
主方法中獲取Bean實例：
package com.java.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.創建spring的IOC對象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.從IOC容器中獲取bean實例
Car car=(Car) ctx.getBean("car2");
System.out.println(car);
}
}
運行后輸出：
Car [brand=Audi, corp=長春一汽, price=0.0, maxSpeed=240]
5.引用其他Bean
5.1 ref引用
組成應用程序的 Bean 經常需要相互協作以完成應用程序的功能.。要使 Bean 能夠相互訪問, 就必須在 Bean 配置文件中指定對 Bean 的引用。在 Bean 的配置文件中, 可以通過 <ref> 元素或 ref 屬性為 Bean 的屬性或構造器參數指定對 Bean 的引用。
新建一個Person類Person.java
package com.java.spring;
public class Person {
private String name;
private int age;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
在xml中進行配置：（value的值只能為字面值，即基本數據類型及其封裝類，String等類型，Car非字面值，需通過ref引用其他bean）
<bean id="person" class="com.java.spring.Person"> <property name="name" value="Tom"></property> <property name="age" value="23"></property> <property name="car" ref="car"></property> </bean>
主方法中獲取Bean實例：
Person person=(Person) ctx.getBean("person");
運行后輸出：
Person [name=Tom, age=23, car=Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0]]
5.2 內部Bean
當 Bean 實例僅僅給一個特定的屬性使用時, 可以將其聲明為內部 Bean。 內部 Bean 聲明直接包含在 <property> 或 <constructor-arg> 元素里，不需要設置任何 id 或 name 屬性。內部 Bean 不能使用在任何其他地方。
同實現上面的功能，在XML中進行配置：
<bean id="person1" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="car">
<bean class="com.java.spring.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="長春一汽" index="1"></constructor-arg>
<constructor-arg value="500000.0000" index="2"></constructor-arg>
</bean>
</property>
</bean>
6.級聯屬性賦值
和 Struts、Hiberante 等框架一樣，Spring 支持級聯屬性的配置。
<bean id="car" class="com.java.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="上海" index="1"></constructor-arg> <constructor-arg value="500000.0000" index="2"></constructor-arg> </bean> <bean id="person" class="com.java.spring.Person"> <property name="name" value="Tom"></property> <property name="age" value="23"></property> <property name="car" ref="car"></property> <property name="car.price" value="300000.0000"></property> </bean>
使用級聯屬性賦值的前提是car中的price必須有setPrice()方法。
運行后輸出：
[name=Tom, age=23, car=Car [brand=Audi, corp=上海, price=300000.0, maxSpeed=0]]
7.集合屬性的配置
在 Spring中可以通過一組內置的 xml 標簽(例如: <list>, <set> 或 <map>) 來配置集合屬性。
7.1 配置 java.util.List 類型的屬性， 需要指定 <list> 標簽, 在標簽里包含一些元素。這些標簽可以通過 <value> 指定簡單的常量值，通過 <ref> 指定對其他 Bean 的引用。 通過<bean> 指定內置 Bean 定義。通過 <null/> 指定空元素。 甚至可以內嵌其他集合。數組的定義和 List 一樣, 都使用 <list>。
示例代碼：
Person.java
package com.java.spring;
import java.util.List;
public class Person {
private String name;
private int age;
private List<Car> cars;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public List<Car> getCars() {
return cars;
}
public void setCars(List<Car> cars) {
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}
在xml中進行配置：
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="cars">
<list>
<ref bean="car"/>
<ref bean="car2"/>
</list>
</property>
</bean>
在主方法中獲取Bean實例：
Person person=(Person) ctx.getBean("person");
運行后輸出：
Person [name=Tom, age=23, cars=[Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0],
Car [brand=Audi, corp=長春一汽, price=0.0, maxSpeed=240]]]
7.2 配置 java.util.Set 需要使用 <set> 標簽，定義元素的方法與 List 一樣。
7.3 Java.util.Map 通過 <map> 標簽定義，<map> 標簽里可以使用多個 <entry> 作為子標簽。每個條目包含一個鍵和一個值，必須在 <key> 標簽里定義鍵。因為鍵和值的類型沒有限制, 所以可以自由地為它們指定 <value>, <ref>, <bean> 或 <null> 元素。可以將 Map 的鍵和值作為 <entry> 的屬性定義: 簡單常量使用 key 和 value 來定義; Bean 引用通過 key-ref 和 value-ref 屬性定義。
Person.java
package com.java.spring;
import java.util.Map;
public class Person {
private String name;
private int age;
private Map<String,Car> cars;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Map<String,Car> getCars() {
return cars;
}
public void setCars(Map<String,Car> cars) {
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}
在xml中進行配置：
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="cars">
<map>
<entry key="A" value-ref="car"></entry>
<entry key="B" value-ref="car2"></entry>
</map>
</property>
</bean>
在主方法中獲取Bean實例：
Person person=(Person) ctx.getBean("person");
運行后輸出：
Person [name=Tom, age=23, cars={A=Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0],
B=Car [brand=Audi, corp=長春一汽, price=0.0, maxSpeed=240]}]
7.4 使用 <props> 定義 java.util.Properties， 該標簽使用多個 <prop> 作為子標簽。每個 <prop> 標簽必須定義 key 屬性。
DataSource.java
package com.java.spring;
import java.util.Properties;
public class DataSource {
private Properties properties;
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "DataSource [properties=" + properties + "]";
}
}
在xml中進行配置：
<bean id="datasource" class="com.java.spring.DataSource">
<property name="properties">
<props>
<prop key="user">root</prop>
<prop key="password">1234</prop>
<prop key="jdbcUrl">jdbc:mysql:///test</prop>
<prop key="driverClass">com.mysql.jdbc.Driver</prop>
</props>
</property>
</bean>
在主方法中獲取Bean實例：
package com.java.spring;
import java.util.Properties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.創建spring的IOC對象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.從IOC容器中獲取bean實例
DataSource datasource= (DataSource) ctx.getBean(DataSource.class);
System.out.println(datasource);
}
}
運行后輸出：
DataSource [properties={driverClass=com.mysql.jdbc.Driver, user=root, password=1234, jdbcUrl=jdbc:mysql:///test}]
8.使用 utility scheme 定義集合
使用基本的集合標簽定義集合時, 不能將集合作為獨立的 Bean 定義, 導致其他 Bean 無法引用該集合, 所以無法在不同 Bean 之間共享集合。解決這個問題的方法是使用 util schema 里的集合標簽定義獨立的集合 Bean. 需要注意的是, 必須在 <beans> 根元素里添加 util schema 定義。使用前需要先導入util命名空間，導入方式如下：
示例代碼：
在xml中進行配置：
<util:list id="cars"> <ref bean="car"/> <ref bean="car2"/> </util:list>
就可以在另一個Bean里進行引用：
<bean id="person" class="com.java.spring.Person"> <property name="name" value="Tom"></property> <property name="age" value="23"></property> <property name="cars" ref="cars"></property> </bean>
9.使用p命名空間
為了簡化 XML 文件的配置，越來越多的 XML 文件采用屬性而非子元素配置信息。Spring 從 2.5 版本開始引入了一個新的 p 命名空間，可以通過 <bean> 元素屬性的方式配置 Bean 的屬性。使用之前像導入util命名空間一樣先導入p命名空間。這種配置方式相對於傳統的配置方式更加簡潔。
<bean id="person" class="com.java.spring.Person" p:age="24" p:name="Tom" p:cars-ref="cars"></bean>
wx搜索“程序員考拉”，專注java領域，一個伴你成長的公眾號！
