图书

电子书

课程

VIP会员

书课包

深入浅出Spring Boot 2.x

978-7-115-48638-7

作者: 杨开振

译者:

编辑: 杨海玲

分类: Spring

图书目录:

详情

Spring框架是Java EE开发的事实标准，而Spring Boot是业界最流行的微服务开发框架。本书从一个最简单的工程开始讲解Spring Boot企业级开发，其内容包含全注解下的Spring IoC和AOP、数据库编程、数据库事务、NoSQL技术、Spring MVC、Spring 5新一代响应式框架WebFlux、REST风格和Spring Cloud分布式开发等。

图书摘要

版权信息

书名：深入浅出Spring Boot 2.x

ISBN：978-7-115-48638-7

您购买的人民邮电出版社电子书仅供您个人使用，未经授权，不得以任何方式复制和传播本书内容。

我们愿意相信读者具有这样的良知和觉悟，与我们共同保护知识产权。

如果购买者有侵权行为，我们可能对该用户实施包括但不限于关闭该帐号等维权措施，并可能追究法律责任。

版权

著　　　　杨开振

责任编辑　杨海玲

人民邮电出版社出版发行　　北京市丰台区成寿寺路11号

邮编　100164 　电子邮件　315@ptpress.com.cn

网址　http://www.ptpress.com.cn

读者服务热线：(010)81055410

反盗版热线：(010)81055315

内容提要

Spring框架是Java EE开发的强有力的工具和事实标准，而Spring Boot采用“约定优于配置”的原则简化了Spring的开发，从而成为业界最流行的微服务开发框架，已经被越来越多的企业采用。2018年3月Spring Boot的版本正式从1.x升级到了2.x，为了适应新潮流，本书将对Spring Boot 2.x技术进行深入讲解。

本书从一个最简单的工程开始讲解Spring Boot企业级开发，其内容包含全注解下的Spring IoC和AOP、数据库编程（JDBC、JPA和MyBatis）、数据库事务、NoSQL（Redis和MongoDB）技术、Spring MVC、Spring 5新一代响应式框架WebFlux、互联网抢购业务、部署与监控、REST风格和Spring Cloud分布式开发等。

本书内容紧扣互联网企业的实际要求，从全注解下Spring知识讲到Spring Boot的企业级开发，对于Java开发人员，尤其是初学Spring Boot的人员和需要从传统Spring转向Spring Boot开发的技术人员，具有很高的参考价值。

前言

本书的缘起

当前互联网后端开发中Java EE占据了主导地位。对于Java EE开发，首选框架和事实标准是Spring框架。在传统的Spring开发中需要使用大量的XML配置才能使Spring框架运行起来，这备受许多开发者诟病。随着Spring 4.x的发布，Spring已经完全可以脱离XML，只使用注解就可以运行项目。近两三年里，互联网世界掀起了“微服务”热潮。“微服务”将一个大的系统拆分为多个子系统，然后通过REST风格的请求将它们集成起来，进一步简化了分布式系统的开发。为了进一步简化Spring的开发，2014年Spring Boot诞生了，它是一个由Pivotal团队提供的全新框架，其设计目的是简化Spring应用的搭建以及开发过程，并迎合时下流行的微服务思维，越来越多的企业选择了Spring Boot。随着2017年9月Spring 5.x的推出，2018年Spring Boot也推出了2.x版本，进入2.x版本时代。

基于这样的趋势，在我和朋友合作创作完成《Java EE互联网轻量级框架整合开发：SSM框架（Spring MVC+Spring+MyBatis）和Redis实现》后，收到了许多的读者、前同事和业内朋友的建议，他们希望我创作一本关于Spring Boot的书，来给需要学习Spring Boot的从业人员提供参考，这就是创作本书的缘起。Spring Boot采用了“约定优于配置”的规则，大部分情况下依赖它提供的starter后，就可以使用默认的约定，加上属性文件，做大量的自定义配置，使开发更为简单；对于部署，Spring Boot提供了内嵌服务器和Maven（或Gradle）打包，进一步降低了企业部署的难度；对于测试，它提供了快速测试的环境，进一步提高了开发效率，因此它渐渐成为中小型企业甚至是一些大型企业开发的主流选择。加之在互联网世界中，分布式已经是一种必然的趋势，而分布式的治理和组件研发成本并非一般公司所能承担，为此Spring社区还在Spring Boot的基础上提供了Spring Cloud分布式开发组件，从而进一步简化了企业级分布式开发，这让Spring Boot和Spring Cloud都站到了互联网后端开发的主流方向上，越来越受到企业的青睐。

本书的安排

Spring Boot不是代替Spring，而是使Spring项目可以更加快速地开发、部署和测试。它采用了“约定优于配置”的理念，在其内部提供了大量的starter，而这些starter又提供了许多自动配置类，让开发者可以奉行“拿来主义”，开箱即用。虽然这样能够快速地开发、部署和测试，但是也会带来很大的问题，那就是，如果不懂Spring的原理，一旦出现开发的问题，开发者就很容易陷入困境，难以找到问题的根源，造成开发者的困扰。所以要学习Spring Boot就必须掌握Spring的基础知识。基于这种情况，本书会结合Spring的原理讨论Spring Boot的应用。

为了更好地讨论Spring Boot的相关知识，本书内容安排如下。

第1章和第2章先讲Spring Boot和传统Spring开发的区别，以及如何搭建Spring Boot开发环境。
第3章和第4章讨论在全注解下的Spring基础IoC和AOP，让初学者可以无缝对接Spring Boot的全注解开发方式。
第5章和第6章讲述数据库的开发、基于SSM框架（Spring MVC+Spring+MyBatis）的流行以及数据库事务的重要性，除了讨论传统的JDBC和JPA开发，还会重点讨论和MyBatis框架的整合，以及Spring数据库事务的编程。
第7章和第8章主要讲互联网中广泛使用的两种NoSQL数据库（即Redis和MongoDB），使用它们可以极大地提高系统的性能。
第9章和第10章讲解在Spring Boot和全注解下的Spring MVC开发，从Spring MVC的基础讲到实际的开发和应用，让读者能够掌握各种Spring Web后端的开发技巧。
第11章讲构建REST风格的网站。因为当前各个微服务是以REST风格请求相互融合的，所以时下它已经成为一种广泛使用的风格。
第12章讲Spring Security，通过它可以保护我们的站点，使其远离各种各样的攻击，保证网站安全，这是互联网应用必须做到的。
第13章讲一些Spring常用的技术，如异步线程、定时器、消息机制和WebSocket等，以满足企业的其他开发需要。
第14章讲解Spring 5推出的新的非阻塞框架WebFlux，介绍非阻塞编程的技巧，通过它可以构建非阻塞的网站。
第15章讲SSM整合，并通过抢购场景讲述互联网中的高并发与锁的应用。
第16章讲Spring Boot的打包、部署、测试和监控。
第17章讲基于Spring Cloud的分布式开发入门知识，使用它可以构建企业级分布式系统。

上述内容可以让读者对Spring Boot有深入的了解，并且通过进一步学习掌握企业级应用的开发技巧。

阅读本书的要求和目标读者

阅读本书前，读者需要具备Java编程语言基础、Java EE（Servlet和JSP）基础、前端（HTML、JavaScript和JQuery）基础和数据库（MySQL、Redis和MongoDB）基础。当然读者也可以根据自己感兴趣的技术选择部分章节来学习。

本书使用全注解讲解Spring基础技术（IoC和AOP），因此适合从事或者即将使用Spring Boot开发的人员阅读和学习，也适合基于传统Spring需要转向Spring Boot开发方式的开发者阅读，当然也适合作为大中专院校作为教材，帮助在校师生贴近企业级Java EE开发。读者通过本书的学习可以有效地提高自身的技术能力，并能将这些技术应用于实际学习和工作当中，当然读者也可以把本书当作工作手册来查阅。

本书使用的Spring Boot版本

Spring Boot作为一个被市场高度关注的微服务开发框架，版本迭代十分频繁，这给我创作本书带来了极大的挑战。本书出版前还有一个有趣的插曲，在本书初创时Spring Boot的最新正式版是1.5.4，到我最初定稿时更新到了1.5.9，都是基于Spring Boot的1.x版本。在2018年3月初，在书稿进入复审环节之前，Spring Boot发生了重大的版本更替，正式更新到了2.x的正式（GA）版本。为了与时俱进，保证本书更有参考价值，我决定将本书采用的Spring Boot版本从最初定稿的1.5.9更新到2.0.0。因此，本书采用版本2.0.0.RELEASE进行讲解。Spring Boot 2.x和Spring Boot 1.x在使用上有很多地方存在很多不同，并且只能支持JDK 8或者以上版本，这些是读者在阅读本书和实践中需要注意的。

致谢

本书得以顺利出版要感谢人民邮电出版社的编辑们，尤其是杨海玲编辑，她以编辑的专业精神时常鞭策我，并给予我很多帮助和支持，没有编辑的付出就不会有本书的出版。

感谢我的家人对我的支持和理解，当在电脑桌前写书、写代码和录视频课程时，牺牲了很多本该好好陪伴他们的时光。

感谢鼓励我编写本书的读者和朋友们，没有他们的鼓励，就不会有本书的缘起。

纠错、源码和课程

Spring和Spring Boot技术的使用和涉及面十分广泛，一些技术博大精深，版本更替也十分频繁，加上本人能力有限，所以书中错误之处在所难免。但是，正如没有完美的技术一样，也没有完美的书籍。尊敬的读者，如果你对本书有任何意见或建议，欢迎给我发送邮件（ykzhen2013@163.com），或者在我的博客（https://blog.csdn.net/ykzhen2015）上留言，以便于及时修订本书的错漏。

为了更好地帮助读者学习和理解本书内容，本书还提供免费的基础入门视频课程（扫封面上的二维码在线观看）和源代码下载，相关信息会发布到异步社区（https://www.epubit.com）和作者博客上，欢迎读者关注。

杨开振

2018年5月

资源与支持

本书由异步社区出品，社区（https://www.epubit.com/）为您提供相关资源和后续服务。

配套资源

本书提供如下资源：

本书源代码；
书中彩图文件。

要获得以上配套资源，请在异步社区本书页面中点击，跳转到下载界面，按提示进行操作即可。注意：为保证购书读者的权益，该操作会给出相关提示，要求输入提取码进行验证。

提交勘误

作者和编辑尽最大努力来确保书中内容的准确性，但难免会存在疏漏。欢迎您将发现的问题反馈给我们，帮助我们提升图书的质量。

当您发现错误时，请登录异步社区，按书名搜索，进入本书页面，点击“提交勘误”，输入勘误信息，点击“提交”按钮即可。本书的作者和编辑会对您提交的勘误进行审核，确认并接受后，您将获赠异步社区的100积分。积分可用于在异步社区兑换优惠券、样书或奖品。

与我们联系

我们的联系邮箱是contact@epubit.com.cn。

如果您对本书有任何疑问或建议，请您发邮件给我们，并请在邮件标题中注明本书书名，以便我们更高效地做出反馈。

如果您有兴趣出版图书、录制教学视频，或者参与图书翻译、技术审校等工作，可以发邮件给我们；有意出版图书的作者也可以到异步社区在线提交投稿（直接访问www.epubit.com/selfpublish/submission即可）。

如果您是学校、培训机构或企业，想批量购买本书或异步社区出版的其他图书，也可以发邮件给我们。

如果您在网上发现有针对异步社区出品图书的各种形式的盗版行为，包括对图书全部或部分内容的非授权传播，请您将怀疑有侵权行为的链接发邮件给我们。您的这一举动是对作者权益的保护，也是我们持续为您提供有价值的内容的动力之源。

关于异步社区和异步图书

“异步社区”是人民邮电出版社旗下IT专业图书社区，致力于出版精品IT技术图书和相关学习产品，为作译者提供优质出版服务。异步社区创办于2015年8月，提供大量精品IT技术图书和电子书，以及高品质技术文章和视频课程。更多详情请访问异步社区官网https://www.epubit.com。

“异步图书”是由异步社区编辑团队策划出版的精品IT专业图书的品牌，依托于人民邮电出版社近30年的计算机图书出版积累和专业编辑团队，相关图书在封面上印有异步图书的LOGO。异步图书的出版领域包括软件开发、大数据、AI、测试、前端、网络技术等。

异步社区

微信服务号

第1章　Spring Boot来临

当今许多互联网企业采用Java EE的技术开发自己的后端服务器，其原因在于Java语言的简单、安全、支持多线程、高性能和多年Java EE的技术积累，能够快速、安全、高性能地构建互联网项目。而如果你身处于Java EE的领域，那么你一定听过Spring的大名，它是当今Java EE开发的事实标准，也是绝大部分企业构建Java EE应用的基础。开启Spring Boot讲解之前，让我们先回顾Spring Framework的历史。

1.1　Spring的历史

在Spring框架没有开发出来时，Java EE是以Sun公司（已经被Oracle公司收购，不复存在，但为了纪念其对Java发展进程的巨大影响力，全书还是保留其名称，以表致敬之意）所制定的EJB（Enterprise Java Bean）作为标准的。在“遥远”的EJB年代，开发一个EJB需要大量的接口和配置文件，直至EJB 2.0的年代，开发一个EJB还需要配置两个文件，其结果就是配置的工作量比开发的工作量还要大。其次EJB是运行在EJB容器中的，而Sun公司定义的JSP和Servlet却是运行在Web容器中的，于是你可以想象得到，你需要使用Web容器去调用EJB容器的服务。这就意味着存在以下的弊端：需要增加调用的配置文件才能让Web容器调用EJB容器；与此同时需要开发两个容器，非常多的配置内容和烦琐的规范导致开发效率十分低下，这非常让当时的开发者诟病；对于Web容器调用EJB容器的服务这种模式，注定了需要通过网络传递，造成性能不佳；对于测试人员还需要了解许多EJB烦琐的细节，才能进行配置和测试，这样测试也难以进行。

就在大家诟病EJB的时候，2002年澳大利亚工程师Rod Johnson（论学历他应该是音乐家，因为他是音乐博士）在其著名的著作Expert One-on-One J2EE Design and Development中提出了Spring的概念。按书中的描述，Spring是如下的框架。

We believe that:

J2EE should be easier to use.

It is best to program to interfaces, rather than classes. Spring reduces the complexity cost of using interfaces to zero.

JavaBean offers a great way of configuring applications.

OO design is more important than any implementation technology, such as J2EE.

Checked exceptions are overused in Java. A platform should not force you to catch exceptions you are unlikely to recover from Testability is essential and a platform such as spring should help make your code easier to test.

We aim that:

Spring should be a pleasure to use.

Your application codes should not depend on Spring APIs.

Spring should not compete with good existing solutions, but should foster integration.

然后在2004年由Rod Johnson主导的Spring项目推出了1.0版本，这彻底地改变了Java EE开发的世界，很快人们就抛弃了繁重的EJB的标准，迅速地投入到了Spring框架中，于是Spring成为了现实中Java EE开发的标准。Spring以强大的控制反转（IoC）来管理各类Java资源，从而降低了各种资源的耦合；并且提供了极低的侵入性，也就是使用Spring框架开发的编码，脱离了Spring API也可以继续使用；而Spring的面向切面的编程（AOP）通过动态代理技术，允许我们按照约定进行配置编程，进而增强了Bean的功能，它擦除了大量重复的代码，如数据库编程所需大量的try...catch...finally...语句以及数据库事务控制代码逻辑，使得开发人员能够更加集中精力于业务开发，而非资源功能性的开发；Spring还提供许多整合了当时非常流行的框架的模板，如持久层Hibernate的HibernateTemplate模板、iBATIS的SqlMapClientTemplate模板等，极大地融合并简化了当时主流技术的使用，使得其展示了强有力的生命力，并延续至今。

值得一提的是，EJB 3.0的规范也引入了Spring的理念，而且整合了Hibernate框架的思想，但是也未能挽回其颓势，主要原因在于它的规范还是比较死板，而且比较难整合其他开源框架。其次，它运行在EJB容器之中，使用上还是比较困难，性能也不高。

1.2　注解还是XML

只是在Spring早期的1.x版本中，由于当时的JDK并不能支持注解，因此只能使用XML。而很快随着JDK升级到JDK5，它加入了注解的新特性，这样注解就被广泛地使用起来，于是Spring的内部也分为了两派，一派是使用XML的赞同派，一派是使用注解的赞同派。为了简化开发，在Spring 2.x之后的版本也引入了注解，不过只是少量的注解，如@Component、@Service等，但是功能还不够强大，因此对于Spring的开发，绝大部分的情况下还是以使用XML为主，注解为辅。

到了Spring 3.0后，引入了更多的注解功能，于是在Spring中产生了这样一个很大的分歧，即是使用注解还是使用XML？对于XML的引入，有些人觉得过于繁复，而对于注解的使用，会使得注解分布得到处都是，难以控制，有时候还需要了解很多框架的内部实现才能准确使用注解开发所需的功能。这个时候大家形成了这样的一个不成文的共识，对于业务类使用注解，例如，对于MVC开发，控制器使用@Controller，业务层使用@Service，持久层使用@Repository；而对于一些公用的Bean，例如，对于数据库（如Redis）、第三方资源等则使用XML进行配置，直至今时今日这样的配置方式还在企业中广泛地使用着。也许使用注解还是XML是一个长期存在的话题，但是无论如何都有道理。

随着注解的功能增强，尤其是Servlet 3.0规范的提出，Web容器可以脱离web.xml的部署，使得Web容器完全可以基于注解开发，对于Spring 3.x和Spring 4.x的版本注解功能越来越强大，对于XML的依赖越来越少，到了4.x的版本后甚至可以完全脱离XML，因此在Spring中使用注解开发占据了主流的地位。与此同时，Pivotal团队在原有Spring的基础上主要通过注解的方式继续简化了Spring框架的开发，它们基于Spring框架开发了Spring Boot，所以Spring Boot并非是代替Spring框架，而是让Spring框架更加容易得到快速的使用。Pivotal团队在2014年推出Spring Boot的1.0版本，该版本使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。在2018年3月Spring Boot推出了2.0.0 GA版本，该版本是基于Spring 5的，并引入其最新的功能，能够有效支持Java 9的开发。Spring Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）借助Java EE在企业互联网的强势地位成为业界领导者，它也是近年来Java开发最令人感到惊喜的项目之一。

随着近年来微服务的流行，越来越多的企业需要快速的开发，而Spring Boot除了以注解为主的开发，还有其他的绑定，例如，对服务器进行了绑定和默认对Spring的最大化配置，所以开发者能够尽快进行开发代码、发布和测试自己的项目。这符合了现今微服务快速开发、测试和部署的需要，于是越来越多的企业选择Spring Boot作为开发的选型，进而使得Spring Boot更加兴旺起来。本书主要就是论述Spring Boot这一令人激动的开发工具。

1.3　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（或者Gradle）依赖的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入门实例，并进行比较。

1.4　传统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")
    @ResponseBody
    public 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")
    @ResponseBody
    public 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的运行日志：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.0.RELEASE)

2018-03-01 22:21:55.843  INFO 16324 --- [           main] 
com.springboot.chapter1.Chapter1Main     : 
Starting Chapter1Main on AFOIF-703271542 with PID 16324 
(G:\springboot\v2\chapter1\target\classes started by Administrator in 
G:\springboot\v2\chapter1)
......
2018-03-01 22:21:57.270  INFO 16324 --- [           main] 
s.w.s.m.m.a.RequestMappingHandlerMapping : 
Mapped "{[/test]}" onto public java.util.Map<java.lang.String, java.lang.String> 
com.springboot.chapter1.Chapter1Main.test()
......
2018-03-01 22:21:57.270  INFO 16324 --- [           main] 
com.springboot.chapter1.Chapter1Main : Started Chapter1Main in 1.845 seconds (JVM running for 2.143)

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

图1-2　Spring Boot运行结果

与传统的Spring MVC是不是很不一样呢？从上面的对比可以看出，Spring Boot 允许直接进行开发，这就是它的优势。在传统所需要配置的地方，Spring Boot都进行了约定，也就是你可以直接以Spring Boot约定的方式进行开发和运行你的项目。当你需要修改配置的时候，它也提供了一些快速配置的约定，犹如它所承诺的那样，尽可能地配置好Spring项目和绑定对应的服务器，使得开发人员的配置更少，更加直接地开发项目。对于那些微服务而言，更喜欢的就是这样能够快速搭建环境的项目，而Spring Boot提供了这种可能性，同时Spring Boot还提供了监控的功能，随着云技术的到来，微服务成了市场的热点，于是代表Java微服务时代的Spring Boot微服务开发的时代已经到来，结合Spring Cloud后它还能很方便地构建分布式系统开发，满足大部分无能力单独开发分布式架构的企业所需，所以这无疑是激动人心的技术。后面的章节让我们走进Spring Boot开发的森林中。

第2章　聊聊开发环境搭建和基本开发

第1章的入门实例，只是开发了最简单的场景，我们还需要对Spring Boot做进一步的了解才能理解如何开发它和定制自己的开发。不过在此之前，需要对Spring Boot的开发环境进行搭建，并对它的特点做进一步的了解，才能更好地对Spring Boot有更深入的介绍。但是无论如何都需要先来搭建Spring Boot的工程。

2.1　搭建Spring Boot开发环境

使用Spring Boot，首先需要搭建一个快速开发的工程环境。Spring Boot工程的创建存在多种方式，但是因为当前Eclipse和IntelliJ IDEA这两种IDE的广泛应用，所以本书只介绍这两种IDE环境下的搭建。

2.1.1　搭建Eclipse开发环境

首先找到Eclipse的菜单Help→Eclipse Marketplace，打开这个菜单后，可以看到一个新的窗口，然后选择标签页Popular，从中找到Spring Tool Suite（STS）的插件，如图2-1所示。

这样就可以点击安装STS插件了，通过它可以很方便地引入Spring Boot的starter，而starter会引入对应的依赖包和服务器，这样就能够帮助我们快速地搭建开发环境。

下面让我们使用它创建一个工程。首先点击熟悉的菜单File→New→Project，然后输入spring过滤一些无关的内容，再选用Spring Starter Project，点击Next，创建项目，如图2-2所示。

于是它会再打开一个新的对话框，如图2-3所示。

图2-3中画框的地方是我根据自己需要进行的自定义，其中选择了使用War形式的打包，这意味着将使用的是一个带有JSP工程的项目。在实际的操作中，读者也需要根据自己的情况来定义它们。做完这些工作后，就可以点击Next进行下一步了，这样它又会弹出另外一个窗口，如图2-4所示。

图2-1　安装STS插件

图2-2　创建Spring Boot工程

图2-3　配置Spring Boot工程

图2-4　选择依赖的starter

这里选择AOP和Web，只是做最简单的项目而已，因此没有引入太多的内容。在现实的开发中，可能还需要选择NoSQL开发工具，如Redis、MongoDB等，还有数据库，如MySQL，以及持久层Hibernate或者MyBatis等项目的依赖，这些都是开发中经常用到的。当你选中所需要的包后，就可以直接点击Finish，这个时候一个新的Spring Boot工程就建好了，如图2-5所示。

图2-5　新的Spring Boot工程

从图2-5可以看到它是一个Maven项目，其中pom.xml文件已经建好，而且给我们创建了带有main方法的Chapter2Application.java文件和初始化Servlet的ServletInitializer.java文件。这里通过Chapter2Application就可以运行Spring Boot工程了。下面再打开工程中的pom.xml文件，就可以看到这些代码，如代码清单2-1所示。

代码清单2-1　项目中的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 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>springboot</groupId>
    <artifactId>chapter2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>chapter2</name>
    <description>chapter2 for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </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>

这些代码是STS插件根据你选择的starter依赖来创建的，这样关于Eclipse搭建的开发环境就结束了。此时只需要使用Java Application的形式运行Chapter2Application就可以启动Spring Boot项目。

2.1.2　搭建IntelliJ IDEA开发环境

首先是启动IntelliJ IDEA开发环境，然后选择Create New Project，就可以看到一个新的窗口。我们选择Spring Initializr，并且将JDK切换为你想要的版本，如图2-6所示。

图2-6　使用IntelliJ IDEA创建Spring Boot工程

点击Next，也会弹出另外一个窗口，它将允许我们进行一定的配置，如图2-7所示。

图2-7　配置Spring Boot项目

同样，图中加框的地方是我根据自己的需要进行修改的内容。注意，这里还是选择了以War打包的形式，然后点击Next，又到了可以选择starter的窗口，如图2-8所示。

图2-8　选择对应的starter

也与Eclipse一样，可以根据自己的需要选择对应的starter进行依赖，IntelliJ IDEA也会为你建好工程，如图2-9所示。

你也可以看到一个建好的类Chapter2Application、ServletInitializer和Maven的pom.xml文件。运行Chapter2Application就可以启动Spring Boot工程，而pom.xml则配置好了你选中的starter依赖，这样就能够基于IntelliJ IDEA开发Spring Boot工程了。

图2-9　IntelliJ IDEA创建Spring Boot工程

到这里，如果你想使用Jetty或者Undertow作为服务器，又或者说你想切换后台日志中的商标，那么可以参考附录中的内容。

2.2　Spring Boot的依赖和自动配置

在上节中已经介绍了如何搭建Spring Boot工程，下面需要讨论它为什么在很少的配置下就能够运行。

下面以最常用的Spring MVC为例进行说明。首先打开Maven的本地仓库，找到对应Spring Boot的文件夹，可以看到图2-10所示的目录。

图2-10　Spring Boot的Maven本地仓库

这里先谈spring-boot-starter-web的内容，未来还会谈到spring-boot-autoconfigure文件夹的内容，所以图 2-10 中一并加了框。打开spring-boot-starter-web文件夹，就可以看到一个名为spring-boot-starter-web-2.0.0.RELEASE.pom的文件，打开它就可以看到代码清单2-2所示的代码。

代码清单2-2　spring-boot-starter-web的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starters</artifactId>
    <version>2.0.0.RELEASE</version>
  </parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.0.0.RELEASE</version>
  <name>Spring Boot Web Starter</name>
  <description>Starter for building web, including RESTful, applications using Spring
        MVC. Uses Tomcat as the default embedded container</description>
  <url>https://projects.spring.io/spring-boot/#/spring-boot-parent/spring-boot-starters/
  spring-boot-starter-web</url>
  <organization>
    <name>Pivotal Software, Inc.</name>
    <url>https://spring.io</url>
  </organization>
  <licenses>
    <license>
      <name>Apache License, Version 2.0</name>
      <url>http://www.apache.org/licenses/LICENSE-2.0</url>
    </license>
  </licenses>
  <developers>
    <developer>
      <name>Pivotal</name>
      <email>info@pivotal.io</email>
      <organization>Pivotal Software, Inc.</organization>
      <organizationUrl>http://www.spring.io</organizationUrl>
    </developer>
  </developers>
  <scm>
<connection>scm:git:git://github.com/spring-projects/spring-boot.git/spring-boot-
starters/spring-boot-starter-web</connection>
<developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git/
spring-boot-starters/spring-boot-starter-web</developerConnection>
<url>http://github.com/spring-projects/spring-boot/spring-boot-starters/spring-boot-
starter-web</url>
  </scm>
  <issueManagement>
    <system>Github</system>
    <url>https://github.com/spring-projects/spring-boot/issues</url>
  </issueManagement>
  <dependencies>
    <!-- Spring Boot的依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.0.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <!-- JSON依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.0.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <!-- Tomcat依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.0.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <!-- Hibernate Validator依赖-->
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.7.Final</version>
      <scope>compile</scope>
    </dependency>
    <!-- Spring Web依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <!-- Spring Web MVC依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

代码中的中文注释是我加入的。从这里可以看出，当加入spring-boot-starter-web后，它会通过Maven将对应的资源加载到我们的工程中，这样便能够形成依赖。但是这样还不足以运行Spring MVC项目，要运行它还需要对Spring MVC进行配置，让它能够生成Spring MVC所需的对象，才能启用Spring MVC，所以还需要进一步探讨。

为了探讨Spring MVC在Spring Boot自动配置的问题，首先在本地下载的Maven仓库的目录spring-boot-autoconfigure中找到spring-boot-autoconfigure-2.0.0.RELEASE-sources.jar的包。它是一个源码包，把它解压缩出来，打开它目录下的子目录org\springframework\boot\autoconfigure\web\servlet后，我们就可以看到许多配置类，如图2-11所示。

图2-11　Spring Boot的默认配置类

这里可以看到存在很多的类，其中加框的类DispatcherServletAutoConfiguration就是一个对DispatcherServlet进行自动配置的类。因为本书不是源码分析的书，所以不对注解这些内容进行深入的探讨，只是截取DispatcherServletAutoConfiguration源码中的一个内部类DispatcherServletConfiguration对Spring Boot的自动配置做最基本的讲解，如代码清单2-3所示。

代码清单2-3　DispatcherServletAutoConfiguration部分源码分析

// 配置文件
@Configuration
// 配置条件满足类DefaultDispatcherServletCondition的验证
@Conditional(DefaultDispatcherServletCondition.class)
// 如果存在ServletRegistration类则进行配置
@ConditionalOnClass(ServletRegistration.class)
// 如果存在对应的属性配置（Spring MVC的是spring.mvc.*）则启用配置
@EnableConfigurationProperties(WebMvcProperties.class)
protected static class DispatcherServletConfiguration {

    private final WebMvcProperties webMvcProperties;

    public DispatcherServletConfiguration(WebMvcProperties webMvcProperties) {
        this.webMvcProperties = webMvcProperties;
    }

    @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    public DispatcherServlet dispatcherServlet() {
        DispatcherServlet dispatcherServlet = new DispatcherServlet();
        dispatcherServlet.setDispatchOptionsRequest(
                this.webMvcProperties.isDispatchOptionsRequest());
        dispatcherServlet.setDispatchTraceRequest(
                this.webMvcProperties.isDispatchTraceRequest());
        dispatcherServlet.setThrowExceptionIfNoHandlerFound(
                this.webMvcProperties.isThrowExceptionIfNoHandlerFound());
        return dispatcherServlet;
    }

    @Bean
    // 如果存在类定义则配置
    @ConditionalOnBean(MultipartResolver.class)
    // 判断如果不存在bean名称为DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME，则配置Bean
    @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
    public MultipartResolver multipartResolver(MultipartResolver resolver) {
        // Detect if the user has created a MultipartResolver but named it incorrectly
        return resolver;
    }

}

注意上述代码中加粗注解的注释，这些中文注释是我加入的，为的是更好地说明Spring Boot的自动配置功能。通过上面的代码，可以看到Spring Boot内部已经自动为我们做了很多关于DispatcherServlet的配置，其中的@EnableConfigurationProperties还能够在读取配置内容的情况下自动生成Spring MVC所需的类，有关这些内容的讨论可以参考附录。到这里，应该明白为什么几乎在没有任何配置下就能用Spring Boot启动Spring MVC项目，这些都是Spring Boot通过Maven依赖找到对应的jar包和嵌入的服务器，然后使用默认自动配置类来创建默认的开发环境。但是有时候，我们需要对这些默认的环境进行修改以适应个性化的要求，这些在Spring Boot中也是非常简单的，正如@EnableConfigurationProperties注解那样，它允许读入配置文件的内容来自定义自动初始化所需的内容，下节将探讨这个问题。

2.3　使用自定义配置

上节讨论了Spring Boot存在自动装配组件和自定义的配置，这些它都给予了开发者默认的约定配置项。关于这些内容，可以在它公布的网址上看到所有的配置项，网址是http://docs.spring.io/spring- boot/docs/current-SNAPSHOT/reference/htmlsingle/#appendix。这些配置项多达300多项，所以十分繁复，好在我们并不需要全部去配置，只是根据自己工程的需要引入对应的starter，对其进行必要的配置就可以了。

本书不会像流水账那样罗列这些配置项，因为这些很无趣也没有必要，而只是根据讲解的需要，引入对应的starter，才会讨论对应的配置项。将来在讨论数据库、NoSQL等内容时，才会讨论对应的配置项。这里需要我们记住的是通过这些约定的配置就可以在很大程度上自定义开发环境，以适应真实需求。这就是Spring Boot的理念，配置尽量简单并且存在约定，屏蔽Spring内部的细节，使得Spring能够开箱后经过简单的配置后即可让开发者使用，以满足快速开发、部署和测试的需要。

如果你按照上述使用Eclipse或者IntelliJ IDEA进行新建工程，那么可以在项目中发现它还会为你创建一个属性文件application.properties，如图2-12所示。

它是一个默认的配置文件，通过它可以根据自己的需要实现自定义。例如，假设当前8080端口已经被占用，我们希望使用8090端口启动Tomcat，那么只需要在这个文件中添加一行：

server.port=8090

图2-12　Spring Boot的配置文件

这样以Java Application的形式运行Chapter2Application就可以看到Spring Boot绑定的Tomcat的启动日志：

......
2018-03-01 23:22:50.304  INFO 13428 --- [           main]
o.s.j.e.a.AnnotationMBeanExporter     : Registering beans for JMX exposure on startup
2018-03-01 23:22:50.336 INFO 13428 --- [ main] 
o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8090 (http) with 
context path ''
2018-03-01 23:22:50.338  INFO 13428 --- [           main] 
c.s.chapter1.Chapter2Application      : Started Chapter2Application in 1.965 seconds 
(JVM running for 2.314)

注意，通过加粗的这行日志可以看到Tomcat是以8090端口启动的，相信读者明白了。也就是说，我们只需要修改配置文件，就能将开发的默认配置变为自定义配置。

事实上，Spring Boot的参数配置除了使用properties文件之外，还可以使用yml文件等，它会以下列的优先级顺序进行加载：

命令行参数；
来自java:comp/env的JNDI属性；
Java系统属性（System.getProperties()）；
操作系统环境变量；
RandomValuePropertySource配置的random.*属性值；
jar包外部的application-{profile}.properties或application.yml（带spring.profile）配置文件；
jar包内部的application-{profile}.properties或application.ym（带spring.profile）配置文件；
jar包外部的application.properties或application.yml（不带spring.profile）配置文件；
jar包内部的application.properties或application.ym（不带spring.profile）配置文件；
@Configuration注解类上的@PropertySource；
通过SpringApplication.setDefaultProperties指定的默认属性。

实际上，yml文件的配置与properties文件只是简写和缩进的差别，因此差异并不大，所以本书统一使用properties文件进行配置。对于需要使用yml文件的读者，只是需要稍加改动即可。

2.4　开发自己的Spring Boot项目

上面我们修改了服务器的启动端口，有时候还需要修改Spring MVC的视图解析器（ViewResolver）。Spring MVC的视图解析器的作用主要是定位视图，也就是当控制器只是返回一个逻辑名称的时候，是没有办法直接对应找到视图的，这就需要视图解析器进行解析了。在实际的开发中最常用的视图之一就是JSP，例如，现在控制器中返回一个字符串“index”，那么我们希望它对应的是开发项目的/WEB-INF/jsp/index.jsp文件。如果你还对Spring MVC不熟悉，那也没有关系，未来我们还会谈到它，这里的代码很简单，你只需要依葫芦画瓢就可以体验运行Spring Boot项目了。下面的主要任务就是展示如何通过Spring Boot完成这个功能。首先我们需要在Maven的pom.xml中加入JSP和JSTL的依赖包，如代码清单2-4所示。

代码清单2-4　新增JSP和JSTL的Maven依赖配置

dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <scope>provided</scope>
</dependency>

为了配置视图解析器（ViewResolver），将application.properties文件修改为如代码清单2-5所示。

代码清单2-5　定义视图前后缀

server.port=8090
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

这里的spring.mvc.view.prefix和spring.mvc.view.suffix是Spring Boot与我们约定的视图前缀和后缀配置，意思是找到文件夹/WEB-INF/jsp/下以.jsp为后缀的JSP文件，那么前缀和后缀之间显然又缺了一个文件名称，在Spring MVC机制中，这个名称则是由控制器（Controller）给出的，为此新建一个控制器IndexController，其代码如代码清单2-6所示。

代码清单2-6　开发控制器

package com.springboot.chapter2.main;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class IndexController {

    @RequestMapping("/index")
    public String index() {
        return "index";
    }
}

这里定义了一个映射为/index的路径，然后方法返回了“index”，这样它就与之前配置的前缀和后缀结合起来找对应的jsp文件，为此我们还需要开发一个对应的jsp文件，因此我们再建一个/webapp/WEB-INF/jsp/index.jsp文件，如代码清单2-7所示。

代码清单2-7　开发视图（/webapp/WEB-INF/jsp/index.jsp）

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Spring boot 视图解析器</title>
</head>
<body>
    <h1>测试视图解析器</h1>
</body>
</html>

这样我们就完成了一个简单的控制器，并且让视图解析器找到视图的功能。从上面来看定义视图解析器，在Spring Boot中只需要通过配置文件定义视图解析器的前后缀即可，而无须任何代码，这是因为Spring Boot给了我们自定义配置项，它会读入这些自定义的配置项，为我们生成Spring MVC中的视图解析器。正如它所承诺的尽可能地配置Spring开发环境，然后再看看即将运行的Chapter2Application.java文件，如代码清单2-8所示。

代码清单2-8　Spring Boot运行文件Chapter2Application

package com.springboot.chapter2.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Chapter2Application {

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

这里的注解@SpringBootApplication标志着这是一个Spring Boot入门文件。加粗的代码则是以Chapter2Application类作为配置类来运行Spring Boot项目，于是Spring Boot就会根据你在Maven加载的依赖来完成运行了。接下来我们以Java Application的形式运行类Chapter2Application，就可以看到Tomcat的运行日志。由于已经把端口修改为了8090，因此打开浏览器后输入http://localhost:8090/index，就可以看到运行的结果如图2-13所示。

图2-13　测试视图解析器

这样我们就搭建完成Spring Boot的开发环境了。因为Spring Boot是基于Spring原理基础之上的，所以在讨论Spring Boot时，也十分有必要介绍Spring的技术原理，这样才能知其然，亦知其所以然。这些是后续章节的任务了。

深入浅出Spring Boot 2.x

图书目录:

详情

图书摘要

版权信息

版权

内容提要

前言

本书的缘起

本书的安排

阅读本书的要求和目标读者

本书使用的Spring Boot版本

致谢

纠错、源码和课程

资源与支持

配套资源

提交勘误

与我们联系

关于异步社区和异步图书

第1章　Spring Boot来临

1.1　Spring的历史

1.2　注解还是XML

1.3　Spring Boot的优点

1.4　传统Spring MVC和Spring Boot的对比

第2章　聊聊开发环境搭建和基本开发

2.1　搭建Spring Boot开发环境

2.1.1　搭建Eclipse开发环境

2.1.2　搭建IntelliJ IDEA开发环境

2.2　Spring Boot的依赖和自动配置

2.3　使用自定义配置

2.4　开发自己的Spring Boot项目

相关图书

相关文章

相关课程

深入浅出Spring Boot 2.x

图书目录:

详情

图书摘要

版权信息

版权

内容提要

前言

本书的缘起

本书的安排

阅读本书的要求和目标读者

本书使用的Spring Boot版本

致谢

纠错、源码和课程

资源与支持

配套资源

提交勘误

与我们联系

关于异步社区和异步图书

第1章 Spring Boot来临

1.1 Spring的历史

1.2 注解还是XML

1.3 Spring Boot的优点

1.4 传统Spring MVC和Spring Boot的对比

第2章 聊聊开发环境搭建和基本开发

2.1 搭建Spring Boot开发环境

2.1.1 搭建Eclipse开发环境

2.1.2 搭建IntelliJ IDEA开发环境

2.2 Spring Boot的依赖和自动配置

2.3 使用自定义配置

2.4 开发自己的Spring Boot项目

相关图书

相关文章

相关课程

第1章　Spring Boot来临

1.1　Spring的历史

1.2　注解还是XML

1.3　Spring Boot的优点

1.4　传统Spring MVC和Spring Boot的对比

第2章　聊聊开发环境搭建和基本开发

2.1　搭建Spring Boot开发环境

2.1.1　搭建Eclipse开发环境

2.1.2　搭建IntelliJ IDEA开发环境

2.2　Spring Boot的依赖和自动配置

2.3　使用自定义配置

2.4　开发自己的Spring Boot项目