精通Springboot

目  录

1       开篇词：为何要学 Spring Boot. 1

1.1        Spring Boot 2.0 课程... 2

1.2        Spring Boot 介绍... 3

1.3        Spring Boot 市场热度... 5

1.4        Spring Boot 和微服务架构... 6

1.5        为何学习 Spring Boot ？... 7

1.6        总结... 8

2       第1-1课：Spring Boot 产生的背景和它的设计理念... 9

2.1        Spring 的发展史... 9

2.2        Spring Boot 的诞生... 11

2.3        Spring Boot 开发团队... 12

2.4        Spring Boot 的核心：约定优于配置... 15

2.5        Starters. 16

2.6        Spring、Spring Boot 和 Spring Cloud 的关系... 19

2.7        总结... 20

3       第1-2课：Spring Boot 2.0 都更新了什么（上）... 20

3.1        基础环境升级... 21

3.1.1         最低 JDK 8，支持 JDK 9，再也不支持 Java 6 和 7. 21

3.1.2         依赖组件升级... 21

3.2        默认软件替换和优化... 22

3.2.1         HikariCP. 22

3.2.2         Security. 23

3.2.3         OAuth 2.0. 23

3.2.4         Micrometer 24

3.2.5         Redis 默认使用 Lettuce. 24

3.2.6         配置属性绑定... 25

3.2.7         Actuator 改进... 26

3.2.8         测试... 26

3.2.9         其余... 27

3.3        新技术的引入... 27

3.3.1         支持 HTTP/2. 27

3.3.2         嵌入式 Netty 服务器... 28

3.3.3         Kotlin的支持... 28

3.3.4         JOOQ 的支持... 29

3.3.5         支持 Quartz. 29

3.3.6         响应式编程... 29

4       第1-2课：Spring Boot 2.0 都更新了什么（下）... 31

4.1.1         彩蛋... 31

4.2        1.0 升级 2.0 API 变化... 31

4.2.1         启动类 SpringBootServletInitializer 31

4.2.2         Thymeleaf 3.0 默认不包含布局模块... 33

4.2.3         配置文件... 33

4.2.4         WebMvcConfigurerAdapter 过时... 34

4.2.5         Spring Boot JPA 变化... 34

4.3        是否选择升级... 37

4.4        总结... 37

5       第1-3课：Spring Boot 依赖环境和项目结构介绍... 38

5.1        安装 JDK. 40

5.1.1         下载安装... 40

5.1.2         环境变量配置... 40

5.1.3         测试... 42

5.2        安装 Maven. 42

5.2.1         下载安装... 43

5.2.2         环境变量配置... 43

5.2.3         测试... 44

5.2.4         settings.xml 设置... 45

5.3        IntelliJ IDEA 安装... 46

5.3.1         下载... 46

5.3.2         安装... 46

5.3.3         配置... 47

5.4        构建项目... 48

5.5        项目结构介绍... 50

5.6        Pom 包介绍... 52

5.7        总结... 56

 

 

 

1    开篇词：为何要学 Spring Boot

你们好，我是纯洁的微笑，从 2013 年到如今，我一直从业于第三方支付和互联网金融这两个领域。在互联网金融公司工做期间，从零参与了公司技术平台建设，随着公司业务不断发展，组织技术团队对平台进行过四次大架构升级，从最初单体架构发展到最后的微服务架构，我也从一个一线开发人员成长为互联网金融公司的技术负责人。

2016 年，也就是构建第四代平台架构的时候，我在技术调研时了解到了 Spring Boot，初步尝试使用后，被其简洁快速开发的魅力所吸引，随即推广到公司全部项目中。为了促进学习，我在网络上连载了 Spring Boot 的系列文章，意外获得广大网友的承认，早期的文章能够在个人我的公众号或者博客查看：

• 个人公众号
• 个人博客

2017 年我又从互联网金融回归到第三方支付行业，当时公司正在构建新一代的支付平台，技术栈和互金的第四代平台同样，采用的 Spring Boot + Spring Cloud 相关生态，有所不一样的是支付行业所面临的业务更加复杂，交易规模更为庞大。在互联网金融公司中第四代平台大概有二十多个微服务支撑平台，如今公司的新一代支付系统微服务项目六十多个，每一个服务部署三个实例就高达一百多个；在互金行业只有在抢标的时候有大量的流量，一年交易2、三十亿，如今我就任的支付公司天天交易量就高达4、五十亿，对系统的稳定性和性能要求更高。

回到第三方支付行业后，我开始负责公司新一代平台的微服务架构实践，以及微服务架构下大数据平台建设。通过两家公司对 Spring Boot 的使用，我愈加认识到 Spring Boot 对传统开发带来的挑战，Spring Cloud 将来可能会随着 Kubernetes 和 Service Mesh 的发展有所弱化，可是 Spring Boot 给开发带来的影响是深远的。恰逢今年 Spring Boot 2.0 的推出，能够预见的是将来的发展会愈来愈好。

1.1   Spring Boot 2.0 课程

Spring Boot 2.0 的推出又激起了一阵学习 Spring Boot 的热潮，单从我我的博客访问量大幅增长，就能够感觉到你们对学习 Spring Boot 的热情。

去年 11 月，我在 GitChat 平台上发布的达人课《快速学习 Spring Boot 技术栈》已经累计销售了 2400 余份，目前还在不断的增加中，说明行业内对学习 Spring Boot 的需求在不断地上涨。

去年在写 Spring Boot 课程时版本仍是 1.5.8，在今年的 3 月，Spring 官方发布了 Spring Boot 2.0，其在 1.0 的基础上进行了大幅优化，2.0 集成了不少优秀的技术和新特性，对性能的提高很是明显。

Spring Boot 2.0 升级的同时也在 1.0 的基础上大量优化了 API 的使用，不少 1.0 的 API 在 2.0 版本中已经不适用，在 2.0 版本中使用以前的 API 操做每每会报错，我也收到了大量相似的留言。结合这些反馈信息，本课程会参考以上内容的基础上彻底从新设计，课程的变更点以下：

• 2.0 的课程将包含 1.0 的课程，而且会对 1.0 的课程内容进行升级，Spring Boot 使用的版本升级为 2.X。
• 1.0 只是将当时最经常使用的实战功能进行了提炼，2.0 课程将会系统性介绍 Spring Boot 各类使用场景。
• 课程内容和技术栈都会使用最新稳定版本，课程数量也由以前的 16 课扩充为如今的 42 课，至关于写了一本 Spring Boot 的系统图书。

经过此课程的学习，相信你会彻底掌握 Spring Boot 2.0 的使用。下面咱们先来了解一下什么是 Spring Boot ?

《精通 Spring Boot 42 讲》。

1.2   Spring Boot 介绍

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程，该框架使用了特定的方式来进行配置，从而使开发人员再也不须要定义样板化的配置。Spring Boot 默认配置了不少框架的使用方式，就像 Maven 整合了全部的 Jar 包，Spring Boot 整合了全部的框架。它的核心设计思想是：约定优于配置，Spring Boot 全部开发细节都是依据此思想进行实现的。

Spring Boot 是一套全新的框架，它来自于 Spring 你们族，所以 Spring 全部具有的功能它都有而且更容易使用；同时还简化了基于 Spring 的应用开发，经过少许的代码就能建立一个独立的、产品级别的 Spring 应用。 

下图展现出了 Spring Boot 在 Spring 生态中的位置：

 

该项目主要的目的是：

• 上手 Spring 开发更快、更普遍；
• 使用默认方式实现快速开发；
• 提供大多数项目所需的非功能特性，诸如：嵌入式服务器、安全、心跳检查、外部配置等。

Spring Boot 特性

• 使用 Spring 项目引导页面能够在几秒构建一个项目；
• 方便对外输出各类形式的服务，如 REST API、WebSocket、Web、Streaming、Tasks；
• 很是简洁的安全策略集成；
• 支持关系数据库和非关系数据库；
• 支持运行期内嵌容器，如 Tomcat、Jetty；
• 强大的开发包，支持热启动；
• 自动管理依赖；
• 自带应用监控；
• 支持各类 IED，如 IntelliJ IDEA、NetBeans。

1.3   Spring Boot 市场热度

Spring Boot 于 2014 年发布了第一个正式版本，发布以后陆续有一些开源爱好者进行了研究，并迅速喜欢上了这款开源软件，Spring Boot 在初期低调快速发展，直到 2016 年才被真正使用起来。期间不少研究 Spring Boot 的开发者，在网上写了大量文章，推进了 Spring Boot 在行业内的发展。

从 2016 年到 2018 年，是 Spring Boot 在中国发展的黄金时期，使用 Spring Boot 的企业和我的开发者愈来愈多，咱们从 Spring Boot 关键字的百度指数能够看出。

 

上图为 2014 年到 2018 年 Spring Boot 的百度指数，能够看出 2.0 的推出引起了搜索高峰。

经过谷歌趋势来看 Spring Boot 在美国的使用状况发现，中国和美国使用 Spring Boot 的总体频率保持一致，看来国内技术人同步全球的技术频率愈来愈快。

 

看到社区使用 Spring Boot 的热情，Spring 官方也很是重视 Spring Boot 的后续发展，已经把它做为公司最顶级的项目来推广，放到了官网上第一的位置，后续 Spring Boot 的发展也被看好。

 

1.4   Spring Boot 和微服务架构

微服务架构是在互联网高速发展，技术突飞猛进的变化以及传统架构没法适应快速变化等多重因素的推进下诞生的产物。互联网时代的产品一般有两类特色：需求变化快和用户群体庞大。在这种状况下，如何从系统架构的角度出发，构建灵活、易扩展的系统，快速应对需求的变化；在用户增长的同时如何保证系统的可伸缩性、高可用性，成为系统架构面临的挑战。

若是还按照之前传统开发模式，开发一个大而全的系统已经很难知足市场对技术的需求，这时候分而治之的思想被提了出来，因而咱们从单独架构发展到分布式架构，又从分布式架构发展到 SOA 架构，服务不断地被拆分和分解，粒度也愈来愈小，直到微服务架构的诞生。

大约 2009 年开始，Netflix 彻底从新定义了它的应用程序开发和操做模型，拉开了微服务探索的第一步，直到 2014 年 3 月 Martin Fowler 写的一篇文章 Microservices 以更加通俗易懂的形式为你们定义了什么是微服务架构。Martin Fowler 在文中阐述了对微服务架构的设想，认为微服务架构是一种架构模式，它提倡将单一应用程序划分红一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。

Spring Boot 诞生时，正处于微服务概念在慢慢酝酿中，Spring Boot 的研发融合了微服务架构的理念，实现了在 Java 领域内微服务架构落地的技术支撑。Spring Boot 在开发、测试、部署、运维等方面都作了大量的优化，使用 Spring Boot 开发项目，能够快速响应需求、独立完成开发部署上线。

Spring Boot 的一系列特性有助于实现微服务架构的落地，从目前众多的技术栈对比来看它是 Java 领域微服务架构最优落地技术，没有之一。

1.5   为何学习 Spring Boot ？

《精通 Spring Boot 42 讲》。

Spring Boot 自己并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。同时它集成了大量经常使用的第三方库配置（如 Redis、MongoDB、JPA、RabbitMQ、Quartz 等），Spring Boot 应用中这些第三方库几乎能够零配置进行开箱即用，大部分的 Spring Boot 应用都只须要很是少许的配置代码，开发者可以更加专一于业务逻辑。

使用 Spring Boot 开发项目，有如下几方面优点：

• Spring Boot 使开发变得简单，提供了丰富的解决方案，快速集成各类解决方案提高开发效率。
• Spring Boot 使配置变得简单，提供了丰富的 Starters，集成主流开源产品每每只须要简单的配置便可。
• Spring Boot 使部署变得简单，其自己内嵌启动容器，仅仅须要一个命令便可启动项目，结合 Jenkins、Docker 自动化运维很是容易实现。
• Spring Boot 使监控变得简单，自带监控组件，使用 Actuator 轻松监控服务各项状态。

从软件发展的角度来说，越简单的开发模式越流行，简单的开发模式解放出更多生产力，让开发人员能够避免将精力耗费在各类配置、语法所设置的门槛上，从而更专一于业务。这点上，Spring Boot 已尽量地简化了应用开发的门槛。

Spring Boot 所集成的技术栈，涵盖了各大互联网公司的主流技术，跟着 Spring Boot 的路线去学习，基本能够了解国内外互联网公司的技术特色。 

1.6   总结

Spring Boot 是一套快速开发框架，在微服务架构的大环境下 Spring Boot 一经推出就受到开源社区的追捧。Spring Boot 有强大的生态整合能力，提供了众多的 Starters 包，很是方便 Spring Boot 集成第三方开源软件达到开箱即用的效果。

Spring Boot 和微服务架构都是将来软件开发的大趋势，越早参与，受益越大。

2    第1-1课：Spring Boot 产生的背景和它的设计理念

《精通 Spring Boot 42 讲》共分五大部分，第一部分是从零起步的基础内容，共4课，帮助你们快速认识 Spring Boot ，我会带领你们熟悉 Spring Boot 产生的背景和设计理念，同时也会讲解 Spring Boot 的环境搭建和项目介绍，最后以一个 Hello World 为例，来测试一下环境的搭建以及熟悉开发的流程。本章的重点内容是 Spring Boot 2.0 的新变化，若是学习过此前课程的同窗能够重点关注这一节。下面咱们就具体进入第一讲的内容。

要了解 Spring Boot 产生的背景，咱们就必需要先了解一下 Spring 的发展史，不只由于 Spring Boot 来源于 Spring 体系，并且 Spring Boot 的诞生和 Spring 框架的发展息息相关。

2.1   Spring 的发展史

时间回到 2002 年，当时正是 Java EE 和 EJB 大行其道的时候，不少知名公司都是采用此技术方案进行项目开发。这时候有一个美国的小伙子认为 EJB 太过臃肿，并非全部的项目都须要使用 EJB 这种大型框架，应该会有一种更好的方案来解决这个问题。

他为了证实本身的想法是正确的，在 2002 年 10 月写了一本书《Expert One-on-One J2EE》，介绍了当时 Java 企业应用程序开发的状况，并指出了 Java EE 和 EJB 组件框架中存在的一些主要缺陷。在这本书中，他提出了一个基于普通 Java 类和依赖注入的更简单的解决方案。

在书中，他展现了如何在不使用 EJB 的状况下构建高质量、可扩展的在线座位预留系统。为了构建应用程序，他编写了超过 30,000 行的基础结构代码，项目中的根包命名为 com.interface21，因此人们最初称这套开源框架为 interface21，这就是 Spring 的前身。

他是谁呢？他就是大名鼎鼎的 Rod Johnson（下图），Rod Johnson 在悉尼大学不只得到了计算机学位，同时还得到了音乐学位，更使人吃惊的是在回到软件开发领域以前，他还得到了音乐学的博士学位。如今 Rod Johnson 已经离开了 Spring，成为了一个天使投资人，同时也是多个公司的董事，早已走上人生巅峰。

 

在这本书发布后，一对一的 J2EE 设计和开发一炮而红。这本书免费提供的大部分基础架构代码都是高度可重用的。2003 年 Rod Johnson 和同伴在此框架的基础上开发了一个全新的框架命名为 Spring，据 Rod Johnson 介绍 Spring 是传统 J2EE 新的开始，随后 Spring 发展进入快车道。

• 2004 年 03 月，1.0 版发布。
• 2006 年 10 月，2.0 版发布。
• 2007 年 11 月，改名为 SpringSource，同时发布了 Spring 2.5。
• 2009 年 12 月，Spring 3.0 发布。
• 2013 年 12 月，Pivotal 宣布发布 Spring 框架 4.0。
• 2017 年 09 月，Spring 5.0 发布。

2.2   Spring Boot 的诞生

多年以来，Spring 平台饱受非议的一点就是大量的 XML 配置以及复杂的依赖管理。

随着使用 Spring 进行开发的我的和企业愈来愈多，Spring 也慢慢从一个单一简洁的小框架变成一个大而全的开源软件，Spring 的边界不断进行扩充，到了后来 Spring 几乎能够作任何事情，市面上主流的开源软件、中间件都有 Spring 对应组件支持，人们在享用 Spring 的便利以后，也遇到了一些问题。

Spring 每集成一个开源软件，就须要增长一些基础配置，随着开发项目的逐渐庞大，每每须要集成不少开源软件。后期使用 Spring 开发大型项目须要引入不少配置文件，致使配置工做难以理解且出错率高，到了后来人们甚至称 Spring 为配置地狱。

在 2013 年的 SpringOne 2GX 会议上，Pivotal 的 CTO Adrian Colyer 回应了这些批评，而且特别提到该平台未来的目标之一就是实现免 XML 配置的开发体验。Spring Boot 所实现的功能超出了这个任务的描述，开发人员不只再也不须要编写 XML，并且在一些场景中甚至不须要编写繁琐的 import 语句。

2013 年，微服务的概念也慢慢兴起，快速开发微小独立的应用变得更为急迫，Spring 恰好处在这样一个交叉点上，于 2013 年初启动了 Spring Boot 项目的研发。2014 年，Spring Boot 伴随着 Spring 4.0 诞生发布了第一个正式版本。

Spring Boot 并非要成为 Spring 平台里面众多“Foundation”层项目的替代者。Spring Boot 的目标不在于为已解决的问题域提供新的解决方案，而是为平台带来另外一种开发体验，从而简化对这些已有技术的使用。对于已经熟悉 Spring 生态系统的开发人员来讲，Spring Boot 是一个很理想的选择；对于采用 Spring 技术的新人来讲，Spring Boot 提供一种更简洁的方式来使用这些技术。

2.3   Spring Boot 开发团队

咱们常常会看到在介绍 Spring Boot 的时候有这么一句：Spring Boot 是由 Pivotal 团队提供的全新框架。由此咱们得知 Spring Boot 是由 Pivotal 团队所研发，那么 Pivotal 团队究竟是一个什么样的团队呢？其实这里的 Pivotal 团队是指 Pivotal 公司。

Pivotal 公司：致力于“改变世界构造软件的方式（We are transforming how the world builds software）”，提供云原生应用开发 PaaS 平台及服务，帮助企业客户采用敏捷软件开发方法论，从而提升软件开发人员工做效率、减小运维成本，实现数字化转型、IT 创新，并最终实现业务创新。

Pivotal 公司可谓是大牛云集，公司的开源产品有：Spring 以及 Spring 衍生产品、Web 服务器 Tomcat、缓存中间件 Redis、消息中间件 RabbitMQ、平台即服务的 Cloud Foundry、Greenplum 数据引擎、还有大名鼎鼎的 GemFire（12306 系统解决方案组件之一）。这些著名开源产品背后的开发者都在 Pivotal 公司，其研发团队聚集了全球的一流开发者，Spring Boot 为何如此优秀，或许在这里能够找到一些答案。

回顾 Pivotal 公司的发展历史，简直就是一场商业并购大片：

• 1989 年，罗伯·米创立 Pivotal Labs 公司，它的主营业务是帮助客户开发软件，曾给谷歌、Twitter 公司作技术支持；
• 2003 年，EMC 收购了 VMware；
• 2009 年，VMware 收购了 Spring 公司；
• 2012 年，EMC 以现金方式收购了 Pivotal Labs 公司； 
• 2013 年，EMC 和 VMware 分拆出其 Cloud Foundry、Pivotal Labs、Greenplum 等云计算、大数据资源，GE 投资 1.05 亿美圆，成立新公司 Pivotal；
• 2015 年，EMC 又被 DELL 所收购。

Pivotal 公司成立以后，于 2014 年发布了 Spring Boot，2015 年发布了 Spring Cloud，2018 年 Pivotal 公司在纽约上市。咱们能够经过一张图来了解 Pivotal 公司的发展史。

 

《精通 Spring Boot 42 讲》。

2.4   Spring Boot 的核心：约定优于配置

那么什么是约定优于配置呢？

约定优于配置（Convention Over Configuration），也称做按约定编程，是一种软件设计范式，旨在减小软件开发人员需作决定的数量、得到简单的好处，而又不失灵活性。

本质是说，开发人员仅需规定应用中不符约定的部分。例如，若是模型中有个名为 User 的类，那么数据库中对应的表就会默认命名为 user。只有在偏离这一约定时，例如将该表命名为“user_info”，才需写有关这个名字的配置。

咱们能够按照这个思路来设想，咱们约定 Controller 层就是 Web 请求层能够省略 MVC 的配置；咱们约定在 Service 结尾的类自动注入事务，就能够省略了 Spring 的切面事务配置。

在 Spring 体系中，Spring Boot JPA 就是约定优于配置最佳实现之一，不须要关注表结构，咱们约定类名便是表名，属性名便是表的字段，String 对应 varchar，long 对应 bigint，只有须要一些特殊要求的属性，咱们再单独进行配置，按照这个约定咱们能够将之前的工做大大简化。

Spring Boot 体系将约定优于配置的思想展示得淋漓尽致，小到配置文件、中间件的默认配置，大到内置容器、生态中的各类 Starters 无不遵循此设计规则。Spring Boot 鼓励各软件组织方建立本身的 Starter，建立 Starter 的核心组件之一就是 autoconfigure 模块，也是 Starter 的核心功能，在启动的时候进行自动装配，属性默认化配置。

能够说正是由于 Spring Boot 简化的配置和众多的 Starters 才让 Spring Boot 变得简单、易用、快速上手，也能够说正是约定优于配置的思想完全落地才让 Spring Boot 走向辉煌。Spring Boot 约定优于配置的思想让 Spring Boot 项目很是容易上手，让编程变得更简单，其实编程本该很简单，简单才是编程的美。 

2.5   Starters

Spring Boot Starters 基于约定优于配置的理念来设计，Spring Boot Starter 中有两个核心组件：自动配置代码和提供自动配置模块及其它有用的依赖。也就意味着当咱们项目中引入某个 Starter，即拥有了此软件的默认使用能力，除非咱们须要特定的配置，通常状况下我仅须要少许的配置或者不配置便可使用组件对应的功能。

Spring Boot 由众多 Starter 组成，随着版本的推移 Starter 家族成员也与日俱增。在传统 Maven 项目中一般将一些层、组件拆分为模块来管理，以便相互依赖复用，在 Spring Boot 项目中咱们则能够建立自定义 Spring Boot Starter 来达成该目的。

Spring Boot 拥有强大融合社区开源软件的能力，在没有使用 Spring Boot 以前，咱们须要按照每一个开源软件的特性，将对应的组件包集成到咱们的开发项目中，由于每一个组件的设计理念和开发团队都不一致，所以会有不少不一样的调用风格在咱们的项目中。

Spring Boot 整合了主流的开源软件造成了一系列的 Starter，让咱们有了一致的编程体验来集成各类软件，Spring Boot 在集成的时候作了大量的优化，让咱们在集成的时候每每只须要不多的配置和代码就能够完成。能够说各类 Starters 就是 Spring Boot 最大的优点之一。

如下为经常使用的 Spring Boot Starter 列表。

名称	描述	Pom
spring-boot-starter	核心 Starter，包括自动配置支持，日志和 YAML	Pom
spring-boot-starter-activemq	用于使用 Apache ActiveMQ 实现 JMS 消息	Pom
spring-boot-starter-amqp	用于使用 Spring AMQP 和 Rabbit MQ	Pom
spring-boot-starter-cache	用于使用 Spring 框架的缓存支持	Pom
spring-boot-starter-data-elasticsearch	用于使用 ElasticSearch 搜索，分析引擎和 Spring Data ElasticSearch	Pom
spring-boot-starter-data-jpa	用于使用 Hibernate 实现 Spring Data JPA	Pom
spring-boot-starter-data-mongodb	用于使用基于文档的数据库 MongoDB 和 Spring Data MongoDB	Pom
spring-boot-starter-data-redis	用于使用 Spring Data Redis 和 Jedis 客户端操做键—值数据存储 Redis	Pom
spring-boot-starter-jta-atomikos	用于使用 Atomikos 实现 JTA 事务	Pom
sring-boot-starter-mail	用于使用 Java Mail 和 Spring 框架 Email 发送支持	Pom
spring-boot-starter-quartz	用于定时任务 Quartz 的支持	Pom
spring-boot-starter-security	对 Spring Security 的支持	Pom
spring-boot-starter-test	用于测试 Spring Boot 应用，支持经常使用测试类库，包括 JUnit、Hamcrest 和 Mockito	Pom
spring-boot-starter-thymeleaf	用于使用 Thymeleaf 模板引擎构建 MVC Web 应用	Pom
spring-boot-starter-validation	用于使用 Hibernate Validator 实现 Java Bean 校验	Pom
spring-boot-starter-web	用于使用 Spring MVC 构建 Web 应用，包括 RESTful。Tomcat 是默认的内嵌容器	Pom
spring-boot-starter-websocket	用于使用 Spring 框架的 WebSocket 支持构建 WebSocket 应用	Pom

这里只节选了咱们最常使用的 Starter，完整的 Starter 参考这里：Spring Boot application starters。

由于 Spring Boot 足够的强大，不少第三方社区都进行了主动的集成。好比：MyBatis、RabbitMQ（高级用法）等，第三方社区支持的列表，能够在这里查看 Community Contributions，能够看到社区贡献的其余 Starters 列表。

看完这些 Starters 会不会瞬间以为 Spring Boot 很强大？几乎咱们涉及的开源软件 Spring Boot 都作了支持，在 Spring Boot 环境下使用这些软件，只须要引入对应的 Starter 包便可。

2.6   Spring、Spring Boot 和 Spring Cloud 的关系

Spring 最初核心的两大核心功能 Spring IoC 和 Spring Aop 成就了 Spring，Spring 在这两大核心功能上不断地发展，才有了 Spring 事务、Spring MVC 等一系列伟大的产品，最终成就了 Spring 帝国，到了后期 Spring 几乎能够解决企业开发中的全部问题。

Spring Boot 是在强大的 Spring 帝国生态基础上面发展而来，发明 Spring Boot 不是为了取代 Spring，是为了让人们更容易的使用 Spring。因此说没有 Spring 强大的功能和生态，就不会有后期 Spring Boot 的火热，Spring Boot 使用约定优于配置的理念，从新重构了 Spring 的使用，让 Spring 后续的发展更有生命力。

Spring 并无重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，经过 Spring Boot 风格进行再封装并屏蔽掉复杂的配置和实现原理，最终给开发者提供了一套简单易懂、易部署、易维护的分布式系统开发工具包。

Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的开发便利性巧妙地简化了分布式系统基础设施的开发。服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，均可以用 Spring Boot 的开发风格作到一键启动和部署。

Spring Cloud 是为了解决微服务架构中服务治理而提供的具有一系列功能的开发框架，而且 Spring Cloud 是彻底基于 Spring Boot 而开发，Spring Cloud 利用 Spring Boot 特性整合了开源行业中优秀的组件，总体对外提供了一套在微服务架构中服务治理的解决方案。

综上咱们能够这样来理解，正是因为 Spring IoC 和 Spring Aop 两个强大的功能才有了 Spring，Spring 生态不断的发展才有了 Spring Boot，使用 Spring Boot 让 Spring 更易用更有生命力，Spring Cloud 是基于 Spring Boot 开发的一套微服务架构下的服务治理方案。

如下为它们之间的关系。

Spring Ioc/Aop > Spring > Spring Boot > Spring Cloud

2.7   总结

Spring Boot 诞生一方面是由于 Spring 自身发展所遇到的问题，另外一方面在微服务思想诞生之际，急须要一款快速开发工具来实现微服务技术落地，在这样的背景下诞生了 Spring Boot。

Spring Boot 总体的设计思想是：约定优于配置。依赖此设计思路，Spring Boot 进行了大刀阔斧的改革，让开发、测试、部署更为便捷。众多的 Starters 成就了 Spring Boot 的发展，让使用 Spring Boot 开发项目变得更加简单。

3    第1-2课：Spring Boot 2.0 都更新了什么（上）

2018 年 3 月 1 号 Spring Boot 2.0.0.RELEASE 正式发布，这是 Spring Boot 1.0 发布 4 年以后第一次重大修订，所以有多新功能和特性值得关注！在 Spring Boot 官方博客中咱们了解到：Spring Boot 2.0 版本经历了 17 个月的开发，有 215 个不一样的使用者提供了超过 6800 次的提交。

咱们将 Spring Boot 2.0 更新的技术分为三类进行解读：

• 第一类，基础环境升级；
• 第二类，默认软件替换和优化；
• 第三类，新技术的引入。

3.1   基础环境升级

3.1.1  最低 JDK 8，支持 JDK 9，再也不支持 Java 6 和 7

Spring Boot 2.0 要求 Java 8 做为最低版本，许多现有的 API 已更新，以利用 Java 8 的特性。例如，接口上的默认方法，函数回调以及新的 API，如 javax.time。若是你正在使用 Java 7 或更早版本，则在开发 Spring Boot 2.0 应用程序以前，须要升级你的 JDK。

Spring Boot 2.0 经过测试能够在 JDK 9 下正常运行，同时 Spring Boot 2.0 宣布再也不支持 Java 6 和 7，据我了解国内绝大部分互联网公司的基本环境还在 JDK 7 或者 6 环境下运行，考虑升级 Spring Boot 2.0 的团队须要考虑这个因素。

3.1.2  依赖组件升级

Spring Boot 2.0 基于 Spring Framework 5 构建，本次 Spring Boot 的升级，同时也升级了部分其依赖的第三方组件，主要有如下几个：

• Jetty 9.4，Jetty 是一个开源的 Servlet 容器，它为基于 Java 的 Web 内容，例如 JSP 和 Servlet 提供运行环境。Jetty 是使用 Java 语言编写的，它的 API 以一组 JAR 包的形式发布。
• Tomcat 8.5，Apache Tomcat 8.5.x 旨在取代 8.0.x，彻底支持 Java 9。
• Flyway 5，Flyway 是独立于数据库的应用、管理并跟踪数据库变动的数据库版本管理工具。用通俗的话讲，Flyway 能够像 SVN 管理不一样人的代码那样，管理不一样人的 SQL 脚本，从而作到数据库同步。
• Hibernate 5.2，Hibernate 是一款很是流行的 ORM 框架。
• Gradle 3.4，Spring Boot 的 Gradle 插件在很大程度上已被重写，有了重大的改进。
• Thymeleaf 3.0，Thymeleaf 3 相对于 Thymeleaf 2 有很是大的性能提高。

3.2   默认软件替换和优化

3.2.1  HikariCP

默认链接池已从 Tomcat 切换到 HikariCP，HikariCP 是一个高性能的 JDBC 链接池，Hikari 是日语“光”的意思。

HikariCP 号称是 Java 业界最快的数据库链接池，官网提供了 c3p0、dbcp二、tomcat、vibur 和 Hikari 等数据链接池的性能对比。

 

关于 Hikari 性能为何如此突出，官网给出的说明以下：

• 字节码精简：优化代码，直到编译后的字节码最少，这样 CPU 缓存能够加载更多的程序代码；
• 优化代理和拦截器：减小代码，例如 HikariCP 的 Statement proxy 只有 100 行代码；
• 自定义数组类型（FastStatementList）代替 ArrayList：避免每次 get() 调用都要进行 range check，避免调用 remove() 时从头至尾的扫描；
• 自定义集合类型（ConcurrentBag）：提升并发读写的效率；
• 其余针对 BoneCP 缺陷的优化，好比对于耗时超过一个 CPU 时间片的方法调用的研究。

3.2.2  Security

Spring Security 是 Spring 社区的一个顶级项目，也是 Spring Boot 官方推荐使用的 Security 框架。除了常规的 Authentication 和 Authorization 以外，Spring Security 还提供了诸如 ACLs、LDAP、JAAS、CAS 等高级特性以知足复杂场景下的安全需求。

没有使用 Spring Boot 以前集成起来相对比较麻烦，而 Spring Boot 中基于 Java 配置实现 Spring Security 功能。Spring Boot 2.0 极大地简化了默认的安全配置，并使添加定制安全变得简单。

Spring Boot 2.0 很是容易使用 Spring Security 5.0 保护响应式应用，当检测到 Spring Security 存在的时候会自动进行默认配置。

3.2.3  OAuth 2.0

OAuth 2.0 是 OAuth 协议的延续版本，但不向后兼容 OAuth 1.0，即彻底废止了 OAuth1.0。OAuth 2.0 关注客户端开发者的简易性。要么经过组织在资源拥有者和 HTTP 服务商之间的被批准的交互动做表明用户，要么容许第三方应用表明用户得到访问的权限。

OAuth 2.0 是一个受权框架，或称受权标准，它能够使第三方应用程序或客户端得到对 HTTP 服务上（如 Google、GitHub ）用户账户信息的有限访问权限。OAuth 2.0 经过将用户身份验证委派给托管用户账户的服务以及受权客户端访问用户账户进行工做。

Spring Boot 2.0 将 Spring Security OAuth 项目迁移到 Spring Security。再也不提供单独的依赖包，Spring Boot 2.0 经过 Spring Security 5 提供 OAuth 2.0 客户端支持。

3.2.4  Micrometer

Micrometer 是一款监控指标的度量类库，可让你在没有供应商锁定的状况下对 JVM 的应用程序代码进行调整。

Spring Boot 2.0 加强了对 Micrometer 的集成，再也不提供本身的指标 API。依靠 micrometer.io 来知足全部应用程序监视需求。

Micrometer 包括尺寸指标的支持，当与尺寸监测系统配对时，尺寸指标能够有效访问特定的指定度量标准，而且能够在其尺寸范围内向下钻取。

指标能够输出到各类系统和开箱即用的 Spring Boot 2.0，为 Atlas、Datadog、Ganglia、Graphite、Influx、JMX、New Relic、Prometheus、SignalFx、StatsD 和 Wavefront 提供支持，另外还能够使用简单的内存中度量标准。

集成后提供 JVM 指标（包括 CPU、内存、线程和 GC）、Logback、Tomcat、Spring MVC ＆ 提供 RestTemplate。

3.2.5  Redis 默认使用 Lettuce

Redis 方面默认引入了 Lettuce，替代了以前的 Jedis 做为底层的 Redis 链接方式。

Lettuce 是一个可伸缩的线程安全的 Redis 客户端，用于同步、异步和反应使用。多个线程能够共享同一个 RedisConnection，它利用优秀 Netty NIO 框架来高效地管理多个链接，支持先进的 Redis 功能，如 Sentinel、集群、流水线、自动从新链接和 Redis 数据模型。

国内使用 Jedis 的居多，看来之后要多研究 Lettuce 了。

3.2.6  配置属性绑定

在 Spring Boot 2.0 中，使用 Environment 绑定机制的 @ConfigurationProperties 数学已经彻底完全修改。借此机会收紧了绑定的规则，并修复了 Spring Boot 1.x 中的许多不一致之处。

新的 Binder API 也能够直接使用 @ConfigurationProperties 在代码中。例如，下面绑定 List 中的 PersonName 对象：

List<PersonName> people = Binder.get(environment)

"my.property"class    .bind(, Bindable.listOf(PersonName.))

new    .orElseThrow(IllegalStateException::);

配置源能够像这样在 YAML 中表示：

my:

  property:

  - first-name: Jane

last   -name: Doe

  - first-name: John

last   -name: Doe

3.2.6.1    转换器支持

Binding 使用了一个新的 ApplicationConversionService 类，它提供了一些额外有用的转化。最引人注目的是转换器的 Duration 类型和分隔字符串。

该 Duration 转换器容许在任一 ISO-8601 格式的持续时间，或是一个简单的字符串（如 10m，10 分钟）。现有的属性已更改成默认使用 Duration，该 @DurationUnit 注释经过设置若是没有指定所使用的单元确保向后兼容性。例如，Spring Boot 1.5 中须要秒数的属性如今必须 @DurationUnit(ChronoUnit.SECONDS) 确保一个简单的值，例如 10 实际使用的值为 10s。

分隔字符串转换容许你将简单绑定 String 到 Collection 或 Array 没必要分割逗号。例如，LDAP base-dn属性用 @Delimiter(Delimiter.NONE)，因此 LDAP DN（一般包含逗号）不会被错误解释。

3.2.7  Actuator 改进

在 Spring Boot 2.0 中 Actuator endpoints 有很大的改进，全部 HTTP Actuator endpoints 如今都在该/actuator路径下公开，而且生成的 JSON 有效负载获得了改进。

如今默认状况下不会暴露不少端点。若是你要从 Spring Boot 1.5 升级现有的应用，请务必查看迁移指南并特别注意该 management.endpoints.web.exposure.include 属性。

Spring Boot 2.0 改进了从许多端点返回的 JSON 有效负载。

如今许多端点都具备更精确地反映底层数据的 JSON。例如，/actuator/conditions终端（/autoconfig在 Spring Boot 1.5 中）如今有一个顶级 contexts 密钥来将结果分组 ApplicationContext。

3.2.8  测试

对 Spring Boot 2.0 中测试进行了一些补充和调整：

• @WebFluxTest 已添加新注释以支持 WebFlux 应用程序的“slice”测试。
• Converter 和 GenericConverter beans 如今自动扫描 @WebMvcTest 和 @WebFluxTest。
• @AutoConfigureWebTestClient 已经添加到 WebTestClient 供测试使用，这个注释会自动应用于 @WebFluxTest 测试。
• 增长了一个新的 ApplicationContextRunner 测试实用程序，能够很容易地测试你的自动配置，咱们已将大部份内部测试套件移至此新模型。

3.2.9  其余

还有一些小的调整和改进：

• @ConditionalOnBean 如今在肯定是否知足条件时使用逻辑 AND 而不是逻辑 OR。
• 无条件类如今包含在自动配置中。
• 该 spring CLI 应用程序如今包括 encodepassword 可用于建立 Spring Security 的兼容散列密码命令。
• 计划任务（即 @EnableScheduling）能够使用 scheduledtasks 执行器端点进行审查。
• 该 loggers 驱动器终端如今容许你从新设置一个日志的默认级别。
• Spring Session 用户如今能够经过 sessions 执行器端点查找和删除会话。
• 使用 spring-boot-starter-parent 如今基于 Maven 的应用程序-parameters默认使用标志。

3.3   新技术的引入

3.3.1  支持 HTTP/2

HTTP/2 是第二代的 HTTP 协议，Spring Boot 的 Web 容器选择中 Tomcat，Undertow 和 Jetty 均已支持 HTTP/2。

相比 HTTP/1.x，HTTP/2 在底层传输作了很大的改动和优化：

• HTTP/2 采用二进制格式传输数据，而非 HTTP/1.x 的文本格式。二进制格式在协议的解析和优化扩展上带来更多的优点和可能。
• HTTP/2 对消息头采用 HPACK 进行压缩传输，可以节省消息头占用的网络的流量；而 HTTP/1.x 每次请求，都会携带大量冗余头信息，浪费了不少带宽资源；头压缩可以很好的解决该问题。
• 多路复用，直白的说就是全部的请求都是经过一个 TCP 链接并发完成。HTTP/1.x 虽然经过 pipeline 也能并发请求，可是多个请求之间的响应会被阻塞的，因此 pipeline 至今也没有被普及应用，而 HTTP/2 作到了真正的并发请求。同时，流还支持优先级和流量控制。
• Server Push：服务端可以更快的把资源推送给客户端。例如，服务端能够主动把 JS 和 CSS 文件推送给客户端，而不须要客户端解析 HTML 再发送这些请求，当客户端须要的时候，它已经在客户端了。

3.3.2  嵌入式 Netty 服务器

因为 WebFlux 不依赖于 Servlet API，咱们如今能够首次为 Netty 做为嵌入式服务器提供支持，该 spring-boot-starter-webflux 启动 POM 将拉取 Netty 4.1 和 Ractor Netty。

注意：你只能将 Netty 用做反应式服务器，不提供阻止 Servlet API 支持。

3.3.3  Kotlin的支持

Spring Boot 2.0 如今包含对 Kotlin 1.2.x 的支持，并提供了 runApplication，一个使用 Kotlin 运行 Spring Boot 应用程序的方法。咱们还公开和利用了 Kotlin 对其余 Spring 项目（如 Spring Framework，Spring Data 和 Reactor）已添加到其最近版本中的支持。

3.3.4  JOOQ 的支持

JOOQ 是基于 Java 访问关系型数据库的工具包。JOOQ 既吸收了传统 ORM 操做数据的简单性和安全性，又保留了原生 SQL 的灵活性，它更像是介于 ORMS 和 JDBC 的中间层。对于喜欢写 SQL 的码农来讲，JOOQ 能够彻底知足你控制欲，能够是用 Java 代码写出 SQL 的感受来。

3.3.5  支持 Quartz

Spring Boot 1.0 并无提供对 Quartz 的支持，以前出现了各类集成方案，Spring Boot2.0 给出了最简单的集成方式。

3.3.6  响应式编程

WebFlux 模块的名称是 spring-webflux，名称中的 Flux 来源于 Reactor 中的类 Flux。Spring WebFlux 有一个全新的非堵塞的函数式 Reactive Web 框架，能够用来构建异步的、非堵塞的、事件驱动的服务，在伸缩性方面表现很是好。

非阻塞的关键预期好处是可以以小的固定数量的线程和较少的内存进行扩展。在服务器端 WebFlux 支持两种不一样的编程模型：

• 基于注解的 @Controller 和其余注解也支持 Spring MVC；
• Functional 、Java 8 Lambda 风格的路由和处理。

 

默认状况下，Spring Boot 2.0 使用 Netty WebFlux，由于 Netty 在异步非阻塞空间中被普遍使用，异步非阻塞链接能够节省更多的资源，提供更高的响应度。经过比较 Servlet 3.1 非阻塞 I/O 没有太多的使用，由于使用它的成本比较高，Spring WebFlux 打开了一条实用的通路。

使用 Spring WebFlux/WebFlux.fn 提供响应式 Web 编程支持，WebFlux 是一个全新的非堵塞的函数式 Reactive Web 框架，能够用来构建异步的、非堵塞的、事件驱动的服务，在伸缩性方面表现很是好，此功能来源于 Spring 5.0。

Spring Boot 2.0 也提供了对响应式编程的自动化配置，如 Reactive Spring Data、Reactive Spring Security 等。

点击了解《精通 Spring Boot 42 讲》。

最后，Spring Boot 2.0 的新技术还有一个有意思的彩蛋设计，咱们会再下一讲介绍。同时，我会详细解释一下 Spring Boot 1.0 到 Spring Boot 2.0 API 上的一些变化，以及关因而否须要升级 Spring Boot 的我的建议。

4    第1-2课：Spring Boot 2.0 都更新了什么（下）

4.1.1  彩蛋

Spring Boot 2.0 支持了动态 Gif 的启动 Logo 打印。

在 Spring Boot 1.0 项目中 src/main/resources 路径下新建一个 banner.txt 文件，文件中写入一些字符，启动项目时就会发现默认的 Banner 被替换了，到了 Spring Boot 2.0 如今能够支持 Gif 文件的打印，Spring Boot 2.0 在项目启动的时候，会将 Gif 图片的每个画面，按照顺序打印在日志中，全部的画面打印完毕后，才会启动 Spring Boot 项目。

 

    

项目的启动 Banner 有什么用呢，在一些大的组织或者公司中，能够利用这个特性定制本身专属的启动画面，增长团队对品牌的认同感。

4.2   1.0 升级 2.0 API 变化

从 Spring Boot 1.0 升级到 2.0 以后，有不少的 API 已通过时，在使用的时候须要注意。

4.2.1  启动类 SpringBootServletInitializer

Spring Boot 部署到 Tomcat 中去启动时须要在启动类添加 SpringBootServletInitializer，2.0 和 1.0 有区别。

// 1.0

importorg.springframework.boot.web.support.SpringBootServletInitializer;

// 2.0

importorg.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication

publicclass UserManageApplication extends SpringBootServletInitializer {

@Override   

protected SpringApplicationBuilder configure(SpringApplicationBuilder application)    {

return       application.sources(UserManageApplication.class);

    }

public static void main(String[] args) throws Exception    {

        SpringApplication.run(UserManageApplication.class, args);

    }

}

Spring Boot 2.0 默认不包含 log4j，建议使用 slf4j。

importorg.apache.log4j.Logger;

protectedthisLogger logger = Logger.getLogger(.getClass());

改成：

importorg.slf4j.Logger;

importorg.slf4j.LoggerFactory;

protectedthisLogger logger =  LoggerFactory.getLogger(.getClass());

4.2.2  Thymeleaf 3.0 默认不包含布局模块

Spring Boot 2.0 中 spring-boot-starter-thymeleaf 包默认并不包含布局模块，使用 Thymeleaf 对页面进行布局时，须要单独添加布局模块，以下：

<dependency>

<groupId></groupId>  nz.net.ultraq.thymeleaf

<artifactId></artifactId>  thymeleaf-layout-dialect

</dependency>

layout:decorator 标签在 3.0 过时，推荐使用新的标签 layout:decorate 进行页面布局。

4.2.3  配置文件

大量的 Servlet 专属的 server.* 被移到了 server.servlet.* 下：

Old property	New property
server.context-parameters.*	server.servlet.context-parameters.*
server.context-path	server.servlet.context-path
server.jsp.class-name	server.servlet.jsp.class-name
server.jsp.init-parameters.*	server.servlet.jsp.init-parameters.*
server.jsp.registered	server.servlet.jsp.registered
server.servlet-path	server.servlet.path

原 spring.http.* 或 spring.server.* 下的一些参数，例如我用到了文件上传参数，已修改成 sping.servlet.multipart 下。

4.2.4  WebMvcConfigurerAdapter 过时

Spring Boot 2.0 中将原来的 WebMvcConfigurerAdapter 替换为 WebMvcConfigurer。

1.0 中的用法：

class MyWebMvcConfigurerAdapter extends WebMvcConfigurerAdapterpublic

2.0 中的用法：

publicclass MyWebMvcConfigurerAdapter implements WebMvcConfigurer

4.2.5  Spring Boot JPA 变化

去掉了 xxxOne() 方法

之前的 findOne() 方法其实就是根据传入的 ID 来查找对象，因此在 Spring Boot 2.0 的 Repository 中咱们能够添加 findById(long id) 来替换使用。

例如：

Useruser=userRepository.findOne(Long id)

改成手动在 userRepository 手动添加 findById(long id) 方法，使用时将 findOne() 调用改成 findById(long id)：

longidUser user=userRepository.findById()

delete() 方法和 findOne() 相似也被去掉了，能够使用 deleteById(Long id) 来替换，还有一个不一样点是 deleteById(Long id) 默认实现返回值为 void。

Long deleteById(Long id);

改成：

deletevoid//改成类型

voidLongiddeleteById();

固然咱们还有一种方案能够解决上述的两种变化，就是自定义 SQL（以下），可是没有上述方案简单，不建议使用。

@Query"select t from Tag t where t.tagId = :tagId"()

Tag getByTagId(@Param("tagId") long tagId);

须要指定主键的自增策略

Spring Boot 2.0 须要指定主键的自增策略，这个和 Spring Boot 1.0 有所区别，1.0 会使用默认的策略，若是不指定自增策略会报错。

@Id

@GeneratedValue(strategy= GenerationType.IDENTITY)

privatelongid;

分页组件 PageRequest 变化

在 Spring Boot 2.0 中 ，方法 new PageRequest(page, size, sort) 已通过期再也不推荐使用，推荐使用如下方式来构建分页信息：

ofby"id"Pageable pageable =PageRequest.(page, size, Sort.(Sort.Direction.ASC,));

跟踪了一下源码发现 PageRequest.of() 方法，内部仍是使用的 new PageRequest(page, size, sort)，只是最新的写法更简洁一些。

public static PageRequest of(int page, int size, Sort sort) {

returnnew   PageRequest(page, size, sort);

}

JPA 关联查询

在使用 Spring Boot 1.0 时，使用 JPA 关联查询时咱们会构建一个接口对象来接收结果集，相似以下：

publicinterfaceCollectView{

Long getId()  ;

Long getUserId()  ;

String getProfilePicture()  ;

String getTitle()  ;

}

在使用 Spring Boot 1.0 时，若是没有查询到对应的字段会返回空，在 Spring Boot 2.0 中会直接报空指针异常，对结果集的检查会更加严格一些。

这只是目前升级过程当中发现的一些问题，不表明 Spring Boot 2.0 升级中的全部问题，在随后的课程中会再一一介绍。

4.3   是否选择升级

经过以上内容能够看出 Spring Boot 2.0 相对于 1.0 增长了不少新特性，而且最重要的是 Spring Boot 2.0 依赖的 JDK 最低版本是 1.8，估计国内大多互联网公司尚未这么激进。另一个新的重大版本更新以后，不免会有一些小 Bug 什么的，每每须要再发布几个小版本以后，才会慢慢稳定下来。

所以个人建议是，若是不是特别须要使用 Spring Boot 2.0 上面提到的新特性，就尽可能不要着急进行升级，等 Spring Boot 2.0 完全稳定下来后再使用。若是想要升级也请先从早期的版本升级到 Spring Boot 1.5X 系列以后，再升级到 Spring Boot 2.0 版本，Spring Boot 2.0 的不少配置内容和 Spring Boot 1.0 不一致须要注意。

Spring Boot 1.0 发布以后给咱们带来了全新的开发模式，Spring Boot 2.0 发布标志着 Spring Boot 已经走向成熟，对 Java 领域带来的变革已经开启！

4.4   总结

能够看出 Spring Boot 2.0 是历时 4 年开发出来的巨做，在 Spring Boot 1.0 的基础上进行了大量的优化，淘汰了不少过时的 API，同时引入了一大批最新的技术，这些新技术在将来的一段时间内都具备引导性。在咱们学习 Spring Boot 2.0 的同时，须要同时学习 Spring Boot 2.0 引入的一些新技术，不建议你们在生产环境直接进行升级，等 Spring Boot 2.0 进一步稳定以后再升级替换。

5    第1-3课：Spring Boot 依赖环境和项目结构介绍

使用 Spring Boot 开发项目须要有两个基础环境和一个开发工具，这两个环境是指 Java 编译环境和构建工具环境，一个开发工具是指 IDE 开发工具。

Spring Boot 2.0 要求 Java 8 做为最低版本，须要在本机安装 JDK 1.8 并进行环境变量配置，同时须要安装构建工具编译 Spring Boot 项目，最后准备一个顺手的 IDE 开发工具便可。

构建工具是一个把源代码生成可执行应用程序的自动化工具，Java 领域中主要有三大构建工具：Ant、Maven 和 Gradle。

• Ant（AnotherNeatTool）的核心是由 Java 编写，采用 XML 做为构建脚本，这样就容许你在任何环境下运行构建。Ant 是 Java 领域最先的构建工具，不过由于操做复杂，慢慢的已经被淘汰了。
• Maven，Maven 发布于 2004 年，目的是解决程序员使用 Ant 所带来的一些问题，它的好处在于能够将项目过程规范化、自动化、高效化以及强大的可扩展性。
• Gradle，Gradle 是一个基于 Apache Ant 和 Apache Maven 概念的项目自动化建构工具。它使用一种基于 Groovy 的特定领域语言来声明项目设置，而不是传统的 XML。结合了前二者的优势，在此基础之上作了不少改进，它具备 Ant 的强大和灵活，又有 Maven 的生命周期管理且易于使用。

 

Spring Boot 官方支持 Maven 和 Gradle 作为项目构建工具。Gradle 虽然有更好的理念，可是相比 Maven 来说其行业使用率偏低，而且 Spring Boot 官方默认使用 Maven，所以本系列课程选择使用 Maven 做为 Spring Boot 项目构建工具。

Java 领域最流行的 IDE 开发工具备 Eclipse 和 IDEA。Eclipse 是 Java 的集成开发环境（IDE），也是 Java 领域最流行的 IDE 开发工具之一，只是 Eclipse 这些年发展缓慢，慢慢的有些陈旧。IDEA（IntelliJ IDEA）是用于 Java 语言开发的集成环境，在业界被公认为是最好的 Java 开发工具之一，尤为在智能代码助手、代码自动提示、重构、J2EE 支持、创新的 GUI 设计等方面的功能能够说是超常的。所以强烈推荐你们使用 IntelliJ IDEA 开发 Spring Boot 项目。

接下来将介绍如何搭建基础环境以及 IntelliJ IDEA 的安装。

5.1     安装 JDK

5.1.1   下载安装

首先打开 Oracle 官网 JDK 1.8 下载页面，根据下图选择下载各系统对应的版本，这里以 Win10 64 位操做系统为例。

 

下载完成以后，双击鼠标进行安装，一直单击“下一步”按钮直至安装完毕。

5.1.2   环境变量配置

JDK 安装完毕后，接下来配置 JDK 环境变量，选择“个人电脑” | “属性” | “高级系统设置” | “环境变量” | “新建”命令： 

 

在弹出的对话框中新建JAVA_HOME变量以及 Java 安装地址，以下图：

 

单击“肯定”按钮后，回到环境变量界面，双击Path变量，添加两条 JDK 路径，以下：

 

以上，Java 环境变量配置完毕！

5.1.3   测试

配置完成以后，测试一下 JDK 是否配置正确，Win10 下使用快捷 window+r 输入 cmd 命令，进入运行窗口，执行命令java -version，若出现以下结果，则表示安装成功！

 

5.2     安装 Maven

安装 Maven 的前提是完成 Java 环境安装，Maven 依赖于 Java 环境。

5.2.1   下载安装

访问 Maven 官网下载 Maven 对应的压缩包，以下：

 

选择 Maven 的 zip 压缩包（apache-maven-3.5.4.zip），下载完成后解压到本机目录下。例如，路径：D:\Common Files\apache-maven-3.5.4：

 

Maven 为绿色软件解压后便可使用。

5.2.2   环境变量配置

按照上面步骤打开环境变量设置页面，双击 Path 变量，将上一步解压的目录添加到 Path 中。

 

以上，Maven 环境配置完毕！

5.2.3   测试

Win10 下使用快捷 window+r 输入 cmd 命令，弹出“运行”对话框，执行命令 mvn -v，若出现以下结果，则表示安装成功！

 

5.2.4   settings.xml 设置

Maven 解压后目录下会有一个 settings.xml 文件，位置：${M2_HOME}/conf/settings.xml，用来配置 Maven 的仓库和本地 Jar 包存储地址。Maven 仓库地址表明从哪里去下载项目中的依赖包 Jar 包；Maven 会将全部的 Jar 包统一存储到一个地址下，方便各个项目复用。

localRepository 设置本地存放 Jar 包地址，能够根据本身的状况改动：

locallocal<Repository>D:\Common Files\maven\repository</Repository>

mirrors 为仓库列表配置的下载镜像列表：

<mirrors>

<mirror>    

<id></id>        repo2 

<mirrorOf></mirrorOf>        central 

<name></name>        spring2.0 for this Mirror. 

<url></url>        https://repo.spring.io/libs-milestone 

</mirror>    

    ...

<mirrors>

为了方便你们使用，我已经配好了一份 settings.xml 模板，可下载后直接覆盖默认的 settings.xml 文件，覆盖完成后须要修改 localRepository 路径。

模板 settings.xml 文件地址，详见这里。

5.3     IntelliJ IDEA 安装

5.3.1   下载

打开 IntelliJ IDEA 2018 官方下载地址，IDEA 分为两种版本，即社区版和商业版，商业版付费的功能多，社区版免费的功能少。

 

5.3.2   安装

下载完成后，双击安装包开始安装，一直单击 Next 按钮：

 

安装过程当中会选择安装路径，展现 32 或者 64 位的启动快捷键，最后单击 Finish 按钮，安装完成。

5.3.3   配置

安装完成后，第一次会提示选择配置设置，选择下面一个，单击 OK 按钮。

 

后面选择赞成协议，输入“License server”激活软件，根据本身的习惯选择白色或者黑色的默认主题，而后选择 IntelliJ IDEA 支持的扩展功能，也能够使用默认直接单击“下一步”按钮，最后单击 Start using IntelliJ IDEA 按钮完成配置。

以上，开发工具安装完毕！

5.4     构建项目

咱们有两种方式来构建 Spring Boot 项目基础框架，第一种是使用 Spring 官方提供的构建页面；第二种是使用 IntelliJ IDEA 中的 Spring 插件来建立。

使用 Spring 官方提供页面构建

• 访问 http://start.spring.io/ 网址。 
• 选择构建工具 Maven Project，编程语言选择 Java、Spring Boot 版本 2.0.5 以及一些工程基本信息，具体可参考下图：

 

• 单击 Generate Project 下载项目压缩包。
• 解压后，使用 IDEA 导入项目，选择 File | New | Model from Existing Source.. | 选择解压后的文件夹 | OK 命令，选择 Maven，一路单击 Next 按钮，OK done! 
• 若是使用的是 Eclipse，选择 Import | Existing Maven Projects | Next | 选择解压后的文件夹 | Finsh 按钮，OK done! 

使用 IDEA 构建

• 选择 File | New | Project... 命令，弹出新建项目的对话框。
• 选择 Spring Initializr，Next 也会出现上述相似的配置界面，IDEA 帮咱们作了集成。

 

• 填写相关内容后，单击 Next 按钮，选择依赖的包再单击 Next 按钮，最后肯定信息无误单击 Finish 按钮。

对上面的配置作一个解释：

• 第一个选择框选择建立以 Maven 构建项目，仍是以 Gradle 构建项目，这是两种不一样的构建方式，其中 Gradle 配置内容更简洁一些，而且包含了 maven 的使用，但咱们平常使用 maven 居多。 
• 第二个选择框选择编程语言，如今支持 Java、Kotlin、和 Groovy。
• 第三个选择框选择 Spring Boot 版本，能够看出 Spring Boot 2.0 的最新版本是 2.0.5。

下面就是项目的配置信息了。

• Group，通常填写公司域名，好比百度公司就会填：com.baidu，演示使用 com.neo。
• Artifact，能够理解为项目的名称了，能够根据实际状况来填，本次演示填 hello。
• Dependencies，在这块添加咱们项目所依赖的 Spring Boot 组件，能够多选，本次选择 Web、Devtools 两个模块。

5.5     项目结构介绍

 

如上图所示，Spring Boot 的基础结构共三个文件，具体以下。

• src/main/java：程序开发以及主程序入口；
• src/main/resources：配置文件；
• src/test/java：测试程序。

另外，Spring Boot 建议的目录结构以下。

com.example.myproject 目录下：

myproject

-src+

-main    +

-java         +

-com.example.myproject              +

-comm                    +

-model                    +

-repository                    +

-service                    +

-web                    +

-Application.java                    +

-resources         +

-static              +

-templates              +

-application.properties              +

-test    +

-pom.xml+

com.example.myproject 目录下：

• Application.java，建议放到根目录下面，是项目的启动类，Spring Boot 项目只能有一个 main() 方面。
• comm 目录建议放置公共的类，如全局的配置文件、工具类等。
• model 目录主要用于实体（Entity）与数据访问层（Repository）。
• repository 层主要是数据库访问层代码。
• service 层主要是业务类代码。
• web 层负责页面访问控制。

resources 目录下：

• static 目录存放 web 访问的静态资源，如 js、css、图片等。
• templates 目录存放页面模板。
• application.properties 存放项目的配置信息。

test 目录存放单元测试的代码；pom.xml 用于配置项目依赖包，以及其余配置。

采用默认配置能够省去不少设置，也能够根据公司的规范进行修改，至此一个 Java 项目搭建好了！

5.6     Pom 包介绍

pom.xml 文件主要描述了项目包的依赖和项目构建时的配置，在默认的 pom.xml 包中分为五大块。

第一部分为项目的描述信息：

<groupId></groupId>com.neo

<artifactId></artifactId>hello

<version></version>2.0.5.RELEASE

<packaging></packaging>jar

<name></name>hello

<description></description>Demo project for Spring Boot

• groupId，项目的包路径；
• artifactId，项目名称；
• version，项目版本号；
• packaging，通常有两个值：jar、war，表示使用 Maven 打包时构建成 Jar 包仍是 War 包；
• name，项目名称；
• description，项目描述。

第二部分为项目的依赖配置信息：

<parent>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-starter-parent

<version></version> 2.0.5.RELEASE

<relativePath/><!-- lookup parent from repository --> 

</parent>

<dependencies>

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-starter-web

</dependency> 

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-devtools

<scope></scope>   runtime

</dependency> 

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-starter-test

<scope></scope>   test

</dependency> 

</dependencies>

• parent，标签内配置 Spring Boot 父级版本 spring-boot-starter-parent，Maven 支持项目的父子结构，引入父级后会默认继承父级的配置。
• dependencies，标签内配置项目所须要的依赖包，Spring Boot 体系内的依赖组件不须要填写具体版本号，spring-boot-starter-parent 维护了体系内全部依赖包的版本信息。

第三部分为构建时须要的公共变量：

<properties>

<project.build.sourceEncoding></project.build.sourceEncoding> UTF-8

<project.reporting.outputEncoding></project.reporting.outputEncoding> UTF-8

<java.version></java.version> 1.8

</properties>

上面配置了项目构建时所使用的编码，输出所使用的编码，最后指定了项目使用的 JDK 版本。

第四部分为构建配置：

<build>

<plugins> 

<plugin>   

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-maven-plugin

</plugin>   

</plugins> 

</build>

使用 Maven 构建 Spring Boot 项目必须依赖于 spring-boot-maven-plugin 组件，spring-boot-maven-plugin 可以以 Maven 的方式为应用提供 Spring Boot 的支持，即为 Spring Boot 应用提供了执行 Maven 操做的可能。spring-boot-maven-plugin 可以将 Spring Boot 应用打包为可执行的 jar 或 war 文件，而后以简单的方式运行 Spring Boot 应用。

以上即为 pom.xml 文件基础内容，几乎全部的 Spring Boot 项目都会用到以上配置信息。

5.7     总结

这一课咱们介绍了 Spring Boot 所依赖的基础环境，如何去搭建 JDK、Maven 环境，安装开发工具 IDEA；对 Spring Boot 项目结构进行了解读，介绍了 pom.xml 文件内容的含义。经过本课的学习，咱们发现构建 Spring Boot 项目更简单方便，相比传统项目 Spring Boot 项目配置更加灵活。

6    第1-4课：写一个 Hello World 来感觉 Spring Boot

在学习新技术的时候咱们都喜欢先写一个 Hello World 程序，一方面能够验证基础环境的搭建是否正确；另外一方面能够快速了解整个开发流程。本节课咱们就来学习 Spring Boot 的第一个 Hello World 程序。

6.1     什么是 Spring Boot

Spring 在官方首页是这样介绍的：

BUILD ANYTHING.Spring Boot is designed to get you up and running as quickly as possible,with minimal upfront configuration of Spring.Spring Boot takes an opinionated view of building production ready applications.

中文翻译：Spring Boot 能够构建一切。Spring Boot 设计之初就是为了用最少的配置，以最快的速度来启动和运行 Spring 项目。Spring Boot 使用特定的配置来构建生产就绪型的项目。

6.2     来一个 Hello World

（1）能够在 Spring Initializr 上面添加，也能够手动在 pom.xml 中添加以下代码： 

<dependency>

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-starter-web

</dependency>

pom.xml 文件中默认有个模块：

<dependency>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-starter-test

<scope></scope> test

</dependency>

• <scope>test</scope>，表示依赖的组件仅仅参与测试相关的工做，包括测试代码的编译和执行，不会被打包包含进去；
• spring-boot-starter-test 是 Spring Boot 提供项目测试的工具包，内置了多种测试工具，方便咱们在项目中作单元测试、集成测试。

（2）编写 Controller 内容

在目录 src\main\java\com\neo\web 下建立 HelloController：

@RestController

publicclass HelloController {

@RequestMapping"/hello"   ()

public String hello()    {

return"hello world"       ;

    }

}

• @RestController 的意思是 Controller 里面的方法都以 JSON 格式输出，不须要有其余额外的配置；若是配置为 @Controller，表明输出内容到页面。
• @RequestMapping("/hello") 提供路由信息，"/hello" 路径的 HTTP Request 都会被映射到 hello() 方法上进行处理。

（3）启动主程序

右键单击项目中的 HelloApplication | run 命令，就能够启动项目了，若出现如下内容表示启动成功：

2018-09-19133357.80132996on8080''::  INFO--- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat startedport(s):(http) with context path

2018-09-19133357.80232996in0.88::  INFO--- [  restartedMain] com.neo.hello.HelloApplication           : Started HelloApplicationseconds

若是启动过程当中出现 java ClassNotFoundException 异常，请检查 Maven 配置是否正确，具体以下。

• 检查 Maven 的 settings.xml 文件是否引入正确，请参考模板 settings.xml 文件。
• 检查 IDE 工具中的 Maven 插件是否配置为本机的 Maven 地址，以下图：

 

Spring Boot 还提供了另外两种启动项目的方式：

• 在项目路径下，使用命令行 mvn spring-boot:run 来启动，其效果和上面“启动主程序”的效果是一致的；
• 或者将项目打包，打包后以 Jar 包的形式来启动。

# 进行项目根目录

cd../hello

# 执行打包命令

mvn clean package

# 以 Jar 包的形式启动

java -jar target/hello-0.0.1-SNAPSHOT.jar

启动成功后，打开浏览器输入网址：http://localhost:8080/hello，就能够看到如下内容了：

helloworld

开发阶段建议使用第一种方式启动，便于开发过程当中调试。

（4）若是咱们想传入参数怎么办？

请求传参通常分为 URL 地址传参和表单传参两种方式，二者各有优缺点，但基本都以键值对的方式将参数传递到后端。做为后端程序不用关注前端采用的那种方式，只须要根据参数的键来获取值，Spring 提供了不少种参数接收方式，今天咱们了解最简单的方式：经过 URL 传参。

只要后端处理请求的方法中存在参数键相同名称的属性，在请求的过程当中 Spring 会自动将参数值赋值到属性中，最后在方法中直接使用便可。下面咱们以 hello() 为例进行演示。

@RestController

publicclass HelloController {

@RequestMapping"/hello"   ()

public String hello(String name)    {

return"hello world, "       +name;

    }

}

从新启动项目，打开浏览器输入网址 http://localhost:8080/hello?name=neo，返回以下内容。

helloworld，neo

到这里，咱们的第一个 Spring Boot 项目就开发完成了，有没有感受很简单？通过测试发现，修改 Controller 内相关的代码，须要从新启动项目才能生效，这样作很麻烦是否是？别着急，Spring Boot 又给咱们提供了另一个组件来解决。

6.3     热部署

热启动就须要用到咱们在一开始就引入的另一个组件：spring-boot-devtools。它是 Spring Boot 提供的一组开发工具包，其中就包含咱们须要的热部署功能，在使用这个功能以前还须要再作一些配置。

6.3.1   添加依赖

在 pom.xml 文件中添加 spring-boot-devtools 组件。

<dependency>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-devtools

<scope></scope> runtime

</dependency>

其中，<scope>runtime</scope> 表示被依赖组件无需参与项目的编译，不事后期的测试和运行周期须要其参与。

OK，以上的配置就完成了，若是你使用的是 Eclipse 集成开发环境，那么恭喜你大功告成了；若是你使用的是 IDEA 集成开发环境，那么还须要作如下配置。

6.3.2   配置 IDEA

选择 File | Settings | Compiler 命令，而后勾选 Build project automatically 复选框，低版本的 IDEA 请勾选 make project automatically 复选框。

 

使用快捷键 Ctrl + Shift + A，在输入框中输入 Registry，勾选 compile.automake.allow.when.app.running 复选框：

 

所有配置完成后，IDEA 就支持热部署了，你们能够试着去改动一下代码就会发现 Spring Boot 会自动从新加载，不再须要手动单击从新部署了。

为何 IDEA 须要多配置后面这一步呢？由于 IDEA 默认不是自动编译的，须要咱们手动去配置后才会自动编译，而热部署依赖于项目的自动编译功能。

该模块在完整的打包环境下运行的时候会被禁用，若是你使用 java-jar 启动应用或者用一个特定的 classloader 启动，它会认为这是一个“生产环境”。

6.4     单元测试

单元测试在咱们平常开发中必不可少，一个优秀的程序员，单元测试开发也很是完善。下面咱们看下 Spring Boot 对单元测试又作了哪些支持？

若是咱们只想运行一个 hello world，只须要一个 @Test 注解就能够了。在 src/test 目录下新建一个 HelloTest 类，代码以下：

publicclassHelloTest{

Test    @

    public void hello(){

out"hello world"        System..println();

    }

}

右键单击“运行”按钮，发现控制台会输出：hello world。若是须要测试 Web 层的请求呢？Spring Boot 也给出了支持。

以往咱们在测试 Web 请求的时候，须要手动输入相关参数在页面测试查看效果，或者本身写 post 请求。在 Spring Boot 体系中，Spring 给出了一个简单的解决方案，使用 MockMVC 进行 Web 测试，MockMVC 内置了不少工具类和方法，能够模拟 post、get 请求，而且判断返回的结果是否正确等，也能够利用 print() 打印执行结果。

@SpringBootTest

publicclass HelloTest {

private   MockMvc mockMvc;

@Before   

public void setUp() throws Exception    {

new        mockMvc = MockMvcBuilders.standaloneSetup(HelloController()).build();

    }

@Test   

public void getHello() throws Exception    {

"/hello?name=小明"        mockMvc.perform(MockMvcRequestBuilders.post()

          .accept(MediaType.APPLICATION_JSON_UTF8)).andDo(print());

    }

}

• @Before 注解的方法表示在测试启动的时候优先执行，通常用做资源初始化。
• .accept(MediaType.APPLICATION_JSON_UTF8)) 这句是设置 JSON 返回编码，避免出现中文乱码的问题。
• 注意导包须要加入如下代码： 

importstaticorg.springframework.test.web.servlet.result.MockMvcResultHandlers.*;

由于 print() 等方法都是 MockMvcResultHandlers 类的静态方法。

在类的上面添加 @SpringBootTest，系统会自动加载 Spring Boot 容器。在平常测试中，能够注入 bean 来作一些局部的业务测试。MockMvcRequestBuilders 能够支持 post、get 请求，使用 print() 方法会将请求和相应的过程都打印出来，具体以下：

MockHttpServletRequest:

      HTTP Method = POST

      Request URI = /hello

       Parameters = {name=[小明]}

-8          Headers = {Accept=[application/json;charset=UTF]}

set             Body = <no character encoding>

    Session Attrs = {}

Handler:

             Type = com.neo.hello.web.HelloController

public           Method =java.lang.String com.neo.hello.web.HelloController.hello(java.lang.String)

...

MockHttpServletResponse:

200           Status =

null    Error message =

-819          Headers = {Content-Type=[application/json;charset=UTF], Content-Length=[]}

-8     Content type = application/json;charset=UTF

             Body = hello world ,小明

null    Forwarded URL =

null   Redirected URL =

          Cookies = []

从返回的Body = hello world ,neo能够看出请求成功了。

固然每次请求都看这么多返回结果，不太容易识别，MockMVC 提供了更多方法来判断返回结果，其中就有判断返回值。咱们将上面的 getHello() 方法稍稍进行改造，具体以下所示：

@Test

public void getHello() throws Exception {

"/hello?name=小明"    mockMvc.perform(MockMvcRequestBuilders.post()

/*.andDo(print())*/            .accept(MediaType.APPLICATION_JSON_UTF8))

"小明"            .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString()));

}

把刚才的 .andDo(print()) 方法注释掉，添加如下代码：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("小明")));

• MockMvcResultMatchers.content()，这段代码的意思是获取到 Web 请求执行后的结果；
• Matchers.containsString("小明")，判断返回的结果集中是否包含“小明”这个字符串。

咱们先将上面代码改成：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("微笑")));

而后执行 test 便可返回如下结果：

java.lang.AssertionError: Response content

string"微笑"Expected: acontaining

"hello world ,小明"     but: was

...

抛出异常说明：指望的结果是包含“微笑”，结果返回内容是“hello world ,小明”，不符合预期。

接下来咱们把代码改回：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("小明")));

再次执行测试方法，测试用例执行成功，说明请求的返回结果中包含了“小明”字段。

以上实践的测试方法，只是 spring-boot-starter-test 组件中的一部分功能，spring-boot-starter-test 对测试的支持是全方位的，后面会一一介绍到。

6.5     对比

咱们简单作一下对比，使用 Spring Boot 以前和使用以后。

使用 Spring Boot 以前：

• 配置 web.xml，加载 Spring 和 Spring MVC
• 配置数据库链接、配置 Spring 事务
• 配置加载配置文件的读取，开启注解
• 配置日志文件
• …
• 配置完成以后部署 Tomcat 调试
• …

如今很是流行微服务，若是项目只是简单发送邮件的需求，咱们也须要这样操做一遍。

使用 Spring Boot 以后，仅仅三步便可快速搭建起一个 Web 项目：

• 页面配置导入到开发工具中
• 进行代码编写
• 运行

经过对比能够发现 Spring Boot 在开发阶段作了大量优化，很是容易快速构建一个项目。

6.6     总结

本课学习了如何搭建 Spring Boot 开发项目所需的基础环境，了解了如何开发一个 Spring Boot 的 Hello World 项目。使用 Spring Boot 能够很是方便地快速搭建项目，不用关心框架之间的兼容性、组件版本差别化等问题；项目中使用组件，仅仅添加一个配置便可，因此使用 Spring Boot 很是适合构建微服务。

点击这里下载源码。

7    第 2-1 课：Spring Boot 对基础 Web 开发的支持（上）

《精通 Spring Boot 42 讲》共分五大部分，这是第二部份内容，主要讲解了 Web 开发相关的技术点，共 10 课。首先让你们快速认识 Spring Boot 对基础 Web 开发所作的优化；接下来说解了如何在 Spring Boot 中使用前端技术 JSP、Thymeleaf，重点介绍了 Thymeleaf 的各类使用场景；后面几课介绍了如何使用 Spring Boot 来构建 RESTful 服务、RESTful APIs，利用 WebSocket 双向通讯的特性建立聊天室。

自从 B/S 架构（Browser/Server，浏览器/服务器模式）被发明以来，由于其具备跨平台、易移植、方便使用等特色，迅速地成为了技术架构的首选，前端 Web 技术迅速发展起来。人们利用前端 Web 技术构建各类应用场景，如电子商务平台、在线聊天室、后台管理系统等。页面技术也从最初的 JSP 演化为如今的模板引擎；信息交互由之前的 XML 发展到如今更流行的 JSON；Spring Filter、IoC、Aop 等概念的发展更加方便人们构建 Web 系统。

Spring Boot 对 Web 开发的支持很全面，包括开发、测试和部署阶段都作了支持。spring-boot-starter-web 是 Spring Boot 对 Web 开发提供支持的组件，主要包括 RESTful，参数校验、使用 Tomcat 做为内嵌容器等功能，接下来给你们一一介绍。

7.1 JSON 的支持

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。JSON 采用彻底独立于语言的文本格式，可是也使用了相似于 C 语言家族的习惯（包括 C、C++、C#、Java、JavaScript、Perl、Python 等），这些特性使 JSON 成为理想的数据交换语言。

早期人们习惯使用 XML 进行信息交互，后来 JSON 的使用更加简单，到了如今信息交互大部分都以 JSON 为主。早期在 Spring 体系中使用 JSON 还比较复杂，须要配置多项 XML 和注解，如今在 Spring Boot 体系中，对 JSON 支持简单而又完善，在 Web 层使用仅仅只须要一个注解便可完成。接下来使用案例说明。

新建一个 spring-boot-web 项目，在 pom.xml 中添加 Web 依赖。

<dependency>

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-starter-web

</dependency>

启动类：

@SpringBootApplication

publicclass WebApplication {

public static void main(String[] args)    {

        SpringApplication.run(WebApplication.class, args);

    }

}

在项目根路径下新建 model 包，在包下新建一个实体类 User，User 信息以下：

publicclassUser{

private   String name;

privateint   age;

private   String pass;

//setter、getter省略   

}

在项目中新建 Web 包，并在 Web 包下新建一个类 WebController，在类中建立一个方法返回 User，以下：

@RestController

publicclass WebController {

@RequestMapping"/getUser"   (name=, method= RequestMethod.POST)

public User getUser()    {

new        User user=User();

"小明"        user.setName();

12        user.setAge();

"123456"        user.setPass();

return       user;

    }

}

• @RestController 注解至关于 @ResponseBody ＋ @Controller 合在一块儿的做用，若是 Web 层的类上使用了 @RestController 注解，就表明这个类中全部的方法都会以 JSON 的形式返回结果，也至关于 JSON 的一种快捷使用方式；
• @RequestMapping(name="/getUser", method= RequestMethod.POST)，以 /getUser 的方式去请求，method= RequestMethod.POST 是指只能够使用 Post 的方式去请求，若是使用 Get 的方式去请求的话，则会报 405 不容许访问的错误。

在 test 包下新建 WebControllerTest 测试类，对 getUser() 方法进行测试。

@SpringBootTest

publicclass WebControllerTest {

//省略部分代码   

@Test   

public void getUser() throws Exception    {

"/getUser"        String responseString = mockMvc.perform(MockMvcRequestBuilders.post())

                .andReturn().getResponse().getContentAsString();

"result : "        System.out.println(+responseString);

    }

}

这里的测试代码和上面的稍有区别，“.andReturn().getResponse().getContentAsString(); ”的意思是获取请求的返回信息，并将返回信息转换为字符串，最后将请求的响应结果打印出来。

执行完 Test，返回结果以下：

result"name""小明""age""pass""123456": {:,:12,:}

说明 Spring Boot 自动将 User 对象转成了 JSON 进行返回。那么若是返回的是一个 list 呢，在 WebController 添加方法 getUsers()，代码以下：

"/getUsers"@RequestMapping()

public List<User> getUsers() {

new    List<User> users=ArrayList<User>();

new    User user1=User();

"neo"    user1.setName();

30    user1.setAge();

"neo123"    user1.setPass();

add    users.(user1);

new    User user2=User();

"小明"    user2.setName();

12    user2.setAge();

"123456"    user2.setPass();

add    users.(user2);

return  users;

}

添加测试方法：

Test@

public void getUsers() throws Exception {

get"/getUsers"    String responseString = mockMvc.perform(MockMvcRequestBuilders.())

            .andReturn().getResponse().getContentAsString();

out"result : "    System..println(+responseString);

}

执行测试方法，返回内容以下：

"name""neo""age""pass""neo123""name""小明""age""pass""123456"result : [{:,:30,:},{:,:12,:}]

说明无论是对象仍是集合或者对象嵌套，Spring Boot 都可以将其转换为 JSON 字符串，这种方式特别适合系统提供接口时使用。

7.2 请求传参

请求传参是 Web 开发最基础的内容，前端浏览器和后端服务器正是依赖交互过程当中的参数，来判断用户是否登陆、用户正在执行时哪些动做，所以参数的传递和接收是一个 Web 系统最基础的功能。Spring Boot 内置了不少种参数接收方式，提供一些注解来帮助限制请求的类型、接收不一样格式的参数等，接下来咱们举例介绍。

使用 Spring Boot 能够轻松的对请求作一些限制，好比为了安全咱们只容许 POST 请求的访问，只须要在方法上添加一个配置既可：

RequestMappingnamegetUser@(="/", method= RequestMethod.POST)

public User getUser() {

    ...

}

这时候再以 GET 请求去访问，就会返回以下结果： 

'GET'notRequest methodsupported

若是要求其请求只支持 GET 请求，method 设置为：method= RequestMethod.GET；若是不进行设置默认两种方式的请求都支持。

Spring Web 层支持多种方法传参，在上一课中咱们传入一个属性 name，直接使用对象接收也能够支持。

RequestMappingnamegetUser@(="/", method= RequestMethod.POST)

public String getUser(User user) {

    ...

}

这样的写法，只要是 User 的属性都会被自动填充到 User 对象中；还有另一种传参的方式，使用 URL 进行传参，这种形式的传参地址栏会更加美观一些。

value"get/{name}"@RequestMapping(=, method=RequestMethod.GET)

public String get(@PathVariable String name) {

return   name;

}

在浏览器中输入网址：http://localhost:8080/get/neo，返回：neo，说明 name 值已经成功传入。

下一课咱们继续讲解“数据校验”、“自定义 Filter”、“配置文件”等内容。