目录
- 二丶Spring核心和设计思想
- <1>Spring是什么？如何理解Spring<2>IoC和DI是什么？区别？
- <1>通过容器对象.getBean()获取<2>依赖注入：把一个Bean对象，注入到另一个Bean的属性当中byName:通过Bean的id/名称来匹配如果此时你的id/名称不存在或者说不唯一。怎么绑定？方式一：使用 @Qualifier("XXX")方式二： 使用@Resource(name="XXX")<3>说一下@Autowired 和 @Resource 的区别
这一部分就是关于Spring的部分了，在这里我们主要学习四个部分
1、Spring 2、Spring Boot 3、Spring NVC 4、MyBatis
这里特别对最后一个说一下，MyBatus。它是用来 代替 JDBC 编程，JDBC 作为Java 提供的一组 用来 操作数据库 的 API非常繁琐
1、获取数据源 2、与数据建立连接 3、编写 SQL 语句。 4、执行SQL 5、此时 SQL 已经执行完毕，然后需要我们去释放资源
所以重复的代码就很多，所以不推荐使用。这里我们一步一步来
一丶为什么学框架
- 学习框架相当于从“小作坊”到“工厂”的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。
- 框架更加易用、简单且高效
<1>框架的便捷性
什么意思呢？
1、 ⽆需配置 Tomcat，点击“运⾏”按钮就可以运⾏项⽬，Spring Boot 内置了 Web 容器（可直接运⾏）。
2、 快速添加外部 jar 包（依赖）。
3、 快速发布项⽬（使⽤ java -jar ⽅式就可以发布）。
4、 对象⾃动装配。
5、 …
<2>和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核心和设计思想
<1>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 称为是一个容器，没有任何问题
<2>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 是具体的实现。
<3>Spring核心功能？
这里上面也说了，这里最后再提一下
既然 Spring 是一个容器，那么，肯定是具有容器的两个核心功能（存 和 取）。
1、将 Bean（反转的对象）存储到 Spring 容器中。
2、将 Bean（反转的对象）从 Spring 容器中取出来。
这也就是 Spring 的 两个核心功能。
三丶Spring创建和使用
<1>准备环境
首先就是创建一个maven项目
然后之后直接创建就好
这里没有太多可以说的，主要就是要记得添加一下spring的依赖
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.3.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.2.3.RELEASE</version> </dependency> </dependencies>
<2>创建核心容器–注解配置方式
这里我们创建容器有多种方式，比如说
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<String,Object> 的这样子的结构，这里的键就是我们的 BeanID ，值呢就是我们的 Bean对象
<3>总结
这里小小的总结一下
说一下ApplicationContexte和BeanFactory的区别
四丶Bean对象的使用
<1>通过容器对象.getBean()获取
这里就是我们上面的使用方式
所以这里不做过多阐述，主要是下面的这种，是我们主要的学习目标
<2>依赖注入：把一个Bean对象，注入到另一个Bean的属性当中
获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注入。
对象装配（对象注入）的实现方法以下 3 种：
- 属性注入
- 构造方法注入
- Setter 注入
接下来，我们分别来看具体的实现
byType类型匹配
属性注入是使用 @Autowired 实现的，将 Service 类注入到 Controller 类中。
这种的就是属性/setter方法上加 @Autowired ，这里我们直接来代码演示
继续往下走，如果说你再多来几个呢？就是我再来一个 属性：二号张三 还能往出拿嘛？当然可以拿，这根本不冲突，不是嘛？
那么问题就来了，既然字符对象我可以往出拿，那么其他类的对象我是不是也可以存着，然后需要的时候往出拿呢？
那就试一试呗？
byName:通过Bean的id/名称来匹配
但是你仔细看一看，有没有发现这个打印出来的有点眼熟？没错，他就是我们第一个创建的UserService对象
所以这啥意思？你是通过变量名称去获取打印对象的？？？
不知道，也不好说，所以我们试一试好嘛？
这里如果说对我这个us1有疑问的，那么可以看我上面 [三丶Spring创建和使用 == ><2>创建核心容器–注解配置方式 ==> 3>添加方法注解]这里。往下走：
然后我们之后打印一下
所以就是的了？那么规则是什么呢？如果说我此时来一个us3呢？我这个时候是没有new us3呢呀？
然后此时解决一下我们上面的问题，这里你怎么搞？那么触发一个问题
如果此时你的id/名称不存在或者说不唯一。怎么绑定？
这里先梳理一下，先是检查类型，发现好几个相同类型，然后就去检查id，然后你此时id不唯一或者id不存在怎么办？那就要会报错！！！
方式一：使用 @Qualifier(“XXX”)
直接加注解，里面指定唯一的对象
方式二： 使用@Resource(name=“XXX”)
<3>说一下@Autowired 和 @Resource 的区别
1.出身不同：@Autowired 来自于 Spring，而 @Resource 来自于 JDK 的注解； 2.使用时设置的参数不同：相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置，根据名称获取 Bean，@Autowired 只有一个 value 属性 3.用法不同 @Autowired 支持 属性注入，构造方法注入，Setter 注入 @Resource 支持 属性注入，Setter 注入
