初识SpringBoot
|
264
|
0
|
SpringBoot

2345 字
|
10 分钟

SpringBoot可是说是目前最流行的Web后端框架之一了，为了面向日后的实习，只能从现在开始学习相关的专业知识。为此我也在博客之中开设了一个板块，来记录自己学习SpringBoot路程中的相关笔记。希望可以坚持学完着一个框架，话不多说，加油吧。

SpringBoot初步

SpringBoot是基于Java的一个框架，通常采用maven这一个构建系统。对此，想要建立一个SpringBoot项目，得先配置好自己的maven。对此，我使用Idea作为此次学习所使用的IDE。在IDEA里面创建一个，maven项目十分方便，就不过多的赘述了。我们知道，pom.xml是maven项目的配置文件，想要在一个maven项目中引入SpringBoot，这就是一个绕不开的话题。其中，pom.xml的相关配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 所有SpringBoot项目都要继承这个父类 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
    </parent>
    <!-- SpringBoot WEB场景的启动器 -->
    <groupId>cn.nkkxzxx</groupId>
    <artifactId>springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

   <!-- SpringBoot应用打包器 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

以上是一个SpringBoot项目的经典引入方式。可以看到，每一个依赖，都是一个starter。那什么是starter呢，稍后将详细叙述。将依赖引入之后，可以开始编写一个主类了。为了启动一个SpringBoot程序，我们需要一个主入口。对此，定义如下：

package cn.nkkxzxx;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@EnableAutoConfiguration
public class Main {
    @RequestMapping("/")
    @ResponseBody
    public String home() {
        return "Hello Word！";
    }
    public static void main(String[] args) throws Exception {
        SpringApplication.run(Main.class, args);
    }
}

运行结果如下：

SpringBoot的应用分析

依赖管理

基本原则

SpringBoot的依赖遵守依赖传递原则，即是一个树形的结构，自动的导入某一个场景下的所有依赖。

而且，每一个SpringBoot都有一个父项目：spring-boot-start-parent，在该依赖中指定了相关的依赖对应的版本，所以导入场景无需填写版本号。

其中，该父项目称为版本仲裁中心。

自定义版本号

利用maven的就近原则，直接在当前项目中使用的key的相关版本号。

  1. 利用项目的properties标签
  2. 导入场景的时候手动指定

其中第三方包不被管理器管理，需要自行指定。

自动配置机制

包扫描机制

  1. 默认的包扫描规则：SpringBoot主程序只会扫描主程序所在的包以及下面的子包，这是属于自动的component-scan功能

  2. 自定义的扫描规则

    • 在主程序注解中声明：@SpringBootApplication(scanBasePackages = “包的位置”)

    @SpringBootApplication 是一个组合注解，它包含了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 三个注解。

    • @SpringBootConfiguration 继承自 @Configuration，表示该类是 Spring 的配置类，可以被 @ComponentScan 扫描到。
    • @EnableAutoConfiguration 开启 Spring Boot 的自动配置功能，它会尝试根据类路径设置、其他 bean 和各种属性设置自动配置。
    • @ComponentScan 会扫描指定包及其子包下的所有被 @Component、@Service、@Repository 等注解的类，并注册为 Spring 的 bean。
    • ComponentScan注解声明：@ComponentScan(“要扫描的包的位置”)

配置默认值

配置文件的所有配置项都是和某一个类的对象一一进行绑定的。其中，这个类称为配置属性类。即所有的配置都是以类的形式存在，在application.properties里面更改的属性最终都会成为对类的对象属性的更改。具体的默认值可以参照官方文档。

按需配置加载

导入相应的场景 ，例如导入 spring-boot-starter-web。场景启动器进而导入相关功能的依赖，还会导入一个 spring-boot-starter 基础核心starter。spring-boot-starter 进而导入一个 spring-boot-autoconfigure 自动配置包。这个包里面都是各种场景的自动配置类。

但是，不是所有自动配置都会自动生效。实际上，是自己导入了什么包，对应包的自动配置才会被激活。

深入了解自动配置原理

主程序：@SpringBootApplication

1、@SpringBootApplication 有三个注解组成：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan

2、SpringBoot默认只能扫描到自己主程序所在的包以及他下面的子包，扫描不到spring-boot-autoconfigure包中官方写好的配置类

3、@EnableAutoCondition：SpringBoot开启自动配置的核心

  • 是由@Import(AutoConfigurationImportSelector)提供功能：批量给容器导入组件
  • SpringBoot启动会默认加载142个配置类
  • 这个配置类有spring-boot-autoconfigure文件指定
  • 项目启动的时候利用@import批量导入机制吧autoconfigure里面的包全部导入进来（自动配置类）
  • 导入的142个类不一定全部都生效了，代码中利用@ConditionalOnClass注解来实现类存在才可以加载

4、按需生效：不是所有导入的自动配置类都可以生效，每一个自动配置类都有自己的条件注解，满足条件注解的情况之下自动配置类才可以生效

自动配置类（xxxxAutoConfiguration）

1、给容器中放一堆组件（Bean）

2、每个自动配置类都可能有注解 @EnableConditionProperties 把配置文件中配的指定前缀的属性值封装到 xxxProperties 属性类中

流程

1、导入starter就会自动导入autoconfigure

2、autoconfigure里面有一个文件，里面指定了所有启动要加载的自动配置类

3、@EnableAutoConfiguration 会自动地把上面的文件里面写的所有自动配置类都自动导入进来

4、xxxAutoConfiguration（带条件注解，按需加载），给容器中导入一堆组件。组件都是从xxxxproperties中提取属性值的

5、xxxpeoperties又和配置文件（application…properties）进行了绑定

常用注解

组件注册

（1）@Configuration（@SpringBootConfiguration）：标注一个配置类

（2）@Bean：标注一个容器中注册的组件。组件在容器中的名称默认为方法名。

（3）@Scope：获取一个组件时，都重新返回一 个新的对象。

（4）@Controller

（5）@Service

（6）@Repository

（7）@Component

（8）@Import

（9）@ComponentScan

使用流程

1、@Configuration 编写一个配置类

2、在配置类中，自定义方法给容器中注册组件。配合@Bean注解

3、可以使用@Import 来导入第三方的组件

条件注解

如果注解指定的条件成立，就触发指定行为。标准格式为：@ConditionalOn*******

（1）@ConditionalOnClass：如果路径中存在这个类，就触发指定的行为

（2）@ConditionalOnMissingClass：如果路径中不存在这个类，就触发指定的行为

（3）@ConditionalOnBean：如果路径中存在这个Bean（组件），就触发指定的行为

（4）@ConditionalOnMissingBean：如果路径中不存在这个Bean（组件），就触发指定的行为

还有更多的条件注解，可以查阅官方文档

这个注解可以作为方法级别和类级别注解

属性绑定

将容器中任意组件值和配置文件的配置项的值进行绑定

（1）@ConfigurationProperties(prefix = “前缀”)

（2）@EnableConfigurationProperties：开启组件的属性绑定，并且自动把组件放进容器中（常用于加入第三方包）

使用步骤：
1、先将组件注册进如容器（@Component，@Bean）

2、使用@ConfigurationProperties进行绑定

配置文件

在SpringBoot中，可以在每个模块下resources文件夹中创建application.properties或者application.yml文件来作为SpringBoot的配置文件。这些配置文件利用Java的反射机制来实现。

对场景的配置

我们知道，SpringBoot的各个功能模块称为场景。一个场景对应一个starter。在创建场景的时候，依据自动配置的原理，一个场景会对应一个xxxxAutoConfigure的配置类，在这个配置类中，可能会对某一个配置进行绑定。例如：Redis中RedisAutoConfigure就通过RedisProperties类对srping.data.redis配置进行绑定。RedisProperties类部分结构如下：

 public class RedisProperties {
     ....
     private String url ;
     private String host = "localhost";
     ....
 }

我们想要对Redis进行配置，便可以在配置文件中输入以下内容：

 

properties文件
spring.data.redis.host=192.168.1.1

yaml文件
spring:
  data:
    redis:
      host: 192.168.1.1

通过编写如上配置文件，便可以更改Redis配置中的相关属性。

实例化复杂类

前面说到，Redis通过读取配置文件来进行相关参数的配置。同样的，我们自己定义的类也可以读取配置文件来进行实例化。

例如，定义一个Person类：

package cn.nkkxzxx.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private String gender;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

我们在配置文件中输入如下部分：

person:
  name: 张三
  gender: 男

在通过有@SpringBootApplication注解的主函数运行SpringBoot程序的时候，便会在初始的时候扫描到Person类，并进行实例化。由于Person类带@ConfigurationProperties(prefix = “person”)注解，在实例化的过程中会读取配置文件中对应的值，从而示例化对应的对象。

 

上一篇
下一篇