【应用篇】第 1 节 • SpringBoot 入门案例

第 1 节 SpringBoot 入门案例

一、前言

SpringBoot 官网：https://spring.io/projects/spring-boot

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

简单来说，SpringBoot 是建立在 Spring 基础之上更加易用框架，使得基于 Spring 的应用程序开发变得更加简单。

二、案例目标

本章节是使用 SpringBoot 搭建的第一个工程，主要通过第一个简单的案例来学习以下知识点：

1. 项目工程如何创建
2. maven 都需要配置哪些内容
3. 创建后是如何开发一个对外的接口的
4. 程序是怎么启动的
5. 如何进行单元测试

三、开发环境

1. JDK 1.8.0_45
2. Maven 3.6.2
3. SpringBoot 2.3.5.RELEASE

四、工程搭建

1. 工程结构

Hi-SpringBoot
├── src
│   ├── main
│   │  └── java
│   │      ├── cn.bugstack.middleware.demo 
│   │      │   ├── domain
│   │      │   │   └── UserService.java 
│   │      │   ├── interfaces
│   │      │   │   ├── dto
│   │      │   │   │   └── UserInfo.java
│   │      │   │   └── ApiController.java
│   │      │   └── HiApplication.java
│   │      └── resources 
│   │          └── application.yml
│   └── test
│        └── java
│            └── cn.bugstack.middleware.test
│                └── ApiTest.java 
└── pom.xml 

工程源码：https://codechina.csdn.net/FrameworkDesign/Hi-SpringBoot

1.1 创建工程

1.2 Maven工程

1.3 Maven配置

以上是基于 SpringBoot 搭建的一个简单案例工程，实现内容包括；

1. 使用 IDEA 创建的整体工程框架
2. HiApplication.java 启动类
3. UserService.java 接口类
4. UserInfo.java 是一个 DTO 对象
5. application.yml 工程配置文件，这里配置了端口信息
6. ApiTest.java 单元测试类
7. pom.xml POM 文件配置，用于 maven 下载工程依赖的 JAR 包

2. POM 配置

POM 文件是 Maven 用于拉取工程依赖 JAR 包或构件系统的配置文件，比如你要拉取哪个 JAR 包、拉取哪个版本，也是你在构建系统生成系统 JAR 包还是 WAR 包，以及其他配置内容。

官网：https://maven.apache.org/pom.html

2.1 packaging 标签

<packaging>pom</packaging>
<packaging>jar</packaging>
<packaging>war</packaging>

• packaging 有以上三种类型的配置，pom、jar、war，分别用于在 Maven install 时打出相应的类型包。
• 在我们这个案例工程中，配置的是 <packaging>war</packaging> 把工程打成一个 war 包。

打包结果

[INFO] Installing E:\itstack\git\FrameworkDesign\Hi-SpringBoot\target\Hi-SpringBoot.war to D:\Program Files (x86)\maven\apache-maven-3.6.2\repository\cn\bugstack\Hi-SpringBoot\1.0-SNAPSHOT\Hi-SpringBoot-1.0-SNAPSHOT.war
[INFO] Installing E:\itstack\git\FrameworkDesign\Hi-SpringBoot\pom.xml to D:\Program Files (x86)\maven\apache-maven-3.6.2\repository\cn\bugstack\Hi-SpringBoot\1.0-SNAPSHOT\Hi-SpringBoot-1.0-SNAPSHOT.pom
[INFO] Installing E:\itstack\git\FrameworkDesign\Hi-SpringBoot\target\Hi-SpringBoot-sources.jar to D:\Program Files (x86)\maven\apache-maven-3.6.2\repository\cn\bugstack\Hi-SpringBoot\1.0-SNAPSHOT\Hi-SpringBoot-1.0-SNAPSHOT-sources.jar

• 打包完成以后可以看到有一个 Hi-SpringBoot.war 在 target 目录下，这个 war 包就可以配置到 tomcat 等服务器中使用。

2.2 properties 标签

<properties>
    <!-- built-in libs -->
    <commons-beanutils.version>1.8.3</commons-beanutils.version>
    <fastjson.version>1.2.75</fastjson.version>
    <!-- Build args -->
    <jdk.version>1.8</jdk.version>
    <skip_maven_deploy>false</skip_maven_deploy>
    <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
    <maven.test.skip>true</maven.test.skip>
</properties>

• properties 标签用于定义 POM 文件中关于各类组件的版本和类型，而后使用 ${fastjson.version} 占位符进行使用

例如

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>${fastjson.version}</version>
</dependency>

2.3 parent 标签

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.5.RELEASE</version>
    <relativePath/>
</parent>

• parent 标签是用于引入父类配置，在 SpringBoot 的父类中已经定义好了几乎所有常用的组件，同时会预先定义好与之匹配的版本。这相当于简化了对 Spring 的使用。

2.5 dependencies 标签

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>   
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${fastjson.version}</version>
    </dependency>
</dependencies>

• dependencies 标签引入的是当前工程实际使用到的 JAR 包，例如有些 JAR 包在父类文件已经定义过，那么就不在需要维护版本信息，当然你也可以使用 version 标签改动版本。
• 如果像 fastjson 这样组件在父POM中不存在，则需要自己引入并加上版本信息。

2.6 build 标签

<build>
    <finalName>Hi-SpringBoot</finalName>   
    <!-- 打包资源文件配置 -->
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/**</include>
            </includes>
        </resource> 
        <resource>
            <directory>src/main/java</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.xml</include>
                <include>**/*.tl</include>
                <include>**/*.propertie</include>
            </includes>
        </resource>
    </resources>
    <!-- 打包测试资源文件配置 -->
    <testResources>
        <testResource>
            <directory>src/test/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/**</include>
            </includes>
        </testResource>
    </testResources>  
    <!-- plugins 是插件配置 -->
    <plugins>   
        <!-- 用于mvn生命周期的测试阶段的插件，可以通过一些参数设置方便的在junit下对测试阶段进行自定义 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12.4</version>
            <configuration>
                <skipTests>${maven.test.skip}</skipTests>
            </configuration>
        </plugin>   
        <!-- 指定maven编译的jdk版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
                <source>${jdk.version}</source>
                <target>${jdk.version}</target>
                <encoding>${project.build.sourceEncoding}</encoding>
            </configuration>
        </plugin>   
        <!-- Maven工程的源码进行打jar包 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>2.1.2</version>
            <executions>
                <execution>
                    <id>attach-sources</id>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

• 在 build 标签下包括；finalName、resources、testResources、plugin的使用，每一个类型的使用已经标注在注解文件中。

3. Application 启动工程

cn.bugstack.framework.demo.HiApplication

@SpringBootApplication
public class HiApplication {

    public static void main(String[] args) {
        SpringApplication.run(HiApplication.class, args);
    }

}

• HiApplication 类使用 @SpringBootApplication 注解，创建出一个SpringBoot的启动类，这个启动时会加载相应的配置、文件，扫描 Bean 信息注册实例化等。
• 后续当你有需要新增的配置，都会在这个启动类入口中添加。

4. 定义接口类

cn.bugstack.framework.demo.interfaces.ApiController

@RestController
public class ApiController {

    private Logger logger = LoggerFactory.getLogger(ApiController.class);

    @Resource
    private UserService userService;

    /**
     * 测试：http://localhost:8080/api/queryUserInfo?userId=10001
     */
    @RequestMapping(path = "/api/queryUserInfo", method = RequestMethod.GET)
    public UserInfo queryUserInfo(@RequestParam String userId) {
        logger.info("查询用户信息，userId：{}", userId);
        // 查询信息
        String name = userService.queryUserName(userId);
        int age = userService.queryUserAge(userId);
        String address = userService.queryUserAddress(userId);
        // 封装结果
        return new UserInfo(name + "：" + userId, age, address);
    }

}

• 这是一个创建API接口的类，在这个类中需要使用到 @RestController、@RequestMapping(path = "/api/queryUserInfo", method = RequestMethod.GET)，两个注解。
• @RestController，注解是一种快捷方式，它所声明的控制器在返回响应时，就如同使用了@ResponseBody 注解一样。它会告诉Spring 将返回类型序列化为合适的格式，默认情况下为JSON 格式。通过用@RestController注释控制器类，您不再需要向所有请求映射方法添加@ResponseBody。
• @RequestMapping，是一个用来处理请求地址映射的注解，在这里我们用到了 path 路径、method 请求类型。

5. yml 配置

# 服务端口配置
server:
  port: 8080

• 关于工程中用到的配置都会放到 yml 文件中，这里暂时只配置了端口，后续还会有数据库配置、mybatis配置等。

五、测试验证

1. 单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Resource
    private UserService userService;

    @Test
    public void test_queryUserInfo() {
        String address = userService.queryUserAddress("10001");
        logger.info("测试结果：{}", address);
    }

}

• 单元测试是用于测试程序实现中的类方法或接口，在SpringBoot中使用单元测试需要新增加注解；@RunWith(SpringJUnit4ClassRunner.class)、@SpringBootTest
• 另外就是你的测试方法，你需要在一个 public 类型的方法上添加 @Test 注解，在这里可以执行你的测试方法。

测试结果

2021-04-18 17:35:50.273  INFO 19404 --- [           main] cn.bugstack.framework.demo.test.ApiTest  : 测试结果：天津市东丽区万科赏溪苑
2021-04-18 17:35:50.284  INFO 19404 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'

Process finished with exit code 0

2. 工程测试

在 HiApplication 中，右键启动，如下：

启动信息

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.3.5.RELEASE)

2021-04-18 17:38:49.105  INFO 17844 --- [           main] c.bugstack.framework.demo.HiApplication  : Starting HiApplication on JDDBJ1PC1DATDF with PID 17844 (E:\itstack\git\FrameworkDesign\Hi-SpringBoot\target\classes started by fuzhengwei1 in E:\itstack\git\FrameworkDesign\Hi-SpringBoot)
2021-04-18 17:38:49.107  INFO 17844 --- [           main] c.bugstack.framework.demo.HiApplication  : No active profile set, falling back to default profiles: default
2021-04-18 17:38:49.812  INFO 17844 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-04-18 17:38:49.819  INFO 17844 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-04-18 17:38:49.820  INFO 17844 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.39]
2021-04-18 17:38:49.907  INFO 17844 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-04-18 17:38:49.908  INFO 17844 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 772 ms
2021-04-18 17:38:50.008  INFO 17844 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2021-04-18 17:38:50.117  INFO 17844 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-04-18 17:38:50.123  INFO 17844 --- [           main] c.bugstack.framework.demo.HiApplication  : Started HiApplication in 1.324 seconds (JVM running for 2.453)

• 运行到这，说明你的程序已经可以正常启动了，接下来就是访问接口做测试。

测试结果

接口：http://localhost:8080/api/queryUserInfo?userId=10001

{
    "code": "0000",
    "info": "success",
    "name": "虫虫：10001",
    "age": 19,
    "address": "天津市东丽区万科赏溪苑"
}

• 在浏览器访问后就可以看到相应的测试信息打印了，这返回的是一个 JSON 格式的结果。

六、总结

• 综上就是整个 SpringBoot 的案例工程实现，本工程主要以帮助还没有使用过 SpringBoot 搭建项目的读者做一个参考案例。
• 在这个项目中你可以了解到 SpringBoot 的工程结构、注解使用、POM 配置以及单元测试，这些内容并没有多复杂，多参考实践即可完成。
• 另外如果你是新接触此类技术，那么一定要动手实践，不要觉得一个东西看着简单，就看看。可能当你上手后会遇到各种情况的问题，学习编程并不只是看重结果，也要重视过程。