SpringCloud 由浅入深系列：第 2 章初识 SpringBoot 之 SpringBoot 快速入门

男娘i 2022-02-02 09:29 223阅读 0赞

# 什么是 Spring Boot #

Spring Boot 是由 Pivotal 团队提供的基于 Spring 的全新框架，其设计目的是为了简化 Spring 应用的搭建和开发过程。该框架遵循“约定大于配置”原则，采用特定的方式进行配置，从而使开发者无需定义大量的 XML 配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域成为领导者。

Spring Boot 并不重复造轮子，而且在原有 Spring 的框架基础上封装了一层，并且它集成了一些类库，用于简化开发。换句话说，Spring Boot 就是一个大容器，将我们开发中所遇到的场景及该开发场景所需要用到的框架集成进来，方便了开发者开箱即用。譬如：一个简单的web开发，我们就需要Spring SpringWebMVC 等开发框架，SpringBoot 就给我们集成了该对应的开发场景。

下面几张图展示了[官网][Link 1]上提供的 Spring Boot 所集成的所有开发场景![a4bfe2f0-5353-11e8-aed0-2dd5314cde1c][]

Spring Boot 官方推荐使用 Maven 或 Gradle 来构建项目，SpringCloud 由浅入深系列教程采用 Maven来进行构建。

### 第一个 Spring Boot 项目 ###

程序员学习的新东西都是以一个hello world 来开始我们的表演，接下来，我们就来搭建一个最简单的 Spring Boot 项目（hello world）。

1.创建一个名为Maven 工程项目,请看下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70][]

2.在 pom.xml 加入 Spring Boot 依赖：

<?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>
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.example</groupId>
        <artifactId>hello-springboot</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>hello-springboot</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

3.创建应用程序启动类 DemoApplication，并编写以下代码：

package com.example.hello.springboot;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * SpringBoot 应用启动类
     * @SpringBootApplication： 该注解标注该类为SpringBoot 应用的启动类，入口类
     */
    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

4.创建一个 Controller 类 HelloController，用以测试我们的第一个基于 Spring Boot 的 Web 应用：

package com.example.hello.springboot.controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController //@RestController = @Controller + @ResponseBody
    @RequestMapping("/hello")
    public class HelloController {
        
        @GetMapping(value = "/")
        public String hello () {
            return "我的第一个SpringBoot 入门项目!";
        }
    }

5.运行 DemoApplication 类中的 main 方法，看到下图所示内容说明应用启动成功：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70 1][]

6.浏览器访问：http://localhost:8080/hello，则会看到下图所示界面：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70 2][]

我们可以注意到，没有写任何的配置文件，更没有显示使用任何容器，只需要启动 Main 方法即可开启 Web 服务，从而访问到 HelloController 类里定义的路由地址即Url 地址。

这就是 Spring Boot 的强大之处，它默认集成了 Tomcat 容器并以内嵌的方式出现，通过 Main 方法编写的 SpringApplication.run 方法即可启动内置 Tomcat。

它是如何启动的，内部又是如何运行的呢？具体原理我将在【Spring Boot 启动原理 】为大家进行详细的剖析。

在上面的示例中，我们没有定义应用程序启动端口，可以看到控制台，它开启了 8080 端口，这是 Spring Boot 默认的启动端口。Spring Boot 提供了默认的配置，我们也可以改变这些配置，具体方法将在后面介绍。

我们在启动类里加入 @SpringBootApplication 注解，则这个类就是整个应用程序的启动类。如果不加这个注解，那就不能识别该SpringBoot 应用的入口类在何方，就没法启动我们的SpringBoot应用。

刚才应用默认以8080端口启动的，那我们怎么去自定义端口呢？接下来，我将介绍其配置文件application.yml 或 application.properties的用法。

### properties 和 yaml ###

在前面的示例代码中，我们并没有看到该配置文件，那是因为 Spring Boot 对每个配置项都有默认值。当然，我们也可以添加配置文件，用以覆盖其默认值，这里以 .properties 文件为例，首先在 resources 下新建一个名为 application.properties（注意：文件名必须是 application）的文件，键入内容为：

server.port=8081
    server.servlet.context-path=/api

并且启动 Main 方法，这时程序请求地址则变成了：http://localhost:8081/api/hello。

Spring Boot 支持 properties 和 yaml 两种格式的文件，文件名分别对应 application.properties 和 application.yml，下面贴出 yaml 文件格式供大家参考：

server:
      port: 8080
      servlet:
        context-path: /api

可以看出 properties 是以逗号隔开，而 yaml 则换行+ 两个空格 隔开，这里需要注意的是冒号后面必须空格，否则会报错。yaml 文件格式更清晰，更易读，这里笔者建议大家都采用 yaml 文件来配置。

之后本教程的所有配置均采用 yaml 文件，作为配置文件。

### 打包、运行 ###

Spring Boot 打包分为 war 和 jar 两个格式，下面将分别演示如何构建这两种格式的启动包。

在 pom.xml 加入如下配置：

<packaging>war</packaging>
    <build>
        <finalName>api</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>

这个时候运行 mvn package 就会生成 war 包，然后放到 Tomcat 当中就能启动，但是我们单纯这样配置在 Tomcat 是不能成功运行的，会报错，需要通过编码指定 Tomcat 容器启动，修改 DemoApplication 类：

@SpringBootApplication
    public class DemoApplication extends SpringBootServletInitializer {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
            return application.sources(DemoApplication.class);
        }
    }

这时再打包放到 Tomcat，启动就不会报错了。

在上述代码中，DemoApplication 类继承了 SpringBootServletInitializer，并重写 configure 方法，目的是告诉外部 Tomcat，启动时执行该方法，然后在该方法体内指定应用程序入口为 DemoApplication 类，如果通过外部 Tomcat 启动 Spring Boot 应用，则其配置文件设置的端口和 contextPath 是无效的。这时，应用程序的启动端口即是 Tomcat 的启动端口，contextPath 和 war 包的文件名相同

接下来我们继续看如果达成 jar 包，在 pom.xml 加入如下配置：

<packaging>jar</packaging>
    <build>
        <finalName>api</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    
                    <mainClass>com.example.hello.springboot.DemoApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                    <useDefaultDelimiters>true</useDefaultDelimiters>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

然后通过 mvn package 打包，最后通过 java 命令启动：

java -jar api.jar

如果是 Linux 服务器，上述命令是前台进程，点击 Ctrl+C 进程就会停止，可以考虑用 nohup 命令开启守护进程，这样应用程序才不会自动停止。

这样，最简单的 Spring Boot 就完成了，但是对于一个大型项目，这是远远不够的，Spring Boot 的详细操作可以参照[官网][Link 2]。

以上实例只是最简单的 Spring Boot 项目入门实例，后面会深入研究 Spring Boot。

[Link 1]: http://projects.spring.io/spring-boot/
[a4bfe2f0-5353-11e8-aed0-2dd5314cde1c]: /images/20220202/8108e480aa6142f9a260777441c4fa6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70]: /images/20220202/24e09481a4164c6cbe8041b023fd372c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70 1]: /images/20220202/c1ed1fd860e6491d805dcc09097dd60b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NzZG5fd2VsZWFybg_size_16_color_FFFFFF_t_70 2]: /images/20220202/0cfcec830a9c43bb94a3d5482df3fdb2.png
[Link 2]: https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/