Spring-IOC容器-Bean管理-基于XML方式超詳解

更新時間：2021年08月31日 18:03:24 作者：牛哄哄的柯南

這篇文章主要介紹了Spring為IOC容器Bean的管理,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下

Spring框架概述
IOC概念和原理
IOC 操作 Bean 管理（set方式注入&&使用有參構(gòu)造進行注入）
IOC 操作 Bean 管理（xml注入其他類型屬性）
IOC 操作 Bean 管理（xml注入集合屬性）
IOC 操作 Bean 管理（FactoryBean）
IOC 操作 Bean 管理（bean 作用域）
IOC 操作 Bean 管理（bean 生命周期）
IOC 操作 Bean 管理（XML自動裝配）
IOC 操作 Bean 管理（外部屬性文件）

總結(jié)

Spring-IOC容器-Bean管理-基于XML方式

Spring框架概述

1.Spring是輕量級的開源的JavaEE框架

2.Spring可以解決企業(yè)應(yīng)用開發(fā)的復(fù)雜性

3.Spring有兩個核心部分：IOC和AOP

1.IOC：控制反轉(zhuǎn)，把創(chuàng)建對象過程交給Spring進行管理

2.AOP：面向切面，不修改源代碼進行功能增強

4.Spring的特點

1.方便解耦，簡化開發(fā)

2.AOP編程支持

3.方便程序測試

4.方便和其他框架進行整合

5.方便進行事務(wù)操作

6.降低API開發(fā)難度

IOC概念和原理

1.什么是IOC？

1.控制反轉(zhuǎn)，把對象創(chuàng)建和對象之間的調(diào)用過程，交給 Spring 進行管理使用

2. IOC 目的：為了耦合度降低

2.IOC底層原理

1.xml解析，工廠模式，反射

3.圖解IOC底層原理

4.IOC（BeanFactory接口）

1.IOC 思想基于 IOC 容器完成，IOC 容器底層就是對象工廠

2.Spring 提供 IOC 容器實現(xiàn)兩種方式：（兩個接口）

①BeanFactory：IOC 容器基本實現(xiàn)，是 Spring 內(nèi)部的使用接口，不提供開發(fā)人員進行使用加載配置文件時候不會創(chuàng)建對象，在獲取對象（使用）才去創(chuàng)建對象

②ApplicationContext：BeanFactory接口的子接口，提供更多更強大的功能，提供給開發(fā)人員使用（加載配置文件時候就會把在配置文件對象進行創(chuàng)建）推薦使用！

5.IOC操作Bean管理

1.什么是Bean管理？

Bean管理指的是兩個操作：

1.Spring創(chuàng)建對象

2.Spring注入屬性

2.Bean管理操作的兩種方式

1.基于xml配置文件方式實現(xiàn)

2.基于注解方式實現(xiàn)

接下來的部分詳細(xì)講解IOC操作Bean管理基于XML方式的詳解

IOC 操作 Bean 管理（set方式注入&&使用有參構(gòu)造進行注入）

1.set方式注入

①創(chuàng)建類，定義屬性和對應(yīng)的 set 方法

public class Book {
    private String bName;
    private String bAuthor;
	//創(chuàng)建屬性
    public void setbName(String bName) {
        this.bName = bName;
    }
	//創(chuàng)建屬性對應(yīng)的 set 方法
    public void setbAuthor(String bAuthor) {
        this.bAuthor = bAuthor;
    }
}

②在 spring 配置文件配置對象創(chuàng)建，配置屬性注入

 <!--使用set方法注入屬性-->
<bean id="book" class="com.atguigu.spring5.testDemo.Book">
    <!--使用property完成屬性注入
            name：類里面屬性名稱
            value：向?qū)傩宰⑷氲闹?
        -->
    <property name="bAuthor" value="發(fā)如雪"></property>
    <property name="bName" value="周杰倫"></property>
</bean>

使用有參數(shù)構(gòu)造進行注入

①創(chuàng)建類，定義屬性，創(chuàng)建屬性對應(yīng)有參數(shù)構(gòu)造方法

public class Order {
    private String oName;
    private String address;
    public Order(String oName, String address) {
        this.oName = oName;
        this.address = address;
    }
}

②在 spring 配置文件中進行配置

<!--有參數(shù)構(gòu)造注入屬性-->
<bean id="order" class="com.atguigu.spring5.testDemo.Order">
    <constructor-arg name="address" value="東風(fēng)破"/>
    <constructor-arg name="oName" value="周杰倫"/>
</bean>

IOC 操作 Bean 管理（xml注入其他類型屬性）

注入空值和特殊符號

<bean id="book" class="com.atguigu.spring5.Book">
    <!--（1）null值-->
    <property name="address">
        <null/><!--屬性里邊添加一個null標(biāo)簽-->
    </property>
    <!--（2）特殊符號賦值-->
     <!--屬性值包含特殊符號
       a 把<>進行轉(zhuǎn)義 &lt; &gt;
       b 把帶特殊符號內(nèi)容寫到CDATA
      -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>
</bean>

注入屬性-外部bean

①創(chuàng)建兩個類service和dao類

public class UserService {//service類
    //創(chuàng)建UserDao類型屬性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add() {
        System.out.println("service add...............");
        userDao.update();//調(diào)用dao方法
    }
}
public class UserDaoImpl implements UserDao {//dao類
    @Override
    public void update() {
        System.out.println("dao update...........");
    }
}

②在spring配置文件中進行配置

<!--1 service和dao對象創(chuàng)建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--注入userDao對象
        name屬性：類里面屬性名稱
        ref屬性：創(chuàng)建userDao對象bean標(biāo)簽id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

注入屬性-內(nèi)部 bean

①在實體類之間表示一對多關(guān)系，員工表示所屬部門，使用對象類型屬性進行表示

//部門類
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}
//員工類
public class Emp {
    private String ename;
    private String gender;
    //員工屬于某一個部門，使用對象形式表示
    private Dept dept;
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}

②在spring配置文件中配置

<!--內(nèi)部bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--設(shè)置兩個普通屬性-->
    <property name="ename" value="周杰倫"></property>
    <property name="gender" value="男"></property>
    <!--設(shè)置對象類型屬性-->
    <property name="dept">
        <bean id="dept" class="com.atguigu.spring5.bean.Dept"><!--內(nèi)部bean賦值-->
            <property name="dname" value="宣傳部門"></property>
        </bean>
    </property>
</bean>

注入屬性-級聯(lián)賦值

<!--方式一：級聯(lián)賦值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--設(shè)置兩個普通屬性-->
    <property name="ename" value="Andy"></property>
    <property name="gender" value="女"></property>
    <!--級聯(lián)賦值-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
    <property name="dname" value="公關(guān)部門"></property>
</bean>

 //方式二：生成dept的get方法（get方法必須有?。。?
public Dept getDept() {
    return dept;
}

 <!--級聯(lián)賦值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--設(shè)置兩個普通屬性-->
    <property name="ename" value="jams"></property>
    <property name="gender" value="男"></property>
    <!--級聯(lián)賦值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技術(shù)部門"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
</bean>

IOC 操作 Bean 管理（xml注入集合屬性）

1.xml注入數(shù)組類型屬性

2.xml注入List集合類型屬性

3.xml注入Map集合類型屬性

//（1）創(chuàng)建類，定義數(shù)組、list、map、set 類型屬性，生成對應(yīng) set 方法
public class Stu {
    //1 數(shù)組類型屬性
    private String[] courses;
    //2 list集合類型屬性
    private List<String> list;
    //3 map集合類型屬性
    private Map<String,String> maps;
    //4 set集合類型屬性
    private Set<String> sets;
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

<!--（2）在 spring 配置文件進行配置-->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--數(shù)組類型屬性注入-->
        <property name="courses">
            <array>
                <value>java課程</value>
                <value>數(shù)據(jù)庫課程</value>
            </array>
        </property>
        <!--list類型屬性注入-->
        <property name="list">
            <list>
                <value>張三</value>
                <value>小三</value>
            </list>
        </property>
        <!--map類型屬性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--set類型屬性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
</bean>

在集合里面設(shè)置對象類型值

//學(xué)生所學(xué)多門課程
private List<Course> courseList;//創(chuàng)建集合
public void setCourseList(List<Course> courseList) {
    this.courseList = courseList;
}

<!--創(chuàng)建多個course對象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="MyBatis框架"></property>
</bean>
<!--注入list集合類型，值是對象-->
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

<!--第一步：在 spring 配置文件中引入名稱空間 util-->
<?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:util="http://www.springframework.org/schema/util" <!--添加util名稱空間-->
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  <!--添加util名稱空間-->
<!--第二步：使用 util 標(biāo)簽完成 list 集合注入提取-->
<!--把集合注入部分提取出來-->
<!--1 提取list集合類型屬性注入-->
<util:list id="bookList">
    <value>易筋經(jīng)</value>
    <value>九陰真經(jīng)</value>
    <value>九陽神功</value>
</util:list>
<!--2 提取list集合類型屬性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

IOC 操作 Bean 管理（FactoryBean）

1.Spring 有兩種類型 bean，一種普通 bean，另外一種工廠 bean（FactoryBean）

2.普通 bean：在配置文件中定義 bean 類型就是返回類型

3.工廠 bean：在配置文件定義 bean 類型可以和返回類型不一樣

（1）創(chuàng)建類，讓這個類作為工廠 bean，實現(xiàn)接口 FactoryBean。

（2）第二步實現(xiàn)接口里面的方法，在實現(xiàn)的方法中定義返回的 bean 類型。

public class MyBean implements FactoryBean<Course> {
    //定義返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
}

<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean">
</bean>

@Test
public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);//返回值類型可以不是定義的bean類型！
 System.out.println(course);
}

IOC 操作 Bean 管理（bean 作用域）

在 Spring 里面，默認(rèn)情況下，bean 是單實例對象，下面進行作用域設(shè)置：

1.在 spring 配置文件 bean 標(biāo)簽里面有屬性（scope）用于設(shè)置單實例還是多實例。

2.scope 屬性值

1.第一個值：默認(rèn)值，singleton，表示是單實例對象。

2.第二個值：prototype，表示是多實例對象。

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype"><!--設(shè)置為多實例-->
        <property name="list" ref="bookList"></property>
</bean>

3.singleton 和 prototype 區(qū)別：

1.singleton 單實例，prototype 多實例。

2.設(shè)置 scope 值是 singleton 時候，加載 spring 配置文件時候就會創(chuàng)建單實例對象。設(shè)置 scope 值是 prototype 時候，不是在加載 spring 配置文件時候創(chuàng)建對象，在調(diào)用 getBean 方法時候創(chuàng)建多實例對象。

IOC 操作 Bean 管理（bean 生命周期）

1.生命周期：從對象創(chuàng)建到對象銷毀的過程。

2.bean 生命周期

①通過構(gòu)造器創(chuàng)建 bean 實例（無參數(shù)構(gòu)造）

②為 bean 的屬性設(shè)置值和對其他 bean 引用（調(diào)用 set 方法）

③調(diào)用 bean 的初始化的方法（需要進行配置初始化的方法）

④bean 可以使用了（對象獲取到了）

⑤當(dāng)容器關(guān)閉時候，調(diào)用 bean 的銷毀的方法（需要進行配置銷毀的方法）

3.演示bean生命周期

public class Orders {
    //無參數(shù)構(gòu)造
    public Orders() {
        System.out.println("第一步---執(zhí)行無參數(shù)構(gòu)造創(chuàng)建bean實例");
    }
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步---調(diào)用set方法設(shè)置屬性值");
    }
    //創(chuàng)建執(zhí)行的初始化的方法
    public void initMethod() {
        System.out.println("第三步---執(zhí)行初始化的方法");
    }
    //創(chuàng)建執(zhí)行的銷毀的方法
    public void destroyMethod() {
        System.out.println("第五步---執(zhí)行銷毀的方法");
    }
}

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oName" value="周杰倫">
    </property>
</bean>

@Test
public void test1(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步---獲取創(chuàng)建bean實例對象");
    System.out.println(orders);
    ((ClassPathXmlApplicationContext)context).close();
}

輸出：
第一步---執(zhí)行無參數(shù)構(gòu)造創(chuàng)建bean實例
第二步---調(diào)用set方法設(shè)置屬性值
第三步---執(zhí)行初始化的方法
第四步---獲取創(chuàng)建bean實例對象

4.bean 的后置處理器，bean 生命周期有七步

①通過構(gòu)造器創(chuàng)建 bean 實例（無參數(shù)構(gòu)造）

②為 bean 的屬性設(shè)置值和對其他 bean 引用（調(diào)用 set 方法）

③把 bean 實例傳遞 bean 后置處理器的方法 postProcessBeforeInitialization

④調(diào)用 bean 的初始化的方法（需要進行配置初始化的方法）

⑤把 bean 實例傳遞 bean 后置處理器的方法 postProcessAfterInitialization

⑥bean 可以使用了（對象獲取到了）

⑦當(dāng)容器關(guān)閉時候，調(diào)用 bean 的銷毀的方法（需要進行配置銷毀的方法）

5.演示添加后置處理器效果

（1）創(chuàng)建類，實現(xiàn)接口BeanPostProcessor，創(chuàng)建后置處理器。

public class MyBeanPost implements BeanPostProcessor {//創(chuàng)建后置處理器實現(xiàn)類
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前執(zhí)行的方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后執(zhí)行的方法");
        return bean;
    }
}

（2）配置后置處理器

<!--配置文件的bean參數(shù)配置-->
<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">	<!--配置初始化方法和銷毀方法-->
    <property name="oname" value="手機"></property><!--這里就是通過set方式（注入屬性）賦值-->
</bean>
<!--配置后置處理器-->
<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

IOC 操作 Bean 管理（XML自動裝配）

1.什么是自動裝配？

根據(jù)指定裝配規(guī)則（屬性名稱或者屬性類型），Spring 自動將匹配的屬性值進行注

2.演示自動裝配過程

①根據(jù)屬性名稱自動注入

<!--實現(xiàn)自動裝配
   bean 標(biāo)簽屬性 autowire，配置自動裝配
   autowire 屬性常用兩個值：
   byName 根據(jù)屬性名稱注入 ，注入值 bean 的 id 值和類屬性名稱一樣
   byType 根據(jù)屬性類型注入
  -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

②根據(jù)屬性類型自動注入

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

IOC 操作 Bean 管理（外部屬性文件）

1.直接配置數(shù)據(jù)庫信息

①配置Druid連接池。

②引入Druid連接池依賴 jar 包。

<!--直接配置連接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

引入外部屬性文件配置數(shù)據(jù)庫連接池

①創(chuàng)建外部屬性文件，properties 格式文件，寫數(shù)據(jù)庫信息（jdbc.properties）

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

②把外部 properties 屬性文件引入到 spring 配置文件中 —— 引入 context 名稱空間。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--引入context名稱空間-->
        <!--引入外部屬性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置連接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean> 
</beans>