Spring系列之Spring Boot（二）

入门指南 使用Spring Boot构建应用程序

本指南提供了如何帮助你快速开发应用程序的示例。阅读更多的Spring入门指南时，你将看到更多的Spring Boot用例，本指南旨在使您快速了解Spring Boot。如果要创建自己的项目，请访问Spring Initializr，填写项目详细信息，选择选项，然后下载Zip文件。

你将构建什么
你将使用Spring Boot 构建一个简单的Web应用程序，并向其中添加一些有用的服务。

你需要什么
15分钟
1个IDE
java8或者11
Gradle 4+或Maven 3.2+
你也可以将代码直接导入到IDE中

如何完成指南
像大多数Spring入门指南一样，你可以从头开始完成每个步骤，也可以绕过你熟悉的基本步骤，无论哪个方式都可以。
要从头开始，请继续运行。
要跳过基础知识，请执行以下操作。
了解使用Spring Boot可以做什么
Spring Boot提供了一种快速构建应用程序的方法。他查看你的类路径和已配置Bean,然后添加这些项，借助Spring Boot，你可以将更多精力放在业务功能上，而不必耗在基础架构上。
以下示例显示了Spring Boot可以为你做什么：

• Spring MVC是否在类路径上？你所需要的Bean,Spring会自动添加他们。Spring MVC应用程序还需要一个Servlet容器，Spring Boot会自动配置嵌入式Tomcat。
• Jetty 是否在类路径上？如果是这样，你可以不想要Tomcat，而是想要嵌入式Jetty，Spring Boot会为你处理该问题。
• Thymeleaf是否在类路径上？如果是这样，那么有些Bean必须添加到您的application context，Spring Boot为您做了。

这些只是Spring Boot提供的自动配置的一些示例。例如，如果Thymeleaf在类路径上，那么Spring Boot会自动添加SpringTemplateEngine到你的application context,但是如果SpringTemplateEngine使用自定义的设置，Spring Boot不会添加。
Spring Boot 不会添加代码或对文件进行编辑。相反，当你启动应用程序时，Spring Boot会动动态的连接Bean并将它们应用于你的应用程序上下文。

从Spring Initializr开始
对于所有的Spring应用程序，您应该从Spring Initializr开始。Initializr提供了一种快速方法来获取应用程序所需的所有依赖项，并为你完成许多设置。该示例需要Web依赖，下图显示了此示例的设置：

上图显示了使用Maven作为项目构建工具，你也可以使用Gradle。设置com.example和spring-boo作为Group和Artifact，在本示例的其他部分，将使用这些值。

选择Maven时，会创建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 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.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>spring-boot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-boot</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>

选择Gradle时会创建build.gradle文件：

plugins {
	id 'org.springframework.boot' version '2.2.2.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

test {
	useJUnitPlatform()
}

创建一个简单的Web应用程序
现在，你可以为一个简单的Web应用程序创建一个Web控制器，src/main/java/com/example/springboot/HelloController.java，如下所示：

package com.example.springboot;

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

@RestController
public class HelloController {

	@RequestMapping("/")
	public String index() {
		return "Greetings from Spring Boot!";
	}

}

该类被标记为@RestController，这表示Spring MVC可以用它来处理Web请求。@RequestMapping表示映射“/”到“index()”方法，在浏览器上调用时，该方法返回纯文本。这是因为@RestController将@Controller和@ResponseBody组合在一起，这两个注解会导致Web请求会返回数据而不是视图。

创建一个Application class
Spring Initializr为您创建了一个简单的Application class。但是，这个class太简单，你需要修改这个class，src/main/java/com/example/springboot/Application.java：

package com.example.springboot;

import java.util.Arrays;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

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

	@Bean
	public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
		return args -> {

			System.out.println("Let's inspect the beans provided by Spring Boot:");

			String[] beanNames = ctx.getBeanDefinitionNames();
			Arrays.sort(beanNames);
			for (String beanName : beanNames) {
				System.out.println(beanName);
			}

		};
	}

}

@SpringBootApplication是一个注解，他添加了以下所有内容：

• @Configuration 将该类标记为Application context，bean definitions 的源头。
• @EnableAutoConfiguration 启用自动配置。
• @ComponentScan 告诉Spring在com/example包中寻找其他组件、配置和服务，让他找到控制器。

该main()方法使用Spring Boot的SpringApplication.run()方法来启动应用程序。你是否注意到一行XML代码都没有，也没有web.xml，该Web应用程序是100%纯Java，
还有一个@Bean注解标记在commandLineRunner方法上，该方法在启动时运行，他检索所有的Bean，排序打印。

运行应用程序
要运行该应用程序，请在终端窗口complete目录中执行下列命令：

./gradlew bootRun

如果使用Maven，请在终端窗口complete目录中执行下列命令：

./mvnw spring-boot:run

你应该看到类似以下内容的输出：

Let's inspect the beans provided by Spring Boot:
application
beanNameHandlerMapping
defaultServletHandlerMapping
dispatcherServlet
embeddedServletContainerCustomizerBeanPostProcessor
handlerExceptionResolver
helloController
httpRequestHandlerAdapter
messageSource
mvcContentNegotiationManager
mvcConversionService
mvcValidator
org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration
org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$DispatcherServletConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$EmbeddedTomcat
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration
org.springframework.boot.context.embedded.properties.ServerProperties
org.springframework.context.annotation.ConfigurationClassPostProcessor.enhancedConfigurationProcessor
org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration
propertySourcesBinder
propertySourcesPlaceholderConfigurer
requestMappingHandlerAdapter
requestMappingHandlerMapping
resourceHandlerMapping
simpleControllerHandlerAdapter
tomcatEmbeddedServletContainerFactory
viewControllerHandlerMapping

你可以清楚的看到org.springframework.boot.autoconfigure，还有一个tomcatEmbeddedServletContainerFactory。
现在通过运行以下命令（输出显示），运行该服务：

$ curl localhost:8080
Greetings from Spring Boot!

添加单元测试
你将要为端点添加一个测试，Spring Test为此提供了一些机制。
如果你使用Gradle，请将以下依赖项添加到build.gradle文件：

testImplementation('org.springframework.boot:spring-boot-starter-test') {
	exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}

如果使用Maven，请将以下内容添加到pom.xml中：

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

现在编写一个简单的单元测试，以模拟你的servlet请求和响应。如下清单（src/test/java/com/example/springboot/HelloControllerTest.java）所示：

package com.example.springboot;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {

	@Autowired
	private MockMvc mvc;

	@Test
	public void getHello() throws Exception {
		mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
				.andExpect(status().isOk())
				.andExpect(content().string(equalTo("Greetings from Spring Boot!")));
	}
}

MockMvc来自Spring Test，你可以通过一组便捷的构建器将HTTP请求发送到DispatcherServlet，并对结果进行断言，注意使用@AutoConfigureMockMvc和@SpringBootTest注入MockMvc实例。
除了模拟HTTP请求外，你还可以使用Spring Boot编写简单的全栈集成测试，例如，除了前面显示的模拟测试，我们还可以创建以下测试（来自src/test/java/com/example/springboot/HelloControllerIT.java）：

package com.example.springboot;

import static org.assertj.core.api.Assertions.*;

import java.net.URL;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.ResponseEntity;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class HelloControllerIT {

	@LocalServerPort
	private int port;

	private URL base;

	@Autowired
	private TestRestTemplate template;

    @BeforeEach
    public void setUp() throws Exception {
        this.base = new URL("http://localhost:" + port + "/");
    }

    @Test
    public void getHello() throws Exception {
        ResponseEntity<String> response = template.getForEntity(base.toString(),
                String.class);
        assertThat(response.getBody()).isEqualTo("Greetings from Spring Boot!");
    }
}

嵌入式服务器在一个随机端口上启动，port会随机分配。

添加Production-grade服务
如果要为你的企业构建网站，需要添加一些管理服务，Spring Boot执行器模块提供了多种此类服务，（例如运行状况，审计，Bean）。
如果你使用Gradle，请将以下依赖项添加到build.gradle：

implementation 'org.springframework.boot:spring-boot-starter-actuator'

如果你使用Maven，请将以下依赖项添加到pom.xml：

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

然后重新启动应用程序，如果使用Gradle，请在终端窗口运行以下命令：

./gradlew bootRun

如果使用Maven，请在终端窗口运行以下命令：

./mvnw spring-boot:run

你应该看到已经像应用程序添加了一组新的RESTful端点，这些是Spring Boot提供的管理服务。以下是清单输出：

management.endpoint.configprops-org.springframework.boot.actuate.autoconfigure.context.properties.ConfigurationPropertiesReportEndpointProperties
management.endpoint.env-org.springframework.boot.actuate.autoconfigure.env.EnvironmentEndpointProperties
management.endpoint.health-org.springframework.boot.actuate.autoconfigure.health.HealthEndpointProperties
management.endpoint.logfile-org.springframework.boot.actuate.autoconfigure.logging.LogFileWebEndpointProperties
management.endpoints.jmx-org.springframework.boot.actuate.autoconfigure.endpoint.jmx.JmxEndpointProperties
management.endpoints.web-org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties
management.endpoints.web.cors-org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties
management.health.status-org.springframework.boot.actuate.autoconfigure.health.HealthIndicatorProperties
management.info-org.springframework.boot.actuate.autoconfigure.info.InfoContributorProperties
management.metrics-org.springframework.boot.actuate.autoconfigure.metrics.MetricsProperties
management.metrics.export.simple-org.springframework.boot.actuate.autoconfigure.metrics.export.simple.SimpleProperties
management.server-org.springframework.boot.actuate.autoconfigure.web.server.ManagementServerProperties
management.trace.http-org.springframework.boot.actuate.autoconfigure.trace.http.HttpTraceProperties

执行器有以下特点：

• errors
• actuator/health
• actuator/info
• actuator

还有一个actuator/shutdown端点，但是默认情况下，他只通过JMX可见。要将其改为HTTP端点，请添加management.endpoints.web.exposure.include=health,info,shutdown到你的application.properties，一般情况下，不应该为公共应用程序启用这个端点。
你可以通过以下命令来检查应用程序的应用状况：

$ curl localhost:8080/actuator/health
{"status":"UP"}

你可以尝试通过curl调用shutdown：

$ curl -X POST localhost:8080/actuator/shutdown
{"timestamp":1401820343710,"error":"Method Not Allowed","status":405,"message":"Request method 'POST' not supported"}

因为我们未启用它，所以该请求被阻止。
有关这些Rest端点中的每个端点具体如何使用，以及application.properties的配置修改，请查阅有关文档。

查看Spring Boot’s Starters
你已经查看了一些Spring Boot’s Starters，你可以查看所有的，源码地址在这里

JAR支持和Groovy支持
最后一个示例显示了如何开展便捷的管理服务。但是，Spring Boot的作用还不止这些，借助Spring Boot的程序加载模块，他不仅支持传统的War文件部署，还支持使用可执行的Jar。
最重要的是，Spring Boot支持Groovy，让你只用一个文件就可以构建Spring MVC Web程序。
创建一个新文件app.groovy，放入以下代码：

@RestController
class ThisWillActuallyRun {

    @RequestMapping("/")
    String home() {
        return "Hello, World!"
    }

}

文件在那里都没有关系，甚至可以在一个 single tweet中。
接下來，安裝Spring Boot的CLI。
通过以下命令来运行Groovy应用程序：

$ spring run app.groovy

关闭前一个应用程序，以避免端口冲突。
在另一个终端窗口中，输入curl命令（带输出显示）：

$ curl localhost:8080
Hello, World!

Spring Boot 通过将关键注解添加动态添加到代码中，并使用Groovy Grape来实现。

总结
恭喜您！您使用Spring Boot构建了一个简单的Web应用程序，并了解他如果加快您的开发速度，您还打开了一些便捷的production 服务。这只是Spring Boot可以做的一小部分。有关更多信息请参考Spring Boot在线文档。