7天学完SpringSpring框架搭建和解析以及Bean对象的创建

　　目录二丶Spring核心和设计思想  Spring是什么？如何理解SpringIoC和DI是什么？区别？  通过容器对象.getBean()获取依赖注入：把一个Bean对象，注入到另一个Bean的属性当中byName:通过Bean的id/名称来匹配如果此时你的id/名称不存在或者说不唯一。怎么绑定？方式一：使用 @Qualifier(＂XXX＂)方式二： 使用@Resource(name=＂XXX＂)说一下@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、  需配置 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 种：  属性注入  构造方法注入  Setter 注入
　　接下来，我们分别来看具体的实现  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 注入