day05-Spring管理Bean-IOC-03

一刀一個小西瓜發表於2023-01-18
SpringBean

Spring管理Bean-IOC-03

2.基於XML配置bean

2.15bean的生命週期

bean物件的建立是由JVM完成的，然後執行如下方法：

  1. 執行構造器
  2. 執行set相關方法
  3. 呼叫bean的初始化方法（需要配置）
  4. 使用bean
  5. 當容器關閉時，呼叫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 class="com.li.bean.House" id="house"
      init-method="init"
      destroy-method="destroy">
    <property name="name" value="北京大豪宅"/>
</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();
}
image-20230118165712355

使用細節：

  1. 初始化方法和銷燬方法由程式設計師自定義（包括方法名稱，在配置bean的時候指定即可）
  2. 銷燬方法只有當關閉容器時才會被呼叫

2.16配置bean的後置處理器

  1. 在spring的ioc容器，可以配置bean的後置處理器（後置處理器其實就是一個java物件）
  2. 該處理器會在bean 初始化方法呼叫前 和 初始化方法呼叫後 被呼叫
  3. 程式設計師可以在後置處理器中編寫自己的業務程式碼

例子

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 class="com.li.bean.House" id="house"
      init-method="init" destroy-method="destroy">
    <property name="name" value="海景大豪宅"/>
</bean>

<!--配置後置處理器物件
    1.當我們在beans02.xml容器配置檔案 配置了MyBeanPostProcessor後
    2.該後置處理器物件，就會作用在該容器檔案的所有Bean物件中
-->
<bean class="com.li.bean.MyBeanPostProcessor" 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的初始化方法前後呼叫

image-20230118174535499

細節說明：

  1. 怎麼執行到這個方法？==>使用AOP（反射+動態代理+IO+容器+註解）
  2. 有什麼用？==>可以對IOC容器中所有物件進行統一處理，如：日誌處理/許可權校驗/安全的驗證/事務管理
  3. 針對容器的所有物件嗎？ 是的==>切面程式設計特點

後置處理器是一個比較難理解的知識點，後面會實現這個機制，深入理解

2.17透過屬性檔案給bean注入值

在spring的ioc容器中，可以透過屬性檔案給bean注入值

例子

1.在src目錄下建立my.properties檔案

monsterId=1000
name=jack
skill=hello

2.在beans.xml中配置：

使用配置檔案的方式需要引入名稱空間：

image-20230118182107473 
<!--指定屬性檔案
    1.注意要引入名稱空間才能使用
    2.location="classpath:my.properties" 表示指定屬性檔案的位置
        （注意需要帶上"classpath"）
    3.這時我們的屬性值透過${屬性名} 獲取
    4.這裡的屬性名就是my.properties中的 key
    -->
<context:property-placeholder location="classpath:my.properties"/>

<!--配置Monster物件
    透過屬性檔案給Monster物件賦值-->
<bean class="com.li.bean.Monster" id="monster1000">
    <property name="monsterId" value="${monsterId}"/>
    <property name="name" value="${name}"/>
    <property name="skill" value="${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);
}
image-20230118183405855

注意：如果properties檔案中的value是中文，會出現亂碼，需要將中文轉為unicode編碼：

image-20230118183938938

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 class="com.li.dao.OrderDAO" id="orderDAO"/>

<!--配置OrderService物件
    1. 屬性 autowire="byType" 表示在建立OrderService時，
       透過型別的方式，給物件的屬性自動完成賦值/引用
    2. 比如OrderService物件有private OrderDAO屬性，就會在容器中找有沒有OrderDAO型別的物件
       如果有，就會自動進行裝配（按照型別的方式來裝配時，那麼該容器中不能有超過一個OrderService物件）
-->
<bean autowire="byType" class="com.li.service.OrderService" id="orderService"/>

<!--配置OrderServlet物件，同理-->
<bean autowire="byType" class="com.li.web.OrderServlet" id="orderServlet"/>
  • 使用autowire="byName"方式
<!--配置OrderDAO物件-->
<bean class="com.li.dao.OrderDAO" id="orderDAO"/>

<!--配置OrderService物件
   3.如果設定的是 autowire="byName" 表示透過名字完成自動裝配
     比如下面的 autowire=" byName" class="com.li.service.OrderService"
    （1）spring會按照 OrderService物件的屬性（如orderDAO）
    （2）找到這個屬性的setXxx()方法的Xxx名稱，在容器中找到相同id的物件來進行自動裝配
    （3）例如我們的orderService物件中有一個setOrderDAO()，就會找id="orderDAO"的物件來進行自動裝配
    （4）如果沒有就裝配失敗
-->
<bean autowire="byName" class="com.li.service.OrderService" id="orderService"/>

<!--配置OrderServlet物件，同理-->
<bean autowire="byName" class="com.li.web.OrderServlet" 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"方式）

image-20230118193845625

2.19Spring EL表示式

非重點，瞭解即可

  1. Spring Expression Language，Spring表示式語言，簡稱SpEL。支援執行時查詢並可以操作物件。
  2. 和 JSP的EL表示式一樣，SpEL根據Javabean風格的getXxx()、setXxx()方法定義的屬性訪問物件
  3. 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 class="com.li.bean.Monster" id="monster01">
    <property name="monsterId" value="100"/>
    <property name="name" value="蜈蚣精"/>
    <property name="skill" value="蜇人"/>
</bean>

<!--spring el 表示式使用-透過sp el給bean的屬性賦值-->
<bean class="com.li.bean.SpELBean" id="spELBean">
    <!--sp el 給字面量-->
    <property name="name" value="#{'一隻貓貓'}"/>
    <!--sp el 引用其他 bean（該bean要存在）-->
    <property name="monster" value="#{monster01}"/>
    <!--sp el 引用其他 bean 的屬性值-->
    <property name="monsterName" value="#{monster01.name}"/>
    <!--sp el 呼叫普通方法，將該方法的返回值賦給 bean物件的屬性-->
    <property name="crySound" value="#{spELBean.cry('喵喵喵')}"/>
    <!--sp el 呼叫靜態方法，將該方法的返回值賦給 bean物件的屬性
        注意：需要寫上類全路徑-->
    <property name="bookName" value="#{T(com.li.bean.SpELBean).read('紅樓夢')}"/>
    <!--sp el 透過運算賦值-->
    <property name="result" value="#{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);
}
image-20230118211255129 image-20230118211301603

相關文章