手撕Spring5框架（三）IOC操作Bean管理（基于XML）

清疚 2022-12-02 01:14 164阅读 0赞

**什么是Bean管理？**

通常是指依据Spring进行的两个操作：

1）Spring创建对象

2）Spring注入属性

Bean管理的两种实现方式：

*  基于XML方式
 *  基于注解方式

### IOC操作Bean管理（基于XML） ###

通过Spring去管理Bean我们下面具体讲解实现管理的两种方式：

*  **基于xml方式创建对象**

在之前入门案例章节我们已经初步认识了Spring基于xml方式创建对象。

<bean id="user" class="org.learn.spring5.User"></bean>

基本描述：

1）在Spring配置文件中，使用bean标签，标签里添加相应属性，就可以实现对象的创建。

2）在bean标签中包含许多属性

3）创建对象时，默认也是执行无参构造方法完成对象的创建。

bean标签下常用的几个属性介绍：

> **id**：唯一标识，不能添加特殊符号
> 
> **class**：类的全路径，
> 
> **name**：定义对象的标识，可以加特殊符号

*  **基于xml方式注入属性**

**DI**:依赖注入，就是注入属性

1.  第一种方式使用set方式注入
    
    (1)创建类，定义属性和对应的set方法

package org.learn.spring5;
    
    public class User {
    
        private String userName;
        private Integer age;
        
           public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public void addUser() {
    
            System.out.println("添加一个用户。。。。");
        }
    
        public void getUserInfo() {
            System.out.println("userName:" + userName);
            System.out.println("age:" + age);
    
        }
    }

(2)在Spring配置文件中，配置对象创建、配置属性注入

<?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">
    		
        <bean id="user" class="org.learn.spring5.User">
            
            <property name="userName" value="joh"></property>
            <property name="age" value="11"></property>
        </bean>
    
    </beans>

（3）编写测试程序

package org.learn.spring5;
    
    
    import org.junit.Test;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestSpring5 {
        @Test
        public void test() {
            //1.加载spring的配置文件
            BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
            //2.获取配置创建的对象
            //第一个参数是配置文件中配置的User对象的ID
            User user = context.getBean("user", User.class);
            System.out.println(user);
            user.addUser();
            user.getUserInfo();
        }
    }

执行测试方法得到结果如下：

org.learn.spring5.User@12c8a2c0
     添加一个用户。。。。
     userName:joh
     age:11

2.第二种方式使用构造函数注入

（1）创建类，定义属性和对应的构造方法

package org.learn.spring5;
    
    public class Order {
    
        private String orderNo;
    
        private String address;
    
        public Order(String orderNo, String address) {
            this.orderNo = orderNo;
            this.address = address;
        }
    
        public void orderIno(){
            System.out.println("orderNo:"+orderNo);
            System.out.println("address:"+address);
        }
    }

（2）在Spring配置文件中，配置对象创建、配置属性注入

<bean id="order" class="org.learn.spring5.Order">
            <constructor-arg name="orderNo" value="12333"></constructor-arg>
            <constructor-arg name="address" value="china"></constructor-arg>
        </bean>

（3）编写测试程序

@Test
        public void test2() {
            //1.加载spring的配置文件
            BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
            //2.获取配置创建的对象
            //第一个参数是配置文件中配置的User对象的ID
            Order order = context.getBean("order", Order.class);
            System.out.println(order);
            order.orderIno();
        }

执行测试方法得到结果如下：

org.learn.spring5.Order@fcd6521
    orderNo:12333
    address:china

3.Set方法注入的另一种方式，p命名空间

(1)在Spring配置文件中，配置对象创建、使用P命名空间配置属性注入

<bean id="user1" class="org.learn.spring5.User" p:userName="jack" p:age="15">
        </bean>

(2)编写测试程序

/**
         * P命名空间方式注入属性
         */
        @Test
        public void test3() {
            //1.加载spring的配置文件
            BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
            //2.获取配置创建的对象
            //第一个参数是配置文件中配置的User对象的ID
            User user = context.getBean("user1", User.class);
            System.out.println(user);
            user.addUser();
            user.getUserInfo();
        }

执行测试方法得到结果

org.learn.spring5.User@6dde5c8c
    添加一个用户。。。。
    userName:jack
    age:15

**注入空值和特殊符号**

1）空值

<property name="email">
                <null />
            </property>

2）特殊符号

<property name="email">
            <value>
                <![CDATA[<<email@qq.com>>]]>
            </value>
        </property>

**注入属性-外部bean**

场景：UserService和UserDao的关系

步骤：1）创建UserService类和UserDao接口、UserDAOImpl实现类

package org.learn.spring5.service;
    
    import org.learn.spring5.dao.UserDao;
    
    public class UserService {
    
        //创建userDao属性，生成set方法
    
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void userAdd() {
            //调用 userDao对象的userAdd方法
            System.out.println("service userAdd");
            userDao.userAdd();
    
        }
    }

package org.learn.spring5.dao;
    
    public interface UserDao {
    
        int userAdd();
    }

package org.learn.spring5.dao.impl;
    
    import org.learn.spring5.dao.UserDao;
    
    public class UserDaoImpl implements UserDao {
        public int userAdd() {
            System.out.println("UserDao userAdd");
            return 0;
        }
    }

2）在bean2.xml配置文件中创建对象UserDao和UserDao，并且在UserService对象中注入UserDao属性

3）创建测试程序

/**
         *注入属性-外部bean
         */
        @Test
        public void test4() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
           UserService userService =  context.getBean("userService", UserService.class);
           userService.userAdd();
        }

执行测试方法得到的结果

service userAdd
    UserDao userAdd

** 注入属性-内部bean**

场景：一对多关系： 班级和学生的关系

一个班级有多个学生，一个学生只属于一个班级

在实体类中表示一对多的关系

1）创建类和属性

package org.learn.spring5.bean;
    
    //班级类
    public class Classes {
    
        public void setName(String name) {
            this.name = name;
        }
    
        private String name;
    
        @Override
        public String toString() {
            return "Classes{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

package org.learn.spring5.bean;
    
    //学生类
    public class Student {
    
        //学生名称
        private String studentName;
        //学生的年龄
        private String age;
    
        public void setStudentName(String studentName) {
            this.studentName = studentName;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        public void setClasses(Classes classes) {
            this.classes = classes;
        }
    
        //学生所属的班级
        private Classes classes;
    
    
        public void add() {
            System.out.println("studentName:" + studentName + "----" + "age:" + age);
            System.out.println("classes:" + classes);
        }
    }

2）创建配置文件

3）创建测试程序

/**
         * 注入属性-内部bean
         */
        @Test
        public void test5() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
            Student student = context.getBean("student", Student.class);
            student.add();
        }

执行测试方法得到的结果

studentName:xiaoming----age:15
    classes:Classes{name='初三一班'}

**注入属性-级联赋值**

方式1：

配置文件中设置

<bean id="student" class="org.learn.spring5.bean.Student">
            
            <property name="studentName" value="xiaoming"></property>
            <property name="age" value="15"></property>
            
            <property name="classes" ref="classes"></property>
        </bean>
        <bean id="classes" class="org.learn.spring5.bean.Classes">
            <property name="name" value="初三一班"></property>
        </bean>

方式2：

Student类中class属性增加get方法

//学生所属的班级
        private Classes classes;
    
    
        public Classes getClasses() {
            return classes;
        }

配置文件中设置

**IOC操作Bean管理-注入集合属性**

1）注入数组类型属性

2）注入集合类型属性

3）注入Map类型属性

4）集合里设置对象的值

第一步：创建类

package org.learn.spring5.bean;
    
    
    import java.lang.reflect.Array;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    //班级类
    public class Classes {
    
        //数组类型
        private String[] student;
        //集合类型
        private List<String> list;
        //map类型
        private Map<String, String> maps;
    
        public void setStudents(List<Student> students) {
            this.students = students;
        }
    
        //对象类型
        private List<Student> students;
    
    
        public void setStudent(String[] student) {
            this.student = student;
        }
    
        public void setList(List<String> list) {
            this.list = list;
        }
    
        public void setMaps(Map<String, String> maps) {
            this.maps = maps;
        }
    
    
        public void test() {
            System.out.println(Arrays.toString(student));
            System.out.println(list);
            System.out.println(maps);
            System.out.println(students);
    
        }
    }

package org.learn.spring5.bean;
    
    
    //學生類
    public class Student {
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        //学生名称
        private String name;
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        //年龄
        private int age;
    }

第二步：创建Spring配置文件

<?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">
        
    
        <bean id="classes" class="org.learn.spring5.bean.Classes">
                
        <property name="student">
            <array>
                <value>zhangsan</value>
                <value>lisi</value>
                <value>wangwu </value>
            </array>
    
        </property>
                
            <property name="list">
                <list>
                    <value>list1</value>
                    <value>list2</value>
                    <value>list3</value>
                </list>
            </property>
                
            <property name="maps">
                <map>
                    <entry key="k1" value="v1"></entry>
                    <entry key="k2" value="v2"></entry>
                    <entry key="k3" value="v3"></entry>
                </map>
            </property>
            
            <property name="students">
                <list>
                    <ref bean="student1"></ref>
                    <ref bean="student2"></ref>
                </list>
            </property>
        </bean>
    
    
        <bean id="student1" class="org.learn.spring5.bean.Student">
            <property name="name" value="xiaoming"></property>
            <property name="age" value="15"></property>
        </bean>
        <bean id="student2" class="org.learn.spring5.bean.Student">
            <property name="name" value="xiaohong"></property>
            <property name="age" value="16"></property>
        </bean>
    </beans>

第三步：创建测试程序

/**
         * IOC操作Bean管理-注入集合属性
         */
        @Test
        public void test() {
    
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            Classes classes = context.getBean("classes", Classes.class);
            classes.test();
        }

测试程序执行结果：

[zhangsan, lisi, wangwu]
    [list1, list2, list3]
    {k1=v1, k2=v2, k3=v3}
    [Student{name='xiaoming', age=15}, Student{name='xiaohong', age=16}]

5）把集合属性抽取成公共部分

<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
    
    
        
        
        <util:list id="list1">
            <value>list1</value>
            <value>list2</value>
            <value>list3</value>
        </util:list>
    
        <bean id="classes" class="org.learn.spring5.bean.Classes">
            
            <property name="student">
                <array>
                    <value>zhangsan</value>
                    <value>lisi</value>
                    <value>wangwu</value>
                </array>
    
            </property>
            
            <property name="list" ref="list1"></property>
    
            
            <property name="maps">
                <map>
                    <entry key="k1" value="v1"></entry>
                    <entry key="k2" value="v2"></entry>
                    <entry key="k3" value="v3"></entry>
                </map>
            </property>
            
            <property name="students">
                <list>
                    <ref bean="student1"></ref>
                    <ref bean="student2"></ref>
                </list>
            </property>
        </bean>
    
    
        <bean id="student1" class="org.learn.spring5.bean.Student">
            <property name="name" value="xiaoming"></property>
            <property name="age" value="15"></property>
        </bean>
        <bean id="student2" class="org.learn.spring5.bean.Student">
            <property name="name" value="xiaohong"></property>
            <property name="age" value="16"></property>
        </bean>
    </beans>

**IOC操作Bean管理-工厂bean**

Spring 有两种类型的Bean，一种是普通bean，另一种是工厂bean（FactoryBbean）

普通bean：在配置文件中定义的类型和返回类型一致

工厂bean：在配置文件中定义的类型可以和返回类型不一致

工厂bean的实现步骤

1）创建普通类Student

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

2）创建自定义工厂类并实现接口FactoryBean

import org.springframework.beans.factory.FactoryBean;
    
    public class MyBean implements FactoryBean<Student> {
        //定义返回的bean
        public Student getObject() throws Exception {
            Student student = new Student();
            student.setName("zhangsan");
            return student;
        }
    
        public Class<?> getObjectType() {
            return null;
        }
    }

3）创建Spring的配置文件

4）创建测试类

/**
         * IOC操作Bean管理-工厂bean
         */
        @Test
        public void test() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            Student student = context.getBean("myBean", Student.class);
            System.out.println(student);
        }

测试程序执行结果：

Student@23d2a7e8

以上就是对Spring的Bean管理具体的一些实现进行讲解，包括了bean的对象如何创建和属性如何注入的，以及工厂bean是如何创建和创建的。

具体源码可访问我的码云，下载完整源码。