目录

• 前言
• 一丶为什么学框架
• • <1>框架的便捷性
  • <2>和servlet进行对比
• 二丶Spring核心和设计思想
• • <1>Spring是什么？如何理解Spring
  • <2>IoC和DI是什么？区别？
  • • 1>理解loC
    • 2>理解DI
    • • 说一说DI和loC的区别
    • 3>总结
  • <3>Spring核心功能？
• 三丶Spring创建和使用
• • <1>准备环境
  • <2>创建核心容器–注解配置方式
  • • 1>包扫描
    • 2>添加类注解–五类注解解析
    • 3>添加方法注解
  • <3>总结
  • 说一下ApplicationContexte和BeanFactory的区别
• 四丶Bean对象的使用
• • <1>通过容器对象.getBean()获取
  • <2>依赖注入：把一个Bean对象，注入到另一个Bean的属性当中
  • • byType类型匹配
    • byName:通过Bean的id/名称来匹配
    • 如果此时你的id/名称不存在或者说不唯一。怎么绑定？
    • 方式一：使用 @Qualifier(“XXX”)
    • 方式二： 使用@Resource(name=“XXX”)
  • <3>说一下@Autowired 和 @Resource 的区别

前言

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

1、Spring
2、Spring Boot
3、Spring NVC
4、MyBatis
1
2
3
4

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

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

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

一丶为什么学框架

1. 学习框架相当于从“小作坊”到“工厂”的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。
2. 框架更加易用、简单且高效

<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
1
2

通用程序的实现代码，类的创建顺序是反的，传统代码是 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关于于怎么将依赖注入对应的对象里面。
1
2
3
4

哪一个例子来说

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

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

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

3>总结

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的依赖

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

1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
1

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

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("org.example.lifecycle");
1

首先说一下这种方式

具体的格式为

Application context = new 接口实现类()
这里我们就会有很多很多的接口，但是这里我们就只介绍两种

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

1>包扫描

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

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

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

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

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

这里的话一一说明一下：

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

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

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

这里特别说明一下！！！！！！！！！！！！！！！！！！！！！！！！
你类注解这里的ID是有讲究的：
就是说：Bean ID/名称，默认是类名首字母小写

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

3>添加方法注解

这里我们就直接上代码图

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

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

<3>总结

这里小小的总结一下

说一下ApplicationContexte和BeanFactory的区别

四丶Bean对象的使用

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

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

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

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

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注入。
对象装配（对象注入）的实现方法以下 3 种：

1. 属性注入
2. 构造方法注入
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 注入
1
2
3
4
5
6

先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦