Spring Boot基础

本文以实战为导向，讲解了如何使用Spring Cloud开发微服务项目，而Spring Cloud基于SpringBoot，所以本篇先来初步了解如何使用Spring Boot搭建框架。

Spring Boot简介

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

Spring Boot并不重复“造轮子”，而是在原有Spring框架的基础上进行封装，并且它集成了一些类库，用于简化开发。换句话说，Spring Boot就是一个大容器。

关于Spring Boot，其官网是这样描述的:

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications thatyou can "just run".

We take an opinionated view of the Spring platform and third-party libraries so you can get startedwith minimum fuss. Most Spring Boot applications need very little Spring configuration.

从上面的描述中，我们可以了解到，Spring Boot带给了我们全新的应用部署方案，通过它可以很方便地创建独立的、生产级的基于Spring的应用程序。同时，通过Spring平台和第三方库可以轻松构建视图。

其实，Spring Boot默认集成了Tomcat，因此我们可以只编译成jar包，通过Java命令启动应用，大多数Spring Boot应用程序只需要很少的Spring 配置。

第一个 Spring Boot工程

本节中，我们将创建第一个Spring Boot工程，读者可以按照下面的步骤进行操作。

(1)打开 IntelliJ IDEA，依次点击 File→New→Module，在弹出的对话框中选择Maven，并点击Next按钮，创建一个Maven项目。这里我们在 Artifactld一栏中输入demo-lesson-one，在Groupld一栏中输入com.lynn.boot。创建好工程后，为pom.xml增加以下内容:

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent< / artifactId><version>2.0.3.RELEASE</version>
</ parent>
<dependencies>
<dependency>
<groupId>org.springframework. boot</groupId>
<artifactId>spring-boot-starter-web</ artifactId></dependency>
</dependencies>

其中，<parent>标签声明了Spring Boot 的父项目，版本号定义为2.0.3.RELEASE。我们还可以注意到，<dependencies>标签中声明了spring-boot-starter-web依赖，它提供了对Spring MVC的支持。

(2)编写应用启动类Application:

package com.lynn.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot. autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args){
SpringApplication.run(Application.class,args);
}
}

Spring Boot 的强大之处在于可以直接通过main方法启动Web应用程序。在上述代码中，我们提供了应用程序的入口，通过调用SpringApplication.run()来启动内置Web容器。我们注意到，在Application类中添加了@SpringBootApplication注解，我们将在2.4节中介绍它的作用。

默认情况下，Spring Boot 内置了Tomcat。当然，它还支持其他容器，如Jetty。倘若我们要将默认容器改为Jetty ，可以将pom.xml文件修改成下面这样:

<dependency>
<groupId>org.springframework. boot</groupId>
<artifactId>spring-boot-starter-web</ artifactId><exclusions>
<exclusion>
<groupId>org.springframework . boot</groupId>
<artifactId>spring-boot-starter-tomcat</ artifactId></exclusion>
< / exclusions>< / dependency><dependency>
<groupId>org.springframework .boot</groupId>
<artifactId>spring-boot-starter-jetty</ artifactId></dependency>

在上述代码中，我们通过<exclusion>标签将Tomcat的依赖包移除，并增加了Jetty 的依赖包。

(3)编写控制器以验证 Spring Boot框架:

package com. lynn.boot.controller;
import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController f
@RequestMapping(value = "hello")public String hello(){i
return "Hello world!";
}
}

在上述代码中,@RestController注解指示了该类为控制器类，与它对应的注解是@Controller。@RestController注解相当于@Controller注解和@ResponseBody注解的结合。@RequestMapping注解的作用是定义一个HTTP请求地址，默认不限制请求方式，可以是GET、POST亦或其他方法，如果要限制请求方法,可以在注解后面增加 method 属性，如 method=RequestMethod.GET表示只有GET请求才能调用该HTTP地址。

上面提到的注解均为Spring MVC注解，我们之所以能够在这里很方便地使用Spring MVC注解，是因为第(1)步的依赖中添加了spring-boot-starter-web依赖，该依赖集成了Spring MVC.

(4)运行Application类的main方法,并访问localhost:8080/hello,即可看到如图2-1所示的界面。

通过以上示例，我们可以知道:

使用Spring Boot创建一个工程非常简单，既没有XML配置文件，也没有Tomcat，通过几个简单的注解，运行main方法就能启动一个Web应用;
Spring Boot默认内置Tomcat;
Spring Boot用注解代替了烦琐的XML配置。

使用 YAML文件配置属性

在上一节中，我们实现了一个最简单的 Web 工程，没有创建任何配置文件。当然，Spring Boot的任何配置都可以通过代码实现。为了便于扩展,它引入了PROPERTIES格式和YAML格式"的文件，可以在其中定义一些常用属性或自定义属性。

YAML的基本用法

下面我们先来看一下Spring Boot的一般配置，步骤如下。

(1)在 src/main/resources目录下创建一个名为application.yml的配置文件，并编写以下内容:

server:
servlet:
#定义上下文路径
context-path: /demo#定义工程启动的端口
port: 8081

在上述配置中，我们通过server.servlet.context-path定义了应用的上下文路径为/demo，它的默认值为l,server.port定义应用的启动端口，其默认值为8080，这里设置为8081。

(2)启动工程并访问localhost:8081/demo/hello，就可以看到如图2-1所示的界面。

在2.2节中，我们启动工程时的监听端口为 8080，上下文路径为/，但是我们并没有配置任何信息，那是因为所有配置属性都有默认值，如端口的默认值为8080。

接下来，我们看一下YAML文件的结构，其基本格式为:

key1:
key2:
key3: value

我们将它替换成properties 的形式，即 key1.key2.key3=value。当然，key 的个数不是固定的。这里需要说明的是，YAML格式非常严格。如果当前key后面需要跟value，则冒号后面必须至少有一个空格，否则编译不会通过;其次，每个子属性之间需要通过空格或制表符(即按下Tab键)分隔，否则可能无法正确取到属性值。

如果我们将上面例子中的YAML文件改成以下形式:

server:
servlet:
context-path: /demo#冒号后面直接跟端口号
port:8081

那么启动工程后，控制台会打印如下的报错信息:

Caused by: org.yaml.snakeyaml.scanner.ScannerException: while scanning a simple keyin 'reader ', line 6, column 3:
port:8081
A
could not find expected " : '
in " reader', line 6, column 12:
port:8081

多环境配置

在一个企业级应用中，我们可能开发时使用开发环境，测试时使用测试环境，上线时使用生产环境。每个环境的配置都不一样,比如开发环境的数据库是本地地址,而测试环境的数据库是测试地址。因此会遇到这样一个问题:我们在打包的时候，如何生成不同环境的包呢?

这里的解决方案有很多，具体如下。

每次编译之前，手动把所有配置信息修改成当前运行的环境信息。这种方式导致每次都需要修改，相当麻烦，也容易出错。
利用Maven，在 pom.xml里配置多个环境，每次编译之前将settings.xml修改成当前要编译的环境ID。这种方式的缺点就是每次都需要手动指定环境，而且如果环境指定错误，发布前是不知道的。
创建多个针对不同环境的配置文件，通过启动命令指定。这个方案就是本节重点介绍的，也是我强烈推荐的方式。

接下来，我们看一下配置多环境的步骤。

(1)将application.yml文件修改如下:

server:
servlet:
context-path: /demoport: 8081
spring:
profiles:
active: dev

这里通过spring.profiles.active指了明当前启动的环境。

(2)创建多环境配置文件，文件命名格式为application-{fprofile}.yml，其中{profile}即为上述配置将要指定的环境名，如新增名为 application-dev.yml的文件，我们可以在里面添加配置:

server:
port: 8080

并将spring.profiles.active设置为dev。

此时启动工程，可以看到工程的监听端口已变为8080。

你可以继续创建多环境文件，比如命名为 application-test.yml，将监听端口改为 8082，然后将spring.profiles.active改为test，再启动工程观察效果。在实际项目发布的过程中，不会手动修改spring.profiles.active 的值，而是通过启动命令来动态修改，具体细节见2.7节。

常用注解

前面提到过，Spring Boot主要是以注解形式代替烦琐的XML配置。在这一节中，我将带领大家了解一些常用注解的用法。

@SpringBootApplication

在前面的章节中，读者是否注意到，Spring Boot支持main方法启动。在我们需要启动的主类中加入注解@SpringBootApplication，就可以告诉Spring Boot这个类是工程的入口。如果不加这个注解，启动就会报错。读者可以尝试去掉该注解，看一下效果。

查看@SpringBootApplication 注解的源码,可以发现该注解由@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan组成。我们可以将@SpringBootApplication替换为以上3个注解，如:

package com.lynn.boot;
import org.springframework . boot.SpringApplication;
import org.springframework. boot.autoconfigure.SpringBootApplication;
@SpringBootConfiguration
@EnableAutoConfiguration@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

此时代码的运行效果与2.2节一致。

@SpringBootConfiguration

加人了@SpringBootConfiguration注解的类会被认为是Spring Boot的配置类。我们既可以在application.yml 中进行一些配置，也可以通过代码进行配置。

如果要通过代码进行配置，就必须在这个类中添加@SpringBootConfiguration 注解。我们既可以在标注了这个注解的类中定义Bean，也可以通过它用代码动态改变application.yml的一些配置。例如，创建webConfig类，并改变工程启动的端口号:

package com.lynn.boot;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework . boot.web.server.webServerFactorycustomizer;
import org.springframework. boot.web.servlet.server.ConfigurableServletwebServerFactory;
@SpringBootConfiguration
public class webConfig implements
webServerFactorycustomizer<ConfigurableServletwebServerFactory>{
@override
public void customize(ConfigurableServletwebServerFactory factory) {
//给代码设置应用启动端口
factory . setPort(8888);
}
}

启动工程,可以看到监听端口已经变成了8888。

此外，也可以使用@Configuration注解，它和@SpringBootConfiguration 的效果一样，不过Spring Boot官方推荐采用@SpringBootConfiguration注解。

@Bean

@Bean注解是方法级别的注解，主要添加在@SpringBootConfiguration注解的类中，有时也添加在@Component注解的类中。它的作用是定义一个Bean，类似于Spring XML配置文件的<bean>。

下面我们就来看一下如何通过@Bean注解注入一个普通类。

(1)创建一个普通类Person，为了便于测试，我们为该类增加了一个字段name :

package com. lynn.boot. bean;
public class Person {
private String name;
public void setName( String name){
this.name = name;
}
public String getName() {
return name;
}
@override
public String toString({
return "Person{"+
" name= '”+name +' "'}';
}
}

(2)在2.4.2节创建的 webConfig 类中增加以下代码:

@Bean
public Person person(){
Person person = new Person();person. setName( "lynn");
return person;
}

在上述代码中，我们通过一个@Bean注解就可以将Person对象加入Spring容器中，它简化了传统的Spring XML的方式。

(3)进行单元测试。首先，添加单元测试依赖:

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

Spring Boot默认集成JUnit测试框架,通过添加spring-boot-starter-test依赖就可以集成它。然后在src/main/test目录下创建一个测试类，并编写测试代码:

package com.lynn.boot.test;
import com. lynn.boot.Application;import com. lynn. boot.bean.Person;import org.junit.Test;
import org.junit.runner.Runwith;
import org.springframework.beans.factory .annotation.Autowired;import org.springframework .boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringUnit4ClassRunner;
@SpringBootTest(classes = Application.class)
@RunWith(SpringUnit4classRunner.class)public class MyTest {
@Autowired
private Person person;
@Test
public void test(){
System.out.print1n(person);
}
}

在上述代码中,我们添加@SpringBootTest注解来指定入口类为Application,再添加@Runwith注解指定单元测试的运行环境为SpringJUnit4ClassRunner,即使用JUnit4的单元测试框架,接着通过@Autowired注解注入了Person类，最后通过test方法打印 person信息。

注意:在test方法中需要添加@Test注解才能启用单元测试。

启动单元测试时，可以看到控制台打印出了以下信息:

Person{name='lynn '}

@value

通常情况下，我们需要定义一些全局变量，此时想到的方法是定义一个public static常量并在需要时调用它。那么是否有其他更好的方案呢?答案是肯定的，这就是本节要讲的@value注解。

(1)在application.yml里自定义一个属性data:

self:
message:
data:这是我自定义的属性

上述配置不是 Spring Boot内置属性,而是我们自定义的属性。

(2)修改HelloController类:

package com.lynn.boot.controller;
import org.springframework.beans.factory. annotation.value;import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework .web.bind.annotation.RestController;
@RestController
public class Hellocontroller {
@Value( "${self.message.data}")private String value;
@RequestMapping(value = "hello" ,produces = MediaType.APPLICATION_SON_UTF8_VALUE)public string hello(){
return value;
}
}

其中，@Value注解的参数需要使用${}将目标属性包装起来，该属性既可以是Spring 内置的属性，也可以是自定义的属性。

(3)启动工程并访问localhost:8080/demo/hello，可以看到如图2-2所示的界面。

Spring Boot集成模板引擎

在传统的Spring MVC架构中，我们一般将JSP、HTML页面放到webapps目录下。但Spring Boot没有webapps，更没有web.xml，如果要写界面的话，该如何做呢?

我们可以集成模板引擎。Spring Boot 官方提供了几种模板引擎: FreeMarker 、Velocity. Thymeleaf.Groovy、Mustache和JSP。本节中，我们以FrceMarker为例讲解Spring Boot是如何集成模板引擎的。

首先,在pom.xml 中添加对FreeMarker的依赖:

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

在resources目录下建立 static和 templates两个目录，如图2-3所示。其中 static目录用于存放静态资源，譬如CSS、JavaScript和 HTML等，templates目录用于存放模板引擎文件。

然后在templates目录下面创建index.ftl文件，并添加如下内容:

<! DOCTYPE html>
<html>
<head></head><body>
<h1>Hello world!</h1></body>
</html>

接着创建控制器类:

@Controller
public class Pagecontroller {
@RequestMapping("index.html")public String index()i
return "index" ;
}
}

最后，启动Application.java，访问localhost:8080/demo/index.html，就可以看到如图2-4所示的界面。

在上述代码中，我们要返回FreeMarker模板页面，因此必须将其定义为@Controller，而不是前面定义的@RestController。@RestController相当于@Controller和@ResponseBody的结合体。标注为@RestController注解时，SpringMVC的视图解析器(ViewResolver )将不起作用，即无法返回HTML或JSP页面。ViewResolver的主要作用是把一个逻辑上的视图名解析为一个真正的视图。当我们将一个控制器标注为@Controller并返回一个视图名时，ViewResolver会通过该视图名找到实际的视图，并呈现给客户端。

更改默认的JSON转换器

Spring Boot默认使用Jackson引擎去解析控制器返回的对象，该引擎在性能和便捷性上与第三方引擎( FastJson和Gson等)还有一定的差距，本节将介绍如何将默认转换器替换为FastJson转换器。

(1)在pom.xml中添加对FastJson的依赖:

<dependency>
<groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.47</version>
< /dependency>

(2)修改webConfig 类，为其添加方法并设置FastJson转换器:

@SpringBootConfiguration
public class webConfig extends webMvcConfigurationSupport{
@override
public void configureMessageConverters(List<HttpMessageConverter< ?>> converters) {
super.configureMessageConverters(converters);
Fast3sonHttpMessageConverter fastConverter=new FastJsonHttpMessageConverter();FastJsonconfig fast]sonconfig=new FastsonConfig();
fastJsonConfig.setSerializerFeatures(
SerializerFeature.PrettyFormat
);
List<MediaType> mediaTypeList = new ArrayList<>();
/I/设置编码为UTF-8
mediaTypeList.add(MediaType.APPLICATION_JSON_UTF8);fastconverter.setSupportedMediaTypes(mediaTypeList);fastconverter.setFast]sonConfig(fastsonconfig);
converters.add(fastConverter);
}
}

首先应继承webMvcConfigurationSupport类，该类提供了Spring Boot对Spring MVC的支持。然后重写configureMessageConverters方法，该方法配置了消息转换器。如果第三方框架希望处理Spring MVC 中的请求和响应时，那么需要实现HttpMessageConverter接口。而在上述代码中，FastJsonHttpMessageConverter便是如此，它实现了HttpMessageConverter接口，并通过Fast]sonConfig设置FastJson 的处理参数，如通过MediaType设置编码为UTF-8，最后添加到HttpMessageConverter 中。

这样Spring MVC在处理响应时就可以将JSON解析引擎替换为FastJson。

打包发布到服务器上

Spring Boot支持使用jar和 war两种方式启动应用，下面分别来介绍这两种方式是怎么启动的。

使用内置Tomcat发布jar包

由于Spring Boot内置了Tomcat,我们可以将工程打包成jar ,通过Java命令运行我们的Web工程，具体步骤如下。

(1)在pom.xml文件中添加以下内容:

<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. lynn.boot.Application</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>

在pom.xml中，<build>标签定义了关于Maven编译和打包的一些信息。其中，<finalName>为打包后的文件名，<plugins>设置了编译的一些参数。Maven支持第三方插件，而Spring Boot 的编译插件就是spring-boot-maven-plugin，并通过<mainClass>指定了启动类。后面maven-surefire-plugin就是Maven官方提供的用于构建测试用例的插件，如果有单元测试类，它在编译完成后会执行单元测试，单元测试成功后才会打包;如果不希望执行单元测试，那么将<skipTests>设置为true即可。我建议将<skipTests>设置为true，如果设置为false，会导致打包时间过长。如果单元测试类中存在对数据库的增删改测试，编译时执行了它，可能会对原有数据造成影响。maven-compiler-plugin为Maven官方提供的指定编译器版本的插件，上述代码中的1.8表示使用JDK 1.8版本编译。

(2)通过mvn clean package编译并打包，如图2-5所示。

(3)将打包的内容上传到服务器中，运行命令:

java -jar api.jar

这样就能启动一个Spring Boot应用。前面提到，可以通过命令参数来设置不同环境或者动态设置参数，那么如何设置呢?下面以设置环境为例，输入命令:

java -jar api.jar --spring.profiles.active=dev

应用启动时，就会拉取 application-dev.yml 内的配置信息。如果你想改变任何属性值，在--后面加上相应的属性名和要改变的属性值即可。

打包成war包发布

除了编译成jar包发布外，Spring Boot也支持编译成war包部署到Tomcat。(1)在pom.xml中将应用打包格式改成war:

<packaging>war</packaging>

这里的<packaging>就是告诉 Maven，需要编译成何种后缀的文件。

(2)将<build>标签下的内容修改如下:

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

上述内容和2.7.1节中的内容相似,增加了maven-resources-plugin插件，它用于编译resources目录下的文件。而在spring-boot-maven-plugin插件中无须指定<mainClass>，因为编译后的 war部署在外部 Tomact上，它依托于Tomcat容器运行，不会执行main方法。

(3)添加Tomcat依赖，将<scope>设置为provided。这样做的目的是编译时去掉tomcat包，否则启动时可能会报错。我们也不能直接通过<exclusion>标签去掉tomcat包，因为在本地开发时，需要通过Application类启动。相关代码如下:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope></ dependency>

(4)修改启动类Application,它继承了SpringBootServletInitializer类,并重写了configure方法，以便Tomcat在启动时能加载Spring Boot应用:

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

在上述代码中，如果我们是通过外部Tomcat启动应用，则可以去掉 main方法。因为Tomcat在启动时会执行configure方法，而configure方法会调用source方法并指定Application类，其作用与main方法一致。

(5)使用mvn clean package编译并打包成WAR格式的文件，然后将其复制到Tomcat 中。启动Tomcat，可以看到应用能够被正常访问。如果通过外部Tomcat启动应用，则 server.port 指定的端口失效，转而使用Tomcat设置的端口号。

通过 war启动程序无法像jar包那样，在启动时指定运行环境或其他想要动态改变的参数值，且上下文路径以war包的名字为准，还需要自己安装Tomcat，比较麻烦，因此我推荐优先考虑jar包的启动方式。

WebFlux快速入门

Spring Boot 2.0为我们带来了WebFlux,它采用Reactor作为首选的流式框架,并且提供了对RxJava的支持。通过WebFlux，我们可以建立一个异步的、非阻塞的应用程序。接下来，我们就一起来领略WebFlux的风采。

(1)创建一个基于Spring Boot的Maven工程,将其命名为demo-lesson-one-webflux ,然后在pom.xml文件中添加对WebFlux的依赖:

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

(2)编写一个Handler，用于包装数据:

@Component
public class HelloHandler {
public Mono<ServerResponse> hello(ServerRequest request) {
return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN)
.body(BodyInserters.fromobject( "Hello, world ! "));
}
}

该类自定义了一个方法，该方法返回Mono对象。这里在ServerResponse的 body方法中设置要返回的数据。

(3)编写接口类，即定义我们通常所说的路由地址(接口地址):

@springBootConfigurationpublic class He1loRouter {
@Bean
public RouterFunction<ServerResponse> routeHello(HelloHandler helloHandler){
return RouterFunctions.route(RequestPredicates.GET( "/hello")
.and(RequestPredicates.accept(MediaType.TEXT_PLAIN))，helloHandler: : hello);
}
}

因为路由需要注册到Spring容器中，所以该类也需要添加@SpringBootConfiguration注解，而将返回的路由标识为一个Bean，这样才能注册到Spring容器中。

在上述代码中,我们定义一个方法 routeHello并且返回了RouterFunction对象。在RouterFunction中，指定路由地址为/hello，并指定Handler和对应的方法，即前面创建的 HelloHandler。这样通过路由地址/hello就可以返回Handler的hello方法所设置的数据。

(4)启动Application.java并访问地址 localhost:8080/hello，可以看到浏览器正常显示HelloWorld。通过控制台，我们可以很清楚地看到它是通过NettyServerR启动的:

Netty started on port(s):808e

这样我们就建立了一个路由地址。细心的读者可以发现，上述代码过于烦琐，Spring Boot也考虑到了这一点。为了便于将MVC应用迁移到WebFlux，Spring Boot官方兼容了WebFlux和 MVC，即我们可以使用MVC的注解来创建WebFlux的路由地址。

(1)创建Hellocontroller类并编写以下代码:

@RestController
public class Hellocontroller {
@RequestMapping(value = "hello")public Mono<String> hello({
return Mono.just( "Hello world! ");
}
}

可以看到，上述代码和前面编写的代码很相似，只是这里我们需要返回Mono对象，WebFlux 将数据都包装到Mono返回，通过调用just方法即可。just方法传入的参数类型取决于Mono后面的泛型指定的类型。

(2)启动Application.java，我们可以得到和前面代码一样的结果。

小结

通过本篇的学习，我们了解了Spring Boot的基本用法并感受到了YAML的优雅。

本篇涵盖了一些实际项目中可能会用到的知识点，如常用注解、Spring Boot默认引擎的集成、JSON转换器的更改以及编译部署应用等。最后还介绍了目前较为流行的WebFlux框架。在后面的内容中，我们将进一步学习Spring Boot的其他特性。

本文给大家讲解的内容是springcloud实战：springboot的基础

下篇文章给大家讲解的是springcloud实战：springboot核心原理；
觉得文章不错的朋友可以转发此文关注小编；
感谢大家的支持!

一线开发大牛带你初步了解如何使用SpringBoot搭建框架相关推荐

【干货】如何打造HR无法拒绝的简历？测试开发大牛带手把手你写简历！
通过率90%,优秀的软件测试简历长什么样? 也许口才好的人会觉得简历不重要,能说就行了,那是因为你没有体会过石沉大海的感觉! 很多人觉得疑惑,为什么我投了那么多简历,都没有接到面试通知,也没有HR给我 ...
一线程序员带你实践学习企业实战C/C++程序员课程
作者吴从周资源简介: 传统的C/C++的教材和课程都属于学院派,只是单纯的讲一些知识点,却没有讲到实际开发中我们常用的知识点有哪些,本课程将打破传统的弊端,一线程序员将带你实践学习企业实战项目中LI ...
视频教程-大牛带你全面剖析Python高频面试真题-Python
大牛带你全面剖析Python高频面试真题毕业于德国奥格斯堡大学计算机系,先从事分布式网络,搜索引擎等领域的设计开发工作,于2017底混入图灵学院,立志挑战传统培训,做中国最好的Python教育刘英 ...
在Windows中搭建python开发环境与使用初步（适合初学者）
在Windows中搭建python开发环境与使用初步安装设置python运行环境到网站https://www.python.org/downloads/windows/ 找到合适版本,下载. 双击 ...
stm32非操作系统开发和带uCos的开发的区别，及一些解析
源:stm32非操作系统开发和带uCos的开发的区别,及一些解析转载于:https://www.cnblogs.com/LittleTiger/p/7427039.html
带你初步了解药物设计中的生物信息学
带你初步了解药物设计中的生物信息学随着人类基因组计划和各种组学计划的实施.大量疾病相关基因及作用靶点被发现.生物信息学的兴起,为新药设计提供了新的理论和思路.高通量数据,例如基因组,转录组,蛋白质组 ...
用Qt在Iinux上开发一个带UI的工业控制系统，应该用C++还是QML
用Qt在Iinux上开发一个带UI的工业控制系统,应该用C++还是QML? 之前有人推荐说要用QML,QtQuick来开发.可是学习了一段时间对于QML和C++的混合编程还是不甚理解,觉得还是应该用C ...
软件开发大牛们需要遵守的10大原则
软件开发是根据用户要求建造出软件系统或者系统中的软件部分的过程.一般来说,软件开发工程师承担着软件的设计.和架构的任务.作为一名优秀的程序猿可谓是十八般武器样样精通,标准的高薪技术人才.而软件开发大牛 ...
程序猿开发大牛成长记 | 龙果社区有奖征文活动
真正的开发大牛是敢于踩坑前行,在踩坑过程中不断的总结解决方法,积累更有效的解决方案. 本期龙果社区征文邀请您来分享技术成长历程内容方向: 1.Java技术架构方案体系 2.分布式架构技术体系 3.运 ...

一线开发大牛带你初步了解如何使用SpringBoot搭建框架