目录

• 二丶Spring核心和设计思想
• Spring是什么？如何理解SpringIoC和DI是什么？区别？
• 通过容器对象.getBean()获取依赖注入：把一个Bean对象，注入到另一个Bean的属性当中byName:通过Bean的id/名称来匹配如果此时你的id/名称不存在或者说不唯一。怎么绑定？方式一：使用 @Qualifier(“XXX”)方式二： 使用@Resource(name=”XXX”)说一下@Autowired 和 @Resource 的区别

这一部分就是关于Spring的部分了，在这里我们主要学习四个部分

1、Spring2、Spring Boot3、Spring NVC4、MyBatis

这里特别对最后一个说一下，MyBatus。它是用来 代替 JDBC 编程，JDBC 作为Java 提供的一组 用来 操作数据库 的 API非常繁琐

1、获取数据源2、与数据建立连接3、编写 SQL 语句。4、执行SQL5、此时 SQL 已经执行完毕，然后需要我们去释放资源

所以重复的代码就很多，所以不推荐使用。这里我们一步一步来

一丶为什么学框架

框架的便捷性

什么意思呢？

1、 需配置 Tomcat，点击“运 ”按钮就可以运 项 ，Spring Boot 内置了 Web 容器（可直接运 ）。2、 快速添加外部 jar 包（依赖）。3、 快速发布项 （使 java -jar 式就可以发布）。4、 对象 动装配。5、 …

和servlet进行对比

我们传统的servlet怎么使用的呢？

1、创建一个 maven 项目2、在 pom.xml 中 引入相关依赖3、创建特定的目录4、编写代码5、打包6、部署7、验证程序8、发布【使用 （Tomcat） 进行 程序的部署和发布】

光是这一连串的流程下来，就让人绝望，我们可以清楚的发现servlet有以下不足

1、添加外部 jar 不 便，容易出错， 如添加了 个不匹配的外部 jar 版本；

2、运 和调试的时候需要配置 tomcat 不 便；

3、 发布不 便，servlet 项 必须依靠外置的 tomcat（外置的 web 容器）运 。

4、 路由配置不 便， 个访问地址对应 个 Servlet 类。

5、…

而以上痛点问题，都可以通过 JavaEE 进阶框架解决，接下来我们一起来看。

二丶Spring核心和设计思想

Spring是什么？如何理解Spring

先从第一个问题开始，啥是Spring？

Spring 指的是 Spring Framework（Spring 框架），它是 个开源框架，有着活跃 庞 的社区，这就是它之所以能 久不衰的原因。Spring 持 泛的应 场景，它可以让 Java 企业级的应 程序开发起来更简单。

所以总结一下： Spring就是包含了众多工具方法的loC容器

这里可能就有铁子会发问啥是容器？

容器是用容纳某种物品的（基本）装置。

是不是有点迷，那就想想我们的数据结构，List,Map。如果还是想不出来，那就再想想我们的Tomcat

List/Map -> 数据存储容器

Tomcat -> Web 容器

这里是不是好奇为啥Tomcat是一个容器呢？

但是 Tomcat 为什么是一个 Web 容器呢？

思考一下：

Tomcat 是用来运行 外部的项目，因此它是一个 Web 容器。

你有一个项目，想要运行。

肯定是要将项目部署到 Tomcat 的 webapps 目录底下，才可以运行。

此时，webapps 就是一个项目的容器

而 webapps 目录，就是 Tomcat 下面的一个子目录。

那么，我们将 Tomcat 称为是一个容器，没有任何问题

IoC和DI是什么？区别？

IoC = Inversion of Control 翻译成中文是“控制反转”的意思，也就是说 Spring 是一个“控制反转”的容器，怎么理解这句话呢？

分成两点，第一个点是控制，第二个点是反转。

也就是说：之前程序的控制权限是在我们自己手上，现在，我们把这个控制权交出去了。

那么通过一个实际的情况来说一下

我们在 A 类 中，想去调用 B 类中的方法，是怎么做的？

是不是 要去new B 类对象，通过 对象 去调用 B类中的方法。当前 B 的控制权，是我们手上的。而 控制反转，就是将我们手上的权限，交由 “其他人” 来操作这个类。这个“其他人”，就是 Spring 框架。

此时，我们想要 A 类中调用 B 的时候， 告诉 框架，我要在 A 中 调用 B 了。

至于 B 的生命周期，和我们没有任何关系。

这是控制反转。

前面也说了：spring是一个控制反转容器

也就是 像之前在传统开发的时候，所有需要我们自己去new东西，都不需要我们再去new 了。因为我们把控制权 “反转给了” Spring 框架。Spring 会帮我们管理所有的对象（Bean）。

哪一个例子来举例吧

比如说我们构造一个car类，然后我们肯定是要new一个car对象，在car对象进行初始化的时候是不是要new一个Framework对象？那么继续往下走，每一次的初始化都带着底层的对象的new，那么问题就来了，这对应着什么呢？

如果轮胎的尺寸的固定的，然而随着对的车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了。这一修改，就是全部的修改呀！

那么我们怎么解决呢？

我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。

此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任

何代码，这样就完成了程序的解耦。

是不是有点绕？没关系，这样想，原来我们是从下往上，一层包含一层，上面包含这下一层的New的对象，然后我们可以不这样搞，我们可以从下往上走

也就是说，我们先创建好下层，然后把下层的属性注入到上层，一层一层往上递归包含，最后到最顶上。

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

通用程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了

Framework，Framework 创建并创建了 Bottom，依次往下，而用了容器之后是上级对象创建并控制下级对象了，而是下级对象把注入将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想

那么回到开头，什么是loC？什么是DI？

1>理解loC

我们可以直接认为 Spring 就是一个 IoC 容器。

既然它是一个容器，那么，容器主要的两个核心功能，肯定是具有的

1、装东西： 那些被 控制反转 的对象（Bean），都可以存储在 Spring 中。 2、取东西: 作为一个容器，不可能只存不取吧？ 将 对象（Bean），从 Spring 中 取出来。

这也是 Spring IoC 容器 最核心的两个功能【存 和 取 】。

那根据上面我的例子，为啥说能简化开发呢？

将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而 new 对象的方式相当于，每次需要工具了，才现做，用完就扔掉了也不会保存，下次再用的时候还得重新做，这就是 IoC 容器和普通程序开发的区别。

2>理解DI

说到 IoC 不得不提的一个词就是“DI”，DI 是 Dependency Injection 的缩写，翻译成中文是“依赖注入”的意思。

所谓依赖注入，就是由 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中。所以，依赖注入（DI）和控制反转（IoC）是从不同的角度的描述的同一件事情，就是指通过引入 IoC 容器，利用依赖关系注入的方式，实现对象之间的解耦。

说一说DI和loC的区别

两者其实是一个东西，但是是对一个事物从不同角度进行了阐述。loC就是把某个对象交给Spring，然后用的时候跟他要，Spring怎么把对象给我我我不关心，我只要能拿到就可以了。而DI就是一个具体的实现，DI关于于怎么将依赖注入对应的对象里面。

哪一个例子来说

还是这个车，我们从两个角度来说一下

处理思维(loC):一个类外部依赖的对象，其控制权限发生了反转，我们就不再去new它了，而是直接用。然后直接从Spring哪里拿，告诉他，我要用实际操作(DI):这里我们从底向上就不是new了，而是Spring中，把我的下一级拿过来，直接注入。

所以DI是实际实现，但是loC是思想。

1>Spring 是什么？如何理解 Spring？

Spring 是一个包含 众多工具方法 的 IoC 容器。既然 Spring 是一个 IoC 容器（反转控制容器）。Spring是 存储 IoC【反转控制（后的对象）】 的一个容器

2>IoC 和 DI 是什么？有什么区别？

IoC – Inversion Of Control（控制反转）主要是将 对象的权限（创建与销毁）交由 Spring 来管理。程序员 不必再去 new 对象了！在使用到某个对象的时候，直接向 Spring 索取，直接使用即可。DI dependency injection（依赖注入）将 引入的依赖 （执行所依赖的对象），拿过来使用。区别：IoC 是一种 思想。DI 是具体的实现。

Spring核心功能？

这里上面也说了，这里最后再提一下

既然 Spring 是一个容器，那么，肯定是具有容器的两个核心功能（存 和 取）。1、将 Bean（反转的对象）存储到 Spring 容器中。2、将 Bean（反转的对象）从 Spring 容器中取出来。这也就是 Spring 的 两个核心功能。

三丶Spring创建和使用

准备环境

首先就是创建一个maven项目

然后之后直接创建就好

这里没有太多可以说的，主要就是要记得添加一下spring的依赖

org.springframework spring-context 5.2.3.RELEASE org.springframework spring-beans 5.2.3.RELEASE

创建核心容器–注解配置方式

这里我们创建容器有多种方式，比如说

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

但是这里种方式用的很少，这里我也不在对他介绍过多，这里我介绍另外一种

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(“org.example.lifecycle”);

首先说一下这种方式

具体的格式为

Application context = new 接口实现类()

这里我们就会有很多很多的接口，但是这里我们就只介绍两种

如果说你是加载类加载路径下的xml容器，然后再把内容装到容器当中，那么过程无疑就很麻烦，这里我们不推荐使用这种方式。我们推荐用配置的方式去创建容器

1>包扫描

可以看到，我上面的图中，通过注解配置的方式去创建容器的时候，加了个包的路径，什么意思呢？

但是这里有问题呀！我不可能这个类中所有的东西都是要使用的，那我怎么办呢？

2>添加类注解–五类注解解析

这里的话就要加注解，告诉容器，那个类是我需要的，那个是我不需要的

1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration。2. 方法注解：@Bean。

这里的话一一说明一下：

@Controller：表示的是业务逻辑层；用于web开发处理http请求和响应，类似servlet@Servie：服务层；做业务逻辑的@Repository：持久层；数据库访问，一般是数据库操作@Component:一般组件@Configuration：配置层。系统启动前提前加载一些资源

然后这里我们进行写个代码验证一下

那么谁可以被扫描注册到容器中呢？答案毋庸置疑，肯定就是 UserService

这里特别说明一下！！！！！！！！！！！！！！！！！！！！！！！！

你类注解这里的ID是有讲究的：

就是说：

Bean ID/名称，默认是类名首字母小写

那么我接就接着往下说，你类当中所有的东西都是需要的嘛？那肯定不一定呀，对不对？那么我们怎么办呢？这个时候就要用到我们的方法注解了

3>添加方法注解

这里我们就直接上代码图

所以你甚至还可以再过分一点：在当前方法注解的同时放开类注解，让类一边被扫描的时候方法也在被扫描（玩的挺花哈）

所以其实你可以发现， Spring 存放的东西，其实是一个类似于 Map 的这样子的结构，这里的键就是我们的 BeanID ，值呢就是我们的 Bean对象

总结

这里小小的总结一下

说一下ApplicationContexte和BeanFactory的区别

四丶Bean对象的使用

通过容器对象.getBean()获取

这里就是我们上面的使用方式

所以这里不做过多阐述，主要是下面的这种，是我们主要的学习目标

依赖注入：把一个Bean对象，注入到另一个Bean的属性当中

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注入。

对象装配（对象注入）的实现方法以下 3 种：

接下来，我们分别来看具体的实现

byType类型匹配

属性注入是使用 @Autowired 实现的，将 Service 类注入到 Controller 类中。

这种的就是属性/setter方法上加 @Autowired ，这里我们直接来代码演示

继续往下走，如果说你再多来几个呢？就是我再来一个 属性：二号张三 还能往出拿嘛？当然可以拿，这根本不冲突，不是嘛？

那么问题就来了，既然字符对象我可以往出拿，那么其他类的对象我是不是也可以存着，然后需要的时候往出拿呢？

那就试一试呗？

byName:通过Bean的id/名称来匹配

但是你仔细看一看，有没有发现这个打印出来的有点眼熟？没错，他就是我们第一个创建的UserService对象

所以这啥意思？你是通过变量名称去获取打印对象的？？？

不知道，也不好说，所以我们试一试好嘛？

这里如果说对我这个us1有疑问的，那么可以看我上面 [三丶Spring创建和使用 == >创建核心容器–注解配置方式 ==> 3>添加方法注解]这里。往下走：

然后我们之后打印一下

所以就是的了？那么规则是什么呢？如果说我此时来一个us3呢？我这个时候是没有new us3呢呀？

然后此时解决一下我们上面的问题，这里你怎么搞？那么触发一个问题

如果此时你的id/名称不存在或者说不唯一。怎么绑定？

这里先梳理一下，先是检查类型，发现好几个相同类型，然后就去检查id，然后你此时id不唯一或者id不存在怎么办？那就要会报错！！！

方式一：使用 @Qualifier(“XXX”)

直接加注解，里面指定唯一的对象

方式二： 使用@Resource(name=“XXX”)

说一下@Autowired 和 @Resource 的区别

1.出身不同：@Autowired 来自于 Spring，而 @Resource 来自于 JDK 的注解；2.使用时设置的参数不同：相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如name 设置，根据名称获取 Bean，@Autowired 只有一个 value 属性3.用法不同@Autowired 支持 属性注入，构造方法注入，Setter 注入@Resource 支持 属性注入，Setter 注入