一个打通基于XML管理Bean

冷不防 2023-10-09 21:40 14阅读 0赞

**目录**

准备工作

添加依赖

引入配置文件

获取bean

①方式一：根据id获取

②方式二：根据类型获取

③方式三：根据id和类型

④注意的地方

⑤扩展知识

依赖注入之setter注入

①创建学生类Student

②配置bean时为属性赋值

③测试

依赖注入之构造器注入

①在Student类中添加有参构造

②配置bean

③测试

特殊值处理

①字面量赋值

②null值

③xml实体

④CDATA节

为对象类型属性赋值

方式一：引用外部bean

方式二：内部bean

方式三：级联属性赋值

为数组类型属性赋值

①修改Student类

②配置bean

为集合类型属性赋值

①为List集合类型属性赋值

②为Map集合类型属性赋值

③引用集合类型的bean

p命名空间

引入外部属性文件

①加入依赖

②创建外部属性文件

③引入属性文件

④配置bean

⑤测试

--------------------

### 准备工作 ###

搭建模块springIoc，新建一个module

![37f8756881214e4681d327395460af26.png][]

#### 添加依赖 ####

<dependencies>
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.3</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>5.3.1</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.19.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-slf4j2-impl</artifactId>
                <version>2.19.0</version>
            </dependency>
        </dependencies>

#### **引入配置文件** ####

引入模块配置文件：beans.xml、log4j2.xml

![203187fb5edc4d86b313b23fd5bba646.png][]

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

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <loggers>
            
            <root level="debug">
                <appender-ref ref="spring6log"/>
                <appender-ref ref="RollingFile"/>
                <appender-ref ref="log"/>
            </root>
        </loggers>
    
        <appenders>
            
            <console name="spring6log" target="SYSTEM_OUT">
                
                <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
            </console>
    
            
            <File name="log" fileName="d:/spring6_log/test.log" append="false">
                <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
            </File>
    
            
            <RollingFile name="RollingFile" fileName="d:/spring6_log/app.log"
                         filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
                <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
                <SizeBasedTriggeringPolicy size="50MB"/>
                
                <DefaultRolloverStrategy max="20"/>
            </RollingFile>
        </appenders>
    </configuration>

### 获取bean ###

#### ①方式一：根据id获取 ####

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

public class HelloWorld {
    
        public void sayHello() {
            System.out.println("helloworld");
        }
    }

@Test
        public void testHelloWorld(){
            ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
            HelloWorld helloworld = (HelloWorld) ac.getBean("helloWorld");
            helloworld.sayHello();
        }

#### ②方式二：根据类型获取 ####

@Test
    public void testHelloWorld1(){
    	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld bean = ac.getBean(HelloWorld.class);
        bean.sayHello();
    }

> 需要注意如果在beans.xml中配置多个Helloword的bean对象，则会报错

#### ③方式三：根据id和类型 ####

@Test
    public void testHelloWorld2(){
    	ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);
        bean.sayHello();
    }

#### ④注意的地方 ####

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个当IOC容器中一共配置了两个：

根据类型获取时会抛出异常：

> org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.atguigu.spring6.bean.HelloWorld' available: expected single matching bean but found 2: helloworldOne,helloworldTwo

#### ⑤扩展知识 ####

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

> 可以，前提是bean唯一

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

> 不行，因为bean不唯一

**结论**

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 **instanceof** 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

> java中，instanceof运算符用于判断前面的对象是否是后面的类，或其子类、实现类的实例。如果是返回true，否则返回false。也就是说：用instanceof关键字做判断时， instanceof 操作符的左右操作必须有继承或实现关系

### 依赖注入之setter注入 ###

#### ①创建学生类Student ####

public class Student {
    
        private Integer id;
    
        private String name;
    
        private Integer age;
    
        private String sex;
    
        public Student() {
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        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 String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    
    }

#### ②配置bean时为属性赋值 ####

新建一个spring-di.xml在resources目录下

#### **③测试** ####

@Test
    public void testDIBySet(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-di.xml");
        Student studentOne = ac.getBean("studentOne", Student.class);
        System.out.println(studentOne);
    }

![87b2f7bfbee84802bc8208860bde97a2.png][]

### 依赖注入之构造器注入 ###

#### **①在Student类中添加有参构造** ####

public Student(Integer id, String name, Integer age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

#### **②配置bean** ####

spring-di.xml

> 注意：
> 
> constructor-arg标签还有两个属性可以进一步描述构造器参数：
> 
>  *  index属性：指定参数所在位置的索引（从0开始）
>  *  name属性：指定参数名

#### **③测试** ####

@Test
    public void testDIByConstructor(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-di.xml");
        Student studentOne = ac.getBean("studentTwo", Student.class);
        System.out.println(studentOne);
    }

### 特殊值处理 ###

#### ①字面量赋值 ####

> 什么是字面量？
> 
> int a = 10;
> 
> 声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。
> 
> 而如果a是带引号的：'a'，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<property name="name" value="张三"/>

#### ②null值 ####

注意：

>     <property name="name" value="null"></property>
>     以上写法，为name所赋的值是字符串null

#### ③xml实体 ####

<property name="expression" value="a < b"/>

#### ④CDATA节 ####

### 为对象类型属性赋值 ###

**①创建班级类Clazz**

public class Clazz {
    
        private Integer clazzId;
    
        private String clazzName;
    
        public Integer getClazzId() {
            return clazzId;
        }
    
        public void setClazzId(Integer clazzId) {
            this.clazzId = clazzId;
        }
    
        public String getClazzName() {
            return clazzName;
        }
    
        public void setClazzName(String clazzName) {
            this.clazzName = clazzName;
        }
    
        @Override
        public String toString() {
            return "Clazz{" +
                    "clazzId=" + clazzId +
                    ", clazzName='" + clazzName + '\'' +
                    '}';
        }
    
        public Clazz() {
        }
    
        public Clazz(Integer clazzId, String clazzName) {
            this.clazzId = clazzId;
            this.clazzName = clazzName;
        }
    }

**②修改Student类**

在Student类中添加以下代码：

private Clazz clazz;
    
    public Clazz getClazz() {
    	return clazz;
    }
    
    public void setClazz(Clazz clazz) {
    	this.clazz = clazz;
    }

#### 方式一：引用外部bean ####

配置Clazz类型的bean：

为Student中的clazz属性赋值：

错误演示：

> 如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException: Cannot convert value of type 'java.lang.String' to required type 'com.study.Clazz' for property 'clazz': no matching editors or conversion strategy found
> 
> 意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值

#### 方式二：内部bean ####

#### 方式三：级联属性赋值 ####

### 为数组类型属性赋值 ###

#### **①修改Student类** ####

在Student类中添加以下代码：

private String[] hobbies;
    
    public String[] getHobbies() {
        return hobbies;
    }
    
    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }

#### **②配置bean** ####

### 为集合类型属性赋值 ###

#### ①为List集合类型属性赋值 ####

在Clazz类中添加以下代码：

private List<Student> students;
    
    public List<Student> getStudents() {
        return students;
    }
    
    public void setStudents(List<Student> students) {
        this.students = students;
    }

配置bean：

> 若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

#### ②为Map集合类型属性赋值 ####

创建教师类Teacher：

public class Teacher {
    
        private Integer teacherId;
    
        private String teacherName;
    
        public Integer getTeacherId() {
            return teacherId;
        }
    
        public void setTeacherId(Integer teacherId) {
            this.teacherId = teacherId;
        }
    
        public String getTeacherName() {
            return teacherName;
        }
    
        public void setTeacherName(String teacherName) {
            this.teacherName = teacherName;
        }
    
        public Teacher(Integer teacherId, String teacherName) {
            this.teacherId = teacherId;
            this.teacherName = teacherName;
        }
    
        public Teacher() {
    
        }
        
        @Override
        public String toString() {
            return "Teacher{" +
                    "teacherId=" + teacherId +
                    ", teacherName='" + teacherName + '\'' +
                    '}';
        }
    }

在Student类中添加以下代码：

private Map<String, Teacher> teacherMap;
    
    public Map<String, Teacher> getTeacherMap() {
        return teacherMap;
    }
    
    public void setTeacherMap(Map<String, Teacher> teacherMap) {
        this.teacherMap = teacherMap;
    }

配置bean：

#### ③引用集合类型的bean ####

<util:list id="students">
        <ref bean="studentOne"></ref>
        <ref bean="studentTwo"></ref>
        <ref bean="studentThree"></ref>
    </util:list>
    
    <util:map id="teacherMap">
        <entry>
            <key>
                <value>10010</value>
            </key>
            <ref bean="teacherOne"></ref>
        </entry>
        <entry>
            <key>
                <value>10086</value>
            </key>
            <ref bean="teacherTwo"></ref>
        </entry>
    </util:map>
    <bean id="clazzTwo" class="com.study.Clazz">
        <property name="clazzId" value="4444"></property>
        <property name="clazzName" value="Javaee0222"></property>
        <property name="students" ref="students"></property>
    </bean>
    <bean id="studentFour" class="com.study.Student">
        <property name="id" value="1004"></property>
        <property name="name" value="赵六"></property>
        <property name="age" value="26"></property>
        <property name="sex" value="女"></property>
        
        <property name="clazz" ref="clazzOne"></property>
        <property name="hobbies">
            <array>
                <value>抽烟</value>
                <value>喝酒</value>
                <value>烫头</value>
            </array>
        </property>
        <property name="teacherMap" ref="teacherMap"></property>
    </bean>

使用util:list、util:map标签必须引入相应的命名空间

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

### p命名空间 ###

引入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:util="http://www.springframework.org/schema/util"
           xmlns:p="http://www.springframework.org/schema/p"
           xsi:schemaLocation="http://www.springframework.org/schema/util
           http://www.springframework.org/schema/util/spring-util.xsd
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

引入p命名空间后，可以通过以下方式为bean的各个属性赋值

### 引入外部属性文件 ###

#### **①加入依赖** ####

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.15</version>
    </dependency>

#### **②创建外部属性文件** ####

![13da072dc00e4feaadd361e1754d1dcf.png][]

jdbc.user=root
    jdbc-.password=atguigu
    jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    jdbc.driver=com.mysql.cj.jdbc.Driver

#### **③引入属性文件** ####

引入context 名称空间

<?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"
           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">
    
    </beans>

<context:property-placeholder location="classpath:jdbc.properties"/>

> 注意：在使用 context:property-placeholder 元素加载外包配置文件功能前，首先需要在 XML 配置的一级标签 <beans> 中添加 context 相关的约束。

#### **④配置bean** ####

#### **⑤测试** ####

@Test
    public void testDataSource() throws SQLException {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-datasource.xml");
        DataSource dataSource = ac.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }

[37f8756881214e4681d327395460af26.png]: https://img-blog.csdnimg.cn/37f8756881214e4681d327395460af26.png
[203187fb5edc4d86b313b23fd5bba646.png]: https://img-blog.csdnimg.cn/203187fb5edc4d86b313b23fd5bba646.png
[87b2f7bfbee84802bc8208860bde97a2.png]: https://img-blog.csdnimg.cn/87b2f7bfbee84802bc8208860bde97a2.png
[13da072dc00e4feaadd361e1754d1dcf.png]: https://img-blog.csdnimg.cn/13da072dc00e4feaadd361e1754d1dcf.png