SpringBoot之初体验

一、SpringBoot 介绍

1.1 SpringBoot 使命

在之前我们学习 Spring 时，我们了解到 Spring 最根本的使命就是 简化Java开发。而 SpringBoot 的出现也有其使命存在，它的使命就是为了简化 Spring 。

SpringBoot 使用 "开箱即用和约定优于配置" 的理念让你的项目无需经过大量的配置就能够快速的运行起来，这些配置工作已经由 SpringBoot 为我们做好了初始化工作，当然如果有额外的配置需求也可以更改。

1.2 SpringBoot 特性

• Spring Boot Starter: 它将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的 Maven 或 Gradle 构建中;
• 自动配置：Spring Boot 的自动配置特性利用了 Spring 4 对条件化配置的支持，合理地推测应用所需的 Bean 并自动化配置它们;
• 命令行接口(Command-line interface,CLI): Sprign Boot 的 CLI 发挥了 Groovy 编程语言的优势，并结合自动配置进一步简化 Spring 应用的开发;
• Actuator:它为 Spring Boot 应用添加了一定的管理特性。

二、创建 SpringBoot 项目

2.1 mavne 自行添加形式

1. 打开 IDEA 创建新项目

   

   或者已经打开 IDEA 的情况下在菜单栏上选择 File --> New --> Project 选项

2.选择 Maven 创建一个空项目

3.输入项目信息，选择下一步

4.创建一个如下目录结构的项目

* java文件夹：存放 java 代码
* resources文件夹：存放资源文件
* test文件夹：存放单元测试代码
* pom.xml：依赖库

5.接下来我们按 SpringBoot 标准的结构我们来新增一些目录

1.在 java 和 目录下新建包名
2.在 resources 下新建 static 和 templates 目录 和 application.properties 文件    
    * static: 存放静态资源文件
    * templates: 存放模板文件
    * application.properties: 存放项目配置信息   

6.在 pom.xml 中增加 web 依赖

<?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.learn</groupId>
    <artifactId>springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 引入 SpringBoot 依赖库 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
    </parent>

    <dependencies>
        <!--引入 web 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

7.在com.learm.springboot 包下新建一个启动类

@SpringBootApplication
public class Application {

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

}

8.新建 HelloController

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello SpringBoot";
    }
}

9.启动项目，观察控制台输出

10.打开浏览器访问 http://localhost:8080/hello

2.2 Spring Initializr 形式

Spring Initializr 是 Spring 官方提供的一个用来初始化 SpringBoot 项目的工具,我们来实践下。

1.选择 Spring Initializr 创建项目

2.输入项目信息

3.选择需要的依赖，这里我们只需要 web 依赖即可

4.选择项目名称和存放的路径

5.创建后的项目结构如图：

6.查看 pox.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 https://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.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
             
    <groupId>com.learm</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

发现和我们手工创建的项目相比多了一个 spring-boot-starter-test 依赖和打包插件

7.新建 HelloController

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello SpringBoot";
    }
}

8.启动项目，观察控制台输出

9.打开浏览器访问 http://localhost:8080/hello

发现效果一样。

二、SpringBoot 打包部署

SpringBoot 支持多种打包方式，如果是前后端分离的项目使用 JAR 包形式可能是更合适的解决方案。

2.1 jar 包部署

1.在 pom.xml 文件中增加打包插件，并将打包格式设为 JAR

	......
    <!--设置打包格式为 JAR -->
    <packaging>jar</packaging>
	
    <build>
        <plugins>
        	<!--增加打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>    

2.运行 Maven install 指令，它会在当前项目下新建一个 target 目录用来存放打包后的文件

3.打开命令行工具,执行 JAR 包

E:\IdeaProject\learn\springboot>cd target

E:\IdeaProject\learn\springboot\target>java -jar springboot-0.0.1-SNAPSHOT.jar

4.观察控制台输出

5.打开浏览器访问 http://localhost:8080/hello

部署成功。

2.2 war 包部署

1.在 pom.xml 文件中增加打包插件，并将打包格式设为 WAR

	......
    <!--设置打包格式为 WAR -->
    <packaging>war</packaging>
	
    <build>
        <plugins>
        	<!--增加打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    

2.修改 SpringbootApplication.java 文件，使其兼容 Tomcat 运行

@SpringBootApplication
public class SpringbootApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringbootApplication.class);
    }

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

}

3.运行 Maven install 指令，它会在当前项目下新建一个 target 目录用来存放打包后的文件

3.将 WAR 包拷贝到 Tomcat/weapps 目录下并启动 Tomcat

4.打开浏览器访问 http://localhost:8080/springboot-0.0.1-SNAPSHOT/hello

部署成功。

注：JDK1.8 需要在 Tomcat8以上才能运行返回会报 java.lang.UnsupportedClassVersionError 异常。

2.3 修改打包文件名称

默认打包生成的文件命名格式是项目名+版本号，我们可以在 pom.xml 文件中指定它的名称：

<build>
	<finalName>SpringBoot</finalName>
    ......
</build>    

执行打包命令后，查看文件：

三、SpringBoot 配置文件

在之前我们就讲到了 SpringBoot 会为我们做大量的初始化工作，如果我们需要调整某些配置的话就可以到 SpringBoot 全局配置文件中调整。Spring Boot 提供了两种常用的配置文件，分别是 properties 文件和 yml 文件。

3.1 properties 格式

语法格式：

 key=value  

一行一个属性。

实例:

# 修改端口号
server.port=8081
# 设置项目名称路径
server.servlet.context-path=/

3.2 yml 格式

yml 格式全程叫 YAML(YAML Ain't Markup Language)，是一种以数据为中心的语言，比 json，xml 更适合做配置文件。

语法格式：

key:[空格]value 

注：冒号之后需要空格

实例：

server:
  # 修改端口号
  port: 8081
  servlet:
    # 设置项目名称路径
    context-path: /

更多属性参考 SpringBoot官网

3.3 读取配置属性

配置文件：

user:
  name: MarkLogZhu
  age: 26
  email: marklogzhu@163.com

通过 @ConfigurationProperties 注解取值：

1.添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

2.创建 User01 对象

@Component
@ConfigurationProperties(prefix = "user")
public class User01 {

    private String name;
    private int age;
    private String email;

    @Override
    public String toString() {
        return "User01{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
 	...get/set   
}    

3.测试输出

@SpringBootTest
class SpringbootApplicationTests {

    @Autowired
    private User01 user01;

    @Test
    public void testUser01() {
        System.out.println("user01:" + user01.toString());
    }

}

4.观察控制台输出：

user01:User01{name='zhu', age=26, email='marklogzhu@163.com'}

通过 @Value 注解取值：

1.创建 User01 对象

@Component
public class User02 {
    @Value("${user.name}")
    private String name;
    @Value("${user.age}")
    private int age;
    @Value("${user.email}")
    private String email;

    @Override
    public String toString() {
        return "User02{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
    ...get/set   
}   

2.测试输出

@SpringBootTest
class SpringbootApplicationTests {

    @Autowired
    private User02 user02;

    @Test
    public void testUser02() {
        System.out.println("user02:" + user01.toString());
    }

}

3.观察控制台输出：

user02:User02{name='zhu', age=26, email='marklogzhu@163.com'}

可以发现两者方式都可以获取到值，它们的优缺点对比如下：

读取方式	优点	缺点
ConfigurationProperties	1.可以从配置文件中批量注入属性； 2.支持获取复杂的数据类型； 3.对属性名匹配的要求较低; 4.支持JAVA的JSR303数据校验；	不支持SpEL表达式；
Value	支持SpEL表达式	1.只能一个个配置注入值; 2.不支持数组、集合等复杂的数据类型; 3.不支持数据校验； 4.对属性名匹配有严格的要求