Spring Bean的管理（IOC 依赖注入）

Spring Bean

bean是什么？
我们可以将Spring的Bean理解为在Spring框架下的对象。

基于xml的实现

bean标签里配置的是需要spring框架管理的类

bean标签里面都可以写
id ：生成对象的名字，是唯一的

class：全类名（就是地址）

name：对象的别名，可以是多个

scope：范围，作用域
● singleton ：单例，也是默认的，在容器中只讲对象创建一个，多次获取时也只是同一个，在Spring启动时就创建好了
● prototype ：原型（多例），单个bean定义可以绑定到多个对象实例。
就是get一次，就创建一个对象。
● request：单个bean定义被绑定到当Http请求的生命周期上。就是每一次Http请求都是有属于自己的单独实例创建。仅用于 WebApplicationContext 环境
就是一个请求创建一个对象。
● session：单个bean的定义会绑定到Http Session的生命周期上。仅用于 WebApplicationContext 环境
一个会话，就创建一个对象。同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean。
● application：带个bean的定义会绑定到 ServletContext的生命周期上。仅用于 WebApplicationContext 环境
整个应用程序只有这一个对象。
● websocket：单个bean的定义会绑定到WebSocket的生命周期中。仅用于 WebApplicationContext 环境
整个服务器中就创建一个对象。

代码演示：

package com.demo.spring.model;

public class User {
   

    private String name;
    private Integer age;

    public User(){
   
        System.out.println("这是User的无参构造方法");
    }


    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;
    }
}

name定义别名的演示

<?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就会对其进行管理（生成对象，存储）
        由Spring框架生成的这个对象就称为一个bean(特值Spring框架创建的对象，它会添加额外的功能)
    -->

    <bean id="user" name="user1,user2" class="com.demo.spring.model.User"></bean>

</beans>

测试代码

package com.demo.spring.test;

import com.demo.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
   
    public static void main(String[] args) {
   

        //ApplicationContext是Spring的一个底层定义的接口，定义了一些接口
        //这个接口最终都会继承与BeanFactory
        //ClassPathXmlApplicationContext()是Spring中的一个具体落地实现的类,它就会创建并管理类
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //现在是测试代码，所以就要启动ClassPathXmlApplicationContext，
        // 如果是web程序的话，就不用书写的，直接就可以启动的

        Object user = applicationContext.getBean("user");
        User user1 = (User) applicationContext.getBean("user1");
        //user1 user2 是通过name中而获得的 和id的意义一样
        User user2 = applicationContext.getBean("user2", User.class);

        System.out.println(user);
        System.out.println(user1);
        System.out.println(user2);
    }
}

通过name定义的别名都是可以调用到定义的bean标签。

scope作用域的演示

singleton 演示

在xml中的bean标签里加上scope="singleton"再执行测试代码

<?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就会对其进行管理（生成对象，存储）
        由Spring框架生成的这个对象就称为一个bean(特值Spring框架创建的对象，它会添加额外的功能)
    -->

    <bean id="user" name="user1,user2" class="com.demo.spring.model.User" scope="singleton"></bean>

</beans>

在将测设代码，通过debug调试可以体现出singleton是在创建Spring时就创建好了对象。
它只是创建了一个对象，每次拿到的是同一对象

prototype 演示

在xml中的bean标签里加上scope="prototype"再执行测试代码

<?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就会对其进行管理（生成对象，存储）
        由Spring框架生成的这个对象就称为一个bean(特值Spring框架创建的对象，它会添加额外的功能)
    -->

    <bean id="user" name="user1,user2" class="com.demo.spring.model.User" scope="prototype"></bean>

</beans>

走测试代码，就可以明显的看出，它创建出了三个对象

xml配置方式的依赖注入（创建对象，为对象中的值赋值）

典型的企业级应用程序不会只有一个对象的（值Spring中的bean）。即使最简单的应用程序也有一些对象是一起工作的，最终传送到达前端的。

依赖项注入（DI：Dependency Injection）是指：对象仅仅通过构造函数的参数，工厂方法的参数或从工厂方法构造，或返回对象实例后在其上设置属性来定义依赖项（即它们使用的其他对象）。然后容器在创建bean时注入这些依赖项。这个过程基本上和bean