从传统Java应用到现代微服务，SpringBoot入门的基础指南

一. 创建SpringBoot项目

1.1 使用Spring Initializr快速构建项目

这里使用maven3.6.1与IDEA2022.2.1版本进行创建（每个版本创建的页面有所不同请自行参考斟酌）。

建议将Server URL修改为国内镜像，下载速度更快：【https://start.aliyun.com/】

点击创建即可，可以先不用选择依赖。

创建好的项目如下（阿里云镜像创建很干净）：

看一下pom文件，pom文件有很多内容，使用阿里云镜像创建方式会默认是一个聚合的Maven项目，更方便管理，我对下面的pom文件的标签进行了解释说明，可以参考：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--表示该项目的模型版本号，告诉Maven该如何解释该项目的pom.xml文件，以及如何构建该项目。
        在这种情况下，版本号"4.0.0"表示使用Maven 2.0及以上版本的模型。-->
    <modelVersion>4.0.0</modelVersion>
    <!-- 建项目时创建的组织名称 -->
    <groupId>com.javadouluo</groupId>
    <!-- 项目名称 -->
    <artifactId>springboo-demo</artifactId>
    <!-- Maven项目的版本号，0.0.1表示这个项目的当前版本号是第一次主要版本、第一次次要版本和第一次补丁版本。
         -SNAPSHOT表示是一个快照版本，这个版本可能不是最终版本，而是开发过程中的一个中间版本，可能会在未来进一步修改和更新。-->
    <version>0.0.1-SNAPSHOT</version>
    <!-- 项目名称 -->
    <name>springboot-demo</name>
    <!-- 项目描述 -->
    <description>这是一个SpringBoot的项目...</description>
    <!-- 配置项目的一些公共属性，这些属性可以在其他地方引用 -->
    <properties>
        <!-- Java语言的版本，此处为1.8 -->
        <java.version>1.8</java.version>
        <!-- 项目源码文件的编码方式，此处为UTF-8 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 项目报告文件的编码方式，此处为UTF-8 -->
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!-- Spring Boot框架的版本号，此处为2.2.6.RELEASE -->
        <spring-boot.version>2.2.6.RELEASE</spring-boot.version>
    </properties>

    <!-- 导入依赖 -->
    <dependencies>

        <!-- 主要的启动依赖项 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- 测试框架，它包含了用于编写和运行测试的工具和库。 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <!-- 排除掉依赖项中的某些特定部分（这里是排除了 junit-vintage-engine 模块）-->
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!-- 统一管理项目中的依赖项版本号这种方式使得多个模块可以共享同一版本的依赖项，
         同时又不必在每个模块中都声明一遍依赖项的版本号，从而避免了重复代码和版本冲突的问题。 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 用于配置 Maven 构建过程中需要执行的插件，可以不配置，但是如果不配置 maven-compiler-plugin 插件，
         Maven 会使用默认、的编译器进行编译，可能会导致编译错误或者不兼容的问题。Maven 默认使用 Java 编译器进行编译，
         其命令为 javac，这个编译器是随 JDK/JRE 一起安装的。在使用 Maven 编译项目时，
         默认会使用配置在项目中的 JDK 版本进行  编译。如果项目中没有显式指定 JDK 版本，那么 Maven 会使用系统中的默认 JDK 版本进行编译 -->
    <build>
        <plugins>
            <!--  Maven 自带的一个插件，用于编译 Java 代码 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <!-- 不受本地 Maven 版本影响 -->
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <!-- 用于将 Spring Boot 应用打包成可执行的 JAR 文件，并在其中包含所有的依赖项 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.javadouluo.springboot.SpringbooDemoApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <!-- 先执行 repackage 目标，重新打包项目，生成可执行的 JAR 文件。 -->
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

1.2 手动创建springboot项目

用maven手动创建一个springboot的项目的话需要手动导入依赖。

然后直接创建即可，项目长这样，自己打开看一下里面是空的，在看一下pom文件，就是一个简简单单的空maven项目：

<?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>

    <groupId>com.javadouluo</groupId>
    <artifactId>springboot01</artifactId>
    <version>1.0-SNAPSHOT</version>

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

</project>

下面我们开始导入springboot依赖：

<?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>

    <groupId>com.javadouluo</groupId>
    <artifactId>springboot01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 声明父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.6.RELEASE</version>
    </parent>

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

    <dependencies>
        <!-- 主要的启动依赖项,不然找不到启动类的注解 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!--加入webmvc的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

这个parent标签包含了很多默认的Maven依赖和插件配置。这些配置会被自动继承到子项目中。这样的话，子项目不需要重复地定义这些配置，而只需要在dependency和build标签中指定需要的依赖和插件即可。

使用parent标签的好处是可以简化项目的配置，减少重复性的配置工作。另外，使用Spring Boot的spring-boot-parent作为父级Maven项目，可以确保项目中的所有Spring Boot相关的依赖版本都是一致的，避免版本冲突的问题。

下面就是加入启动类和测试springboot项目是否可以启动：左边建立一个测试的UserController右边就是启动类的内容了。

UserController简单写一个用Spring MVC的注解来编写的简单的RESTful Web Service的示例。

package com.javadouluo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author jektong
 * @date 2023年04月24日 22:55
 */
@RestController
@RequestMapping("/user")
public class UserController {
    
    

    @RequestMapping("/string")
    public String helloSpring(){
    
    
        return "HELLO,SPRING!!!";
    }
}

在application.yml中指定端口号,然后打开网址访问【http://localhost:1024/user/string】即可出现下面效果说明springboot项目搭建成功。

server:
  port: 1024

二. SpringBoot入门案例解析

2.1 依赖管理特性

上面简单了解了这个parent标签的作用，简单来说，就是springboot为了能够更好的去管理项目中的jar包，将开发者常用的jar包全部整合到它的父项目中，比如上述的：

    <!-- 声明父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.6.RELEASE</version>
    </parent>

进去可以看到它的父依赖：

再次点击进去，可以发现有个properties标签，里面定义很多版本的包，注意这是仅定义版本号，而没有被使用。

这些都是规定此springboot版本适配的各种jar包，当我们在pom文件中引入相关依赖的时候就无需指定版本号了：

假如不需要springboot中已经定义好的版本号，可以在pom文件中自己规定需要的版本，举个例子来说，springboot中规定的activemq版本号为：

<activemq.version>5.15.12</activemq.version>

在pom文件中自己规定重写需要的版本即可：

<properties>
	<activemq.version>5.15.13</activemq.version>
</properties>

2.2 starter场景启动器

Spring Boot的场景启动器（Starter）是一种特殊的依赖项，可以为应用程序提供特定的功能和配置。场景启动器由Spring Boot项目提供，并且通常以spring-boot-starter-*的形式命名。例如，spring-boot-starter-web场景启动器提供了使用Spring MVC构建Web应用程序所需的依赖项和配置。

场景启动器通常包含以下内容：

• 依赖项：包含所需的库和框架，例如Spring框架、数据库驱动程序等。
• 自动配置：为应用程序自动配置所需的Bean和组件。
• 配置文件：包含应用程序所需的默认配置。

在Spring Boot应用程序中，可以使用场景启动器轻松地添加所需的依赖项和配置。例如，如果需要在应用程序中使用Spring Web MVC，只需在pom.xml文件中添加以下依赖项：

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

上述依赖项将包含Spring Web MVC所需的所有库和框架，并将自动配置所需的Bean和组件。此外，还将包含一个默认的配置文件，其中包含Spring Web MVC所需的默认配置。

还可以使用场景启动器创建自定义场景启动器，以将自己的依赖项和配置打包成一个单独的依赖项，springboot建议自己定义的场景启动器使用*.spring-boot-starter这种方式命名。

使用场景启动器时，Spring Boot将自动配置所需的Bean和组件，并将其注入到应用程序中。这使得构建Spring Boot应用程序变得非常容易，不必手动配置所有的Bean和组件。

2.3 引导类自动配置

springboot中帮我们自动配置了一些组件，比如Tomcat，全套的springmvc组件,下面就来打印一下springboot启动的时候加载了多少组件。

@SpringBootApplication
public class JavaSpringbootApplication {
    
    

    public static void main(String[] args) {
    
    
        // ioc容器
        ConfigurableApplicationContext context = SpringApplication.run(JavaSpringbootApplication.class, args);
        // 获取ioc容器所有注入的组件名称
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
    
    
            System.out.println(beanDefinitionName);
        }
    }
}

在main方法中，使用SpringApplication.run方法启动了Spring Boot应用程序，并返回一个ConfigurableApplicationContext对象。该对象代表了Spring应用程序上下文，它是Spring容器的主要接口之一，可以通过它来获取容器中的所有Bean。在该代码中，使用该对象的getBeanDefinitionNames方法获取了所有已经注入到容器中的Bean的名称，并输出到控制台中。

看看之前springmvc中常用配置组件发现都会有，全部给你自动配置好了：

默认包结构扫描

上面的一个`controller``例子中，没有配置任何的扫描规则，springboot还是可以将其中的组件扫描出来，因为提供了默认的扫描规则，就是和启动类同级目录下以及它的子类全部可以扫描。

超出这个范围默认情况下是扫描不出来的，要想扩大扫描范围可以在启动类上扩大包指定的范围：

/**
 * @author jektong
 * @date 2023年04月24日 22:24
 */
@SpringBootApplication(scanBasePackages = "com.javadouluo")
public class JavaSpringbootApplication {
    
    
......

三. REST风格

在springboot开发web应用时，前端向后端请求的路径会用到一种基于HTTP协议构建Web应用程序的软件架构风格，简称REST

它是一种轻量级的、面向资源的Web服务架构风格，强调系统组件之间的互操作性、可扩展性、简洁性和可靠性。

REST（Representational State Transfer）是一种基于HTTP协议构建Web应用程序的软件架构风格。它是一种轻量级的、面向资源的Web服务架构风格，强调系统组件之间的互操作性、可扩展性、简洁性和可靠性。

下面就按照非REST风格与采用是REST风格访问资源时的对比：

假设我们正在构建一个电影信息系统，其中包含电影列表和电影详情两个资源。以下是两个示例API，一个是非RESTful的API，另一个是RESTful的API。

非RESTful的API：

GET /movies/get_all_movies   // 获取所有电影
GET /movies/get_movie_detail?id=123   // 获取电影详情
POST /movies/create_movie   // 创建电影
PUT /movies/update_movie?id=123   // 更新电影
DELETE /movies/delete_movie?id=123   // 删除电影

RESTful的API：

GET /movies   // 获取所有电影
GET /movies/123   // 获取电影详情
POST /movies   // 创建电影
PUT /movies/123   // 更新电影
DELETE /movies/123   // 删除电影

可以看到，在RESTful API中，URI是资源的唯一标识符，而HTTP方法则表示对该资源的操作，比如获取电影详情，更新电影，删除电影用的是同一资源路径（/movies/123）。获取所有电影，创建电影采用的是同一资源路径（/movies），但是他们对应的HTTP方法（GET、POST、PUT、DELETE）不一样。

好了，现在我们在controller中用REST风格来实现上述代码:

@RestController // 声明为Restful风格的Controller
@RequestMapping("/movies") // 设置映射路径为/movies
public class MovieController {
    
    

    @Autowired // 使用Spring的依赖注入功能，注入MovieService
    private MovieService movieService;

    @GetMapping // 定义HTTP GET方法的映射，用于获取所有电影
    public List<Movie> getAllMovies() {
    
    
        return movieService.getAllMovies(); // 调用MovieService的方法获取所有电影
    }

    @GetMapping("/{id}") // 定义HTTP GET方法的映射，用于获取指定id的电影详情
    public Movie getMovieById(@PathVariable("id") Long id) {
    
     // 通过@PathVariable注解获取请求路径中的id参数
        return movieService.getMovieById(id); // 调用MovieService的方法获取指定id的电影详情
    }

    @PostMapping // 定义HTTP POST方法的映射，用于创建电影
    @ResponseStatus(HttpStatus.CREATED) // 设置响应状态码为201，表示资源创建成功
    public Movie createMovie(@RequestBody Movie movie) {
    
     // 通过@RequestBody注解获取请求体中的电影数据
        return movieService.createMovie(movie); // 调用MovieService的方法创建电影
    }

    @PutMapping("/{id}") // 定义HTTP PUT方法的映射，用于更新指定id的电影
    public Movie updateMovie(@PathVariable("id") Long id, @RequestBody Movie movie) {
    
     // 通过@PathVariable注解获取请求路径中的id参数，通过@RequestBody注解获取请求体中的电影数据
        return movieService.updateMovie(id, movie); // 调用MovieService的方法更新电影
    }

    @DeleteMapping("/{id}") // 定义HTTP DELETE方法的映射，用于删除指定id的电影
    public void deleteMovie(@PathVariable("id") Long id) {
    
     // 通过@PathVariable注解获取请求路径中的id参数
        movieService.deleteMovie(id); // 调用MovieService的方法删除电影
    }
}

四. 配置文件

4.1 配置文件类型

在Spring Boot中，有两种常见的配置文件类型：

1. application.properties：这是一个基于键值对的配置文件，用于配置Spring Boot应用程序的各种属性和参数。这些属性和参数可以覆盖应用程序中的默认值。例如，可以使用以下行指定应用程序的端口号：

server.port=8080

2. application.yml：这是一种基于YAML格式的配置文件，它提供了一种更加结构化和易读的方式来配置Spring Boot应用程序。它支持列表、映射和复杂对象的定义。以下是一个使用YAML语法定义端口号的示例：

server:
  port: 8080

通常，application.properties更适合简单的应用程序，而application.yml更适合大型应用程序和需要更多自定义设置的应用程序。

下面主要介绍一下YMAL文件。

4.2 YAML文件的简介与使用

在Spring Boot中，YAML文件（.yml）通常用于配置应用程序的属性。相比于传统的.properties文件，YAML语法更加简洁明了，可读性更强。它的基本语法规则如下：

1. 大小写敏感：比如true和True是不同的值。
2. 使用缩进表示层次结构
3. 使用冒号表示键值对
4. 使用破折号表示列表项
5. 使用#表示注释

下面举一个例子，假设有一个Java对象包含以下属性：

@ConfigurationProperties("example")
@Component
public class ExampleObject {
    
    
    private String name;
    private int age;
    private boolean isActive;
    private List<String> hobbies;
    private Map<String, Integer> scores;
    private String[] friends;
    private Address address;
    // getters and setters
}

其中，Address是另一个Java对象：

public class Address {
    
    
    private String street;
    private String city;
    private String state;
    private String zip;
    // getters and setters
}

现在我们将Java对象与yml配置文件进行对应：

# 定义example作为根节点
example:
  # name属性，类型为字符串
  name: John

  # age属性，类型为整数
  age: 30

  # isActive属性，类型为布尔值
  isActive: true

  # hobbies属性，类型为字符串列表
  hobbies:
    - reading  # 读书
    - hiking   # 徒步旅行
    - swimming # 游泳

  # scores属性，类型为键值对（Map），其中键为字符串，值为整数
  scores:
    math: 90      # 数学成绩
    english: 80   # 英语成绩
    science: 95   # 科学成绩

  # friends属性，类型为字符串数组
  friends: [Mike, Lisa, Mary]

  # address属性，类型为另一个对象，需要嵌套一个新的节点表示地址
  address:
    street: 123 Main St  # 街道地址
    city: Anytown        # 城市
    state: CA            # 州或省
    zip: "12345"         # 邮政编码（注意需要使用双引号包括字符串）

在这个YAML文件中，我们使用example作为根节点，将Java对象的属性映射到YAML文件中的属性。具体地：

• name属性映射到YAML文件中的name属性，类型为字符串。
• age属性映射到YAML文件中的age属性，类型为整数。
• isActive属性映射到YAML文件中的isActive属性，类型为布尔值。
• hobbies属性映射到YAML文件中的hobbies属性，类型为字符串列表。
• scores属性映射到YAML文件中的scores属性，类型为键值对（Map），其中键为字符串，值为整数。
• friends属性映射到YAML文件中的friends属性，类型为字符串数组。
• address属性映射到YAML文件中的address属性，类型为另一个对象，需要嵌套一个新的节点表示地址，其中包含street、city、state和zip属性，均为字符串。

通过这种方式，我们可以将Java对象的属性方便地映射到YAML文件中，并在应用程序中加载和使用这些属性。

4.3 @Value与@ConfigurationProperties

除了之前的@ConfigurationProperties可以从配置文件中获取值之外，@Value也可以从配置文件中获取对应的值。

@Component
public class ExampleObject {
    
    
	@Value("${example.name}")
    private String name;
    @Value("${example.age}")
    private int age;
    @Value("${example.isActive}")
    private boolean isActive;
    private List<String> hobbies;
    private Map<String, Integer> scores;
    private String[] friends;
    private Address address;
    // getters and setters
}

下表列出了@Value注解和@ConfigurationProperties注解的区别和特点：

区别	@Value注解	@ConfigurationProperties注解
数据来源	单个属性值	集合/整个对象
数据绑定	手动绑定	自动绑定
配置项校验	否	是
松散绑定	否	是
SpEL表达式	是	否
支持JSR303	否	是
优点	灵活方便	更加易于管理和组织配置项
缺点	手动绑定	需要定义类来管理配置项

@Value注解适用于较为简单的配置项，而@ConfigurationProperties注解适用于大量的配置项，可以更好地管理和组织配置信息。

4.4 Profile多环境支持

在Spring Boot中，我们可以使用多个application-{profile}.properties文件来支持多个环境配置。其中，{profile}是指环境名称。

假设有一个名为application.properties的配置文件，它包含了应用程序的默认配置信息。

我们还可以创建两个文件，分别命名为application-dev.properties和application-prod.properties，用于分别定义开发环境和生产环境的配置信息。

在这些配置文件中，我们可以使用相同的属性名称来覆盖默认的配置信息。例如，在application-dev.properties文件中，我们可以设置server.port属性的值为8080：

server.port=8080

然后，在application.properties文件中，我们可以设置server.port属性的值为9090：

server.port=9090

在这种情况下，如果我们将spring.profiles.active属性设置为dev，则应用程序将使用application-dev.properties文件中的server.port属性值。如果将spring.profiles.active属性设置为prod，则应用程序将使用application-prod.properties文件中的server.port属性值。

如果我们同时在多个application-{profile}.properties文件中设置了相同的属性，则会根据spring.profiles.active属性的值选择加载哪个文件。如果没有设置spring.profiles.active属性，则默认情况下将加载application.properties文件。

以上就是对于Springboot的基础入门的基本介绍，简单介绍了如何创建一个SpringBoot的应用以及它的配置文件。