Spring Boot 2.X 来临，本文将带你起飞

转载自 Spring Boot 2.X 来临，本文将带你起飞

当前互联网技术盛行，以Spring 框架为主导的Java 互联网技术成了主流，而基于Spring 技术衍生出来的Spring Boot，采用了“约定优于配置”的思想，极大地简化了Spring 框架的开发。

随着近些年来微服务技术的流行，Spring Boot 也成了时下炙手可热的热点技术。2017 年9 月，Spring 框架出现了重大版本升级，从4.x 版本升级为了5.x 版本，随着这次升级，Spring Boot的版本也在2018年3月从1.x升级到了2.x。

Spring Boot的优点

谈到Spring Boot，就让我们先来了解它的优点。依据官方的文档，Spring Boot的优点如下：

创建独立的Spring应用程序；
嵌入的Tomcat、Jetty或者Undertow，无须部署WAR文件；
允许通过Maven来根据需要获取starter；
尽可能地自动配置Spring；
提供生产就绪型功能，如指标、健康检查和外部配置；
绝对没有代码生成，对XML没有要求配置。

这段描述告诉我们，首先Spring Boot是一个基于Spring框架搭建起来的应用，其次它会嵌入Tomcat、Jetty或者Undertow等服务器，并且不需要传统的WAR文件进行部署，也就是说搭建Spring Boot项目并不需要单独下载Tomcat等传统的服务器。

同时提供通过Maven（或者Grandle）依赖的starter，这些starter可以直接获取开发所需的相关包，通过这些starter项目就能以Java Application的形式运行Spring Boot的项目，而无须其他服务器配置。

对于配置，Spring Boot提供Spring框架的最大自动化配置，大量使用自动配置，使得开发者对Spring的配置尽量减少。

此外还提供了一些监测、自动检测的功能和外部配置，与此同时没有附加代码和XML的配置要求。

约定优于配置，这是Spring Boot的主导思想。对于Spring Boot而言，大部分情况下存在默认配置，你甚至可以在没有任何定义的情况下使用Spring框架，如果需要自定义也只需要在配置文件配置一些属性便可以，十分便捷。

而对于部署这些项目必需的功能，Spring Boot提供starter的依赖，例如，spring-boot-starter-web捆绑了Spring MVC所依赖的包，spring-boot-starter-tomcat绑定了内嵌的Tomcat，这样使得开发者能够尽可能快地搭建开发环境，快速进行开发和部署，这就是Spring Boot的特色。也许作为传统开发者的你，还未能理解其意义，但这并不要紧。

为了展示Spring Boot的特色，下节将分别展示传统Spring MVC项目和简易的Spring Boot入门实例，并进行比较。

传统Spring MVC和Spring Boot的对比

在传统的Spring MVC项目开发中，开发一个简易的Spring MVC项目，需要配置DispatcherServlet，也需要配置Spring IoC的容器。你可以选择使用web.xml的配置来实现，当然，如果你使用的是Servlet 3.1规范，也可以继承由Spring MVC提供的AbstractAnnotationConfigDispatcherServletInitializer来配置Spring MVC项目。

这里先给出可以运行的代码示例，即使你还不熟悉Spring MVC也没有关系，这里只是为了说明开发比较烦琐而已，后面将详谈Spring MVC的开发原理。

假设你已经导入需要的Spring和Spring MVC相关的依赖包到工程中，那么就可以开始配置DispatcherServlet了。例如，代码清单1-1就是通过继承AbstractAnnotationConfigDispatcherServletInitializer的方式来配置Spring MVC的DispatcherServlet的。

代码清单1-1　配置Spring MVC

package com.springboot.springmvc.conf;import  org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class MyWebAppInitializer   extends AbstractAnnotationConfigDispatcherServletInitializer {  // Spring IoC容器配置  @Override  protected Class<?>[] getRootConfigClasses() {  // 可以返回Spring的Java配置文件数组  return new Class<?>[] {};  }  // DispatcherServlet的URI映射关系配置  @Override  protected Class<?>[] getServletConfigClasses() {  // 可以返回Spring的Java配置文件数组  return new Class<?>[] { WebConfig.class };  }  // DispatcherServlet拦截请求匹配  @Override  protected String[] getServletMappings() {  return new String[] { "*.do" };  }  
}

注意代码中加粗的地方。这里引入了一个Java配置文件—— WebConfig.java，它的主要作用是配置Spring MVC的核心类DispatcherServlet的上下文，如代码清单1-2所示。

代码清单1-2　配置DispatcherServlet的上下文

package com.springboot.springmvc.conf;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;@Configuration
// 定义Spring MVC扫描的包
@ComponentScan(value="com.*", 
includeFilters = {@Filter(type = FilterType.ANNOTATION,value = Controller.class)})
// 启动Spring MVC配置
@EnableWebMvc
public class WebConfig {/**** 通过注解@Bean初始化视图解析器* * @return ViewResolver视图解析器*/@Bean(name = "internalResourceViewResolver")public ViewResolver initViewResolver() {InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();viewResolver.setPrefix("/WEB-INF/jsp/");viewResolver.setSuffix(".jsp");return viewResolver;}/*** 初始化RequestMappingHandlerAdapter，并加载HTTP的JSON转换器* * @return RequestMappingHandlerAdapter 对象*/@Bean(name = "requestMappingHandlerAdapter")public HandlerAdapter initRequestMappingHandlerAdapter() {// 创建RequestMappingHandlerAdapter适配器RequestMappingHandlerAdapter rmhd = new RequestMappingHandlerAdapter();// HTTP JSON转换器MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();// MappingJackson2HttpMessageConverter接收JSON类型消息的转换mediaType = MediaType.APPLICATION_JSON_UTF8;List<MediaType> mediaTypes = new ArrayList<MediaType>();mediaTypes.add(mediaType);// 加入转换器的支持类型jsonConverter.setSupportedMediaTypes(mediaTypes);// 给适配器加入JSON转换器rmhd.getMessageConverters().add(jsonConverter);return rmhd;}
}

通过上面的代码，配置完成Spring MVC的开发环境后，才可以开发Spring MVC控制器Controller，这样就可以开发一个简单的控制器（Controller），如代码清单1-3所示。

代码清单1-3　开发Spring MVC控制器

package com.springboot.springmvc.controller;import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
public class TestController {@RequestMapping("/test")@ResponseBodypublic Map<String, String> test() {Map<String, String> map = new HashMap<String, String>();map.put("key", "value");return map;}
}

这样就完成了一个传统Spring MVC的开发，但是你还需要第三方服务器，如Tomcat、WebLogic等服务器去部署你的工程。在启动服务器后，再打开浏览器，输入对应的URL，如项目名称为SpringMVC则输入http://localhost:8080/SpringMVC/test.do，就可以得到图1-1所示的页面。

图1-1　测试传统的Spring MVC项目

从上面来看，传统的Spring MVC开发需要配置的内容还是比较多的，而且对设计人员要求较高。开发完成后，开发者还需要找到对应的服务器去运行，如Tomcat或者Jetty等，这样既要进行开发，又要进行配置和部署，工作量还是不少的。

而使用Spring Boot开发后，你就会发现原来一切可以那么简单。不过在入门阶段暂时不需要讨论太多的细节问题，这是未来需要讨论的问题，所以这里只展示它是如何简单而已。首先我们在IDE中创建一个Maven工程，并把其名称定义为Chapter1，这样就可以看到一个Maven配置文件pom.xml，将其内容修改为如代码清单1-4所示。

代码清单1-4　配置Spring Boot依赖环境

<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/maven-v4_0_0.xsd"><modelVersion>4.0.0</modelVersion><groupId>springboot</groupId><artifactId>chapter1</artifactId><packaging>war</packaging><version>0.0.1-SNAPSHOT</version><name>chapter1 Maven Webapp</name><url>http://maven.apache.org</url><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.0.RELEASE</version></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><!-- Spring Boot Starter依赖引入 --><!-- AOP包 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><!-- Web开发包，将载入Spring MVC所需要的包，且内嵌tomcat --><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>

从加粗的代码中可以看到Maven的配置文件引入了多个Spring Boot的starter，Spring Boot会根据Maven配置的starter去寻找对应的依赖，将对应的jar包加载到工程中，而且它还会把绑定的服务器也加载到工程中，这些都不需要你再进行处理。

正如Spring Boot承诺的那样，绑定服务器，并且实现Spring的尽可能的配置，采用约定优于配置的原则。这里我们只需要开发一个类就可以运行Spring Boot的应用了，为此新建类——Chapter1Main，如代码清单1-5所示。

代码清单1-5　开发Spring Boot应用

package com.springboot.chapter1;import java.util.HashMap;
import java.util.Map;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
// 启用Spring Boot自动装配
@EnableAutoConfiguration
public class Chapter1Main {@RequestMapping("/test")@ResponseBodypublic Map<String, String> test() {Map<String, String> map = new HashMap<String, String>();map.put("key", "value");return map;}public static void main(String[] args) throws Exception {SpringApplication.run(Chapter1Main.class, args);}
}

好了，这个入门实例已经完结了。如果你没有接触过Spring Boot那么你会十分惊讶，这样就配置完成Spring MVC的内容了吗？我可以回答你：“是的，已经完成了，现在完全可以使用Java Application的形式去运行类Chapter1Main。”下面是Spring Boot的运行日志：

1 .   ____          _            __ _ _
2 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
3( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
4 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
5  '  |____| .__|_| |_|_| |_\__, | / / / /
6 =========|_|==============|___/=/_/_/_/
7 :: Spring Boot ::        (v2.0.0.RELEASE)
8
92018-03-01 22:21:55.843  INFO 16324 --- [           main]
10com.springboot.chapter1.Chapter1Main     :
11Starting Chapter1Main on AFOIF-703271542 with PID 16324
12(G:\springboot\v2\chapter1\target\classes started by Administrator in
13G:\springboot\v2\chapter1)
14......
152018-03-01 22:21:57.270  INFO 16324 --- [           main]
16s.w.s.m.m.a.RequestMappingHandlerMapping :
17Mapped "{[/test]}" onto public java.util.Map<java.lang.String, java.lang.String>
18com.springboot.chapter1.Chapter1Main.test()
19......
202018-03-01 22:21:57.270  INFO 16324 --- [           main]
21com.springboot.chapter1.Chapter1Main : Started Chapter1Main in 1.845 seconds (JVM running for 2.143)
22

从日志中可以看到，Tomcat已经启动，并且将我们开发的Chapter1Main作为Spring MVC的控制器加载进来了，也将对应的路径（/test）映射到开发的test方法上。因此，接下来就可以进行测试了。打开浏览器，在地址栏输入http://localhost:8080/test，可以看到如图1-2所示的结果。