本文已参与「新人创作礼」活动，一起开启掘金创作之路。

系列文章

零、写在前面

0.1 question

 # 容器与bean（01-08）
1、 @Autowired 和 @Resource区别？

 @Autowired 先按照类型
 @Resource 按照 bean名字
 
 # AOP（09-19）
 
 
 # Web MVC（20-36）
 
 
 # Spring Boot（37-42）
 
 
 # 其它（43-49）

0.2 推荐

视频

黑马Spring5高级49讲_220323

整个 Java 体系最核心的框架，没有之一。
面试必备 / 热点（从Spring的核心原理，到SpringMVC的执行流程，再到SpringBoot的自动配置）
技术、思想提升（大量设计模式的应用和体现）（应用了很多技术，拓宽知识面，了解技术发展趋势）

步骤（重在梳理线索，源码自己阅读）
- 了解欲研究的组件（类）的基本使用
- 用单元测试研究组件的特性
- 试着自己实现类似功能
- 最后再深入阅读该组件的源码
内容（五大篇章，49讲）
- 容器与Bean（1-8）
- AOP（9-19）
- Web MVC（20-36）
- Spring Boot（37-42）
- 其它（43-49）

黑马SSM框架教程_Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus_220420

掌握Spring相关概念
完成IOC/DI的入门案例编写
掌握IOC的相关配置与使用
掌握DI的相关配置与使用

官方文档 spring4 官方文档

spring5.2.19 官方文档

其它极客时间丁雪丰

此处应有图片一张！！！

一、Spring相关概念

1 介绍

1.1 为什么学

Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%
专业角度
- 简化开发，降低企业级开发的复杂性
- 框架整合，高效整合其它技术，提高企业级应用开发与运行效率

1.2 学什么

Spring框架的主要优势在于 简化开发 和 框架整合 上。

# 简化开发
- IOC
- AOP
	- 事务处理（Spring中AOP的具体应用，可以简化项目中的事务管理，也是Spring技术一大亮点。
        事务处理更简单更高效更强大。）

# 框架整合（Spring在框架整合这块已经做到了极致，它可以整合市面上几乎所有主流框架）
- MyBatis
- MyBatis-plus
- Struts
- Struts2
- Hibernate

# 综上，主要分为4部分
(1)IOC
(2)整合Mybatis(IOC的具体应用)
(3)AOP
(4)声明式事务(AOP的具体应用)

1.3 怎么学

# 学习Spring框架设计思想
对于Spring来说，它能迅速占领全球市场，不只是说它的某个功能比较强大，更重要是在它的思想上。

# 学习基础操作，思考操作与思想间的联系
掌握了Spring的设计思想，然后就需要通过一些基础操作来思考操作与思想之间的关联关系。

# 学习案例，熟练应用操作的同时，体会思想
会了基础操作后，就需要通过大量案例来熟练掌握框架的具体应用，加深对设计思想的理解。

2 Spring家族和Spring发展史

spring官网

重点关注 Spring Framework、SpringBoot 和 SpringCloud。

# 1、Spring Framework
Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。
Spring最早出现的技术，本笔记的内容。
Spring全家桶中的地位：其它所有的技术都是依赖它执行的，是一个底层的框架，是一个设计型的框架，
具有举足轻重的地位。

# 2、SpringBoot
Spring是来简化开发，而SpringBoot是来帮助Spring在简化的基础上能更快速进行开发。
简化开发的基础上加速开发，提高开发速度。

# 3、SpringCloud
这个是用来做分布式之微服务架构的相关开发。
分布式开发技术

# 还有很多其他的技术，也比较流行。
如SpringData,SpringSecurity等，这些都可以被应用在我们的项目中。

# 我们今天所学习的Spring其实指的是Spring Framework。

# Spring1.0是[ 纯配置文件] 开发
# Spring2.0为了简化开发[ 引入了注解开发 ]，此时是配置文件加注解的开发方式
# Spring3.0已经可以进行[ 纯注解开发 ]，使开发效率大幅提升，我们的课程会以注解开发为主
# Spring4.0根据JDK的版本升级对个别API进行了调整

# Spring5.0已经全面支持JDK8，现在Spring最新的是5系列所以建议大家把JDK安装成1.8版

3 Spring系统架构

Spring Framework的5版本目前没有最新的架构图，所以接下来主要研究4的架构图。

# （1）Core Container核心层
核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

# （2）AOP层
AOP：面向切面编程（设计概念），它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
Aspects:AOP是思想,Aspects是对AOP思想的具体实现

Spring：Aspects已经做的非常好了，告诉大家Aspects比我做得好，建议大家使用Aspects。
所以后面开发的时候，大家发现，除了要导AOP的坐标，还要导Aspects的坐标。

# （3）数据层
Data Access：数据访问，Spring全家桶中有对数据访问的具体实现技术
Data Integration：数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容

事务这一块做了非常大的突破，提供了效率非常高的事务控制方案。

# （4）web层
这一层的内容将在SpringMVC框架具体学习

# （5）test层
Spring主要整合了Junit来完成单元测试和集成测试

架构图讲究上层依赖下层，如AOP依赖核心容器的执行

4 Spring核心概念

目前项目中的问题：

耦合度偏高

针对这个问题，该如何解决呢?

我们就想，如果能把框中的内容给去掉，不就可以降低依赖了么？
但是又会引入新的问题，去掉以后程序能运行么?

答案肯定是不行，因为bookDao没有赋值，为Null，强行运行就会出空指针异常。

所以现在的问题就是，业务层不想new对象，运行的时候又需要这个对象，该咋办呢?

针对这个问题，Spring就提出了一个解决方案:
- 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象。

提出一个概念必定要解决一些问题，针对如上问题有下面3个关键性概念：

4.1 IoC（Inversion of Control）（由IOC容器提供对象）/DI

4.2 IoC容器

4.3 Bean

IoC（Inversion of Control）控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。

Spring技术对IOC思想进行了实现

Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"
IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean

DI（Dependency Injection）依赖注入

在容器中建立 bean与bean 之间的依赖关系的整个过程，称为依赖注入

# 目标：充分解耦
使用IOC容器管理bean（IOC)
在IOC容器内将有依赖关系的bean进行关系绑定（DI）

# 最终效果
使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系。

二、入门案例

5 IOC入门案例

IOC思路分析

# 1.管理什么？（Service与Dao）
# 2.如何将被管理的对象告知IoC容器？（配置）
# 3.被管理的对象交给IoC容器，如何获取到IoC容器？（接口）
# 4.IoC容器得到后，如何从坐标中获取IoC容器？（接口方法）
# 5.使用Spring导入哪些坐标？（pom.xml）

6 DI入门案例

DI思路分析

# 1.基于IOC管理Bean
# 2.Service中使用new形式创建的Dao对象是否保留?（否）
# 3.Service中需要的Dao对象如何进入到Service中?（提供方法）
# 4.Service与Dao间的关系如何描述?（配置）

代码详见 spring_01_quickstart

applicationContext.xml

// 1.导入spring的坐标spring-context，对应版本是5.2.10.RELEASE
// 添加spring配置文件 applicationContext.xml，并完成bean的配置

<!--2.配置bean-->
<!-- bean标签表示配置bean
id属性表示给bean起名字
class属性表示给bean定义类型
-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <!--7.配置server与dao的关系-->
    <!--property标签表示配置当前bean的属性
    name属性表示配置哪一个具体的属性
    ref属性表示参照哪一个bean-->
    <property name="bookDao" ref="bookDao"/>
</bean>

.java

// 3.获取IoC容器
 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
// 4.获取bean（根据bean配置id获取）
BookService bookService = (BookService) ctx.getBean("bookService");
bookService.save();

public class BookServiceImpl implements BookService {
    // DI入门案例部分开始
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

三、IoC/DI相关内容

7 IOC相关内容

7.1 bean基础配置

7.1.1 bean基础配置(id与class)

bean标签的功能、使用方式以及 id 和 class 属性的作用，我们通过一张图来描述下

# class属性能不能写接口如BookDao的类全名呢?
答案肯定是不行，因为接口是没办法创建对象的。

# 前面提过为bean设置id时，id必须唯一，但是如果由于命名习惯而产生了分歧后，该如何解决?
配置别名

7.1.2 bean的name属性指定别名

<!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔-->
<bean id="bookService" name="service service4 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>

获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常 NoSuchBeanDefinitionException

7.1.3 bean作用范围scope配置

<!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype-->
<bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>

# 为什么bean默认为单例?
bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高

# 哪些bean对象适合交给容器进行管理?
表现层对象
业务层对象
数据层对象
工具对象

# 哪些bean对象不适合交给容器进行管理?
封装实例的域对象，因为会引发线程安全问题，所以不适合。

那么单例 bean是怎么造出来的呢？

7.2 bean实例化

# 在讲解这三种创建方式之前，我们需要先确认一件事:
bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。

代码详见 spring_03_bean_instance

7.2.1 方法1：构造方法（常用）

public class BookDaoImpl implements BookDao {
    // 类中提供构造函数测试
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }

    public void save() {
        System.out.println("book dao save ...");
    }

}

Spring底层用的是反射。

Spring底层使用的是类的无参构造方法。

因为每一个类默认都会提供一个无参构造函数，所以其实真正在使用这种方式的时候，我们什么也不需要做。这也是我们以后比较常用的一种方式。

分析Spring的错误信息：错误信息从下往上依次查看，因为上面的错误大都是对下面错误的一个包装，最核心错误是在最下面。

7.2.2 方法2：静态工厂（了解）

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}

在spring的配置文件 applicationContext.xml中

<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

这种方式一般是用来兼容早期的一些老系统，所以了解为主。

7.2.3 方法3：使用实例工厂实例化bean（了解）

//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

.xml 配置

<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

7.2.4 方法4：使用FactoryBean实例化bean（务必掌握）

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
		// bean类型
    public Class<?> getObjectType() {
        return UserDao.class;
    }

}

.xml配置

<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。

总结一下：

- 构造方法(常用)
- 静态工厂(了解)
- 实例工厂(了解)
	- FactoryBean(实用)

7.3 bean的生命周期

对于生命周期，我们主要围绕着 bean 生命周期控制来讲解。

# 生命周期
从创建到消亡的完整过程

# bean生命周期
bean对象从创建到销毁的整体过程。

# bean生命周期控制
在bean创建后到销毁前做一些事情。

添加初始化和销毁方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化后对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destroy(){
        System.out.println("destroy...");
    }

}

配置生命周期

<!--init-method：设置bean初始化生命周期回调函数-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

测试

# 从结果中可以看出，init方法执行了，但是destroy方法却未执行，这是为什么呢?
- Spring的IOC容器是运行在JVM中
- 运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象，然后调方法执行
- main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了
- 所以没有调用对应的destroy方法

# 知道了出现问题的原因，具体该如何解决呢?
- ApplicationContext中没有close方法,需要将ApplicationContext更换成ClassPathXmlApplicationContext,
调用ctx的close()方法
- 调用ctx的registerShutdownHook()方法
在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器

public class AppForLifeCycle {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        //ctx.registerShutdownHook();
        //关闭容器
        ctx.close();
    }
}

# 分析上面的实现过程，会发现添加初始化和销毁方法，即需要编码也需要配置，实现起来步骤比较多也比较乱。

# Spring提供了两个接口来完成生命周期的控制，好处是可以不用再进行配置init-method和 destroy-method。
- 修改BookServiceImpl类，添加两个接口InitializingBean， DisposableBean
- 并实现接口中的两个方法afterPropertiesSet和destroy

实现2个接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

    public void destroy() throws Exception {
        System.out.println("service destroy");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

打印输出：

init...
set .....
service init
book dao save ...
service destroy
destroy...

总结一下：

初始化容器
1.创建对象(内存分配)
2.执行构造方法
3.执行属性注入(set操作)
4.[ 执行bean初始化方法 ]

使用bean
1.执行业务操作
关闭/销毁容器
1.[ 执行bean销毁方法 ]

8 DI相关内容

接下来就进入第二个大的模块：DI依赖注入

# 思考🤔：向一个类中传递数据的方式有几种?
- 普通方法(set方法)
- 构造方法

# 思考🤔：依赖注入描述了在容器中建立bean与bean之间的依赖关系的过程，如果bean运行需要的是数字或字符串呢?
- 引用类型
- 简单类型(基本数据类型与String)

# Spring就是基于上面这些知识点，为我们提供了两种注入方式，分别是:
- setter注入
	-简单类型
	-引用类型

- 构造器注入
	-简单类型
	-引用类型

8.1 setter注入 property

8.1.1注入引用数据类型

步骤1：声明属性并提供setter方法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;
    //setter注入需要提供要注入对象的set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    //setter注入需要提供要注入对象的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
        userDao.save();
    }
}

步骤2：配置文件中进行注入配置

<!--注入简单类型-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

<!--注入引用类型-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  <!--property标签：设置注入属性-->
  <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
  <!--ref属性：设置注入引用类型bean的id或name-->
  <property name="bookDao" ref="bookDao"/>
  <property name="userDao" ref="userDao"/>
</bean>

8.1.2注入基本数据类型

步骤1：声明属性并提供setter方法

public class BookDaoImpl implements BookDao {

    private String databaseName;
    private int connectionNum;
    //setter注入需要提供要注入对象的set方法
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }
    //setter注入需要提供要注入对象的set方法
    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

步骤2：配置文件中进行注入配置

    <!--注入简单类型-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--property标签：设置注入属性-->
        <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
        <!--value属性：设置注入简单类型数据值-->
        <property name="connectionNum" value="100"/>
        <property name="databaseName" value="mysql"/>
    </bean>

    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <!--注入引用类型-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <!--property标签：设置注入属性-->
        <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
        <!--ref属性：设置注入引用类型bean的id或name-->
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>

需要注意的是：

- 对于引用数据类型使用的是<property name="" ref=""/>
- 对于简单数据类型使用的是<property name="" value=""/>

8.2 构造器（构造方法）注入 constructor-arg

构造器注入引用数据类型

构造器注入多个引用数据类型

步骤1：删除setter方法并提供构造方法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;

    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
        userDao.save();
    }
}

步骤2：配置文件中进行配置构造方式注入

<!--解决参数类型重复问题，使用位置解决参数匹配-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
  <constructor-arg name="userDao" ref="userDao"/>
  <constructor-arg name="bookDao" ref="bookDao"/>
</bean>

name属性对应的值为构造函数中方法形参的参数名，必须要保持一致。
ref属性指向的是spring的IOC容器中其他bean对象。

构造器注入多个简单数据类型

步骤1：添加多个简单属性并提供构造方法

public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connectionNum;

    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

步骤2：配置完成多个属性构造器注入

<!--
    标准书写
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        根据构造方法参数名称注入
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="mysql"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
-->

<!--
    解决形参名称的问题，与形参名不耦合
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        根据构造方法参数类型注入
        <constructor-arg type="int" value="10"/>
        <constructor-arg type="java.lang.String" value="mysql"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>-->

    <!--解决参数类型重复问题，使用位置解决参数匹配-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--根据构造方法参数位置注入-->
        <constructor-arg index="0" value="mysql"/>
        <constructor-arg index="1" value="100"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
</beans>

上面已经完成了构造函数注入的基本使用，但是会存在一些问题：

当构造函数中方法的参数名发生变化后，配置文件中的name属性也需要跟着变
这两块存在紧耦合，具体该如何解决?

在解决这个问题之前，需要提前说明的是，这个参数名发生变化的情况并不多，所以上面的还是比较主流的配置方式，下面介绍的，大家都以了解为主。

# 方式一:删除name属性，添加type属性，按照类型注入
- 这种方式可以解决构造函数形参名发生变化带来的耦合问题
- 但是如果构造方法参数中有类型相同的参数，这种方式就不太好实现了

# 方式二:删除type属性，添加index属性，按照索引下标注入，下标从0开始
- 这种方式可以解决参数类型重复问题
- 但是如果构造方法参数顺序发生变化后，这种方式又带来了耦合问题

介绍完两种参数的注入方式，具体我们该如何选择呢?

# 1.强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
- 强制依赖指对象在创建的过程中必须要注入指定的参数

# 2.可选依赖使用setter注入进行，灵活性强
- 可选依赖指对象在创建过程中注入的参数可有可无

# 3.Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
# 4.如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
# 5.实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入

# 6.[ 自己开发的模块推荐使用setter注入 ]

8.3 自动配置 autowire属性

前面花了大量的时间把Spring的注入去学习了下，总结起来就一个字麻烦。

8.3.1 什么是依赖自动装配?

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

8.3.2 自动装配方式有哪些?

按类型（常用）
按名称
按构造方法
不启用自动装配

<bean class="com.itheima.dao.impl.BookDaoImpl"/>
<!--autowire属性：开启自动装配，通常使用按类型装配-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

注意事项：

# 需要注入属性的类中对应属性的setter方法不能省略
# 被注入的对象必须要被Spring的IOC容器管理
# 按照类型在Spring的IOC容器中如果找到多个对象，会报NoUniqueBeanDefinitionException
# 一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入byName
# 按照名称注入中的名称指的是什么
- 对外部类来说，setBookDao方法名，去掉set后首字母小写是其属性名

# 两种方式介绍完后，以后用的更多的是按照类型注入

1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

8.4 集合注入

前面我们已经能完成引用数据类型和简单数据类型的注入，但是还有一种数据类型集合，集合中既可以装简单数据类型也可以装引用数据类型。

对于集合，在Spring中该如何注入呢?

# 先来回顾下，常见的集合类型有哪些?
数组
List
Set
Map
Properties

# 针对不同的集合类型，该如何实现注入呢?

下面的所有配置方式，都是在bookDao的bean标签中进行注入

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"> 
</bean>

8.4.1 注入数组类型数据

 <!--数组注入-->
 <property name="array">
   <array>
     <value>100</value>
     <value>200</value>
     <value>300</value>
   </array>
 </property>

8.4.2 注入List类型数据

 <!--list集合注入-->
 <property name="list">
   <list>
     <value>itcast</value>
     <value>itheima</value>
     <value>boxuegu</value>
     <value>chuanzhihui</value>
   </list>
 </property>

8.4.3 注入Set类型数据

 <!--set集合注入-->
 <property name="set">
   <set>
     <value>itcast</value>
     <value>itheima</value>
     <value>boxuegu</value>
     <value>boxuegu</value>
   </set>
 </property>

8.4.4 注入map类型数据

 <!--map集合注入-->
 <property name="map">
   <map>
     <entry key="country" value="china"/>
     <entry key="province" value="henan"/>
     <entry key="city" value="kaifeng"/>
   </map>
 </property>

8.4.5 注入Properties类型数据

 <!--Properties注入-->
 <property name="properties">
   <props>
     <prop key="country">china</prop>
     <prop key="province">henan</prop>
     <prop key="city">kaifeng</prop>
   </props>
 </property>

输出结果

 book dao save ...
 遍历数组:[100, 200, 300]
 遍历List[itcast, itheima, boxuegu, chuanzhihui]
 遍历Set[itcast, itheima, boxuegu]
 遍历Map{country=china, province=henan, city=kaifeng}
 遍历Properties{province=henan, city=kaifeng, country=china}

说明

 # property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签
 # List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用
 # 集合中要添加引用类型，只需要把<value>标签改成<ref>标签，这种方式用的比较少

 # day02
 掌握IOC/DI配置管理第三方bean
 掌握IOC/DI的注解开发
 掌握IOC/DI注解管理第三方bean
 完成Spring与Mybatis及Junit的整合开发

Spring5_01