作者：学Java的冬瓜
博客主页：☀冬瓜的主页🌙
专栏：【Framework】
主要内容：往spring中存储Bean对象的三大方式：XML方式(Bean标签)；五大类注解；方法注解。从spring中取对象的两种方式：基本方法、注解方法(属性注入、set注入、构造方法注入)。

在这里插入图片描述

文章目录

Spring中Bean的存取方式
一、三大方式存储对象到spring容器中
- 1、XML方式把Bean存储到spring
- - 1.1、创建Bean类
  - 1.2、将Bean注册到Spring的xml配置文件
- 2、五大类注解方式 @Controller等存储Bean到spring
- - 2.1、五大类注解和JavaEE标准分层
  - 2.2、五大类注解方式往spring中存储Bean对象
- 3、方法注解方式 @Bean存储对象到spring中
- - 3.1、实体类的命名
  - 3.2、存储Bean对象
二、获取Bean对象(依赖注入)
- 1、获取对象的最基本的方法
- - 2.1、获取Spring容器方式
  - - 法一：BeanFactory接口和ClassPathResource继承类
    - 法二：ApplicationContext接口和ClassPathXmlApplicationContext继承类
  - 2.2、getBean获取指定的Bean对象
  - 2.3、获取Bean对象的名称的命名源码分析
- 2、使用依赖注入从spring获取对象
- - - 2.1、法一：属性注入
    - 2.2、法二：setter注入
    - 2.3、法三：构造方法注入
    - 补充：在依赖注入中 @Autowired和 @Resource的区别

Spring中Bean的存取方式

在Spring中，Bean的装配方式有两种，xml方式和注解方式。自己开发的类可以使用@Component注解或xml方式装配，推荐使用注解，因为更加简洁方便。
引入第三方库的包可以使用@Bean注解的方式或xml的方式，推荐使用xml方式，将库的内容和自己的代码分离。

一、三大方式存储对象到spring容器中

1、XML方式把Bean存储到spring

1.1、创建Bean类

a. 在Java目录下创建多级目录包com.spring.bean，在该包下创建Student类和Teacher类

在这里插入图片描述

b. Bean对象中，Student类如下(Teacher类的属性和方法与之相似，有私有属性，有Set和Get方法，构造方法)

package com.spring.bean;

public class Student {
    private String name;
    private int age;

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

    public void wmi(){
        System.out.println("I am student: my name is "+ name);
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.2、将Bean注册到Spring的xml配置文件

a. 在resources下创建spring中对象注册的配置文件，可以命名为spring-config.xml

在这里插入图片描述

b.将下列配置信息粘贴到配置文件中，并且使用bean标签对student和teacher类进行注册，注册时id属性是对保存到spring中的对象的重命名，class 属性是该类在项目中的路径+包名+类名，而相应的文件会从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">

    <!--将类对象，com.spring.bean.Student存进spring容器，名字是student，是一个spring bean-->
    <bean id="student" class="com.spring.bean.Student"/>
    <bean id="teacher" class="com.spring.bean.Teacher"/>
</beans>

2、五大类注解方式 @Controller等存储Bean到spring

2.1、五大类注解和JavaEE标准分层

A：五大类注解
@Controller：控制器，验证用户请求的数据的正确性。
@Service：服务，调度具体的执行方法。
@Repository：用户持久层，和数据库进行交互。
@Component：组件（工具类）
@Configuration：配置项，项目中的一些配置。为什么有配置项类？有很多原因，有一个就是在启动程序时，配置文件不一定会加载，这时就需要使用配置项来起到在程序运行时告诉程序需要先加载配置文件的作用。

B：JavaEE标准分层
在后端的分层当中，至少有控制层、服务层，数据持久层三个层次。

在这里插入图片描述

C：使用五大类注解和标准分层规范项目
下图中：实体类使用entity或model表示，其他部分按照五大类注解的方式分层，分出控制器类，服务类，数据库操作类，组件，配置文件类。

在这里插入图片描述

2.2、五大类注解方式往spring中存储Bean对象

A：创建包，Bean对象，并给类(Bean对象)添加适当的五大类注解
注意：满足需要存储在spring中的类在配置文件的base-package中，且这个类使用了五大类注解，就可以使用spring进行存取。

B：创建spring配置文件spring-config.xml，并在配置文件中注册可能要存入spring所有类的所在包
在下图中，可能存入spring的类是TestController包下的任意一个类(或TestController包的字包中的类)。如下图，springTest包的子包中的类都将保存在spring中，所以注册包springTest：
base-package="springTest"

注意点：

在配置文件中注册可能涉及的包和存储的类使用五大类注解二者缺一不可，如果缺少，报错说没有找到这个Bean对象。
需要存储在spring中的类本身的位置可以在注册的包中或者它的子包中。
使用五大类注解和注册包这个方法与使用bean标签(XML方式)（使用路径+包名+类名）的方式可以混合使用。即如果存在某个类需要存储在spring中，但又不适合放在注册的包里的任何位置，就可以将这个类放在注册包之外，但是使用bean注册当前类对象（即使用XML的方式存取对象）。

3、方法注解方式 @Bean存储对象到spring中

3.1、实体类的命名

补充：
实体类的管理：实体类不交给spring管理，由我们自己管理。
实体类的命名：
DO，基本对象，和数据库表结构一一对应，如UserEntity或UserDO或者直接和数据库表名一致 User。
VO，扩展对象，前端传给后端的对象。如UserVO，使用多个VO描述各种业务。

3.2、存储Bean对象

要点：

1> 方法注解需要配合五大类注解使用。比如UserBeans类下有多个方法注解，在UserBeans上需要加上五大类注解(一般是@Component)。之所以如此，是为了提高效率。
2> 方法注解的对象名可以改名。方法注解对象的名字不同于五大类注解，方法注解是默认方法名，但是可以在方法注解@Bean后加括号，使用name或value属性给Bean对象改名。

在这里插入图片描述

注意：

给Bean对象改名后，就不能再使用方法名获取到对象，只能使用修改后的名字。
如果存在方法名相同的两个@Bean方法在不同类中(都未修改名字)，当获取Bean对象时可以在方法上添加@Order(数字)，数字小的方法会先注入，但是后注入的方法会发生覆盖。

二、获取Bean对象(依赖注入)

1、获取对象的最基本的方法

2.1、获取Spring容器方式

a.目的相同： BeanFactory和ApplicationContext的目的相同，都是为了获取到spring容器
b.实现不同：
BeanFactory是使用类似于懒汉模式进行类加载并进行对象的初始化(获取到spring后，使用getBean方法获取对象时，才进行相关对象的类加载，并进行对象的初始化)。
ApplicationContext则是使用类似于饿汉模式(一获取spring容器会立即加载配置文件，并进行对象的初始化(执行构造方法，静态方法，静态代码块等))
c.父子关系：BeanFactory是ApplicationContext的子类

法一：BeanFactory接口和ClassPathResource继承类

给ClassPathResource传参spring的配置文件的文件名，给XmlBeanFactory传参ClassPathResource文件，最后BeanFactory接口接收其子类XmlBeanFactory类。

// 获取spring容器
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

使用BeanFactory和XmlBeanFactory和ClassPathResource获取Bean对象完整代码：

import com.spring.bean.Student;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class TeacherMain {
    public static void main(String[] args) {
        // 懒汉加载：调用时，才加载spring容器中的bean对象，效率不高，但是内存消耗低。
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

        Student student = (Student) factory.getBean("student");

        student.wmi();
    }
}

法二：ApplicationContext接口和ClassPathXmlApplicationContext继承类

获取spring容器（使用ApplicationContext接收其子类ClassPathXmlApplicationContext，给ClassPathXmlApplicationContext传参配置文件的文件名）

// 获取Spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

使用ApplicationContext接口和其子类ClassPathXmlApplicationContext获取Bean对象的完整代码：

import com.spring.bean.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StudentMain {
    public static void main(String[] args) {
        // 饿汉加载：一次性加载并初始化spring配置文件中的对象，后续操作spring容器中的bean对象时会很快，但是费内存。
        // 1通过resources文件夹中的xml文件名，获取spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        
        // 2获取Bean对象
        Student student2 = context.getBean("student", Student.class);

        // 3使用spring bean对象
        student.wmi();
    }
}

2.2、getBean获取指定的Bean对象

getBean方法的参数，可以使用多种方式进行传参：
一，使用名称获取
二、使用类型获取，（如果存储两个名称不同，类型相同的对象，会找不到唯一的Bean，从而报错）
三、使用名称+类型获取(最保险，不容易出错)

在这里插入图片描述

2.3、获取Bean对象的名称的命名源码分析

在获取Bean对象时，Bean对象名是什么？
首先，为了突出重点，我们先直接亮出结论：

规律：
①：如果需要保存在spring中的对象所属的类的首字母和第二个字母都大写，如（ACar->ACar），那么Bean对象的名字为原类名。使用context.getBean("原类名", 类名.class)方式从spring中获取对象。
②：如果不是情况一，那就把首字母小写(如A->a，RedCar->redCar)。如要从spring中获取一个CarController使用context.getBean("carController", CarController.class)获取CarController对象。

现在，我们查看spring源码，印证我们的结论：

A：操作：双击shift键，搜索BeanName，找到好几个类，因为我们是要找Bean的命名规则，根据Bean的命名英文推导，一个一个去找，我这里直接给出结论：双击shift键，搜索BeanName，出现下图，点击AnnotationBeanNameGenerator（注解BeanName生成类)。

B：点击左边的structure，弹出该类的各种方法。点击generatorBeanName方法。按住ctrl，点击下图中调用的方法。

C：在generatorBeanName方法中 ctrl+点击方法调用，跳转到BuildDefaultBeanName（参数一，参数二），在该方法中再次ctrl+点击方法调用跳转到它的重载函数BuildDefaultBeanName(参数)。再使用ctrl+点击方法调用，跳转到了最终的目的函数。

D：目的函数Introspector类的decapitalize方法中
注意： decapitalize方法中，传入的参数name是要存入spring的对象所属的类名。
如果传入的参数是null，或者参数长度为0，那么直接返回类名，代表这个存入spring的对象的名字是null或空字符串。
如果传入的参数长度大于1，且首字母和次首字母都是大写，那么直接返回类名，代表这个存入spring的对象的名字是原类名。
如果传入参数不是null，长度大于0，如果只有一个字母，将首字母小写返回。如果有多个字母，且首字母和第二个字母不都是大写，那就将原类名的第一个字母小写返回，作为存入spring的对象的名字。

E：结论： spring代码生成Bean对象的命名是使用jdk的标准起名的
看下图，在上面的操作C时，点击标出来的蓝色框定位当前类AnnotationBeanNamGenerator的位置，可以看到这个类是存在于spring源码中的。

操作C完成后，跳转到到Introspector类的decapitalize方法中，再寻找Introspector类的所在位置，如下图，它出现在了jdk的rt.jar中。

2、使用依赖注入从spring获取对象

注意：指在Controller的类中注入Service，在Service中注入Repository。学spring到目前为止暂时无法实现在main方法所在的类中注入Controller，在main中只能使用getBean获取对象，后续在springboot中则不需要main方法，而是tomcat自动执行。

2.1、法一：属性注入

属性注入：
步骤A：加注解 @Autowired
步骤B：写要注入的类作为当前类的属性。
如下图：

属性注入优缺点：
优点：简单，易操作。
缺点：
1> 无法实现final修饰的变量的注入，如private final CarService carService使用属性注入，无法成功注入；
2> 兼容性不足，只适用于IoC容器；
3> 易违反单一设计原则(注入多个对象，做多个功能)。

2.2、法二：setter注入

setter注入：
步骤A：要注入对象作为当前类的属性。
步骤B：注解@Autowired + set方法给要注入的对象赋值。（参数是自己从spring中取出来传给set方法作为参数）set注入的优缺点：
优点：严格遵循单一设计原则
缺点：
1> 无法实现final修饰的变量注入；
2> 注入的对象有被修改的风险，因为set方法是public修饰的。

2.3、法三：构造方法注入

构造方法注入：
步骤A：要注入对象作为当前类的属性。
步骤B：注解+构造方法给注入对象赋值。（参数是自己从spring中取出来传给构造方法作为参数）

构造方法注入优缺点：
优点：
1>可以实现final修饰变量的注入。（在Java中，final修饰的变量要么直接赋值，要么在构造方法中赋值，这是语法规定，因此构造方法可以实现final修饰变量的注入，而set方法无法实现）
2>注入对象无法被修改，因为构造方法只执行一次。
3> 构造方法注入可以保证注入对象被完全初始化。因为构造方法注入是对象实例化的过程中进行的，而属性注入和set注入是在对象实例化之后进行的。
4> 通用性更好，因为是Java语法规定，不仅仅适用于IoC容器。

补充：在依赖注入中 @Autowired和 @Resource的区别

问题1： @Autowired和 @Resource有时可以替换，有时不行，接下来分析它们的区别：
来源不同：@Autowired来自spring，@Resource来自JDK
使用范围不同：@Autowired可以适用于三种注入，@Resource只支持属性注入和set注入，不支持构造方法注入。
参数个数和类型不同：@Resource支持多个参数设置，适用于同一个类注入多个对象情况，对修改对象名字上更加灵活；@Autowired只有一个boolean类型的参数设置。
查找Bean对象方式不同：@Autowired先根据类型查找，后根据名称查找(注入变量的名称)，ByType；@Resource先根据名称查找，后根据类型查找，ByName。

问题2：当存储了同类型的多个对象时，可以使用两种方式依赖注入对象。
1> @Resource参数的设置

2> @Autowired + @Qualifier(value=“对象名”)