Spring管理Bean-IOC-03
2.基于XML配置bean
2.15bean的生命周期
bean物件的創建是由JVM完成的，然后執行如下方法：
- 執行構造器
- 執行set相關方法
- 呼叫bean的初始化方法（需要配置）
- 使用bean
- 當容器關閉時，呼叫bean的銷毀方法（需要配置）
例子
House：
package com.li.bean;
/**
* @author 李
* @version 1.0
*/
public class House {
private String name;
public House() {
System.out.println("House() 構造器被執行...");
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("House setName()=" + name);
this.name = name;
}
//說明：初始化方法是自定義的，名字隨意，只要配置的時候指定名稱就行了
public void init() {
System.out.println("House init() 被執行...");
}
//說明：銷毀的方法是也自定義的，名字隨意
public void destroy() {
System.out.println("House destroy() 被執行...");
}
}
beans.xml：
<!--配置House物件，演示bean的生命周期
1.init-method 指定bean的初始化方法，該方法在bean執行setter方法后執行
2.init-method指定方法執行的時機，由spring容器來控制
3.destroy-method 指定bean的銷毀方法，該方法在容器關閉的時候被執行
4.destroy-method指定方法執行的時機，也是由spring容器來控制
-->
<bean id="house"
init-method="init"
destroy-method="destroy">
<property name="name" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/北京大豪宅"/>
</bean>
測驗方法：
//測驗bean的生命周期
@Test
public void testBeanLife() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
//關閉容器
// 1.ioc的編譯型別 ApplicationContext ，運行型別 ClassPathXmlApplicationContext
// 2.因為 ClassPathXmlApplicationContext 實作了介面 ConfigurableApplicationContext
// 3.而ConfigurableApplicationContext介面有 close方法
// 4.因此將ioc轉成 ConfigurableApplicationContext 型別，呼叫close方法，關閉容器
((ConfigurableApplicationContext)ioc).close();
}
使用細節：
- 初始化方法和銷毀方法由程式員自定義（包括方法名稱，在配置bean的時候指定即可）
- 銷毀方法只有當關閉容器時才會被呼叫
2.16配置bean的后置處理器
- 在spring的ioc容器，可以配置bean的后置處理器（后置處理器其實就是一個java物件）
- 該處理器會在bean 初始化方法呼叫前 和 初始化方法呼叫后 被呼叫
- 程式員可以在后置處理器中撰寫自己的業務代碼
例子
1.House類（見2.15），該方法設定了建構式，bean初始化方法等
2.創建后置處理器MyBeanPostProcessor：
后置處理器需要實作BeanPostProcessor介面，該介面中有兩個重要的方法，對應我們之前說的 “初始化方法呼叫前和初始化方法呼叫后被呼叫”
package com.li.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author 李
* @version 1.0
* 這是一個后置處理器，必須實作介面 BeanPostProcessor
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
/**
* 呼叫時機：在Bean初始化方法前被呼叫（bean沒有配置初始化方法，此方法也會被呼叫）
*
* @param bean 傳入 在IOC容器中創建/配置的Bean
* @param beanName 在IOC容器中創建/配置的Bean的id
* @return Object 回傳 bean（回傳前程式員可以對bean進行修改/處理，再回傳）
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization()被呼叫..." +
"bean=" + bean + " beanName=" + beanName);
return bean;
}
/**
* 呼叫時機：在Bean初始化方法后被呼叫（bean沒有配置初始化方法，此方法也會被呼叫）
*
* @param bean 傳入 在IOC容器中創建/配置的Bean
* @param beanName 在IOC容器中創建/配置的Bean的id
* @return Object 回傳 bean（回傳前程式員可以對bean進行修改/處理，再回傳）
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization()被呼叫..." +
"bean=" + bean + " beanName=" + beanName);
return bean;
}
}
3.beans02.xml：
因為后置處理器物件會作用在容器組態檔的所有bean物件中，因此這里新創建一個容器檔案beans02.xml，為了輸出干凈，該組態檔中只配置了house一個bean物件
<!--配置House物件-->
<bean id="house"
init-method="init" destroy-method="destroy">
<property name="name" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/海景大豪宅"/>
</bean>
<!--配置后置處理器物件
1.當我們在beans02.xml容器組態檔 配置了MyBeanPostProcessor后
2.該后置處理器物件，就會作用在該容器檔案的所有Bean物件中
-->
<bean id="myBeanPostProcessor"/>
4.測驗方法：
//測驗bean的后置處理器
@Test
public void testBeanPostProcessor() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
House house = ioc.getBean("house", House.class);
System.out.println("使用house=" + house);
//關閉容器
((ClassPathXmlApplicationContext)ioc).close();
}
輸出如下：postProcessBeforeInitialization()和postProcessAfterInitialization()方法分別在bean的初始化方法前后呼叫
細節說明：
- 怎么執行到這個方法？==>使用AOP（反射+動態代理+IO+容器+注解）
- 有什么用？==>可以對IOC容器中所有物件進行統一處理，如：日志處理/權限校驗/安全的驗證/事務管理
- 針對容器的所有物件嗎？ 是的==>切面編程特點
后置處理器是一個比較難理解的知識點，后面會實作這個機制，深入理解
2.17通過屬性檔案給bean注入值
在spring的ioc容器中，可以通過屬性檔案給bean注入值
例子
1.在src目錄下創建my.properties檔案
monsterId=1000
name=jack
skill=hello
2.在beans.xml中配置：
使用組態檔的方式需要引入命名空間：
<!--指定屬性檔案
1.注意要引入命名空間才能使用
2.location="classpath:my.properties" 表示指定屬性檔案的位置
（注意需要帶上"classpath"）
3.這時我們的屬性值通過${屬性名} 獲取
4.這里的屬性名就是my.properties中的 key
-->
<context:property-placeholder location="classpath:my.properties"/>
<!--配置Monster物件
通過屬性檔案給Monster物件賦值-->
<bean id="monster1000">
<property name="monsterId" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/${monsterId}"/>
<property name="name" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/${name}"/>
<property name="skill" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/${skill}"/>
</bean>
3.測驗：
//通過屬性檔案給bean屬性賦值
@Test
public void setBeanByFile() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster1000 = ioc.getBean("monster1000", Monster.class);
System.out.println("monster1000=" + monster1000);
}
注意：如果properties檔案中的value是中文，會出現亂碼，需要將中文轉為unicode編碼：
2.18基于XML的bean自動裝配
在spring的ioc容器中，可以實作自動裝配bean
例子
1.OrderDAO
package com.li.dao;
/**
* @author 李
* @version 1.0
* 這是一個DAO類
*/
public class OrderDAO {
public void saveOrder() {
System.out.println("保存一個訂單...");
}
}
2.OrderService
package com.li.service;
import com.li.dao.OrderDAO;
/**
* @author 李
* @version 1.0
* 這是一個Service類
*/
public class OrderService {
//OrderDAO屬性
private OrderDAO orderDAO;
//getter
public OrderDAO getOrderDAO() {
return orderDAO;
}
//setter
public void setOrderDAO(OrderDAO orderDAO) {
this.orderDAO = orderDAO;
}
}
3.OrderServlet：
package com.li.web;
import com.li.service.OrderService;
/**
* @author 李
* @version 1.0
* Servlet即 Controller
*/
public class OrderServlet {
//屬性OrderService
private OrderService orderService;
//getter
public OrderService getOrderService() {
return orderService;
}
//setter
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
}
4.beans.xml：
- autowire="byType"方式
<!--配置OrderDAO物件-->
<bean id="orderDAO"/>
<!--配置OrderService物件
1. 屬性 autowire="byType" 表示在創建OrderService時，
通過型別的方式，給物件的屬性自動完成賦值/參考
2. 比如OrderService物件有private OrderDAO屬性，就會在容器中找有沒有OrderDAO型別的物件
如果有，就會自動進行裝配（按照型別的方式來裝配時，那么該容器中不能有超過一個OrderService物件）
-->
<bean autowire="byType" id="orderService"/>
<!--配置OrderServlet物件，同理-->
<bean autowire="byType" id="orderServlet"/>
- 使用autowire="byName"方式
<!--配置OrderDAO物件-->
<bean id="orderDAO"/>
<!--配置OrderService物件
3.如果設定的是 autowire="byName" 表示通過名字完成自動裝配
比如下面的 autowire=" byName"
（1）spring會按照 OrderService物件的屬性（如orderDAO）
（2）找到這個屬性的setXxx()方法的Xxx名稱，在容器中找到相同id的物件來進行自動裝配
（3）例如我們的orderService物件中有一個setOrderDAO()，就會找id="orderDAO"的物件來進行自動裝配
（4）如果沒有就裝配失敗
-->
<bean autowire="byName" id="orderService"/>
<!--配置OrderServlet物件，同理-->
<bean autowire="byName" id="orderServlet"/>
注意：autowire="byName"不是通過物件屬性名來找到要自動裝配的物件的，而是通過setXxx方法的名稱來找，因為底層是反射實作的，因此如果物件的屬性的setXxx方法的名稱改變了，被自動裝配的物件id也要隨之改變
5.測驗類：
//基于XML的bean自動裝配
@Test
public void setBeanByAutowire() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
OrderServlet orderServlet = ioc.getBean("orderServlet", OrderServlet.class);
//驗證是否自動裝配上了OrderService
System.out.println(orderServlet.getOrderService());
//驗證是否自動裝配上了OrderDAO
System.out.println(orderServlet.getOrderService().getOrderDAO());
}
可以看到orderServlet的orderService屬性，以及屬性的屬性orderDAO成功裝載了:（autowire="byType"/"byName"方式）
2.19Spring EL運算式
非重點，了解即可
- Spring Expression Language，Spring運算式語言，簡稱SpEL，支持運行時查詢并可以操作物件，
- 和 JSP的EL運算式一樣，SpEL根據Javabean風格的getXxx()、setXxx()方法定義的屬性訪問物件
- SpEL使用
#{}作為定界符，所有在大括號中的字符都將被認為是SpEL運算式
應用實體
SpELBean：
package com.li.bean;
/**
* @author 李
* @version 1.0
*/
public class SpELBean {
private String name;
private Monster monster;
private String monsterName;
private String crySound;
private String bookName;
private Double result;
public SpELBean() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Monster getMonster() {
return monster;
}
public void setMonster(Monster monster) {
this.monster = monster;
}
public String getMonsterName() {
return monsterName;
}
public void setMonsterName(String monsterName) {
this.monsterName = monsterName;
}
public String getCrySound() {
return crySound;
}
public void setCrySound(String crySound) {
this.crySound = crySound;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public Double getResult() {
return result;
}
public void setResult(Double result) {
this.result = result;
}
//cry方法回傳字串
public String cry(String sound){
return "發出"+sound+"的叫聲";
}
//read方法回傳字串
public static String read(String bookName){
return "正在看"+bookName;
}
@Override
public String toString() {
return "SpELBean{" +
"name='" + name + '\'' +
", monster=" + monster +
", monsterName='" + monsterName + '\'' +
", crySound='" + crySound + '\'' +
", bookName='" + bookName + '\'' +
", result=" + result +
'}';
}
}
配置beans03.xml：
<!--配置一個Monster物件-->
<bean id="monster01">
<property name="monsterId" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/100"/>
<property name="name" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/蜈蚣精"/>
<property name="skill" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/蜇人"/>
</bean>
<!--spring el 運算式使用-通過sp el給bean的屬性賦值-->
<bean id="spELBean">
<!--sp el 給字面量-->
<property name="name" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{'一只貓貓'}"/>
<!--sp el 參考其他 bean（該bean要存在）-->
<property name="monster" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{monster01}"/>
<!--sp el 參考其他 bean 的屬性值-->
<property name="monsterName" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{monster01.name}"/>
<!--sp el 呼叫普通方法，將該方法的回傳值賦給 bean物件的屬性-->
<property name="crySound" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{spELBean.cry('喵喵喵')}"/>
<!--sp el 呼叫靜態方法，將該方法的回傳值賦給 bean物件的屬性
注意：需要寫上類全路徑-->
<property name="bookName" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{T(com.li.bean.SpELBean).read('紅樓夢')}"/>
<!--sp el 通過運算賦值-->
<property name="result" value="https://www.cnblogs.com/liyuelian/archive/2023/01/18/#{89*1.0+33/3}"/>
</bean>
測驗類：
//通過spring el 對屬性賦值
@Test
public void setBeanBySpel() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
SpELBean spELBean = ioc.getBean("spELBean", SpELBean.class);
System.out.println(spELBean);
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542206.html
標籤：其他
上一篇：Arrays類
下一篇：lambda運算式基礎