目录

一、创建 Bean 对象

二、将Bean对象存储到 Spring容器中

三、创建 Spring 上下文（得到一个Spring容器）

 1. 通过在启动类中 ApplicationContext 获取一个 Spring容器

 2. 通过在启动类种使用 BeanFactory 的方式来得到 Spring 对象 （此时获取 Bean 的路径也要保持一致）

四、从 Spring 容器中获取到 Bean 对象（并使用Bean对象）

1. 通过名称（.xml文件中设置的 id ）

     使用Applicationcontext 和 BeanFactory 的区别

  （1）所以二者的区别之一：

  （2）第二个区别：

 2. 通过类型的方式获取 Bean 对象

 3. 通过名称 + 类型的方式获取 Bean 对象

（1）先在.xml 文件中存储两个相同的 Bean 对象，然后再进行验证。

 四、什么是DI（依赖注入）

前言

    上一篇文章已经详细介绍了如何创建一个 Spring 项目，在创建好了 Spring 项目之后，就需要使用 Spring 容器存储和获取 Bean 对象了。 

    （Bean对象：在Java中，如果一个对象被使用多次，此时就可以成这个对象为 Bean 对象）

一、创建 Bean 对象

public class Student {
    private void sayHi() {
        System.out.println("Hii student");
    }
}

二、将Bean对象存储到 Spring容器中

    此时存储 Bean 对象是要依赖于xml配置文件的，里面要有一些配置信息，之后才能将 Bean对象存储到 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:content="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 https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package="com.bit.service"></content:component-scan>
</beans>

    之后将上述代码复制到创建的配置文件 spring-config.xml 文件中

     在上述配置文件中添加下边代码：

 <!--将 bean对象（com.spring.demo.Student）存到spring容器中，他的名称叫做student -->
    <bean id="student" class="com.spring.demo.Student"></bean>

    此时就把一个 Bean 对象（Student类）存储到 Spring 中了，接下来就是取出 Bean 对象了。

三、创建 Spring 上下文（得到一个Spring容器）

    要想得到一个 Spring 容器有两种方式：

ApplicationContext context = new
        ClassPathXmlApplicationContext("spring-config.xml");

//1. 得到Spring上下文对象
BeanFactory beanFactory =
        new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

 1. 通过在启动类中 ApplicationContext 获取一个 Spring容器

    此时需要注意：参数中的配置路径就是.xml 文件的名称，只有设置了这个文件名称，在程序运行的时候才会去这个文件中将 Bean 对象存储到 Spring 容器中。 

 2. 通过在启动类种使用 BeanFactory 的方式来得到 Spring 对象 （此时获取 Bean 的路径也要保持一致）

四、从 Spring 容器中获取到 Bean 对象（并使用Bean对象）

    获取 Bean 对象有三种方式：（用的方法都是一样的，只是getBean（）方法的传的参数不同）

1. 通过名称（.xml文件中设置的 id ）

//2. 从Spring容器中获取到Bean对象
        Student student = (Student) context.getBean("student");
        //3.使用Bean对象
        student.sayHi();

    此时需要  注意：getBean方法中的参数是 Bean 对象中的名称，此时需要和 spring-config.xml 文件中的 Bean 对象的 id 设置的名称保持相同。

    获取 Bean 对象之后我们可以使用 Student 类的sayHi方法证明以下  Bean 对象是否可以正常使用：

    使用BeanFactory的方式获取并使用 Bean对象

     使用Applicationcontext 和 BeanFactory 的区别

    此时再创建一个新的Teacher类，然后在Student 和 Teacher 类中都加上构造方法，如下代码：

public class Student {
    public Student() {
        System.out.println("do student init");
    }
    public void sayHi() {
        System.out.println("Hii student");
    }
}

public class Teacher {
    public Teacher() {
        System.out.println("do teacher init");
    }
    public void sayHi() {
        System.out.println("Hii Teacher");
    }
}

     此时再去用 ApplicationContext 和 Beanfactory就可以看到以下运行结果：

    在App中并没有获取 Teacher 对象，但是此时却加载了 Teacher 类的构造方法，而BeanFatory只会在 getBean() 方法调用了之后才会加载初始化 Student 对象。

  （1）所以二者的区别之一：

    在使用 ApplicationContext 时是饿汉模式，当得到一个 Spring 容器的时候就初始化了所有的 Bean 对象的，但是使用 BeanFactory 时是懒汉模式（非必要不加载），也就是只有在获取 Bean 对象的时候才会去初始化这个对象。

    这也是一个历史性的原因，在早期内存是比较昂贵的时候，是没有很大的存储空间，在一开始就初始化很多 Bean 对象的，但是随着后来的内存的价格相对不是很昂贵了，此时也就有多余的内存空间来存储很多的 Bean 对象了，尽管 Spring 是一个容器，但是底层存储的 Bean 对象本质还是在内存上存储的。

  （2）第二个区别：

    BeanFactory 是 ApplicationContext 的一个子类，所以ApplicationContext是后来有的，基于 BeanFactory又拓展了新的功能特性。

    按下F4键之后，我们可以看到如下图：

 2. 通过类型的方式获取 Bean 对象

    虽然通过名称是可以获取到 Student 对象，但是需要强转之后才能获取，因为 getBean 方法的返回值是一个Object类型的，所以用 Student 类型的去接收返回值就需要强制类型转换；所以代码看起来好像不是很优雅，此时就可以通过对象的类型来获取一个 Bean 对象。

Student student = context.getBean(Student.class);//根据类型获取

    此时的运行结果如下：

     但是这种方式获取Bean 对象也是有问题的；如果此时有两个同类型的 Bean 对象，此时再去通过类型的方式来获取Bean 对象就会报如下图的错误，因为类型一样时，程序不知道该获取哪一个对象，所以此时虽然不用强转了，但是同类型的 Bean 对象只能有一个。

 3. 通过名称 + 类型的方式获取 Bean 对象

    首先注意一个问题：如果在 Spring 容器中存储同一个对象，存储两份，此时是有两个对象呢，还是只有一个对象，另一个对象的引用指向了第一个对象呢？

（1）先在.xml 文件中存储两个相同的 Bean 对象，然后再进行验证。

 运行结果：

     也就是说首先是允许存储两个相同的 Bean 对象的，但是此时结果是false，所以是在 Spring 容器中存储了两份 Bean 对象的。（每一次存储 Bean 对象的时候，不会因为类型相同就只创建一个对象）

    根据名称 + 类型的方式来获取Bean 对象也是可以的，如下图结果：

 四、什么是DI（依赖注入）

Student student = context.getBean("student",Student.class);//根据类型获取

    上述代码就是依赖注入，就是DI，上一篇文章讲到IoC是一种思想，DI就是它的一种具体的实现方式，所以上面代码就是在程序运行的过程中动态的将 student 对象动态注入到当前运行的动态类中。