SpringBoot一：概述

SpringBoot

一、简介

1. 定位

   是一个高层的spring框架，底层就是Spring。就类似于Spring的底层是Java语言

2. 作用

   创建一个基于Spring的应用，即快速实现整合Spring系列的各个技术栈的一站式框架

3. Spring5的技术更新 - 接口的默认实现

   类实现接口，即使只需要接口中的少量方法，也需要实现接口中的所有方法，大量无用的方法被写成空方法，造成资源浪费。故在在Spring5之前，框架内设计出了一个适配器，适配器实现了接口中的所有方法，类只需要继承适配器，重写里面所需要的少量方法即可

   接口默认实现后，就不再需要适配器了，类实现接口，只需要重写少量需要的方法即可。

4. 优点

   ① 完全取代了spring原生应用的构建

   ② 内嵌了web服务器（Tomcat等）

   ③ 自动starter（场景启动器）依赖，简化构建配置

   ④ 自动配置spring及第三方功能（比如MyBatis等）

   ⑤ 提供生产级别的监控

   ⑤ 无额外代码生成，无需编写xml文件

二、spring生态圈

1. spring官网：Spring | Home

2. Spring项目

   

3. springboot的官方文档

   Spring Boot Reference Documentation

   

4. 版本更新信息

   Home · spring-projects/spring-boot Wiki (github.com)

三、使用SpringBoot

1. 在pom中配置父工程标签

   <!-- 1.创建父项目依赖，固定写法 -->
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.0</version>
   </parent>
   1
   2
   3
   4
   5
   6

2. 导入web场景启动器

   <!--
       2.创建web应用，只需要添加一个web的场景启动器，就会将spring、springmvc、日志等一系列jar包
   	  都导入进来了
   -->
   <dependencies>
       <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

3. 创建主程序

   // @SpringBootApplication：这是一个SpringBoot应用，同时也是一个主程序类，
   @SpringBootApplication
   public class MainApplication {
       // 写一个main程序，固定写法，直接运行main程序即可，无需部署tomcat（tomcat已经内嵌了 ）
       public static void main(String[] args) {
           SpringApplication.run(MainApplication.class, args);
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8

4. 编写业务

   /*
       @Configuration：表明该类是配置类
       ① 配置类本身也是一个组件
       ② proxyBeanMethod：默认值是true，表明配置类是一个代理对象
          Full配置模式：proxyBeanMethods = true，代理对象调用方法，springboot总会检查容器中是否有方法对应的组件，保持组件单实例，即外部无论获取多少次该组件，都是容器中的单实例
          Lite配置模式：proxyBeanMethods = false，表明配置类不是代理对象了，即，配置类再调用方法时，就只是单纯的调用方法，不会从容器中获取，每次都创建新的对象
       ③ 如果组件之间有依赖关系，proxyBeanMethods必须为true。
   */
   @Configuration(proxyBeanMethods = true)
   public class MyConfig {
       /*
           @Bean：标注在方法上给容器中添加组件。默认是单实例
           ① 方法名：作为组件的id，
           ② 返回类型：就是组件类型。
           ③ 返回的值：就是组件在容器中的实例。
       */
       @Bean
       public User user01() {
           User zhangsan = new User("zhangsan", 18);
           // 与tomcatPet()组件产生了依赖
           zhangsan.setPet(tomcatPet());
           return zhangsan;
       }
       @Bean
       public Pet tomcatPet() {
           return new Pet("tomcat");
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28

5. 测试

   直接运行main方法即可

6. 配置文件

   在src/main/resources/目录下新建application.properties，整个项目中所有的配置变更都写在这个配置文件中即可

7. 简化部署

   <!-- 
   	3.该插件可将项目直接打包成jar包，简称“fat jar”，
   	  执行maven中的package命令，即可生成对应项目的jar包。因该jar包自带了整套运行环境，故可直接运行 
   -->
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

   

8. 在cmd中断运行该jar包，要取消终端的“快速编辑模式”

   

四、了解自动配置原理

1. 依赖管理

   1.1 在pom中添加父项目依赖< parent>，管理了版本号，其它的依赖就无需再写版本号了

   <!-- 我们自己配置的父项目，固定写法 -->
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.0</version>
   </parent>
   
   <!-- 我们配置的父项目也有自己的父项目 -->
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-dependencies</artifactId>
       <version>2.7.0</version>
   </parent>
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

   1.2 在父项目的父项目中，有各种常用依赖的版本号声明，所以后续配置的各种依赖就无需写版本号了

   

   1.3 如果要更改某一依赖的版本号（即不使用父项目提供的版本号），只需在pom文件中添加即可

   <!-- 举例 -->
   <properties>
       <mysql.version>5.1.43</mysql.version>
   </properties>
   1
   2
   3
   4

2. 场景启动器 - starter

   只要引入了某个starter，这个场景的所有需要的常规依赖就会被自动引入。

   官方文档中查看提供的starter：Developing with Spring Boot

   注：

   ​ ① 官方提供的starter的版本：以 “ spring - boot ” 开头

   ​ ② 第三方提供的starter版本，以“ * - spring - boot ” 开头

3. 自动配置

   在场景启动器中，已经自动配置了该场景所需的依赖，比如web-starter中，就配置了tomcat、springmvc等。

   在主程序中可查看

   @SpringBootApplication
   public class MainApplication {
       // 写一个main程序，固定写法，直接运行main程序即可，无需部署tomcat（tomcat已经内嵌了 ）
       public static void main(String[] args) {
           // 1.返回一个IOC容器
           ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
           // 2.查看容器中配置过的组件，包括自动配置的，和手动创建的
           String[] names = run.getBeanDefinitionNames();
           for (String name : names) {
               System.out.println(name);
           }
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

4. 默认包结构

   主程序所在的包及其下的所有子包，都会被默认进行组件扫描。如果要更改组件的扫描路径，可在@SrpingBootApplication注解中进行设置

   @SpringBootApplication(scanBackPackage="com.atguigu")
   public class MainApplication {
       public static void main(String[] args) { 	
           SpringApplication.run(MainApplication.class, args);
       }
   }        
   1
   2
   3
   4
   5
   6

5. 各种配置都有默认值

   这些默认值都会映射到某个类上，这个类会在容器中创建对象（后续详细讲解）

6. 按需配置场景

   引入了哪个starter，就配置哪个，其它的starter中内容不会配置

   进入spring-boot-starter中，有一个依赖是spring-boot-autoconfigure，SpringBoot的所有自动配置功能都在这个包中