②【Spring】一文精通：IOC - 基于XML方式管理Bean

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

在这里插入图片描述

个人简介Java领域新星创作者阿里云技术博主、星级博主、专家博主正在Java学习的路上摸爬滚打记录学习的过程~
个人主页.29.的博客
学习社区进去逛一逛~

IOC操作基于XML管理Bean

一、🚀【基于XML创建Bean】
- - 依赖
- - 组件类
- - XML配置文件
- - 测试
- - 默认空参构造器
二、🚀【bean的属性赋值setter注入】
- - 组件类
- - XML配置文件
- - 测试
三、🚀【引用外部已声明的Bean】
- - 组件类
- - XML配置文件
- - 测试
四、🚀【内部Bean】
- - XML配置文件
- - 测试
五、🚀【Bean的级联属性赋值】
- - XML配置文件
- - 测试
六、🚀【bean的属性赋值 (构造方法注入)】
- - 组件类
- - XML配置文件
- - 测试
七、🚀【为bean的属性赋特殊值】
- - 组件类
- - XML配置文件
八、🚀【使用p名称空间赋值Bean属性】
- - XML配置文件
九、🚀【Bean的集合属性赋值】
- - XML配置文件
- - ⚪单列集合
  - ⚪双列集合Map集合
十、🚀【Bean的自动装配】
- - 组件类
- -XML配置文件
- - 测试
十一、🚀【集合类型的Bean】
- -XML配置文件
十二、🚀【Bean属性赋值引入外部属性文件】
- - 依赖
- - 文件
- - 测试

一、🚀【基于XML创建Bean】

- 依赖

准备: 创建maven过程引入相关依赖
注普通java工程导入相关jar包也可。

    <dependencies>
        <!-- 基于Maven依赖传递性导入spring-context依赖即可导入当前所需所有jar包 -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>


        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

- 组件类

1. 首先创建一个类

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-12 11:22
 */
public class demo1 {

    public void doWork(){
        System.out.println("do.....work....");
    }
    
}

- XML配置文件

2. 创建Spring的XML配置文件

3. 在配置文件中配置组件

bean标签通过配置bean标签告诉IOC容器需要创建对象的组件是什么
id属性bean的唯一标识
class属性组件类的全类名

    <!-- 创建Bean -->
    <!-- 通过配置bean标签告诉IOC容器需要创建对象的组件是什么 -->
    <!-- id属性bean的唯一标识 -->
    <!-- class属性组件类的全类名 -->
    <bean id="demo1" class="com.haojin.ioc.demo.demo1"></bean>

注意当多个不同id的bean指向同一个类型class时会报异常

    <bean id="demo1" class="com.haojin.ioc.demo.demo1"></bean>
    <bean id="demo11" class="com.haojin.ioc.demo.demo1"></bean>

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No
qualifying bean of type ‘com.haojin.ioc.demo.demo1’ available:
expected single matching bean but found 2: demo1,demo11

- 测试

4. 测试

这里ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
通过getBean()获取对象
getBean()获取对象的方式 :
方式一根据id获取
方式二根据类型获取
方式三同时根据id和类型获取

import com.haojin.ioc.demo.demo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("demo1_bean.xml");


    @Test
    public void test1(){
        //通过getBean()获取对象
        //1.根据id获取
        demo1 demo1 = (demo1)context.getBean("demo1");
        //2.根据类型获取
        demo1 demo11 = context.getBean(demo1.class);
        //3.同时根据id和类型获取
        demo1 demo111 = context.getBean("demo1",demo1.class);

        demo1.doWork();
        demo11.doWork();
        demo111.doWork();
        System.out.println(demo1);
        System.out.println(demo11);
        System.out.println(demo111);
    }
}

- 默认空参构造器

注意XML配置文件中bean标签创建对象默认调用空参的构造方法

无法调用到空参构造方法将会报异常

org.springframework.beans.factory.BeanCreationException: Error
creating bean with name ‘demo1’ defined in class path resource
[demo1_bean.xml]: Instantiation of bean failed; nested exception is
org.springframework.beans.BeanInstantiationException: Failed to
instantiate [com.haojin.ioc.demo.demo1]: No default constructor found;
nested exception is java.lang.NoSuchMethodException:
com.haojin.ioc.demo.demo1.<init>()

二、🚀【bean的属性赋值setter注入】

- 组件类

1. 组件类增加属性准备GetSet方法

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-12 11:22
 */
public class demo1 {
    //添加的属性
    String str;

    //Get方法
    public String getStr() {
        return str;
    }

    //Set方法
    public void setStr(String str) {
        this.str = str;
    }

    public void doWork(){
        System.out.println("do.....work....");
    }
}

- XML配置文件

2. 通过property标签配置的属性值

property标签通过组件类的setXxx()方法给组件对象设置属性
name属性指定属性名这个属性名是getXxx()、setXxx()方法定义的和成员变量无关
value属性指定属性值

    <bean id="demo1" class="com.haojin.ioc.demo.demo1">
        <!-- property标签通过组件类的setXxx()方法给组件对象设置属性 -->
        <!-- name属性指定属性名这个属性名是getXxx()、setXxx()方法定义的和成员变量无关 -->
        <!-- value属性指定属性值 -->
        <property name="str" value="--这里是注入的内容--"></property>
    </bean>

注入的属性值为--这里是注入的内容--

- 测试

测试类中调用Get()方法验证是否以及为属性赋值。

import com.haojin.ioc.demo.demo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("demo1_bean.xml");


    @Test
    public void test1(){
        demo1 demo1 = context.getBean("demo1", demo1.class);
        String str = demo1.getStr();
        System.out.println(str);
    }
}

三、🚀【引用外部已声明的Bean】

- 组件类

1. 声明新的组件类

准备一个属性以及Get() 和 Set() 方法

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-13 16:16
 */
public class demo2 {

    String name;

    public String getName() {
        return name;
    }

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


}

2. 原组件引用新组件

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-12 11:22
 */
public class demo1 {
    //**********  原组件引用新组件  **********
    demo2 demo2;

    public com.haojin.ioc.demo.demo2 getDemo2() {
        return demo2;
    }

    public void setDemo2(com.haojin.ioc.demo.demo2 demo2) {
        this.demo2 = demo2;
    }
    //**********  原组件引用新组件  **********
    

    String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public void doWork(){
        System.out.println("do.....work....");
    }
}

- XML配置文件

3. 新组件配置Bean

<bean id="demo2" class="com.haojin.ioc.demo.demo2">
        <property name="name" value="my name is demo2"> </property>
    </bean>

4. 原组件Bean 引用新组件Bean

ref 属性通过 bean 的 id 引用另一个 bean
注意这里ref属性不能写成value属性会报异常

    <bean id="demo1" class="com.haojin.ioc.demo.demo1">
        <property name="str" value="--这里是注入的内容--"></property>
        <!--在原组件的 bean 中引用新组件的 bean-->
        <!--ref 属性通过 bean 的 id 引用另一个 bean-->
        <property name="demo2" ref="demo2"></property>

    </bean>

- 测试

5. 测试

import com.haojin.ioc.demo.demo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void test2(){
        //获取demo1对象
        demo1 demo1 = context.getBean("demo1", demo1.class);
        //通过demo1获取demo2对象及其属性
        String name = demo1.getDemo2().getName();
        System.out.println("demo2.name = " + name);
    }
}

四、🚀【内部Bean】

- XML配置文件

1. 重新配置XML文件设置内部Bean

在一个 bean 中再声明一个 bean 就是内部 bean
内部 bean 可以直接用于给属性赋值可以省略 id 属性

    <bean id="demo1" class="com.haojin.ioc.demo.demo1">
        <property name="str" value="--这里是注入的内容--"></property>

        <!-- 在一个 bean 中再声明一个 bean 就是内部 bean -->
        <!-- 内部 bean 可以直接用于给属性赋值可以省略 id 属性 -->
        <property name="demo2">
            <bean class="com.haojin.ioc.demo.demo2">
                <property name="name" value="this is 内部Bean赋值的demo2"/>
            </bean>
        </property>

    </bean>

- 测试

2. 测试

import com.haojin.ioc.demo.demo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void test2(){
        //获取demo1对象
        demo1 demo1 = context.getBean("demo1", demo1.class);
        //通过demo1获取demo2对象及其属性
        String name = demo1.getDemo2().getName();
        System.out.println("demo2.name = " + name);
    }
}

五、🚀【Bean的级联属性赋值】

- XML配置文件

1. 配置关联对象的Bean

<bean id="demo2" class="com.haojin.ioc.demo.demo2"></bean>

2. 装配关联对象赋值级联对象

-关联对象demo2
-级联属性demo2.name

    <bean id="demo1" class="com.haojin.ioc.demo.demo1">
        <!--装配关联对象-->
        <property name="demo2" ref="demo2"></property> 
        <!-- 对于demo1来说demo2的name属性就是 关联对象的级联属性 -->
        <property name="demo2.name" value="this is 级联属性赋值的demo2"></property>
    </bean>

- 测试

3. 测试

import com.haojin.ioc.demo.demo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void test2(){
        //获取demo1对象
        demo1 demo1 = context.getBean("demo1", demo1.class);
        //通过demo1获取demo2对象及其属性
        String name = demo1.getDemo2().getName();
        System.out.println("demo2.name = " + name);
    }
}

六、🚀【bean的属性赋值 (构造方法注入)】

- 组件类

1. 准备一个新的组件类含构造器GettetSettertoString()

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-13 20:37
 */
public class demo3 {
    private String name;
    private Integer age;
    private Double salary;
    
    public demo3(){}

    public demo3(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "demo3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

- XML配置文件

2. 配置组件类demo3的bean标签

使用constructor-arg标签进行构造器注入
index属性 :指定参数所在位置的索引从0开始
name属性指定参数名
不指定 index 和 name 就按照构造器的参数顺序赋值

<bean id="demo3" class="com.haojin.ioc.demo.demo3">
        <constructor-arg index="0" name="name" value="zero"></constructor-arg>
        <constructor-arg index="1" name="age" value="18"></constructor-arg>
        <constructor-arg index="2" name="salary" value="29000.99"></constructor-arg>
    </bean>

- 测试

3. 测试

import com.haojin.ioc.demo.demo3;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-01-12 13:47
 */
public class testDemo1 {

    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void test3(){
        demo3 demo3 = context.getBean("demo3", demo3.class);
        System.out.println("demo3 = "+ demo3);

    }
}

七、🚀【为bean的属性赋特殊值】

- 组件类

1. 设置一个类来演示特殊值的赋值

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-14 11:30
 */
public class demo4 {
    String demoValue;
    String comment;

    public demo4() {
    }

    public demo4(String demoValue, String comment) {
        this.demoValue = demoValue;
        this.comment = comment;
    }

    public String getDemoValue() {
        return demoValue;
    }

    public void setDemoValue(String demoValue) {
        this.demoValue = demoValue;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment;
    }

    @Override
    public String toString() {
        return "demo4{" +
                "demoValue='" + demoValue + '\'' +
                ", comment='" + comment + '\'' +
                '}';
    }
}

- XML配置文件

⚪NULL值

property标签通过组件类的setXxx()方法给组件对象设置属性
null标签将一个属性明确设定为null
name属性指定属性名

    <bean id="demo4" class="com.haojin.ioc.demo.demo4">
        <property name="demoValue">
        <!-- null标签将一个属性明确设定为null -->
            <null/>
        </property>
        <property name="comment" value="这是一个空值"/>
    </bean>

⚪XML实体

为什么使用XML实体

在Spring配置文件中">" "<" 等符号用于定义标签不能随意用于赋值。

XML实体

XML实体	实体字符	十进制表示	十六进制表示
quot;	"	"	"
amp;	&	&	&
apos;	'	'	'
lt;	<	<	<
gt;	>	>	>

例子

    <bean id="demo4" class="com.haojin.ioc.demo.demo4">
        <!-- "<" ">" 在XML文档中用来定义标签不能随便使用 -->
        <!-- 解决方案一使用XML实体来代替 -->
        <property name="demoValue" value="a &lt; b"/>
        <property name="comment" value="b &gt; a"/>
    </bean>

⚪CDATA节

CDATA中的C代表Character是文本、字符的含义CDATA就表示纯文本数据
XML解析器看到CDATA节就知道这里是纯文本就不会当作XML标签或属性来解析
value标签指定属性值
使用方式 : <![CDATA[文本内容]]>

    <bean id="demo4" class="com.haojin.ioc.demo.demo4">
        <property name="demoValue">
            <value><![CDATA[a < b = c & ' "]]></value>
        </property>
        <property name="comment">
            <value><![CDATA[CDATA的演示]]></value>
        </property>
    </bean>

八、🚀【使用p名称空间赋值Bean属性】

- XML配置文件

准备 :导入相关的 XML 约束在 IDEA 的协助下导入

xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"

导入完成

<?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:context="http://www.springframework.org/schema/context" 
       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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
</beans>

使用 p 名称空间的方式可以省略子标签 property将组件属性的设置作为 bean 标签的属性来完成。

使用方式 p:属性名=“属性值”

    <bean id="demo4" class="com.haojin.ioc.demo.demo4" 
          p:demoValue="p名称空间命名的值" 
          p:comment="省略了property标签"> 
    </bean>

注意刚开始 p:会爆红需要根据IDEA提示按下对应组合按键从而导入

九、🚀【Bean的集合属性赋值】

- XML配置文件

⚪单列集合

list标签准备一组集合类型的数据给集合属性赋值

    <bean id="id" class="类目录">
      <property name="属性名">
    <!-- list标签准备一组集合类型的数据给集合属性赋值 -->
        <list>
            <value>member01</value>
            <value>member02</value>
            <value>member03</value>
        </list>
      </property>
    </bean>

set标签使用 set 标签也能实现list标签效果同时附带去重功能

        <!-- 使用set标签也能实现list标签效果只是附带了去重功能 -->
        <set>
            <value>member01</value>
            <value>member02</value>
            <value>member02</value>
        </set>

array标签使用 array 标签也能实现list标签效果

        <array>
            <value>member01</value>
            <value>member02</value>
            <value>member02</value>
        </array>

⚪双列集合Map集合

map标签 \ props标签
给Map类型的属性赋值

        <map>
            <entry key="财务部" value="张三"/>
            <entry key="行政部" value="李四"/>
            <entry key="销售部" value="王麻子"/>
        </map>

        <props>
            <prop key="财务部">张三</prop>
            <prop key="行政部">李四</prop>
            <prop key="销售部">王麻子</prop>
        </props>

十、🚀【Bean的自动装配】

自动装配当一个组件需要其他组件时由 IOC 容器负责找到那个需要的组件并装配进去。

- 组件类

1. 准备两个组件类 controller 和 service随意命名

controller组件:

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-16 14:30
 *
 * 用来演示IOC容器的自动装配
 */
public class controller {

    service service;

    public service getService() {
        return service;
    }

    public void setService(service service) {
        this.service = service;
    }
}

service组件:

package com.haojin.ioc.demo;

/**
 * @author .29.
 * @create 2023-01-16 14:30
 *
 * 用来演示IOC容器的自动装配
 */
public class service {
}

controller类中包含service类型的属性及其Getter和Setter
controller组件自动装配时IOC容器负责找到service组件并装配进去。

-XML配置文件

2. 使用bean标签的autowire属性设置自动装配

自动装配效果有byType 和 byName

    <!--配置service组件的Bean-->
    <bean id="service" class="com.haojin.ioc.demo.service"></bean>

    <!--配置controller组件的Bean使用autowire属性自动装配-->
    <bean id="controller"
          class="com.haojin.ioc.demo.controller"
          autowire="byName">
    </bean>

注意

1、byType表示根据类型进行装配此时如果类型匹配的bean不止一个那么会抛NoUniqueBeanDefinitionException

2、byName表示根据bean的id进行匹配。而bean的id是根据需要装配组件的属性的属性名来确定的

- 测试

3.使用测试类验证自动装配效果。

public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void testAutowire(){
        controller controller = context.getBean("controller", controller.class);
        service service = controller.getService();
        System.out.println("service = " + service);
    }

若结果为null说明没有装配成功

十一、🚀【集合类型的Bean】

-XML配置文件

使用util:list标签及其内部的多个bean标签为集合属性赋值
规律util:list标签中多个bean标签的class属性及name属性一致

<util:list id="集合的id">
    <bean class="集合所在的类目录">
        <property name="集合的属性名" value="machineOne"/>
    </bean>
    <bean class="集合所在的类目录">
        <property name="集合的属性名" value="machineTwo"/>
    </bean>
    <bean class="集合所在的类目录">
        <property name="集合的属性名" value="machineThree"/>
    </bean>
</util:list>

给bean的属性赋值集合属性

十二、🚀【Bean属性赋值引入外部属性文件】

- 依赖

1. 导入连接数据库相关的依赖

        <!-- MySQL驱动,注版本不匹配会出现异常 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>
        <!-- 数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>

- 文件

2. 在配置bean时引入外部属性文件

外部属性文件jdbc.properties

jdbc.username=root
jdbc.password=abc123
jdbc.url=jdbc:mysql://localhost:3306/school?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

mysql 8.0及以上版本需要用驱动器  com.mysql.cj.jdbc.Driver

XML配置文件

    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--bean标签和property标签读取外部属性文件-->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

- 测试

3. 在测试类中尝试通过bean获取数据库连接

public class testDemo1 {

    //ApplicationContext方式实现IOC容器在配置文件被读取时就会将类的对象创建好
    //ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("ioc_bean.xml");

    @Test
    public void testSQL() throws SQLException {
        DruidDataSource dataSource = context.getBean("druidDataSource", DruidDataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println("connection = " + connection);

    }