day03-Spring管理Bean-IOC-01

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

SpringBean

Spring管理Bean-IOC

1.Spring配置/管理bean介紹

Bean管理包括兩方面：
- 建立bean物件
- 給bean注入屬性
Bean的配置方式：
- 基於xml檔案配置方式
- 基於註解配置方式

2.基於XML配置bean

2.1透過型別來獲取bean

透過id來獲取bean在Spring基本介紹中已經使用過，這裡不再贅敘

2.1.1應用案例

案例說明：
1. 透過spring的ioc容器，獲取一個bean物件
2. 說明：獲取bean的方式：按型別
完成步驟：
1. 建立一個Java物件Monster.java
2. 在beans.xml中配置

Monster.java：

package com.li.bean;

/**
 * @author 李
 * @version 1.0
 * Javabean / Entity
 */
public class Monster {
    private Integer monsterId;
    private String name;
    private String skill;

    //無參構造器一定要有，spring底層反射建立物件時需要使用
    public Monster() {
    }

    public Monster(Integer monsterId, String name, String skill) {
        this.monsterId = monsterId;
        this.name = name;
        this.skill = skill;
    }

    public Integer getMonsterId() {
        return monsterId;
    }

    public void setMonsterId(Integer monsterId) {
        this.monsterId = monsterId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "monsterId=" + monsterId +
                ", name='" + name + '\'' +
                ", skill='" + skill + '\'' +
                '}';
    }
}

beans.xml：

<!--配置Monster，希望透過型別來獲取-->
<bean class="com.li.bean.Monster" >
    <property name="monsterId" value="10086"/>
    <property name="name" value="孫悟空"/>
    <property name="skill" value="筋斗雲"/>
</bean>

SpringBeanTest：

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //透過Bean的型別來獲取物件
    @Test
    public void getBeanByType() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        //直接傳入class物件/型別
        Monster bean = ioc.getBean(Monster.class);
        System.out.println(bean);
    }
}

2.1.2細節說明

按照型別來獲取bean，要求ioc容器中的同一個類的bean只能有一個，否則會丟擲異常NoUniqueBeanDefinitionException
用型別來獲取bean的應用場景：XxxAction/Servlet/Controller或者XxxService，在一個執行緒中只需要一個物件例項的情況（單例情況）
在容器配置檔案（比如beans.xml）中給屬性值，底層是透過setter方法完成的，這也是為什麼需要在java物件中提供setter方法，否則會報錯

2.2透過構造器配置bean

2.2.1應用例項

案例說明：

使用spring的ioc容器，可以透過構造器來來配置bean物件
完整步驟：
1. 配置bean.xml

在beans.xml配置：

前提是Monster類中有對應的構造器

   <!--配置Monster物件，並指定構造器-->
    <!--
        1. constructor-arg 標籤可以指定使用構造器的引數
        2. index 表示構造器的第幾個引數，從0開始計算
        3. 除了透過index，還可以透過 name/ type 的方式來指定引數
        4. 類構造器可以有多個，但是不能有引數完全相同的型別和順序的構造器，
           這就決定了 透過構造器引數type 可以唯一確定一個構造器)
    -->
    <bean id="monster03" class="com.li.bean.Monster">
        <constructor-arg value="200" index="0"/>
        <constructor-arg value="白骨精" index="1"/>
        <constructor-arg value="吸血" index="2"/>
    </bean>
    <!--透過 name 的方式來指定引數-->
    <bean id="monster04" class="com.li.bean.Monster">
        <constructor-arg value="200" name="monsterId"/>
        <constructor-arg value="白骨精" name="name"/>
        <constructor-arg value="吸血" name="skill"/>
    </bean>
    <!--透過 type 的方式來指定引數-->
    <bean id="monster05" class="com.li.bean.Monster">
        <constructor-arg value="200" type="java.lang.Integer"/>
        <constructor-arg value="白骨精" type="java.lang.String"/>
        <constructor-arg value="吸血" type="java.lang.String"/>
    </bean>

SpringBeanTest：

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

import java.io.File;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //透過構造器來設定屬性
    @Test
    public void setBeanConstructor() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Monster monster03 = ioc.getBean("monster03", Monster.class);
        System.out.println("monster03=" + monster03);
    }
}

2.2.2細節說明

透過index屬性來區分是第幾個引數
透過type屬性來區分是什麼型別（按照順序）

2.3透過p名稱空間配置bean

2.3.1應用例項

案例說明：

在spring的ioc容器，可以透過p名稱空間來配置bean物件
完成步驟：
1. 在beans.xml配置，增加名稱空間配置，如下，點選Create namespace declaration，成功後在配置檔案頭會自動新增xmlns

beans.xml：

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--透過p名稱空間來配置bean
        將游標放在p，輸入alt+enter，就會自動新增 xmlns
     -->
    <bean id="monster06" class="com.li.bean.Monster"
          p:monsterId="500"
          p:name="紅孩兒"
          p:skill="風火輪"
    />
</beans>

SpringBeanTest：

package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //透過p名稱空間來設定屬性
    @Test
    public void setBeanByP() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Monster monster06 = ioc.getBean("monster06", Monster.class);
        System.out.println("monster06=" + monster06);
    }
}

2.3.2細節說明

注意要引入p名稱空間

2.4引用/注入其他bean物件

2.4.1應用例項

案例說明：

在spring的ioc容器中，可以透過 ref （reference）來實現bean物件的相互應用
完成步驟：
1. 建立MemberDAOImpl.java，MemberServiceImpl.java
2. 配置beans.xml

beans.xml：

<!--配置MemberDAOImpl物件-->
<bean class="com.li.dao.MemberDAOImpl" id="memberDAO"/>

<!--配置MemberServiceImpl物件
     1.ref="memberDAO" 表示
        MemberServiceImpl 物件的屬性memberDAO 引用的物件是id=memberDAO的物件
     2.這就體現了spring容器的依賴注入
     3.注意在spring容器中，是作為一個整體來執行的，也就是說如果你引用到了一個bean物件，對你配置的順序沒有要求
        （在底層，對spring配置檔案進行掃描，將關聯的關係自動梳理，並放到beanDefinitionMap中，
         也就是說，是從beanDefinitionMap中查詢關聯關係的。與spring配置檔案的配置順序無關）
     4.但是建議按照順序配置，易於閱讀
  -->
<bean class="com.li.service.MemberServiceImpl" id="memberService">
    <property name="memberDAO" ref="memberDAO"/>
</bean>

MemberDAOImpl：

package com.li.dao;

/**
 * @author 李
 * @version 1.0
 * DAO 物件
 */
public class MemberDAOImpl {
    //構造器
    public MemberDAOImpl() {
        System.out.println("MemberDAOImpl 構造器...");
    }

    //方法
    public void add() {
        System.out.println("MemberDAOImpl add()方法被執行");
    }

}

MemberServiceImpl：

package com.li.service;

import com.li.dao.MemberDAOImpl;

/**
 * @author 李
 * @version 1.0
 * Service類
 */
public class MemberServiceImpl {
    private MemberDAOImpl memberDAO;

    public MemberDAOImpl getMemberDAO() {
        return memberDAO;
    }

    public void setMemberDAO(MemberDAOImpl memberDAO) {
        this.memberDAO = memberDAO;
    }

    public void add() {
        System.out.println("MemberServiceImpl add() 方法被呼叫...");
        memberDAO.add();
    }
}

SpringBeanTest：

package com.li.test;

import com.li.service.MemberServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;


/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //透過ref 來設定 bean屬性
    @Test
    public void setBeanByRef() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        MemberServiceImpl memberService =
                ioc.getBean("memberService", MemberServiceImpl.class);

        memberService.add();
    }
}

2.4.2細節說明

注意：在spring容器中，是作為一個整體來執行的，也就是說如果你引用到了一個bean物件，對你配置的順序沒有要求。例如這裡的例子，如果我們將Memb erDAOImpl物件的配置，放到MemberServiceImpl物件的配置之後也是可以的。

因為在底層，會對spring的配置檔案進行掃描，將關聯的關係自動梳理，並放到beanDefinitionMap中。

也就是說，是從beanDefinitionMap中查詢關聯關係的。與spring配置檔案的配置順序無關。

但是建議按照順序配置，易於閱讀

2.5引入/注入內部bean物件

2.5.1應用例項

案例說明：

在spring的ioc容器中，可以直接配置內部bean物件
完成步驟：
1. 建立MemberDAOImpl.java，MemberServiceImpl.java
2. 配置beans.xml

建立MemberDAOImpl.java，MemberServiceImpl.java（見2.4）

beans.xml：

<!--配置MemberService物件（使用內部bean）-->
<bean class="com.li.service.MemberServiceImpl" id="memberService2">
    <!--自己配置一個內部bean-->
    <property name="memberDAO">
        <bean class="com.li.dao.MemberDAOImpl"/>
    </property>
</bean>

SpringBeanTest：

package com.li.test;

import com.li.service.MemberServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //透過內部 bean來設定 bean屬性
    @Test
    public void setBeanByProper() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        MemberServiceImpl memberService2 =
                ioc.getBean("memberService2", MemberServiceImpl.class);

        memberService2.add();
    }
}

2.6引用/注入集合/陣列型別

2.6.1應用例項

案例說明

在spring的ioc容器中，看看如何給bean物件的集合/陣列型別屬性賦值
完成步驟：
1. 建立Monster.java
2. 建立Master.java
3. 配置beans.xml

Monster.java：見2.1

Master.java：

package com.li.bean;

import java.util.*;

/**
 * @author 李
 * @version 1.0
 * Master類
 */
public class Master {
    private String name;

    private List<Monster> monsterList;
    private Map<String, Monster> monsterMap;
    private Set<Monster> monsterSet;

    //陣列
    private String[] monsterName;

    // Properties 是 Hashtable 的子類，也是k-v形式
    // 這裡Properties 的key和value都是String型別
    private Properties pros;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Monster> getMonsterList() {
        return monsterList;
    }

    public void setMonsterList(List<Monster> monsterList) {
        this.monsterList = monsterList;
    }

    public Map<String, Monster> getMonsterMap() {
        return monsterMap;
    }

    public void setMonsterMap(Map<String, Monster> monsterMap) {
        this.monsterMap = monsterMap;
    }

    public Set<Monster> getMonsterSet() {
        return monsterSet;
    }

    public void setMonsterSet(Set<Monster> monsterSet) {
        this.monsterSet = monsterSet;
    }

    public String[] getMonsterName() {
        return monsterName;
    }

    public void setMonsterName(String[] monsterName) {
        this.monsterName = monsterName;
    }

    public Properties getPros() {
        return pros;
    }

    public void setPros(Properties pros) {
        this.pros = pros;
    }

    @Override
    public String toString() {
        return "Master{" +
                "name='" + name + '\'' +
                ", monsterList=" + monsterList +
                ", monsterMap=" + monsterMap +
                ", monsterSet=" + monsterSet +
                ", monsterName=" + Arrays.toString(monsterName) +
                ", pros=" + pros +
                '}';
    }
}

beans.xml：

<!--配置Master物件-->
<!--體會Spring容器配置特點-->
<bean class="com.li.bean.Master" id="master">
    <property name="name" value="太上老君"/>

    <!--(1)給list屬性賦值-->
    <property name="monsterList">
        <list>
            <!--方式1.引用的方式-->
            <ref bean="monster01"/>
            <ref bean="monster02"/>
            <!--方式2.內部bean-->
            <bean class="com.li.bean.Monster">
                <property name="name" value="黃袍怪"/>
                <property name="monsterId" value="1024"/>
                <property name="skill" value="吃人"/>
            </bean>
        </list>
    </property>

    <!--(2)給map屬性賦值-->
    <property name="monsterMap">
        <map>
            <entry>
                <key>
                    <value>monster01</value>
                </key>
                <!--也可以透過內部 bean來配置，這裡使用引用-->
                <ref bean="monster01"/>
            </entry>
            <entry>
                <key>
                    <value>monster02</value>
                </key>
                <!--也可以透過內部 bean來配置，這裡使用引用-->
                <ref bean="monster02"/>
            </entry>
        </map>
    </property>

    <!--(3)給set屬性賦值-->
    <property name="monsterSet">
        <set>
            <!--同理，依然可以使用ref或者內部 bean的方式配置-->
            <ref bean="monster05"/>
            <bean class="com.li.bean.Monster">
                <property name="name" value="金角大王"/>
                <property name="monsterId" value="888"/>
                <property name="skill" value="有錢"/>
            </bean>
        </set>
    </property>

    <!--(4)給陣列屬性賦值-->
    <property name="monsterName">
        <array>
            <!--這裡根據陣列的型別來選擇對應的標籤-->
            <value>小豬妖</value>
            <value>大鵬妖</value>
            <value>老狐狸</value>
            <!--同理，依然可以使用ref或者內部 bean的方式配置-->
        </array>
    </property>

    <!--(5)給Properties屬性賦值，結構 k(String)-v(String)-->
    <property name="pros">
        <props>
            <prop key="username">root</prop>
            <prop key="pwd">1234</prop>
            <prop key="ip">127.0.0.1</prop>
        </props>
    </property>
</bean>

SpringBeanTest：

package com.li.test;

import com.li.bean.Master;
import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

import java.util.Iterator;
import java.util.Map;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    //給集合/陣列屬性進行配置值
    @Test
    public void setBeanByCollection() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master", Master.class);

        System.out.println("========master的list屬性=========");
        for (Monster monster : master.getMonsterList()) {
            System.out.println(monster);
        }

        System.out.println("\n========master的map屬性=========");
        Iterator<Map.Entry<String, Monster>> iterator =
                master.getMonsterMap().entrySet().iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("\n========master的set屬性=========");
        for (Monster monster : master.getMonsterSet()) {
            System.out.println(monster);
        }

        System.out.println("\n========master的陣列屬性=========");
        for (int i = 0; i < master.getMonsterName().length; i++) {
            System.out.println(master.getMonsterName()[i]);
        }

        System.out.println("\n========master的Properties屬性=========");
        Iterator<Map.Entry<Object, Object>> iterator1
                = master.getPros().entrySet().iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }
    }
}

2.6.2細節說明

主要掌握List/Map/Properties三種集合的使用
Properties集合的特點：

（1）Properties是Hashtable的子類，也是key-value形式

（2）key是String型別，value也是String型別

任務管理，專案管理和目標管理
2018-01-01
專案管理
No.182# 技術管理之管理任務管理
2023-02-20
Linux系統管理-工作管理（後臺程式管理）
2017-09-05
Linux
phpcms--模型管理，推薦位管理，類別管理
2013-12-11
PHP模型
研發管理流程 - 需求管理
2018-05-28
【儲存管理】日誌管理
2016-10-23
技術管理之路五、管理溝通：管理的必修課！
2021-11-19
Supervisor管理Laravels,Laravels程式管理
2021-05-08
Laravel
IT專案管理中的人員管理
2008-05-15
專案管理
專案管理-原始碼管理薦
2012-02-03
專案管理原始碼
ZooKeeper管理員指南——部署與管理
2015-11-25
從業務管理到業務流程管理
2012-09-09
IBM儲存管理卷管理
2009-11-06
IBM
風險管理是軟體專案管理的第一管理
2008-05-15
專案管理
工程管理系統原始碼-物料管理-工程專案管理系統-建築施工管理軟體
2023-03-09
原始碼專案管理
vps管理系統批次管理程式
2020-04-30
vps管理平臺rdo桌面管理
2019-09-25
專案管理都管理哪些內容？
2021-04-22
專案管理
Linux系統管理之硬碟管理
2018-07-31
Linux硬碟
Linux系統管理之程式管理
2020-08-31
Linux
AIX儲存管理（二）物理卷管理
2016-10-11
AI
AIX儲存管理（三）卷組管理
2016-10-12
AI
ZooKeeper管理員指南——部署與管理ZooKeeper
2015-07-20
多專案管理-資源管理(3)
2008-09-27
專案管理
多專案管理-資源管理(2)
2008-09-26
專案管理
多專案管理-資源管理(1)
2008-09-25
專案管理
Oracle KSL Latch 管理層與 Latch管理
2012-05-30
Oracle
IT專案管理與資料庫管理
2012-10-28
專案管理資料庫
技術管理—管理書籍推薦
2015-11-14
管理觀點系列：團隊管理(轉)
2007-08-14
論專案管理中人的管理(轉)
2007-08-14
專案管理
MySQL 管理
2020-12-02
MySql
IT資產管理
2023-11-02
版本管理
2017-02-21
ASM管理
2011-11-24
ASM
程式管理
2009-05-18
RAC資料庫administrator managed管理員管理OR policy managed策略管理
2017-08-25
資料庫
管理 ES 叢集：分片設定及管理
2020-02-20

day03-Spring管理Bean-IOC-01

Spring管理Bean-IOC

1.Spring配置/管理bean介紹

2.基於XML配置bean

2.1透過型別來獲取bean

2.1.1應用案例

2.1.2細節說明

2.2透過構造器配置bean

2.2.1應用例項

2.2.2細節說明

2.3透過p名稱空間配置bean

2.3.1應用例項

2.3.2細節說明

2.4引用/注入其他bean物件

2.4.1應用例項

2.4.2細節說明

2.5引入/注入內部bean物件

2.5.1應用例項

2.6引用/注入集合/陣列型別

2.6.1應用例項

2.6.2細節說明

相關文章