【Spring框架】爆gan两万六千字，助你通关IoC和DI

✅作者简介：热爱Java后端开发的一名学习者，大家可以跟我一起讨论各种问题喔。
🍎个人主页：Hhzzy99
🍊个人信条：坚持就是胜利！
💞当前专栏：【Spring】
🥭本文内容：Spring框架IoC和DI的深入学习，助你逐步深入领悟这两个技术

Spring

文章目录

前言

我们为什么要学Spring呢?
从使用和占有率看

Spring在市场的占有率与使用率高
Spring在企业的技术选型命中率高
所以说,Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%说明:对于未使用Spring的项目一般都是些比较老的项目，大多都处于维护阶段。

从专业角度看

随着时代发展，软件规模与功能都呈几何式增长，开发难度也在不断递增，该如何解决? - Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷
随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，这些框架如何协调工作? - Spring可以框架整合，高效整合其他技术，提高企业级应用开发与运行效率

综上所述，Spring是一款非常优秀而且功能强大的框架，不仅要学，而且还要学好。

一、Spring相关的概念

Spring家族

官网：Spring官网，从官网我们可以大概了解到：

Spring能做什么:用以开发web、微服务以及分布式系统等,光这三块就已经占了JavaEE开发的九成多。
Spring并不是单一的一个技术，而是一个大家族，可以从官网的Projects中查看其包含的所有技术。

Spring发展到今天已经形成了一种开发的生态圈,Spring提供了若干个项目,每个项目用于完成特定的功能。

Spring已形成了完整的生态圈，也就是说我们可以完全使用Spring技术完成整个项目的构建、设计与开发。
Spring有若干个项目，可以根据需要自行选择，把这些个项目组合起来，起了一个名称叫全家桶，如下图所示我们今天所学习的Spring其实指的是Spring Framework。

Spring系统架构

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。它的发展也经历了很多版本的变更，每个版本都有相应的调整。

在这里插入图片描述

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

在这里插入图片描述

(1)核心层

Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

(2)AOP层

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

(3)数据层

Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现

(4)Web层

这一层的内容将在

SpringMVC

框架具体学习

(5)Test层

Spring主要整合了

Junit

来完成单元测试和集成测试

Spring核心概念

在Spring核心概念这部分内容中主要包含

IOC/DI

、

IOC容器

和

Bean

,那么问题就来了，这些都是什么呢?

IOC（Inversion of Control）控制反转

(1)什么是控制反转呢？

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

业务层要用数据层的类对象，以前是自己new的
现在自己不new了，交给别人[外部]来创建对象
别人[外部]就反转控制了数据层对象的创建权
这种思想就是控制反转
别人[外部]指定是什么呢?继续往下学**(2)Spring和IOC之间的关系是什么呢?**
Spring技术对IOC思想进行了实现
Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"
IOC思想中的别人[外部]指的就是Spring的IOC容器

(3)IOC容器的作用以及内部存放的是什么?

IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
被创建或被管理的对象在IOC容器中统称为Bean
IOC容器中放的就是一个个的Bean对象

(4)当IOC容器中创建好service和dao对象后，程序能正确执行么?

不行，因为service运行需要依赖dao对象
IOC容器中虽然有service和dao对象
但是service对象和dao对象没有任何关系
需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系

像这种在容器中建立对象与对象之间的绑定关系就要用到DI:

DI（Dependency Injection）依赖注入

(1)什么是依赖注入呢?

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入 - 业务层要用数据层的类对象，以前是自己new的- 现在自己不new了，靠别人[外部其实指的就是IOC容器]来给注入进来- 这种思想就是依赖注入

(2)IOC容器中哪些bean之间要建立依赖关系呢?

这个需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系

介绍完Spring的IOC和DI的概念后，我们会发现这两个概念的最终目标就是:充分解耦，具体实现靠:

使用IOC容器管理bean（IOC)
在IOC容器内将有依赖关系的bean进行关系绑定（DI）
最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.

入门案例

介绍完Spring的核心概念后，接下来我们得思考一个问题就是，Spring到底是如何来实现IOC和DI的，那接下来就通过一些简单的入门案例，来演示下具体实现过程:

需求分析:将BookServiceImpl和BookDaoImpl交给Spring管理，并从容器中获取对应的bean对象进行方法调用。

1.创建Maven的java项目

2.pom.xml添加Spring的依赖jar包

3.创建BookService,BookServiceImpl，BookDao和BookDaoImpl四个类

4.resources下添加spring配置文件，并完成bean的配置

5.使用Spring提供的接口完成IOC容器的创建

6.从容器中获取对象进行方法调用

步骤1:创建Maven项目
这个相信大家都会
步骤2:添加Spring的依赖jar包
pom.xml

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

步骤3:添加案例中需要的类
创建BookService,BookServiceImpl，BookDao和BookDaoImpl四个类

//BookDaopublicinterfaceBookDao{publicvoidsave();}//BookDaoImplpublicclassBookDaoImplimplementsBookDao{publicvoidsave(){System.out.println("book dao save ...");}}//BookServicepublicinterfaceBookService{publicvoidsave();}//BookServiceImplpublicclassBookServiceImplimplementsBookService{privateBookDao bookDao =newBookDaoImpl();publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

步骤4:添加spring配置文件
resources下添加spring配置文件applicationContext.xml，并完成bean的配置
在这里插入图片描述
步骤5:在配置文件中完成bean的配置

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><!--bean标签标示配置bean
        id属性标示给bean起名字
        class属性表示给bean定义类型
    --><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"/></beans>

注意事项：bean定义时id属性在同一个上下文中(配置文件)不能重复

步骤6:获取IOC容器
使用Spring提供的接口完成IOC容器的创建，创建App类，编写main方法

publicclassApp{publicstaticvoidmain(String[] args){//获取IOC容器ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");}}

步骤7:从容器中获取对象进行方法调用

publicclassApp{publicstaticvoidmain(String[] args){//获取IOC容器ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");//        bookDao.save();BookService bookService =(BookService) ctx.getBean("bookService");
        bookService.save();}}

步骤8:运行程序
在这里插入图片描述
Spring的IOC入门案例已经完成，但是在

BookServiceImpl

的类中依然存在

BookDaoImpl

对象的new操作，它们之间的耦合度还是比较高，这块该如何解决，就需要用到下面的

DI:依赖注入

。
步骤1: 去除代码中的new
在BookServiceImpl类中，删除业务层中使用new的方式创建的dao对象

publicclassBookServiceImplimplementsBookService{//删除业务层中使用new的方式创建的dao对象privateBookDao bookDao;publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

步骤2:为属性提供setter方法
在BookServiceImpl类中,为BookDao提供setter方法

publicclassBookServiceImplimplementsBookService{//删除业务层中使用new的方式创建的dao对象privateBookDao bookDao;publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}//提供对应的set方法publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}}

步骤3:修改配置完成注入
在配置文件中添加依赖注入的配置

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><!--bean标签标示配置bean
        id属性标示给bean起名字
        class属性表示给bean定义类型
    --><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><!--配置server与dao的关系--><!--property标签表示配置当前bean的属性
                name属性表示配置哪一个具体的属性
                ref属性表示参照哪一个bean
        --><propertyname="bookDao"ref="bookDao"/></bean></beans>

注意:配置中的两个bookDao的含义是不一样的

name="bookDao"中bookDao的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前面加set找对应的setBookDao()方法进行对象注入
ref="bookDao"中bookDao的作用是让Spring能在IOC容器中找到id为bookDao的Bean对象给bookService进行注入
综上所述，对应关系如下:步骤4:运行程序

IOC相关内容

通过前面两个案例，我们已经学习了

bean如何定义配置

，

DI如何定义配置

以及

容器对象如何获取

的内容，接下来主要是把这三块内容展开进行详细的讲解，深入的学习下这三部分的内容，首先是bean基础配置。

bean基础配置

对于bean的配置中，主要会讲解

bean基础配置

bean的别名配置

bean的作用范围配置

(重点),这三部分内容：
bean基础配置(id与class)
对于bean的基础配置，在前面的案例中已经使用过:

<bean id="" class=""/>

其中，bean标签的功能、使用方式以及id和class属性的作用，我们通过表格来描述下
类别描述名称bean类型标签所属beans标签功能定义Spring核心容器管理的对象格式

<bean/> ==== <bean></bean>

属性列表id:bean的id，使用容器可以通过id值获取对应的bean，在一个容器中id值唯一
class:bean的类型，即配置的bean的全部路径名范例

<bean id="bookDao" class="com.hzy.dao.BookDao"/>

其中需要大家重点掌握的是:bean标签的id和class属性的使用。
bean的name属性
步骤1：配置别名
打开spring的配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔--><beanid="bookService"name="service service4 bookEbi"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/></bean><!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype--><beanid="bookDao"name="dao"class="com.hzy.dao.impl.BookDaoImpl"/></beans>

步骤2:根据名称容器中获取bean对象

publicclassAppForName{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");//此处根据bean标签的id属性和name属性的任意一个值来获取bean对象BookService bookService =(BookService) ctx.getBean("service4");
        bookService.save();}}

步骤3:运行程序
在这里插入图片描述
注意事项:

bean依赖注入的ref属性指定bean，必须在容器中存在
在这里插入图片描述
如果不存在,则会报错，如下:

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

bean作用范围scope配置
关于bean的作用范围是bean属性配置的一个重点内容。

看到这个作用范围，我们就得思考bean的作用范围是来控制bean哪块内容的?

bean作用范围的配置属性

:
类别描述名称scope类型属性所属bean标签功能定义bean的作用范围，有singleton：单例（默认）和prototype：非单例范例

<bean id="bookDao" class="com.hzy.dao.impl.BookDaoImpl" scope="prototype"/>

同学们可以通过以下代码测试：

publicclassAppForScope{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao1 =(BookDao) ctx.getBean("bookDao");BookDao bookDao2 =(BookDao) ctx.getBean("bookDao");System.out.println(bookDao1);System.out.println(bookDao2);}}

打印，观察控制台的打印结果会发现两个对象的值是一样的，因此我们可以验证在默认情况下scope的默认值为singleton（单例）
而非单例则需要我们去设置：
在Spring配置文件中，配置scope属性来实现bean的非单例创建
在Spring的配置文件中，修改

<bean>

的scope属性,将scope设置为

prototype

<beanid="bookDao"name="dao"class="com.hzy.dao.impl.BookDaoImpl"scope="prototype"/>

测试打印出的结果会发现对象的值不一样。

bean实例化

对象已经能交给Spring的IOC容器来创建了，但是容器是如何来创建对象的呢?

就需要研究下

bean的实例化过程

，在这块内容中主要解决两部分内容，分别是

bean是如何创建的
实例化bean的三种方式，构造方法,静态工厂和实例工厂

在讲解这三种创建方式之前，我们需要先确认一件事:

bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。

基于这个知识点出发，我们来验证spring中bean的三种创建方式。
我们先来研究下Spring中的第一种bean的创建方式

构造方法实例化

:
步骤1:准备需要被创建的类
准备一个BookDao和BookDaoImpl类

publicinterfaceBookDao{publicvoidsave();}publicclassBookDaoImplimplementsBookDao{publicvoidsave(){System.out.println("book dao save ...");}}

步骤2:将类配置到Spring容器

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/></beans>

步骤3:编写运行程序

publicclassAppForInstanceBook{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");BookDao bookDao =(BookDao) ctx.getBean("bookDao");
        bookDao.save();}}

步骤4:类中提供构造函数测试
在BookDaoImpl类中添加一个无参构造函数，并打印一句话，方便观察结果。

publicclassBookDaoImplimplementsBookDao{publicBookDaoImpl(){System.out.println("book dao constructor is running ....");}publicvoidsave(){System.out.println("book dao save ...");}}

运行程序，如果控制台有打印构造函数中的输出，说明Spring容器在创建对象的时候也走的是构造函数
在这里插入图片描述
步骤5:将构造函数改成private测试

publicclassBookDaoImplimplementsBookDao{privateBookDaoImpl(){System.out.println("book dao constructor is running ....");}publicvoidsave(){System.out.println("book dao save ...");}}

运行程序，能执行成功,说明内部走的依然是构造函数,能访问到类中的私有构造方法,显而易见Spring底层用的是反射
在这里插入图片描述
步骤6:构造函数中添加一个参数测试

publicclassBookDaoImplimplementsBookDao{privateBookDaoImpl(int i){System.out.println("book dao constructor is running ....");}publicvoidsave(){System.out.println("book dao save ...");}}

运行程序，

程序会报错，说明Spring底层使用的是类的无参构造方法。
在这里插入图片描述
分析Spring的错误信息
com.itheima.dao.impl.BookDaoImpl.

<init>

()

nested:嵌套的意思，后面的异常内容和最底层的异常是一致的
Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.itheima.dao.impl.BookDaoImpl]: No default constructor found; - Caused by: 引发- BeanInstantiationException:翻译为bean实例化异常- No default constructor found:没有一个默认的构造函数被发现

静态工厂实例化
接下来研究Spring中的第二种bean的创建方式

静态工厂实例化

:
工厂方式创建bean
在讲这种方式之前，我们需要先回顾一个知识点是使用工厂来创建对象的方式:

(1)准备一个OrderDao和OrderDaoImpl类

publicinterfaceOrderDao{publicvoidsave();}publicclassOrderDaoImplimplementsOrderDao{publicvoidsave(){System.out.println("order dao save ...");}}

(2)创建一个工厂类OrderDaoFactory并提供一个静态方法

//静态工厂创建对象publicclassOrderDaoFactory{publicstaticOrderDaogetOrderDao(){returnnewOrderDaoImpl();}}

(3)编写AppForInstanceOrder运行类，在类中通过工厂获取对象

publicclassAppForInstanceOrder{publicstaticvoidmain(String[] args){//通过静态工厂创建对象OrderDao orderDao =OrderDaoFactory.getOrderDao();
        orderDao.save();}}

(4)运行后，可以查看到结果
在这里插入图片描述
如果代码中对象是通过上面的这种方式来创建的，如何将其交给Spring来管理呢?
这就要用到Spring中的静态工厂实例化的知识了，具体实现步骤为:

(1)在spring的配置文件application.properties中添加以下内容:

<beanid="orderDao"class="com.itheima.factory.OrderDaoFactory"factory-method="getOrderDao"/>

class:工厂类的类全名

factory-mehod:具体工厂类中创建对象的方法名

对应关系是:

<bean id="bookDao" class="com.hzy.factory.BookDaoFactory" factory-method="getBookDao"/>

中的class对应类名，factory-method对应静态工厂类里面的方法。

(2)在AppForInstanceOrder运行类，使用从IOC容器中获取bean的方法进行运行测试

publicclassAppForInstanceOrder{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");OrderDao orderDao =(OrderDao) ctx.getBean("orderDao");

        orderDao.save();}}

(3)运行后，可以查看到结果
在这里插入图片描述
实例工厂与FactoryBean
接下来继续来研究Spring的第三种bean的创建方式

实例工厂实例化

:
(1)准备一个UserDao和UserDaoImpl类

publicinterfaceUserDao{publicvoidsave();}publicclassUserDaoImplimplementsUserDao{publicvoidsave(){System.out.println("user dao save ...");}}

(2)创建一个工厂类OrderDaoFactory并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

publicclassUserDaoFactory{publicUserDaogetUserDao(){returnnewUserDaoImpl();}}

(3)编写AppForInstanceUser运行类，在类中通过工厂获取对象

publicclassAppForInstanceUser{publicstaticvoidmain(String[] args){//创建实例工厂对象UserDaoFactory userDaoFactory =newUserDaoFactory();//通过实例工厂对象创建对象UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();}

(4)运行后，可以查看到结果
在这里插入图片描述
对于上面这种实例工厂的方式如何交给Spring管理呢?
实例工厂实例化
具体实现步骤为:

(1)在spring的配置文件中添加以下内容:

<beanid="userFactory"class="com.hzy.factory.UserDaoFactory"/><beanid="userDao"factory-method="getUserDao"factory-bean="userFactory"/>

实例化工厂运行的顺序是:

创建实例化工厂对象,对应的是第一行配置
调用对象中的方法来创建bean，对应的是第二行配置- factory-bean:工厂的实例对象- factory-method:工厂对象中的具体创建对象的方法名 factory-mehod:具体工厂类中创建对象的方法名

(2)在AppForInstanceUser运行类，使用从IOC容器中获取bean的方法进行运行测试

publicclassAppForInstanceUser{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao =(UserDao) ctx.getBean("userDao");
        userDao.save();}}

(3)运行后，可以查看到结果
在这里插入图片描述
实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫

FactoryBean

的方式来简化开发。
FactoryBean的使用
具体的使用步骤为:

(1)创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法

publicclassUserDaoFactoryBeanimplementsFactoryBean<UserDao>{//代替原始实例工厂中创建对象的方法publicUserDaogetObject()throwsException{returnnewUserDaoImpl();}//返回所创建类的Class对象publicClass<?>getObjectType(){returnUserDao.class;}}

(2)在Spring的配置文件中进行配置

<beanid="userDao"class="com.hzy.factory.UserDaoFactoryBean"/>

(3)AppForInstanceUser运行类不用做任何修改，直接运行
在这里插入图片描述
这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。

查看源码会发现，FactoryBean接口其实会有三个方法，分别是:

TgetObject()throwsException;Class<?>getObjectType();defaultbooleanisSingleton(){returntrue;}

方法一:getObject()，被重写后，在方法中进行对象的创建并返回

方法二:getObjectType(),被重写后，主要返回的是被创建类的Class对象

方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，从意思上来看，我们猜想默认应该是单例，如何来验证呢?

思路很简单，就是从容器中获取该对象的多个值，打印到控制台，查看是否为同一个对象。

publicclassAppForInstanceUser{publicstaticvoidmain(String[] args){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao1 =(UserDao) ctx.getBean("userDao");UserDao userDao2 =(UserDao) ctx.getBean("userDao");System.out.println(userDao1);System.out.println(userDao2);}}

打印结果是两个一摸一样的对象。
通过验证，会发现默认是单例，那如果想改成单例具体如何实现?

只需要将isSingleton()方法进行重写，修改返回为false，即可

//FactoryBean创建对象publicclassUserDaoFactoryBeanimplementsFactoryBean<UserDao>{//代替原始实例工厂中创建对象的方法publicUserDaogetObject()throwsException{returnnewUserDaoImpl();}publicClass<?>getObjectType(){returnUserDao.class;}publicbooleanisSingleton(){returnfalse;}}

重新运行AppForInstanceUser，从结果中可以看出现在已经是非单例了，但是一般情况下我们都会采用单例，也就是采用默认即可。所以isSingleton()方法一般不需要进行重写。

DI相关内容

前面我们已经完成了bean相关操作的讲解，接下来就进入第二个大的模块

DI依赖注入

，首先来介绍下Spring中有哪些注入方式?

我们先来思考

向一个类中传递数据的方式有几种? - 普通方法(set方法)- 构造方法
依赖注入描述了在容器中建立bean与bean之间的依赖关系的过程，如果bean运行需要的是数字或字符串呢? - 引用类型- 简单类型(基本数据类型与String)

Spring就是基于上面这些知识点，为我们提供了两种注入方式，分别是:

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

依赖注入的方式已经介绍完，接下来挨个学习下:

setter注入

对于setter方式注入引用类型的方式之前已经学习过，快速回顾下:

在bean中定义引用类型属性，并提供可访问的set方法

publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}}

配置中使用property标签ref属性注入引用类型对象

<beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/></bean><beanid="bookDao"class="com.hzy.dao.imipl.BookDaoImpl"/>

创建实验环境：
(1)项目中添加BookDao、BookDaoImpl、UserDao、UserDaoImpl、BookService和BookServiceImpl类

publicinterfaceBookDao{publicvoidsave();}publicclassBookDaoImplimplementsBookDao{publicvoidsave(){System.out.println("book dao save ...");}}publicinterfaceUserDao{publicvoidsave();}publicclassUserDaoImplimplementsUserDao{publicvoidsave(){System.out.println("user dao save ...");}}publicinterfaceBookService{publicvoidsave();}publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

(2)resources下提供spring的配置文件

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/></bean></beans>

(3)编写AppForDISet运行类，加载Spring的IOC容器，并从中获取对应的bean对象

publicclassAppForDISet{publicstaticvoidmain(String[] args ){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");BookService bookService =(BookService) ctx.getBean("bookService");
        bookService.save();}}

接下来，在上面这个环境中来完成setter注入的学习:
步骤1:声明属性并提供setter方法
在BookServiceImpl中声明userDao属性，并提供setter方法

publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;privateUserDao userDao;publicvoidsetUserDao(UserDao userDao){this.userDao = userDao;}publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();
        userDao.save();}}

步骤2:配置文件中进行注入配置
在applicationContext.xml配置文件中使用property标签注入

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="userDao"class="com.hzy.dao.impl.UserDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/><propertyname="userDao"ref="userDao"/></bean></beans>

步骤3:运行程序

运行AppForDISet类，查看结果，说明userDao已经成功注入。
在这里插入图片描述

构造器注入

创建环境：
(1)项目中添加BookDao、BookDaoImpl、UserDao、UserDaoImpl、BookService和BookServiceImpl类

publicinterfaceBookDao{publicvoidsave();}publicclassBookDaoImplimplementsBookDao{privateString databaseName;privateint connectionNum;publicvoidsave(){System.out.println("book dao save ...");}}publicinterfaceUserDao{publicvoidsave();}publicclassUserDaoImplimplementsUserDao{publicvoidsave(){System.out.println("user dao save ...");}}publicinterfaceBookService{publicvoidsave();}publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

(2)resources下提供spring的配置文件

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/></bean></beans>

(3)编写AppForDIConstructor运行类，加载Spring的IOC容器，并从中获取对应的bean对象

publicclassAppForDIConstructor{publicstaticvoidmain(String[] args ){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");BookService bookService =(BookService) ctx.getBean("bookService");
        bookService.save();}}

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

在BookServiceImpl类中将bookDao的setter方法删除掉,并添加带有bookDao参数的构造方法

publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;publicBookServiceImpl(BookDao bookDao){this.bookDao = bookDao;}publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

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

在applicationContext.xml中配置

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><constructor-argname="bookDao"ref="bookDao"/></bean></beans>

说明:
标签

<constructor-arg>

中

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

自动配置

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

问:麻烦在哪?

答:配置文件的编写配置上。

问:有更简单方式么?

答:有，自动配置

什么是自动配置以及如何实现自动配置，就是接下来要学习的内容：
什么是依赖自动装配?

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

自动装配方式有哪些?

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

同样创建一个环境：
(1)项目中添加BookDao、BookDaoImpl、BookService和BookServiceImpl类

publicinterfaceBookDao{publicvoidsave();}publicclassBookDaoImplimplementsBookDao{privateString databaseName;privateint connectionNum;publicvoidsave(){System.out.println("book dao save ...");}}publicinterfaceBookService{publicvoidsave();}publicclassBookServiceImplimplementsBookService{privateBookDao bookDao;publicvoidsetBookDao(BookDao bookDao){this.bookDao = bookDao;}publicvoidsave(){System.out.println("book service save ...");
        bookDao.save();}}

(2)resources下提供spring的配置文件

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanid="bookDao"class="com.hzy.dao.impl.BookDaoImpl"/><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"><propertyname="bookDao"ref="bookDao"/></bean></beans>

(3)编写AppForAutoware运行类，加载Spring的IOC容器，并从中获取对应的bean对象

publicclassAppForAutoware{publicstaticvoidmain(String[] args ){ApplicationContext ctx =newClassPathXmlApplicationContext("applicationContext.xml");BookService bookService =(BookService) ctx.getBean("bookService");
        bookService.save();}}

接下来，在上面这个环境中来完成

自动装配

的学习:

自动装配只需要修改applicationContext.xml配置文件即可:

(1)将

<property>

标签删除

(2)在

<bean>

标签中添加autowire属性

首先来实现按照类型注入的配置

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanclass="com.hzy.dao.impl.BookDaoImpl"/><!--autowire属性：开启自动装配，通常使用按类型装配--><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"autowire="byType"/></beans>

注意事项:

需要注入属性的类中对应属性的setter方法不能省略
被注入的对象必须要被Spring的IOC容器管理
按照类型在Spring的IOC容器中如果找到多个对象，会报NoUniqueBeanDefinitionException

一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入，配置方式为:

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><beanclass="com.hzy.dao.impl.BookDaoImpl"/><!--autowire属性：开启自动装配，通常使用按类型装配--><beanid="bookService"class="com.hzy.service.impl.BookServiceImpl"autowire="byName"/></beans>

注意事项:
按照名称注入中的名称指的是什么?
在这里插入图片描述

bookDao是private修饰的，外部类无法直接方法
外部类只能通过属性的set方法进行访问
对外部类来说，setBookDao方法名，去掉set后首字母小写是其属性名 - 为什么是去掉set首字母小写?- 这个规则是set方法生成的默认规则，set方法的生成是把属性名首字母大写前面加set形成的方法名
所以按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的 -如果按照名称去找对应的bean对象，找不到则注入Null -当某一个类型在IOC容器中有多个对象，按照名称注入只找其指定名称对应的bean对象，不会报错两种方式介绍完后，以后用的更多的是按照类型注入。

最后对于依赖注入，需要注意一些其他的配置特征:

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

结语

以上就是今天要讲的内容，涉及了Spring framework的IoC和DI的内容，详细的讲解了这两个功能的实现和使用，希望大家可以有所收获。

如果各位大哥大姐对我所写的内容觉得还行的话，希望可以点个关注，点个收藏，您的支持就是我最大的动力，非常感谢您的阅读

标签： spring java

本文转载自: https://blog.csdn.net/XUHUANGHOST/article/details/128077614
版权归原作者 Hhzzy99 所有，如有侵权，请联系我们删除。