Spring IOC Bean标签属性介绍（内含教学视频+源代码）

`教学视频+源代码下载链接地址`：https://download.csdn.net/download/weixin_46411355/87442649

Spring IOC Bean标签属性介绍（内含教学视频+源代码）
`教学视频+源代码下载链接地址`：[https://download.csdn.net/download/weixin_46411355/87442649](https://download.csdn.net/download/weixin_46411355/87442649)
- 0.Bean标签属性介绍
- 1.0 新建一个Maven工程
- 1.1 pom.xml
- 1.2 实体类JavaBean
- - 1.2.1 User类
- 1.3 当Scope="singleton"时
- 1.4 当 Scope="singleton" 且 lazy-init="true" 时
- 1.5 当scope="prototype"时
- 1.6 当scope="prototype" 且 lazy-init="true" 时
- 1.7 小结
- 1.8 depends-on
- - 1.8.0 实体类JavaBean
  - - 1.8.0.1 Student类
  - 1.8.1 配置文件都不加lazy-init=true
  - 1.8.2 被依赖者(Student)加了lazy-init="true"
  - 1.8.3 依赖者（依赖其它类）（User）加了lazy-init="true"
  - 1.8.4 两者都加lazy-init="true"
- 1.9 init-method和destroy-method
- - 1.9.1 实体类JavaBean User加自定义的初始化方法和销毁方法
  - 1.9.3 加了lazy-init="true"
- 1.10 primary
- - 1.10.1 配置文件
  - 1.10.2 测试类
  - 1.10.3 测试效果

0.Bean标签属性介绍

id：是bean的唯一标识。一个bean，其id值只能有一个。在整个IOC容器中，id值不允许重复，使用id名称作为key。

name：一个bean的名称，可以存在多个，多个之间使用逗号分隔。不论bean有没有定义name属性，默认id都会当做name。

class：bean的具体的类型，即实体类JavaBean的全限定类名，由包名和类名组成。

scope：bean的作用域


prototype	非单例，每次获取都会创建一个新的bean对象
singleton	单例，多次获取永远同一个bean，默认值
request	一次请求，基于web项目的bean的作用域
session	一次会话，基于web项目的bean的作用域

lazy-init：延迟初始化，默认只要加载了配置文件，bean对象就会被初始化。lazy-init则是获取时才会初始化，只针对单例模式有效。非单例每次都会创建，没有延迟初始化的意义。

depends-on：初始化时依赖的对象，当前对象初始化前需先初始化depends-on指定的对象

init-method：对象初始化后调用的方法

destroy-method：对象销毁时，调用的方法

autowire：属性自动装配。byName根据属性名称装配，byType根据类型装配。

autowire-candidate：是否允许作为自动装配的候选项。true作为自动装配的候选项，false不作为自动装配的候选项。

primary：优先使用该bean，因为Spring需要支持使用那些类型查找对象。在一个大类型下，可能存在多个小类型。如果根据大类型装配属性时，不知道使用哪个具体的对象，则可以根据Primary设置优先级。

1.0 新建一个Maven工程

1.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjpowernode</groupId>
    <artifactId>02_IOCProject</artifactId>
    <version>1.0.0</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

1.2 实体类JavaBean

1.2.1 User类

com.bjpowernode.domain包下
User.java

package com.bjpowernode.domain;



import java.util.Objects;


public class User {
    private Long id;
    private String name;
    private Integer age;

    public User(){
        System.out.println("create User");
    }

    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) && Objects.equals(name, user.name) && Objects.equals(age, user.age);
    }

}

1.3 当Scope="singleton"时

resources资源文件夹下
右击New->XML Configuration File->Spring config
命名为applicationContext
在这里插入图片描述

1.3.1 applicationContext.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="singleton"></bean>

</beans>

1.3.2 测试类

     @Test
    public void testBeanLabel_ScopeSingleton() {
        //获取Spring容器
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext1.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        //从spring中获取bean对象
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        User user1Id = (User) classPathXmlApplicationContext.getBean("user1");
        User uName = (User) classPathXmlApplicationContext.getBean("u");
        User u2Name = (User) classPathXmlApplicationContext.getBean("u2");
        
        System.out.println("UserClass = " + UserClass.toString());
        System.out.println("user1Id = " + user1Id.toString());
        System.out.println("uName = " + uName.toString());
        System.out.println("u2Name = " + u2Name.toString());

        System.out.println(UserClass == user1Id);
        System.out.println(UserClass.equals(user1Id));
    }

1.3.3 测试结果
在这里插入图片描述
1.3.4 测试结果分析
说明初始化容器的过程中，就创建了对象
配置scope=“singleton”，打印出来的对象的地址是一样的

单例的饿汉式

1.4 当 Scope=“singleton” 且 lazy-init=“true” 时

1.4.1 applicationContext2.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="singleton" lazy-init="true"></bean>
</beans>

1.4.2 测试类

  @Test
    public void testBeanLabel_ScopeSingleton_LazyInitTrue() {
        //获取Spring容器
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        //从spring中获取bean对象
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        User user1Id = (User) classPathXmlApplicationContext.getBean("user1");
        User uName = (User) classPathXmlApplicationContext.getBean("u");
        User u2Name = (User) classPathXmlApplicationContext.getBean("u2");

        System.out.println("UserClass = " + UserClass.toString());
        System.out.println("user1Id = " + user1Id.toString());
        System.out.println("uName = " + uName.toString());
        System.out.println("u2Name = " + u2Name.toString());

        System.out.println(UserClass == user1Id);
        System.out.println(UserClass.equals(user1Id));

    }

1.4.3 测试结果
在这里插入图片描述
1.4.4 测试结果分析
lazy-init：初始化对象的延迟，默认为false，设置为true，则在初始化容器结束之后创建对象
配置scope=“singleton”，打印出来的对象的地址是一样的

单例的懒汉式

1.5 当scope="prototype"时

1.5.1 applicationContext3.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="prototype"></bean>

</beans>

1.5.2 测试类

  @Test
    public void testBeanLabel_ScopePrototype() {
        //获取Spring容器
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext3.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        //从spring中获取bean对象
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        User user1Id = (User) classPathXmlApplicationContext.getBean("user1");
        User uName = (User) classPathXmlApplicationContext.getBean("u");
        User u2Name = (User) classPathXmlApplicationContext.getBean("u2");

        System.out.println("UserClass = " + UserClass.toString());
        System.out.println("user1Id = " + user1Id.toString());
        System.out.println("uName = " + uName.toString());
        System.out.println("u2Name = " + u2Name.toString());

        System.out.println(UserClass == user1Id);
        System.out.println(UserClass.equals(user1Id));
    }

1.5.3 测试结果
在这里插入图片描述
1.5.4 测试结果分析
在容器初始化结束后创建bean对象
配置scope=“singleton”，打印出来的对象的地址是不同的，说明是多例

1.6 当scope=“prototype” 且 lazy-init=“true” 时

1.6.1 applicationContext4.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="prototype" lazy-init="true"></bean>

</beans>

1.6.2 测试类

  @Test
    public void testBeanLabel_ScopePrototype_LazyInit() {
        //获取Spring容器
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext4.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        //从spring中获取bean对象
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        User user1Id = (User) classPathXmlApplicationContext.getBean("user1");
        User uName = (User) classPathXmlApplicationContext.getBean("u");
        User u2Name = (User) classPathXmlApplicationContext.getBean("u2");

        System.out.println("UserClass = " + UserClass.toString());
        System.out.println("user1Id = " + user1Id.toString());
        System.out.println("uName = " + uName.toString());
        System.out.println("u2Name = " + u2Name.toString());

        System.out.println(UserClass == user1Id);
        System.out.println(UserClass.equals(user1Id));
    }

1.6.3 测试结果
在这里插入图片描述
1.6.4 测试结果分析
在容器初始化结束后创建bean对象，和不配置lazy-init="true"结果一样，说明配置了scope="protoype"多例模式，默认就是init-lazy=“true”，即默认就是懒加载

配置scope=“singleton”，打印出来的对象的地址是不同的说明是多例

1.7 小结

当scope=“singleton”时
默认是单例的饿汉式，即创建bean对象，在初始化容器对象结束之前完成
如果在配置lazy-init=“true”，则就是单例的懒汉式，即创建bean对象，在初始化容器对象结束之后完成

当scope=“prototype”时
是多例，不管是否配置lazy-init=“true”，创建bean对象，都在初始化容器对象结束之后完成，即默认lazy-init=“true”

1.8 depends-on

1.8.0 实体类JavaBean

1.8.0.1 Student类

package com.bjpowernode.domain;

import java.util.Objects;

public class Student {
    private Long id;
    private String name;
    private Integer age;

    public Student(){
        System.out.println("create Student");
    }

    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id) && Objects.equals(name, student.name) && Objects.equals(age, student.age);
    }

}

1.8.1 配置文件都不加lazy-init=true

配置文件
applicationContext5.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user" name="u,u1,u2" class="com.bjpowernode.domain.User" depends-on="student"/>

    <bean id="student" class="com.bjpowernode.domain.Student"/>


</beans>

测试类

 @Test
    public void testBeanLabel_dependsOn(){
        //获取Spring容器对象
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext5.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);
    }

测试结果
在这里插入图片描述
说明：
1、因为在bean中，user加了depends-on student，所以在创建User时会先创建Student对象
2、都在初始化容器结束之前，完成bean对象的创建

1.8.2 被依赖者(Student)加了lazy-init=“true”

配置文件
applicationContext6.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user" name="u,u1,u2" class="com.bjpowernode.domain.User" depends-on="student"/>

    <bean id="student" class="com.bjpowernode.domain.Student" lazy-init="true"/>


</beans>

测试类

  @Test
    public void testBeanLabel_dependsOnStudentLazyInit(){
        //获取Spring容器对象
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext6.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);
    }

测试结果
在这里插入图片描述
说明：
1、因为在bean中，user加了depends-on student，所以在创建User时会先创建Student对象
2、都在初始化容器结束之前，完成bean对象的创建
3、被依赖者（Student）加了"lazy-init=true"没有变化

1.8.3 依赖者（依赖其它类）（User）加了lazy-init=“true”

配置文件applicationContext7.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user" name="u,u1,u2" class="com.bjpowernode.domain.User" depends-on="student" lazy-init="true"/>

    <bean id="student" class="com.bjpowernode.domain.Student" />


</beans>

测试类

 @Test
    public void testBeanLabel_dependsOnUserLazyInit(){
        //获取Spring容器对象
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext7.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);
    }

测试效果
在这里插入图片描述
说明：
1、因为在bean中，user加了depends-on student，所以在创建User时会先创建Student对象
2、被依赖者（Student）在初始化容器结束之前，完成bean对象的创建
3、依赖者（依赖其它类）（User）加了lazy-init="true"发生变化，在初始化容器结束之后创建User bean 对象

1.8.4 两者都加lazy-init=“true”

配置文件applicationContext8.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user" name="u,u1,u2" class="com.bjpowernode.domain.User" depends-on="student" lazy-init="true"/>

    <bean id="student" class="com.bjpowernode.domain.Student" lazy-init="true" />


</beans>

测试类

  @Test
    public void testBeanLabel_dependsOnBothLazyInit(){
        //获取Spring容器对象
        System.out.println("------------------------初始化容器开始------------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext8.xml");
        System.out.println("----------------------初始化容器结束--------------------------------");
        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);
    }

测试效果
在这里插入图片描述
说明：
1、因为在bean中，user加了depends-on student，所以在创建User时会先创建Student对象
2、因为两个bean都加了lazy-init=“true”，所以都在初始化容器结束之后，完成bean对象的创建

1.9 init-method和destroy-method

1.9.1 实体类JavaBean User加自定义的初始化方法和销毁方法

在这里插入图片描述
User类

package com.bjpowernode.domain;



import java.util.Objects;


public class User {
    private Long id;
    private String name;
    private Integer age;

    public User(){
        System.out.println("create User");
    }

    public void MyInitMethod(){
        System.out.println("这是我自定义的初始化方法");
    }

    public void MyDestroyMethod(){
        System.out.println("这是我自定义的销毁方法");
    }

    public Long getId() {
        return id;
    }
```c
在这里插入代码片

public void setId(Long 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;
}


@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    return Objects.equals(id, user.id) && Objects.equals(name, user.name) && Objects.equals(age, user.age);
}

}

### 1.9.2 不加lazy-init="true"
配置文件
applicationContext9.xml

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

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="singleton" init-method="MyInitMethod" destroy-method="MyDestroyMethod" ></bean>

</beans>

测试类

  @Test
    public void testInitMethodAndDestroyMethod(){
        System.out.println("-------------------------初始化容器开始------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext9.xml");
        System.out.println("--------------------------初始化容器结束-----------------------------");

        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);

        classPathXmlApplicationContext.close();
    }

测试效果
在这里插入图片描述

1.9.3 加了lazy-init=“true”

配置文件
applicationContext10.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">

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user1" name="u,u1,u2" class="com.bjpowernode.domain.User" scope="singleton" init-method="MyInitMethod" destroy-method="MyDestroyMethod" lazy-init="true"></bean>

</beans>

测试类

 @Test
    public void testInitMethodAndDestroyMethod_LazyInit(){
        System.out.println("-------------------------初始化容器开始------------------------");
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext10.xml");
        System.out.println("--------------------------初始化容器结束-----------------------------");

        User UserClass = classPathXmlApplicationContext.getBean(User.class);
        System.out.println("UserClass = " + UserClass);

        classPathXmlApplicationContext.close();
    }

测试效果
在这里插入图片描述

1.10 primary

1.10.1 配置文件

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

    <!--配置要交给Spring管理的类的信息
    class属性     配置类的全限定名
    id属性        给当前bean对象，标注一个唯一标识 当前文档中只有一个
    name属性      可以设置多个name的值
    scope属性     表示作用域（指对象的创建是单例还是多例），singleton单例（默认值），prototype多例
    lazy-init    初始化对象的延迟，默认为false

    -->
    <bean id="user" name="u,u1,u2" class="com.bjpowernode.domain.User" depends-on="student" lazy-init="true"/>

    <bean id="student" class="com.bjpowernode.domain.Student" lazy-init="true" />

    <bean id="student1" class="com.bjpowernode.domain.Student" lazy-init="true" primary="true" >
        <property name="id" value="173020444"/>
        <property name="age" value="24"/>
        <property name="name" value="HHH"/>
    </bean>



</beans>

1.10.2 测试类

@Test
    public void testOPrimary(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext11.xml");
        Student student = classPathXmlApplicationContext.getBean(Student.class);
        System.out.println("student = " + student);

    }