• 尚硅谷SpringBoot3笔记

    推荐课程：03.快速入门-示例Demo_哔哩哔哩_bilibili

    官方笔记：SpringBoot3全栈指南 (yuque.com)

    目录

    01 -- 示例demo

    1. 在新建项目创建一个Maven 模块 

    2. 引入 spring-boot-starter-parent 和 spring-boot-starter-web 依赖

    3. 指示 Spring Boot 启动类

    4. 构建控制器

    5. 启动

    6. 使用Maven打包

    02 -- 特性小结

    1. 简化整合

    2. 简化开发

    3. 简化配置

    4. 简化部署

    5. 简化运维

    03 -- spring initializer

    04 --  应用分析

    1. 依赖管理机制

    2. 自动配置机制

    05 -- 核心技能

    1. 常用注解

    2. 组件注册 ✫✫✫✫

    3. 条件注解 ✫✫✫✫

    4. 属性绑定 ✫✫✫✫

    01 -- 示例demo

    1. 在新建项目创建一个Maven 模块 

    2. 引入 spring-boot-starter-parent 和 spring-boot-starter-web 依赖

    spring-boot-starter-parent 是 Spring Boot 提供的一个用于构建 Spring Boot 项目的父项目（Parent Project）。通过使用 spring-boot-starter-parent 作为项目的父项目，你可以继承 Spring Boot 默认的依赖管理、插件配置和默认配置等(这是必要的，如果缺省Maven 将会默认使用)，从而简化项目的配置和构建过程。

    spring-boot-starter-web 是 Spring Boot 提供的一个用于构建 Web 应用程序的起步依赖（Starter Dependency）。通过引入 spring-boot-starter-web，你可以快速地构建基于 Spring MVC 的 Web 应用程序，无需手动管理依赖和配置。

    1.     
    2.     <parent>
    3.         <groupId>org.springframework.bootgroupId>
    4.         <artifactId>spring-boot-starter-parentartifactId>
    5.         <version>3.0.5version>
    6.     parent>
    7.  
    8.     <dependencies>
    9.         
    10.         <dependency>
    11.             <groupId>org.springframework.bootgroupId>
    12.             <artifactId>spring-boot-starter-webartifactId>
    13.         dependency>
    14.     dependencies>

    3. 指示 Spring Boot 启动类

    1. package org.example;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. @SpringBootApplication
    7. public class MainApplication {
    8.     public static void main(String[] args) {
    9.         SpringApplication.run(MainApplication.class,args);
    10.     }
    11. }

    4. 构建控制器

    1. package org.example.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6. import org.springframework.web.bind.annotation.RestController;
    7.  
    8.  
    9. //@ResponseBody                   // 标记返回纯文本
    10. //@Controller                     // 标识一个类作为控制器，用于处理 HTTP 请求并返回相应的视图或数据
    11.  
    12. @RestController                 // 以上两个注解的合成注解
    13. public class HelloController {
    14.  
    15.     @GetMapping("/hello")
    16.     public String hello(){
    17.         return "Hello,Spring Boot 3!";
    18.     }
    19. }

    5. 启动

    6. 使用Maven打包

    1.     
    2.     <build>
    3.         <plugins>
    4.             <plugin>
    5.                 <groupId>org.springframework.bootgroupId>
    6.                 <artifactId>spring-boot-maven-pluginartifactId>
    7.             plugin>
    8.         plugins>
    9.     build>

    打包成jar包后，可以直接在CMD中直接使用Java -jar运行。

    D:\JavaCode\app-demo>Java -jar boot3-01-demo-1.0-SNAPSHOT.jar

    02 -- 特性小结

    1. 简化整合

    导入相关的场景，拥有相关的功能。场景启动器

    默认支持的所有场景：Developing with Spring Boot

    • 官方提供的场景：命名为：spring-boot-starter-*
    • 第三方提供场景：命名为：*-spring-boot-starter

    场景一导入，万物皆就绪

    • 开发什么场景，导入什么场景启动器。
    • 导入“场景启动器”。 场景启动器 自动把这个场景的所有核心依赖全部导入进来。

    2. 简化开发

    无需编写任何配置，直接开发业务

    3. 简化配置

    application.properties：

    • 集中式管理配置。只需要修改这个文件就行 。
    • 配置基本都有默认值
    • 能写的所有配置都在： Common Application Properties

    4. 简化部署

    打包为可执行的jar包。

    linux服务器上有java环境。

    5. 简化运维

    修改配置（外部放一个application.properties文件）、监控、健康检查。

    03 -- spring initializer

    一键创建好整个项目结构

    04 --  应用分析

    1. 依赖管理机制

    自定义版本号

    • 利用maven的就近原则
      • 直接在当前项目properties标签中声明父项目用的版本属性的key，遵循就近原则。
      • 直接在导入依赖的时候声明版本

    2. 自动配置机制

    • 自动配置的 Tomcat、SpringMVC 等
      • 导入场景，容器中就会自动配置好这个场景的核心组件。
      • 以前：DispatcherServlet、ViewResolver、CharacterEncodingFilter....
      • 现在：自动配置好的这些组件
      • 验证：容器中有了什么组件，就具有什么功能
    • 默认的包扫描规则（默认从主程序开始，controller只会从属主程序执行）
      • @SpringBootApplication 标注的类就是主程序类
      • SpringBoot只会扫描主程序所在的包及其下面的子包，自动的component-scan功能
    • 自定义扫描路径（改变执行顺序）
        • @SpringBootApplication(scanBasePackages = "com.atguigu")
        • @ComponentScan("com.atguigu") 直接指定扫描的路径

    非正确主从位置：

           

    执行结果：

    自定义扫描路径：

    1. package org.example.boot;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.SpringBootConfiguration;
    5. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    6. import org.springframework.boot.autoconfigure.SpringBootApplication;
    7. import org.springframework.context.annotation.ComponentScan;
    8.  
    9.  
    10. //@SpringBootApplication(scanBasePackages = "org.example")
    11. @SpringBootConfiguration
    12. @EnableAutoConfiguration
    13. @ComponentScan("org.example")
    14. public class Boot302DemoApplication {
    15.  
    16.     public static void main(String[] args) {
    17.         //java10: 局部变量类型的自动判断
    18.         var ioc = SpringApplication.run(Boot302DemoApplication.class, args);
    19.  
    20.         //1、获取容器中所有组件的名字
    21.         String[] names = ioc.getBeanDefinitionNames();
    22.  
    23.         //2、挨个遍历：
    24.         // dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver
    25.         // SpringBoot把以前配置的核心组件现在都给我们自动配置好了。
    26.         for (String name : names){
    27.             System.out.println(name);
    28.         }
    29.     }
    30.  
    31. }

    @SpringBootApplication(scanBasePackages = "org.example")

    等于以下三个注解：

    @SpringBootConfiguration

    @EnableAutoConfiguration

    @ComponentScan("org.example")

    自定义扫描路径后： 

      

    • 配置默认值 ✫✫✫✫
      • 配置文件的所有配置项是和某个类的对象值进行一一绑定的。
      • 绑定了配置文件中每一项值的类： 属性类。
      • 比如：
        • ServerProperties绑定了所有Tomcat服务器有关的配置
        • MultipartProperties绑定了所有文件上传相关的配置
        • ....参照官方文档：或者参照 绑定的 属性类。

    配置文件的所有配置项是和某个类的对象值进行一一绑定的：

    • 按需加载自动配置 ✫✫✫✫
      • 导入场景spring-boot-starter-web
      • 场景启动器除了会导入相关功能依赖，导入一个spring-boot-starter，是所有starter的starter，基础核心starter
      • spring-boot-starter导入了一个包 spring-boot-autoconfigure。包里面都是各种场景的AutoConfiguration自动配置类
      • 虽然全场景的自动配置都在 spring-boot-autoconfigure这个包，但是不是全都开启的。
        • 导入哪个场景就开启哪个自动配置

       

    05 -- 核心技能

    1. 常用注解

    SpringBoot摒弃XML配置方式，改为全注解驱动

    2. 组件注册 ✫✫✫✫

    @Configuration、@SpringBootConfiguration

    @Bean、@Scope

    @Controller、 @Service、@Repository、@Component

    @Import

    @ComponentScan

    •   @Configuration，@Bean，@Scope注解

    @Configuration：这是一个配置类，@Configuration 注解表示该类是一个配置类，其中包含用于配置 bean 的方法。

    @Bean：申明这是一个bean类，告诉 Spring 容器要将某个实体类的实例作为一个 bean 注册到容器中。

    @Scope ：用于指定 Spring bean 的作用域。

    • prototype：每次请求该 bean 时都会创建一个新的实例。每个实例都是独立的，没有共享状态。

    1. package org.example.boot.bean;
    2.  
    3. public class User {
    4.     private Long id;
    5.     private String name;
    6.  
    7.     public Long getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(Long id) {
    12.         this.id = id;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23. }
    1. package org.example.boot.bean;
    2.  
    3. public class Cat {
    4.     private Long id;
    5.     private String name;
    6.  
    7.     public Long getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(Long id) {
    12.         this.id = id;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22. }
    1. package org.example.boot.config;
    2.  
    3. import org.example.boot.bean.User;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7.  
    8. @Configuration // 这是一个配置类，@Configuration 注解表示该类是一个配置类，其中包含用于配置 bean 的方法。
    9. public class AppConfig {
    10.  
    11.     @Bean("hahabean") // Bean注解，申明这是一个bean类，告诉 Spring 容器要将某个实体类的实例作为一个 bean 注册到容器中
    12.     public User user(){
    13.         var user = new User();
    14.         user.setId(1L);
    15.         user.setName("zhangsan");
    16.  
    17.         return user;
    18.     }
    19. }

    主程序：

    1. package org.example.boot;
    2.  
    3. import org.example.boot.bean.User;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.SpringBootConfiguration;
    6. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    7. import org.springframework.boot.autoconfigure.SpringBootApplication;
    8. import org.springframework.context.annotation.ComponentScan;
    9.  
    10. @SpringBootApplication
    11. public class Boot302DemoApplication {
    12.  
    13.     public static void main(String[] args) {
    14.         var ioc = SpringApplication.run(Boot302DemoApplication.class, args);
    15.  
    16.         String[] names = ioc.getBeanNamesForType(User.class);
    17.  
    18.         for (String name : names){
    19.             System.out.println(name);
    20.         }
    21.  
    22.         Object bean1 = ioc.getBean("hahabean");
    23.         Object bean2 = ioc.getBean("hahabean");
    24.  
    25.         System.out.println(bean1 == bean2);
    26.  
    27.     }
    28.  
    29. }

    执行结果： 

    • @Import：导入第三方组件。

     @Import：向Spring容器中导入一个组件,默认组件名为全类名。

    1. package org.example.boot.config;
    2.  
    3. import org.example.boot.bean.User;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.context.annotation.Import;
    7. import org.springframework.context.annotation.Scope;
    8.  
    9.  
    10. @Import(CatConfig.class)             // 向容器中导入一个组件,默认组件名为全类名
    11. @Configuration        // 这是一个配置类，@Configuration 注解表示该类是一个配置类，其中包含用于配置 bean 的方法。
    12. public class AppConfig {
    13.  
    14.     @Scope("prototype")
    15.     @Bean("hahabean") // Bean注解，申明这是一个bean类，告诉 Spring 容器要将某个实体类的实例作为一个 bean 注册到容器中
    16.     public User user(){
    17.         var user = new User();
    18.         user.setId(1L);
    19.         user.setName("zhangsan");
    20.  
    21.         return user;
    22.     }
    23. }

      

    3. 条件注解 ✫✫✫✫

    如果注解指定的条件成立，则触发指定行为

    @ConditionalOnXxx

    @ConditionalOnClass：如果类路径中存在这个类，则触发指定行为

    @ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为

    @ConditionalOnBean：如果容器中存在这个Bean（组件），则触发指定行为

    @ConditionalOnMissingBean：如果容器中不存在这个Bean（组件），则触发指定行为

    场景：

    • 如果存在CatConfig这个 类，给容器中放一个Cat组件，名cat01，
    • 否则，就给容器中放一个Dog组件，名dog01
    • 如果系统中有dog01这个 组件，就给容器中放一个 User组件，名zhangsan
    • 否则，就放一个User，名叫lisi

    @ConditionalOnBean（value=组件类型，name=组件名字）：判断容器中是否有这个类型的组件，并且名字是指定的值

    主程序：

    1. package org.example.boot;
    2.  
    3. import org.example.boot.bean.Cat;
    4. import org.example.boot.bean.Dog;
    5. import org.example.boot.bean.User;
    6. import org.springframework.boot.SpringApplication;
    7. import org.springframework.boot.autoconfigure.SpringBootApplication;
    8.  
    9. @SpringBootApplication
    10. public class Boot302DemoApplication {
    11.  
    12.     public static void main(String[] args) {
    13.         //java10: 局部变量类型的自动判断
    14.         var ioc = SpringApplication.run(Boot302DemoApplication.class, args);
    15.  
    16.  
    17.         for (String s : ioc.getBeanNamesForType(Cat.class)){
    18.             System.out.println("cat:" + s);
    19.         }
    20.  
    21.  
    22.         for (String s : ioc.getBeanNamesForType(Dog.class)){
    23.             System.out.println("Dog:" + s);
    24.         }
    25.  
    26.         for (String s : ioc.getBeanNamesForType(User.class)){
    27.             System.out.println("User:" + s);
    28.         }
    29.  
    30.     }
    31.  
    32. }

    Dog.py： 

    1. package org.example.boot.bean;
    2.  
    3. public class Dog {
    4.     private Long id;
    5.     private String name;
    6.  
    7.     public Long getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(Long id) {
    12.         this.id = id;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22. }

    AppConfig2.py: 

    1. package org.example.boot.config;
    2.  
    3. import org.example.boot.bean.Cat;
    4. import org.example.boot.bean.Dog;
    5. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    6. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.context.annotation.Configuration;
    9.  
    10. @Configuration
    11. public class AppConfig2 {
    12.     @ConditionalOnClass(name="org.example.boot.config.CatConfig")           // 如果类路径中存在这个类，则触发指定行为
    13.     @Bean
    14.     public Cat cat01(){
    15.         return new Cat();
    16.     }
    17.  
    18.     @ConditionalOnMissingClass(value="org.example.boot.config.CatConfig")       // 如果类路径中不存在这个类，则触发指定行为
    19.     @Bean
    20.     public Dog Dog01(){
    21.         return new Dog();
    22.     }
    23.  
    24.  
    25. }

    CatConfig.py: 

    1. package org.example.boot.config;
    2.  
    3. import org.example.boot.bean.Cat;
    4.  
    5. public class CatConfig {
    6.     public Cat cat(){
    7.         var cat = new Cat();
    8.         cat.setId(1L);
    9.         cat.setName("zhangsan");
    10.  
    11.         return cat;
    12.     }
    13. }

    执行结果： 

     去掉 CatConfig 并注释掉AppConfig里的@import(CatConfig.class)注解，执行结果：

    4. 属性绑定 ✫✫✫✫

    @Component：添加"@Component"注解，可以告诉Spring框架将该类实例化为一个Bean，并由Spring容器进行管理。

    @ConfigurationProperties： 声明组件的属性和配置文件哪些前缀开始项进行绑定。

    @EnableConfigurationProperties：快速注册注解。

    • 场景：SpringBoot默认只扫描自己主程序所在的包。如果导入第三方包，即使组件上标注了 @Component、@ConfigurationProperties 注解，也没用。因为组件都扫描不进来，此时使用@EnableConfigurationProperties就可以快速进行属性绑定并把组件注册进容器。

    将容器中任意组件（Bean）的属性值和配置文件（application.properties）的配置项的值进行绑定

    • 1、给容器中注册组件（@Component、@Bean），@Component一般用于bean类，@Bean一般用于config类。
    • 2、使用 @ConfigurationProperties 声明组件和配置文件（application.properties）的哪些配置项进行绑定

     

    pig.py: 

    1. package org.example.boot.bean;
    2.  
    3. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    4. import org.springframework.boot.context.properties.ConfigurationProperties;
    5. import org.springframework.stereotype.Component;
    6.  
    7.  
    8. //@Component
    9. public class Pig {
    10.     private Long id;
    11.     private String name;
    12.     private Integer age;
    13.  
    14.     public Long getId() {
    15.         return id;
    16.     }
    17.  
    18.     public void setId(Long id) {
    19.         this.id = id;
    20.     }
    21.  
    22.     public String getName() {
    23.         return name;
    24.     }
    25.  
    26.     public void setName(String name) {
    27.         this.name = name;
    28.     }
    29.  
    30.     public Integer getAge() {
    31.         return age;
    32.     }
    33.  
    34.     public void setAge(Integer age) {
    35.         this.age = age;
    36.     }
    37.  
    38.     @Override
    39.     public String toString() {                  //重写 toString() 方法，返回了包含对象的 name 和 age 属性的字符串表示形式。
    40.         return "Pig{" +
    41.                 "id=" + id +
    42.                 ", name='" + name + '\'' +
    43.                 ", age=" + age +
    44.                 '}';
    45.     }
    46. }

    去掉@Component也可以实现相同的功能，在AppConfig.py配置类里加入：

    1.     @Bean
    2.     public Pig pig(){
    3.         return new Pig();
    4.     }

    两种方法的目的都是为了将pig组件加入 spring 容器。

    在主方法里加入：

    1.         Pig pig = ioc.getBean(Pig.class);
    2.         System.out.println("pig:" + pig);

    执行结果： 

    sheep.py:

    1. package org.example.boot.bean;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4. import org.springframework.stereotype.Component;
    5.  
    6. @ConfigurationProperties(prefix = "sheep")
    7. public class sheep {
    8.     private Long id;
    9.     private String name;
    10.     private int age;
    11.  
    12.     public Long getId() {
    13.         return id;
    14.     }
    15.  
    16.     public void setId(Long id) {
    17.         this.id = id;
    18.     }
    19.  
    20.     public String getName() {
    21.         return name;
    22.     }
    23.  
    24.     public void setName(String name) {
    25.         this.name = name;
    26.     }
    27.  
    28.     public int getAge() {
    29.         return age;
    30.     }
    31.  
    32.     public void setAge(int age) {
    33.         this.age = age;
    34.     }
    35.  
    36.     @Override
    37.     public String toString() {
    38.         return "sheep{" +
    39.                 "id=" + id +
    40.                 ", name='" + name + '\'' +
    41.                 ", age=" + age +
    42.                 '}';
    43.     }
    44. }

    在AppConfig.py主类上加上@EnableConfigurationProperties(value = sheep.class)

    在主方法里加入：

    1.         sheep sheep = ioc.getBean(sheep.class);
    2.         System.out.println("sheep:" + sheep);

    执行结果：

  • 相关阅读:
    C++学习：数据的存储、作用域、链接
    Java编程基础
    锐捷链路聚合实验配置
    基于Python实现可视化分析中国500强排行榜数据的设计与实现
    RabbitMQ如何保证消息不丢失呢？
    [C++]ifstream和getline获取中文乱码解决方案
    电脑重装系统word从第二页开始有页眉页脚如何设置
    低代码平台如何借助Nginx实现网关服务
    单片机遥控开关系统设计（结构原理、电路、程序）
    40_ue4进阶末日生存游戏开发[添加和删除内容]
  • 原文地址：https://blog.csdn.net/qq_45981086/article/details/136555897