Spring学习：Bean管理（XML方式）

溪午闻璐

已于 2022-04-03 19:13:15 修改

阅读量2.3k

点赞数 2

分类专栏： spring学习文章标签： spring java 后端

于 2022-02-02 19:01:32 首次发布

本文链接：https://blog.csdn.net/sssxlxwbwz/article/details/122767846

版权

spring学习专栏收录该内容

10 篇文章 2 订阅

订阅专栏

一、Bean管理概述

1.1 Bean管理

1. Bean管理指的是两个操作（依赖注入），分别为：

Spring创建对象（依赖）
Spring注入属性（注入）

2. Bean 管理操作有两种方式：

基于xml配置文件方式实现
基于注解方式实现

1.2 基于XML方式创建对象

（1） 在spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象的创建。如下所示：

    <!-- 配置User对象 -->
    <bean id="user" class="com.wyf.spring5.User"></bean>

（2）在Bean标签中有很多属性，如上例中的id、class。常见的属性及其含义如下：

id属性： 唯一标识（别名）
class属性：类全路径（包类路径）

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

二、基于xml方式注入属性

DI:依赖注入

2.1 第一种注入方式：使用set方式进行注入。

1. 创建类，定义属性和对应的set方法；

public class Book {
    //创建属性
    private String bname;
    private String bauthor;

    //创建属性对应的set方法
    public void setBname(String bname){
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

2. 在spring配置文件配置对象创建（<bean>标签），配置属性注入（<bean>标签内部的<property>标签）。注入属性在创建对象的基础之上完成，先创建对象，在注入属性。

    <!-- set方法注入属性-->
    <bean id = "book" class="com.wyf.spring5.Book">
        <!-- 使用property完成属性注入
            name: 类里面属性名称
            value:向属性注入的值
        -->
        <property name="bname" value="史记"></property>
        <property name="bauthor" value="司马迁"></property>
    </bean>

对xml方式使用set进行注入的测试：

public class TestSpring5 {
    @Test
    public void testbook(){
        //1. 加载spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2. 获取配置创建的对象
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
        book.testDeno();
    }
}

测试结果：

com.wyf.spring5.Book@3c46e67a
史记::司马迁

2.2 第二种注入方式：使用有参数的构造函数进行注入

1. 创建类，定义属性，创建属性对应的有参数构造方法

public class Orders {
    //属性
    private String name;
    private String address;
    //多参数构造函数
    public Orders(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

2. 在spring配置文件中进行配置：

    <!-- 使用有参构造函数注入属性-->
    <bean id = "orsers" class="com.wyf.spring5.Orders">
        <constructor-arg name="name" value="abc"></constructor-arg>
        <constructor-arg name = "address" value="china"></constructor-arg>
    </bean>

对xml方式使用有参构造注入的测试：

public class TestSpring5 {
    @Test
    public void testorder(){
        //1. 加载spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2. 获取配置创建的对象
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println(orders);
        orders.orderTest();
    }
}

测试结果：

com.wyf.spring5.Orders@74e52ef6
abc::china

2.3 xml注入其他类型属性

2.3.1 字面量

（1）设置null值：

        <!-- 向属性注入null值 -->
        <property name="address">
            <null/>
        </property>

(2) 属性值包含特殊符号：

<!--属性值包含特殊符号 ，两种方式可以实现：
    1 把<>进行转义 &lt; &gt; 
    2 把带特殊符号内容写到 CDATA 
--> 
<property name="address"> 
    <value><![CDATA[<<南京>>]]></value> 
</property>

2.3.2 注入属性-外部bean

示例：

1） 创建两个类service类和dao类；

2） 在service调用dao里面的方法；

3） 在sping配置文件中进行配置。

userDao实现类：

public class UserDaoImpl implements UserDao{
    @Override
    public void updata() {
        System.out.println("dao updata....");
    }
}

UserService类：


/**
 * 在UserService中调用UserDao的方法
 */
public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add....");

//        /**
//         * 原始的调用方式
//         */
//        UserDao dao = new UserDaoImpl();
//        dao.updata();

        /**
         * Spring方式
         */
        userDao.updata();

    }
}

配置文件将userDao注入到userService中：

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

    <!-- 创建service和dao对象 -->
    <bean id="userService" class="com.wyf.service.UserService">
        <!-- 在service 中注入UserDao对象
            name属性：类里面的属性名称
            ref属性：创建userDao对象bean标签id值
        -->
        <property name="userDao" ref="userDaoImdl"></property>
    </bean>

    <bean id="userDaoImdl" class="com.wyf.dao.UserDaoImpl"></bean>

</beans>

2.3.3 注入属性—内部bean

示例：

一对多关系，如部门和员工。一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多。

使用实体类表示一对多的关系如下所示：

/**
 * 部门类
 */
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "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;
    }

    public void add(){
        System.out.println(ename+"::"+gender+"::"+dept.toString());
    }
}

在spring配置文件中进行配置（配置为内部bean）：

    <!-- 内部bean -->
    <bean id="emp" class="com.wyf.bean.Emp">
        <!-- 设置两个普通的属性，名称和性别 -->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>

        <!-- 设置对象类型属性 -->
        <property name="dept">
            <!-- 内部bean -->
            <bean id="dept" class="com.wyf.bean.Dept">
                <property name="dname" value="研发部"></property>
            </bean>
        </property>
    </bean>
    <bean id="userDaoImdl" class="com.wyf.dao.UserDaoImpl"></bean>

2.3.4 xml注入集合属性

示例：

注入数组类型属性；
注入 List 集合类型属性
注入 Map 集合类型属性

（1）创建类，并在其中定义数组，list、map、set类型属性，生成对应的set方法

public class Stu {
    //1. 数组类型属性
    private String[] courses;
    //2.list集合类型属性
    private List<String> list;
    //3.Map集合类型属性
    private Map<String,String> maps;
    //4. set集合类型属性
    private Set<String> sets;
    
    //学生所学的多门课程
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
    
    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;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
}

（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">
    <!-- 1.集合类型属性注入 -->
    <bean id="stu" class="com.wyf.collectionType.Stu">
        <!-- 数组类型属性注入 -->
        <property name="courses">
            <array>
                <value>数学</value>
                <value>英语</value>
            </array>
        </property>
        <!-- list类型属性注入 -->
        <property name="list">
            <list>
                <value>java</value>
                <value>C++</value>
                <value>C#</value>
            </list>
        </property>
        <!-- list类型属性注入 -->
        <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>
</beans>

4. 在集合里面设置对象类型值

    <!-- 创建多个course对象 -->
    <bean id="course1" class="com.wyf.collectionType.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.wyf.collectionType.Course">
        <property name="cname" value="Mybatis框架"></property>
    </bean>

        <!-- 注入List集合类型,值为对象 -->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

5. 把集合注入部分提取出来

(1) 在 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:p="http://www.springframework.org/schema/p" 
       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 
http://www.springframework.org/schema/util/spring-util.xsd">

（2）使用 util 标签完成 list 集合注入提取

<!--1 提取list集合类型属性注入--> 
<util:list id="bookList">     
    <value>易筋经</value> 
    <value>九阴真经</value> 
    <value>九阳神功</value> 
</util:list> 
<!--2 提取list集合类型属性注入使用--> 
<bean id="book" class="com.atguigu.spring5.collectiontype.Book"> 
    <property name="list" ref="bookList"></property> 
</bean>

三、FactoryBean

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean)。

普通 bean：在配置文件中定义 bean 类型就是返回类型（前文都是普通Bean）
工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型 ,如下方法getObject

import com.wyf.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course>{

    /**
     * 定义返回bean对象
     * 此处返回Course类型
     * @return
     * @throws Exception
     */
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

配置文件：

    <bean id="mybean" class="com.wyf.facbean.MyBean"></bean>

测试代码：

    @Test
    public void TestBean5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Course myBean = context.getBean("mybean",Course.class);
        System.out.println(myBean);
    }

虽然定义的类型为MyBean，但是工程Bean返回的是Course类型。

四、Bean作用域及声明周期

4.1 Bean作用域

在Spring中，Bean作用域用于确定那种类型的Bean实例应该从Spring容器中返回给调用者，即设置创建bean实例是单实例还是多实例。Spring中默认情况下Bean是单实例的。

默认情况获取Bean:

    @Test
    public void TestBean4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Stu stu = context.getBean("stu",Stu.class);
        Stu stu2 = context.getBean("stu",Stu.class);
        System.out.println(stu);
        System.out.println(stu2);
    }

程序输出结果表明stu和stu2是同一个对象，也就是单实例：

com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@2a5c8d3f

4.2 设置Bean为单实例或多实例

在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例。scope 属性值如下：

第一个值默认值，singleton，表示为单实例对象。
第二个值 prototype, 表示是多实例对象。

在配置文件中设置scope属性值为多实例：

<bean id="stu" class="com.wyf.collectionType.Stu" scope="prototype"></bean>

程序运行结果表明是两个不同的对象：

com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@752325ad

singleton 和 prototype 区别 ：
1. singleton 单实例，prototype 多实例
2. 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象，设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象。

4.3 Bean的生命周期

生命周期是指从对象创建到对象销毁的过程。

Bean的生命周期过程如下：

通过构造器创建 bean 实例（无参数构造）
为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
调用 bean 的初始化的方法（需要进行配置初始化的方法）
bean 可以使用了（对象获取到了）
当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

示例如下：

public class Orders {
    //无参构造
    public Orders(){
        System.out.println("第一步 执行无参构造，创建bean实例");
    }

    private String onname;
    public void setOnname(String onname) {
        this.onname = onname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

配置文件如下：

    <bean id="orders" class="com.wyf.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="onname" value="手机"></property>
    </bean>

测试代码如下：

    @Test
    public void TestBean5(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Orders orsers = context.getBean("orders",Orders.class);
        System.out.println("第四步 获取创建 bean实例对象 ");
        System.out.println(orsers);
        //手动让bean实例销毁
        context.close();
    }

程序运行结果：

第一步执行无参构造，创建bean实例
第二步调用set方法设置属性值
第三步执行初始化方法
第四步获取创建 bean实例对象
com.wyf.bean.Orders@22555ebf
第五步执行销毁的方法

加上bean 的后置处理器，其实bean 生命周期有七步：

（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）把bean 实例传递 bean后置处理器的方法 postProcessBeforeInitialization
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6）bean 可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

五、xml自动装配（很少使用，一般用注解）

自动装配是指根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入。

（1）根据属性名称自动注入。注入值bean的 id值和类属性名称一样

<!--实现自动装配 
    bean标签属性 autowire，配置自动装配 
    autowire属性常用两个值： 
        byName根据属性名称注入 ，注入值bean的 id值和类属性名称一样 
        byType根据属性类型注入 
--> 
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"> 
    <!--<property name="dept" ref="dept"></property>--> 
</bean> 

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

（2）根据属性类型自动注入

<!--实现自动装配 
    bean标签属性 autowire，配置自动装配 
    autowire属性常用两个值： 
        byName根据属性名称注入 ，注入值bean的 id值和类属性名称一样 
        byType根据属性类型注入 
--> 
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"> 
    <!--<property name="dept" ref="dept"></property>--> 
</bean> 
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>