Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架，作者：RodJohnson。

Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。

Spring是如何简化Java开发的

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

什么是SpringBoot

学过javaweb的同学就知道，开发一个web应用，从最初开始接触Servlet结合Tomcat,跑出一个HelloWolrld程序，是要经历特别多的步骤；后来就用了框架Struts，再后来是SpringMVC，到了现在的SpringBoot，过一两年又会有其他web框架出现；你们有经历过框架不断的演进，然后自己开发项目所有的技术也在不断的变化、改造吗？建议都可以去经历一遍；

所有的技术框架的发展似乎都遵循了一条主线规律：从一个复杂应用场景衍生一种规范框架，人们只需要进行各种配置而不需要自己去实现它，这时候强大的配置功能成了优点；发展到一定程度之后，人们根据实际生产应用情况，选取其中实用功能和设计精华，重构出一些轻量级的框架；之后为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。

是的这就是Java企业级应用->J2EE->spring->springboot的过程。

随着Spring不断的发展，涉及的领域越来越多，项目整合开发需要配合各种各样的文件，慢慢变得不那么易用简单，违背了最初的理念，甚至人称配置地狱。SpringBoot正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用Spring、更容易的集成各种常用的中间件、开源软件；

SpringBoot基于Spring开发，SpirngBoot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。SpringBoot以约定大于配置的核心思想，默认帮我们进行了很多设置，多数SpringBoot应用只需要很少的Spring配置。同时它集成了大量常用的第三方库配置（例如Redis、MongoDB、Jpa、RabbitMQ、Quartz等等），SpringBoot应用中这些第三方库几乎可以零配置的开箱即用。

简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，springboot整合了所有的框架。

SpringBoot的主要优点：

真的很爽，我们快速去体验开发个接口的感觉吧！

准备工作

我们将学习如何快速的创建一个SpringBoot应用，并且实现一个简单的Http请求处理。通过这个例子对SpringBoot有一个初步的了解，并体验其结构简单、开发快速的特性。

我的环境准备：

开发工具：

创建基础项目说明

Spring官方提供了非常方便的工具让我们快速构建应用

项目创建方式一：使用SpringInitializr的Web页面创建项目

项目创建方式二：使用IDEA直接创建项目

项目结构分析：

通过上面步骤完成了基础项目的创建。就会自动生成以下文件。

pom.xml分析

打开pom.xml，看看SpringBoot项目的依赖：

简单几步，就完成了一个web接口的开发，SpringBoot就是这么简单。所以我们常用它来建立我们的微服务项目！

将项目打成jar包，点击maven的package

如果遇到错误，可以尝试配置打包时，跳过项目运行测试用例

org.apache.maven.pluginsmaven-surefire-plugintrue如果打包成功，则会在target目录下生成一个jar包

打成了jar包后，就可以在任何地方运行了！OK

彩蛋

如何更改启动时显示的字符拼成的字母，SpringBoot呢？也就是banner图案；

只需一步：到项目下的resources目录下新建一个banner.txt即可。

SpringBoot这么简单的东西背后一定有故事，我们之后去进行一波源码分析！

父依赖

其中它主要是依赖一个父项目，主要是管理项目的资源过滤及插件！

org.springframework.bootspring-boot-starter-parent2.6.6点进去，发现还有一个父依赖

org.springframework.bootspring-boot-dependencies2.6.6../../spring-boot-dependencies这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了；

启动器spring-boot-starter

org.springframework.bootspring-boot-starter-webspringboot-boot-starter-xxx：就是spring-boot的场景启动器

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

分析完了pom.xml来看看这个启动类

默认的主启动类

//@SpringBootApplication来标注一个主程序类//说明这是一个SpringBoot应用@SpringBootApplicationpublicclassSpringbootApplication{publicstaticvoidmain(String[]args){//以为是启动了一个方法，没想到启动了一个服务SpringApplication.run(SpringbootApplication.class,args);}}但是一个简单的启动类并不简单！我们来分析一下这些注解都干了什么

@SpringBootApplication

作用：标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

进入这个注解：可以看到上面还有很多其他注解！

@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters={@Filter(type=FilterType.CUSTOM,classes={TypeExcludeFilter.class}),@Filter(type=FilterType.CUSTOM,classes={AutoConfigurationExcludeFilter.class})})public@interfaceSpringBootApplication{//......}@ComponentScan

这个注解在Spring中很重要,它对应XML配置中的元素。

作用：自动扫描并加载符合条件的组件或者bean，将这个bean定义加载到IOC容器中

@SpringBootConfiguration

作用：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类；

我们继续进去这个注解查看

//点进去得到下面的@Component@Configurationpublic@interfaceSpringBootConfiguration{}@Componentpublic@interfaceConfiguration{}这里的@Configuration，说明这是一个配置类，配置类就是对应Spring的xml配置文件；

里面的@Component这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

我们回到SpringBootApplication注解中继续看。

@EnableAutoConfiguration

@EnableAutoConfiguration：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解接续查看：

@AutoConfigurationPackage：自动配置包

@Import({Registrar.class})public@interfaceAutoConfigurationPackage{}@import：Spring底层注解@import，给容器中导入一个组件

Registrar.class作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器；

这个分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class})：给容器导入组件；

AutoConfigurationImportSelector：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

我们根据源头打开spring.factories，看到了很多自动配置的文件；这就是自动配置根源所在！

WebMvcAutoConfiguration

我们在上面的自动配置类随便找一个打开看看，比如：WebMvcAutoConfiguration

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看着熟悉一下！

所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中对应的org.springframework.boot.autoconfigure.包下的配置项，通过反射实例化为对应标注了@Configuration的JavaConfig形式的IOC容器配置类，然后将这些都汇总成为一个实例并加载到IOC容器中。

结论：

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplicationpublicclassSpringbootApplication{publicstaticvoidmain(String[]args){SpringApplication.run(SpringbootApplication.class,args);}}SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication

这个类主要做了以下四件事情：

查看构造器：

publicSpringApplication(ResourceLoaderresourceLoader,Class...primarySources){//......this.webApplicationType=WebApplicationType.deduceFromClasspath();this.setInitializers(this.getSpringFactoriesInstances();this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));this.mainApplicationClass=this.deduceMainApplicationClass();}run方法流程分析

跟着源码和这幅图就可以一探究竟了！

配置文件

SpringBoot使用一个全局的配置文件，配置文件名称是固定的

配置文件的作用：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

比如我们可以在配置文件中修改Tomcat默认启动的端口号！测试一下！

server:port:8081yaml概述

YAML是"YAMLAin'taMarkupLanguage"（YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML的意思其实是："YetAnotherMarkupLanguage"（仍是一种标记语言）

这种语言以数据作为中心，而不是以标记语言为重点！

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

传统xml配置：

8081yaml配置：

server:port:8080yaml基础语法

说明：语法要求严格！

字面量：普通的值[数字，布尔值，字符串]

字面量直接写在后面就可以，字符串默认不用加上双引号或者单引号；

k:v注意：

对象、Map（键值对）

#对象、Map格式k:v1:v2:在下一行来写对象的属性和值得关系，注意缩进；比如：

student:name:qinjiangage:3行内写法

student:{name:qinjiang,age:3}数组（List、set）

用-值表示数组中的一个元素,比如：

pets:-cat-dog-pig行内写法

pets:[cat,dog,pig]修改SpringBoot的默认端口号

配置文件中添加，端口号的参数，就可以切换端口；

server:port:80823.2、注入配置文件yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

yaml注入配置文件

@Component//注册bean到容器中publicclassDog{privateStringname;privateIntegerage;//有参无参构造、get、set方法、toString()方法}@Component//注册beanpublicclassDog{@Value("阿黄")privateStringname;@Value("18")privateIntegerage;}@SpringBootTestclassDemoApplicationTests{@Autowired//将狗狗自动注入进来privateDogdog;@TestpublicvoidcontextLoads(){System.out.println(dog);//打印看下狗狗对象}}结果成功输出，@Value注入成功，这是我们原来的办法对吧。

yaml配置注入到实体类完全OK！

加载指定的配置文件

@PropertySource：加载指定的配置文件；

@configurationProperties：默认从全局配置文件中获取值；

name=qinjiang@PropertySource(value="classpath:person.properties")@Component//注册beanpublicclassPerson{@Value("${name}")privateStringname;......}配置文件占位符

配置文件还可以编写占位符生成随机数

person:name:qinjiang${random.uuid}#随机uuidage:${random.int}#随机inthappy:falsebirth:2000/01/01maps:{k1:v1,k2:v2}lists:-code-girl-musicdog:name:${person.hello:other}_旺财age:1回顾properties

我们上面采用的yaml方法都是最简单的方式，开发中最常用的；也是springboot所推荐的！那我们来唠唠其他的实现方式，道理都是相同的；写还是那样写；配置文件除了yml还有我们之前常用的properties，我们没有讲，我们来唠唠！

【注意】properties配置文件在写中文的时候，会有乱码，我们需要去IDEA中设置编码格式为UTF-8；

settings-->FileEncodings中配置；

测试步骤：

@Component//注册beanpublicclassUser{privateStringname;privateintage;privateStringsex;}user1.name=kuangshenuser1.age=18user1.sex=男@Component//注册bean@PropertySource(value="classpath:user.properties")publicclassUser{//直接使用@value@Value("${user.name}")//从配置文件中取值privateStringname;@Value("#{9*2}")//#{SPEL}Spring表达式privateintage;@Value("男")//字面量privateStringsex;}@SpringBootTestclassDemoApplicationTests{@AutowiredUseruser;@TestpublicvoidcontextLoads(){System.out.println(user);}}结果正常输出！

对比小结

@Value这个使用起来并不友好！我们需要为每个属性单独注解赋值，比较麻烦；我们来看个功能对比图

配置yml和配置properties都可以获取到值，强烈推荐yml；

如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用一下@value；

如果说，我们专门编写了一个JavaBean来和配置文件进行一一映射，就直接@configurationProperties，不要犹豫！

先看看如何使用

在pom.xml中增加依赖

org.springframework.bootspring-boot-starter-validationSpringboot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。我们这里来写个注解让我们的name只能支持Email格式；

使用数据校验，可以保证数据的正确性；

常见参数

多配置文件

我们在主配置文件编写的时候，文件名可以是application-{profile}.properties/yml,用来指定多个环境版本；

例如：

application-test.properties代表测试环境配置

application-dev.properties代表开发环境配置

但是Springboot并不会直接启动这些配置文件，它默认使用application.properties主配置文件；

我们需要通过一个配置来选择需要激活的环境：

#比如在配置文件中指定使用dev环境，我们可以通过设置不同的端口号进行测试；#我们启动SpringBoot，就可以看到已经切换到dev下的配置了；spring.profiles.active=devyaml的多文档块

和properties配置文件中一样，但是使用yml去实现不需要创建多个配置文件，更加方便了!

server:port:8081#选择要激活那个环境块spring:profiles:active:prod---server:port:8083spring:profiles:dev#配置环境的名称---server:port:8084spring:profiles:prod#配置环境的名称注意：如果yml和properties同时都配置了端口，并且没有激活其他环境，默认会使用properties配置文件的！

配置文件加载位置

外部加载配置文件的方式十分多，我们选择最常用的即可，在开发的资源文件中进行配置！

官方外部配置文件说明参考文档

springboot启动会扫描以下位置的application.properties或者application.yml文件作为Springboot的默认配置文件：

优先级1：项目路径下的config文件夹配置文件优先级2：项目路径下配置文件优先级3：资源路径下的config文件夹配置文件优先级4：资源路径下配置文件优先级由高到底，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件；互补配置；

我们在最低级的配置文件中设置一个项目访问路径的配置来测试互补问题；

#配置项目的访问路径server.servlet.context-path=/kuang拓展，运维小技巧

指定位置加载配置文件

我们还可以通过spring.config.location来改变默认的配置文件位置

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；这种情况，一般是后期运维做的多，相同配置，外部指定的配置文件优先级最高

java-jarspring-boot-config.jar--spring.config.location=F:/application.properties5、自动配置原理配置文件到底能写什么？怎么写？

分析自动配置原理

我们以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理；

这就是自动装配的原理！

精髓

1、SpringBoot启动会加载大量的自动配置类

2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中；

3、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在在其中，我们就不需要再手动配置了）

4、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可；

xxxxAutoConfigurartion：自动配置类；给容器中添加组件

了解：@Conditional

@Conditional派生注解（Spring注解版原生的@Conditional作用）

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

那么多的自动配置类，必须在一定的条件下才能生效；也就是说，我们加载了这么多的配置类，但不是所有的都生效了。

我们怎么知道哪些自动配置类生效？

我们可以通过启用debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

#开启springboot的调试类debug=truePositivematches:（自动配置类启用的：正匹配）

Negativematches:（没有启动，没有匹配成功的自动配置类：负匹配）

Unconditionalclasses:（没有条件的类）

【演示：查看输出的日志】

掌握吸收理解原理，即可以不变应万变！

我们分析完毕了源码以及自动装配的过程，我们可以尝试自定义一个启动器来玩玩！

说明

启动器模块是一个空jar文件，仅提供辅助性依赖管理，这些依赖可能用于自动装配或者其他类库；

命名归约：

官方命名：

自定义命名：

编写启动器

1、在IDEA中新建一个空项目spring-boot-starter-diy

2、新建一个普通Maven模块：kuang-spring-boot-starter

3、新建一个Springboot模块：kuang-spring-boot-starter-autoconfigure

4、点击apply即可，基本结构

5、在我们的starter中导入autoconfigure的依赖！

com.kuangkuang-spring-boot-starter-autoconfigure0.0.1-SNAPSHOT6、将autoconfigure项目下多余的文件都删掉，Pom中只留下一个starter，这是所有的启动器基本配置！

7、我们编写一个自己的服务

publicclassHelloService{HelloPropertieshelloProperties;publicHelloPropertiesgetHelloProperties(){returnhelloProperties;}publicvoidsetHelloProperties(HelloPropertieshelloProperties){this.helloProperties=helloProperties;}publicStringsayHello(Stringname){returnhelloProperties.getPrefix()+name+helloProperties.getSuffix();}}8、编写HelloProperties配置类

//前缀kuang.hello@ConfigurationProperties(prefix="kuang.hello")publicclassHelloProperties{privateStringprefix;privateStringsuffix;publicStringgetPrefix(){returnprefix;}publicvoidsetPrefix(Stringprefix){this.prefix=prefix;}publicStringgetSuffix(){returnsuffix;}publicvoidsetSuffix(Stringsuffix){this.suffix=suffix;}}9、编写我们的自动配置类并注入bean，测试！

@Configuration@ConditionalOnWebApplication//web应用生效@EnableConfigurationProperties(HelloProperties.class)publicclassHelloServiceAutoConfiguration{@AutowiredHelloPropertieshelloProperties;@BeanpublicHelloServicehelloService(){HelloServiceservice=newHelloService();service.setHelloProperties(helloProperties);returnservice;}}10、在resources编写一个自己的META-INF\spring.factories

#AutoConfigureorg.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.kuang.HelloServiceAutoConfiguration11、编写完成后，可以安装到maven仓库中！

新建项目测试我们自己写的启动器

1、新建一个SpringBoot项目

2、导入我们自己写的启动器

com.kuangkuang-spring-boot-starter1.0-SNAPSHOT3、编写一个HelloController进行测试我们自己的写的接口！

@RestControllerpublicclassHelloController{@AutowiredHelloServicehelloService;@RequestMapping("/hello")publicStringhello(){returnhelloService.sayHello("zxc");}}4、编写配置文件application.properties

kuang.hello.prefix="ppp"kuang.hello.suffix="sss"5、启动项目进行测试，结果成功!

简介

好的，同学们，那么接下来呢，我们开始学习SpringBoot与Web开发，从这一章往后，就属于我们实战部分的内容了；

其实SpringBoot的东西用起来非常简单，因为SpringBoot最大的特点就是自动装配。

使用SpringBoot的步骤：

1、创建一个SpringBoot应用，选择我们需要的模块，SpringBoot就会默认将我们的需要的模块自动配置好

2、手动在配置文件中配置部分配置项目就可以运行起来了

3、专注编写业务代码，不需要考虑以前那样一大堆的配置了。

要熟悉掌握开发，之前学习的自动配置的原理一定要搞明白！

比如SpringBoot到底帮我们配置了什么？我们能不能修改？我们能修改哪些配置？我们能不能扩展？

没事就找找类，看看自动装配原理！

我们之后来进行一个单体项目的小项目测试，让大家能够快速上手开发！

静态资源映射规则

首先，我们搭建一个普通的SpringBoot项目，回顾一下HelloWorld程序！

写请求非常简单，那我们要引入我们前端资源，我们项目中有许多的静态资源，比如css，js等文件，这个SpringBoot怎么处理呢？

如果我们是一个web应用，我们的main下会有一个webapp，我们以前都是将所有的页面导在这里面的，对吧！但是我们现在的pom呢，打包方式是为jar的方式，那么这种方式SpringBoot能不能来给我们写页面呢？当然是可以的，但是SpringBoot对于静态资源放置的位置，是有规定的！

我们先来聊聊这个静态资源映射规则：

SpringBoot中，SpringMVC的web配置都在WebMvcAutoConfiguration这个配置类里面；

我们可以去看看WebMvcAutoConfigurationAdapter中有很多配置方法；

有一个方法：addResourceHandlers添加资源处理

什么是webjars呢？

Webjars本质就是以jar包的方式引入我们的静态资源，我们以前要导入一个静态资源文件，直接导入即可。

使用SpringBoot需要使用Webjars，我们可以去搜索一下：

要使用jQuery，我们只要要引入jQuery对应版本的pom依赖即可！

org.webjarsjquery3.4.1导入完毕，查看webjars目录结构，并访问Jquery.js文件！

第二种静态资源映射规则

那我们项目中要是使用自己的静态资源该怎么导入呢？我们看下一行代码；

我们去找staticPathPattern发现第二种映射规则：/**,访问当前的项目任意资源，它会去找resourceProperties这个类，我们可以点进去看一下分析：

//进入方法publicString[]getStaticLocations(){returnthis.staticLocations;}//找到对应的值privateString[]staticLocations=CLASSPATH_RESOURCE_LOCATIONS;//找到路径privatestaticfinalString[]CLASSPATH_RESOURCE_LOCATIONS={"classpath:/META-INF/resources/","classpath:/resources/","classpath:/static/","classpath:/public/"};ResourceProperties可以设置和我们静态资源有关的参数；这里面指向了它会去寻找资源的文件夹，即上面数组的内容。

所以得出结论，以下四个目录存放的静态资源可以被我们识别：

"classpath:/META-INF/resources/""classpath:/resources/""classpath:/static/""classpath:/public/"我们可以在resources根目录下新建对应的文件夹，都可以存放我们的静态文件；

自定义静态资源路径

我们也可以自己通过配置文件来指定一下，哪些文件夹是需要我们放静态资源文件的，在application.properties中配置；

spring.resources.static-locations=classpath:/coding/,classpath:/kuang/一旦自己定义了静态文件夹的路径，原来的自动配置就都会失效了！

静态资源文件夹说完后，我们继续向下看源码！可以看到一个欢迎页的映射，就是我们的首页！

@BeanpublicWelcomePageHandlerMappingwelcomePageHandlerMapping(ApplicationContextapplicationContext,FormattingConversionServicemvcConversionService,ResourceUrlProvidermvcResourceUrlProvider){WelcomePageHandlerMappingwelcomePageHandlerMapping=newWelcomePageHandlerMapping(newTemplateAvailabilityProviders(applicationContext),applicationContext,getWelcomePage(),//getWelcomePage获得欢迎页this.mvcProperties.getStaticPathPattern());welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService,mvcResourceUrlProvider));returnwelcomePageHandlerMapping;}点进去继续看

privateOptionalgetWelcomePage(){String[]locations=getResourceLocations(this.resourceProperties.getStaticLocations());//::是java8中新引入的运算符//Class::function的时候function是属于Class的，应该是静态方法。//this::function的funtion是属于这个对象的。//简而言之，就是一种语法糖而已，是一种简写returnArrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();}//欢迎页就是一个location下的的index.html而已privateResourcegetIndexHtml(Stringlocation){returnthis.resourceLoader.getResource(location+"index.html");}欢迎页，静态资源文件夹下的所有index.html页面；被/**映射。

关于网站图标说明：

与其他静态资源一样，SpringBoot在配置的静态内容位置中查找favicon.ico。如果存在这样的文件，它将自动用作应用程序的favicon。

1、关闭SpringBoot默认图标

#关闭默认图标spring.mvc.favicon.enabled=false2、自己放一个图标在静态资源目录下，我放在public目录下

3、清除浏览器缓存！刷新网页，发现图标已经变成自己的了！

模板引擎

前端交给我们的页面，是html页面。如果是我们以前开发，我们需要把他们转成jsp页面，jsp好处就是当我们查出一些数据转发到JSP页面以后，我们可以用jsp轻松实现数据的显示，及交互等。

jsp支持非常强大的功能，包括能写Java代码，但是呢，我们现在的这种情况，SpringBoot这个项目首先是以jar的方式，不是war，像第二，我们用的还是嵌入式的Tomcat，所以呢，他现在默认是不支持jsp的。

那不支持jsp，如果我们直接用纯静态页面的方式，那给我们开发会带来非常大的麻烦，那怎么办呢？

SpringBoot推荐你可以来使用模板引擎：

模板引擎，我们其实大家听到很多，其实jsp就是一个模板引擎，还有用的比较多的freemarker，包括SpringBoot给我们推荐的Thymeleaf，模板引擎有非常多，但再多的模板引擎，他们的思想都是一样的，什么样一个思想呢我们来看一下这张图：

模板引擎的作用就是我们来写一个页面模板，比如有些值呢，是动态的，我们写一些表达式。而这些值，从哪来呢，就是我们在后台封装一些数据。然后把这个模板和这个数据交给我们模板引擎，模板引擎按照我们这个数据帮你把这表达式解析、填充到我们指定的位置，然后把这个数据最终生成一个我们想要的内容给我们写出去，这就是我们这个模板引擎，不管是jsp还是其他模板引擎，都是这个思想。只不过呢，就是说不同模板引擎之间，他们可能这个语法有点不一样。其他的我就不介绍了，我主要来介绍一下SpringBoot给我们推荐的Thymeleaf模板引擎，这模板引擎呢，是一个高级语言的模板引擎，他的这个语法更简单。而且呢，功能更强大。

我们呢，就来看一下这个模板引擎，那既然要看这个模板引擎。首先，我们来看SpringBoot里边怎么用。

引入Thymeleaf

怎么引入呢，对于springboot来说，什么事情不都是一个start的事情嘛，我们去在项目中引入一下。给大家三个网址：

Spring官方文档：找到我们对应的版本

找到对应的pom依赖：可以适当点进源码看下本来的包！

org.springframework.bootspring-boot-starter-thymeleafMaven会自动下载jar包，我们可以去看下下载的东西；

Thymeleaf分析

前面呢，我们已经引入了Thymeleaf，那这个要怎么使用呢？

我们首先得按照SpringBoot的自动配置原理看一下我们这个Thymeleaf的自动配置规则，在按照那个规则，我们进行使用。

我们去找一下Thymeleaf的自动配置类：ThymeleafProperties

@ConfigurationProperties(prefix="spring.thymeleaf")publicclassThymeleafProperties{privatestaticfinalCharsetDEFAULT_ENCODING;publicstaticfinalStringDEFAULT_PREFIX="classpath:/templates/";publicstaticfinalStringDEFAULT_SUFFIX=".html";privatebooleancheckTemplate=true;privatebooleancheckTemplateLocation=true;privateStringprefix="classpath:/templates/";privateStringsuffix=".html";privateStringmode="HTML";privateCharsetencoding;}我们可以在其中看到默认的前缀和后缀！

我们只需要把我们的html页面放在类路径下的templates下，thymeleaf就可以帮我们自动渲染了。

使用thymeleaf什么都不需要配置，只需要将他放在指定的文件夹下即可！

测试：

1、编写一个TestController

@ControllerpublicclassTestController{@RequestMapping("/t1")publicStringtest1(){//classpath:/templates/test.htmlreturn"test";}}2、编写一个测试页面test.html放在templates目录下

测试页面

Thymeleaf语法学习

要学习语法，还是参考官网文档最为准确，我们找到对应的版本看一下；

我们做个最简单的练习：我们需要查出一些数据，在页面中展示

1、修改测试请求，增加数据传输；

@RequestMapping("/t1")publicStringtest1(Modelmodel){//存入数据model.addAttribute("msg","Hello,Thymeleaf");//classpath:/templates/test.htmlreturn"test";}2、我们要使用thymeleaf，需要在html文件中导入命名空间的约束，方便提示。

我们可以去官方文档的#3中看一下命名空间拿来过来：

OK，入门搞定，我们来认真研习一下Thymeleaf的使用语法！

1、我们可以使用任意的th:attr来替换Html中原生属性的值！

2、我们能写哪些表达式呢？

1、我们编写一个Controller，放一些数据

@RequestMapping("/t2")publicStringtest2(Mapmap){//存入数据map.put("msg","

Hello

我们看完语法，很多样式，我们即使现在学习了，也会忘记，所以我们在学习过程中，需要使用什么，根据官方文档来查询，才是最重要的，要熟练使用官方文档！

官网阅读

在进行项目编写前，我们还需要知道一个东西，就是SpringBoot对我们的SpringMVC还做了哪些配置，包括如何扩展，如何定制。

只有把这些都搞清楚了，我们在之后使用才会更加得心应手。途径一：源码分析，途径二：官方文档！

ContentNegotiatingViewResolver内容协商视图解析器

自动配置了ViewResolver，就是我们之前学习的SpringMVC的视图解析器；

即根据方法的返回值取得视图对象（View），然后由视图对象决定如何渲染（转发，重定向）。

我们去看看这里的源码：我们找到WebMvcAutoConfiguration，然后搜索ContentNegotiatingViewResolver。找到如下方法！

@Bean@ConditionalOnBean(ViewResolver.class)@ConditionalOnMissingBean(name="viewResolver",value=ContentNegotiatingViewResolver.class)publicContentNegotiatingViewResolverviewResolver(BeanFactorybeanFactory){ContentNegotiatingViewResolverresolver=newContentNegotiatingViewResolver();resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));//ContentNegotiatingViewResolver使用所有其他视图解析器来定位视图，因此它应该具有较高的优先级resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);returnresolver;}我们可以点进这类看看！找到对应的解析视图的代码；

@Nullable//注解说明：@Nullable即参数可为nullpublicViewresolveViewName(StringviewName,Localelocale)throwsException{RequestAttributesattrs=RequestContextHolder.getRequestAttributes();Assert.state(attrsinstanceofServletRequestAttributes,"NocurrentServletRequestAttributes");ListrequestedMediaTypes=this.getMediaTypes(((ServletRequestAttributes)attrs).getRequest());if(requestedMediaTypes!=null){//获取候选的视图对象ListcandidateViews=this.getCandidateViews(viewName,locale,requestedMediaTypes);//选择一个最适合的视图对象，然后把这个对象返回ViewbestView=this.getBestView(candidateViews,requestedMediaTypes,attrs);if(bestView!=null){returnbestView;}}//.....}我们继续点进去看，他是怎么获得候选的视图的呢？

getCandidateViews中看到他是把所有的视图解析器拿来，进行while循环，挨个解析！

Iteratorvar5=this.viewResolvers.iterator();所以得出结论：ContentNegotiatingViewResolver这个视图解析器就是用来组合所有的视图解析器的

我们再去研究下他的组合逻辑，看到有个属性viewResolvers，看看它是在哪里进行赋值的！

protectedvoidinitServletContext(ServletContextservletContext){//这里它是从beanFactory工具中获取容器中的所有视图解析器//ViewRescolver.class把所有的视图解析器来组合的CollectionmatchingBeans=BeanFactoryUtils.beansOfTypeIncludingAncestors(this.obtainApplicationContext(),ViewResolver.class).values();ViewResolverviewResolver;if(this.viewResolvers==null){this.viewResolvers=newArrayList(matchingBeans.size());}//...............}既然它是在容器中去找视图解析器，我们是否可以猜想，我们就可以去实现一个视图解析器了呢？

我们可以自己给容器中去添加一个视图解析器；这个类就会帮我们自动的将它组合进来；我们去实现一下

1、我们在我们的主程序中去写一个视图解析器来试试；

@Bean//放到bean中publicViewResolvermyViewResolver(){returnnewMyViewResolver();}//我们写一个静态内部类，视图解析器就需要实现ViewResolver接口privatestaticclassMyViewResolverimplementsViewResolver{@OverridepublicViewresolveViewName(Strings,Localelocale)throwsException{returnnull;}}2、怎么看我们自己写的视图解析器有没有起作用呢？

我们给DispatcherServlet中的doDispatch方法加个断点进行调试一下，因为所有的请求都会走到这个方法中

3、我们启动我们的项目，然后随便访问一个页面，看一下Debug信息；

找到this

找到视图解析器，我们看到我们自己定义的就在这里了；

所以说，我们如果想要使用自己定制化的东西，我们只需要给容器中添加这个组件就好了！剩下的事情SpringBoot就会帮我们做了！

转换器和格式化器

找到格式化转换器：

@Bean@OverridepublicFormattingConversionServicemvcConversionService(){//拿到配置文件中的格式化规则WebConversionServiceconversionService=newWebConversionService(this.mvcProperties.getDateFormat());addFormatters(conversionService);returnconversionService;}点进去：

publicStringgetDateFormat(){returnthis.dateFormat;}/***Dateformattouse.Forinstance,`dd/MM/yyyy`.默认的*/privateStringdateFormat;可以看到在我们的Properties文件中，我们可以进行自动配置它！

如果配置了自己的格式化方式，就会注册到Bean中生效，我们可以在配置文件中配置日期格式化的规则：

spring.mvc.date-format=其余的就不一一举例了，大家可以下去多研究探讨即可！

修改SpringBoot的默认配置

这么多的自动配置，原理都是一样的，通过这个WebMVC的自动配置原理分析，我们要学会一种学习方式，通过源码探究，得出结论；这个结论一定是属于自己的，而且一通百通。

SpringBoot的底层，大量用到了这些设计细节思想，所以，没事需要多阅读源码！得出结论；

SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（如果用户自己配置@bean），如果有就用用户配置的，如果没有就用自动配置的；

如果有些组件可以存在多个，比如我们的视图解析器，就将用户配置的和自己默认的组合起来！

扩展使用SpringMVC官方文档如下：

IfyouwanttokeepSpringBootMVCfeaturesandyouwanttoaddadditionalMVCconfiguration(interceptors,formatters,viewcontrollers,andotherfeatures),youcanaddyourown@ConfigurationclassoftypeWebMvcConfigurerbutwithout@EnableWebMvc.IfyouwishtoprovidecustominstancesofRequestMappingHandlerMapping,RequestMappingHandlerAdapter,orExceptionHandlerExceptionResolver,youcandeclareaWebMvcRegistrationsAdapterinstancetoprovidesuchcomponents.

我们要做的就是编写一个@Configuration注解类，并且类型要为WebMvcConfigurer，还不能标注@EnableWebMvc注解；我们去自己写一个；我们新建一个包叫config，写一个类MyMvcConfig；

//应为类型要求为WebMvcConfigurer，所以我们实现其接口//可以使用自定义类扩展MVC的功能@ConfigurationpublicclassMyMvcConfigimplementsWebMvcConfigurer{@OverridepublicvoidaddViewControllers(ViewControllerRegistryregistry){//浏览器发送/test，就会跳转到test页面；registry.addViewController("/test").setViewName("test");}}我们去浏览器访问一下：

确实也跳转过来了！所以说，我们要扩展SpringMVC，官方就推荐我们这么去使用，既保SpringBoot留所有的自动配置，也能用我们扩展的配置！

我们可以去分析一下原理：

1、WebMvcAutoConfiguration是SpringMVC的自动配置类，里面有一个类WebMvcAutoConfigurationAdapter

2、这个类上有一个注解，在做其他自动配置时会导入：@Import(EnableWebMvcConfiguration.class)

3、我们点进EnableWebMvcConfiguration这个类看一下，它继承了一个父类：DelegatingWebMvcConfiguration

这个父类中有这样一段代码：

publicclassDelegatingWebMvcConfigurationextendsWebMvcConfigurationSupport{privatefinalWebMvcConfigurerCompositeconfigurers=newWebMvcConfigurerComposite();//从容器中获取所有的webmvcConfigurer@Autowired(required=false)publicvoidsetConfigurers(Listconfigurers){if(!CollectionUtils.isEmpty(configurers)){this.configurers.addWebMvcConfigurers(configurers);}}}4、我们可以在这个类中去寻找一个我们刚才设置的viewController当做参考，发现它调用了一个

protectedvoidaddViewControllers(ViewControllerRegistryregistry){this.configurers.addViewControllers(registry);}5、我们点进去看一下

全面接管SpringMVC

官方文档：

IfyouwanttotakecompletecontrolofSpringMVCyoucanaddyourown@Configurationannotatedwith@EnableWebMvc.全面接管即：SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己去配置！

只需在我们的配置类中要加一个@EnableWebMvc。

我们看下如果我们全面接管了SpringMVC了，我们之前SpringBoot给我们配置的静态资源映射一定会无效，我们可以去测试一下；

不加注解之前，访问首页：正常访问

给配置类加上注解：@EnableWebMvc

我们发现所有的SpringMVC自动配置都失效了！回归到了最初的样子；

当然，我们开发中，不推荐使用全面接管SpringMVC

思考问题？为什么加了一个注解，自动配置就失效了！我们看下源码：

1、这里发现它是导入了一个类，我们可以继续进去看

@Import({DelegatingWebMvcConfiguration.class})public@interfaceEnableWebMvc{}2、它继承了一个父类WebMvcConfigurationSupport

publicclassDelegatingWebMvcConfigurationextendsWebMvcConfigurationSupport{//......}3、我们来回顾一下Webmvc自动配置类

@Configuration(proxyBeanMethods=false)@ConditionalOnWebApplication(type=Type.SERVLET)@ConditionalOnClass({Servlet.class,DispatcherServlet.class,WebMvcConfigurer.class})//这个注解的意思就是：容器中没有这个组件的时候，这个自动配置类才生效@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE+10)@AutoConfigureAfter({DispatcherServletAutoConfiguration.class,TaskExecutionAutoConfiguration.class,ValidationAutoConfiguration.class})publicclassWebMvcAutoConfiguration{}总结一句话：@EnableWebMvc将WebMvcConfigurationSupport组件导入进来了；

而导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能！

在SpringBoot中会有非常多的扩展配置，只要看见了这个，我们就应该多留心注意~

#1.前端搞定：页面长什么样子：数据#2.设计数据库（数据库设计难点！）#3.前端让他能够自动运行，独立化工程#4.数据接口如何对接：json，对象allinone！#5.前后端联调测试！1.有一套自己熟悉的后台模板：工作必要！x-admin2.前端界面：至少自己能够通过前端框架，组合出来一个网站页面 -index -about -blog -post -user3.让这个网站能够独立运行！一个月！10.1、首页实现首页配置：注意点，所有页面的静态资源都需要使用thymeleaf接管；@{}

有的时候，我们的网站会去涉及中英文甚至多语言的切换，这时候我们就需要学习国际化了！

先在IDEA中统一设置properties的编码问题！

配置文件编写

1、我们在resources资源文件下新建一个i18n目录，存放国际化配置文件

2、建立一个login.properties文件，还有一个login_zh_CN.properties；发现IDEA自动识别了我们要做国际化操作；文件夹变了！

3、我们可以在这上面去新建一个文件；

我们再添加一个英文的；

这样就快捷多了！

在IDEA插件中搜索ResourceBundleEditor并安装！

4、接下来，我们就来编写配置，我们可以看到idea下面有另外一个视图；

这个视图我们点击+号就可以直接添加属性了；我们新建一个login.tip，可以看到边上有三个文件框可以输入

我们添加一下首页的内容！

然后依次添加其他页面内容即可！

然后去查看我们的配置文件；

login.properties：默认

login.btn=Pleasesigninlogin.password=passwordlogin.remember=Remembermelogin.tip=Pleasesigninlogin.username=UserName中文：

配置文件生效探究

我们去看一下SpringBoot对国际化的自动配置！这里又涉及到一个类：MessageSourceAutoConfiguration

里面有一个方法，这里发现SpringBoot已经自动配置好了管理我们国际化资源文件的组件ResourceBundleMessageSource；

//获取properties传递过来的值进行判断@BeanpublicMessageSourcemessageSource(MessageSourcePropertiesproperties){ResourceBundleMessageSourcemessageSource=newResourceBundleMessageSource();if(StringUtils.hasText(properties.getBasename())){//设置国际化文件的基础名（去掉语言国家代码的）messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));}if(properties.getEncoding()!=null){messageSource.setDefaultEncoding(properties.getEncoding().name());}messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());DurationcacheDuration=properties.getCacheDuration();if(cacheDuration!=null){messageSource.setCacheMillis(cacheDuration.toMillis());}messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());returnmessageSource;}我们真实的情况是放在了i18n目录下，所以我们要去配置这个messages的路径；

spring.messages.basename=i18n.login配置页面国际化值

去页面获取国际化的值，查看Thymeleaf的文档，找到message取值操作为：#{...}。我们去页面测试下：

IDEA还有提示，非常智能的！

我们可以去启动项目，访问一下，发现已经自动识别为中文的了！

但是我们想要更好！可以根据按钮自动切换中文英文！

配置国际化解析

在Spring中有一个国际化的Locale（区域信息对象）；里面有一个叫做LocaleResolver（获取区域信息对象）的解析器！

我们去我们webmvc自动配置文件，寻找一下！看到SpringBoot默认配置：

@Bean@ConditionalOnMissingBean@ConditionalOnProperty(prefix="spring.mvc",name="locale")publicLocaleResolverlocaleResolver(){//容器中没有就自己配，有的话就用用户配置的if(this.mvcProperties.getLocaleResolver()==WebMvcProperties.LocaleResolver.FIXED){returnnewFixedLocaleResolver(this.mvcProperties.getLocale());}//接收头国际化分解AcceptHeaderLocaleResolverlocaleResolver=newAcceptHeaderLocaleResolver();localeResolver.setDefaultLocale(this.mvcProperties.getLocale());returnlocaleResolver;}AcceptHeaderLocaleResolver这个类中有一个方法

publicLocaleresolveLocale(HttpServletRequestrequest){LocaledefaultLocale=this.getDefaultLocale();//默认的就是根据请求头带来的区域信息获取Locale进行国际化if(defaultLocale!=null&&request.getHeader("Accept-Language")==null){returndefaultLocale;}else{LocalerequestLocale=request.getLocale();ListsupportedLocales=this.getSupportedLocales();if(!supportedLocales.isEmpty()&&!supportedLocales.contains(requestLocale)){LocalesupportedLocale=this.findSupportedLocale(request,supportedLocales);if(supportedLocale!=null){returnsupportedLocale;}else{returndefaultLocale!=nulldefaultLocale:requestLocale;}}else{returnrequestLocale;}}}那假如我们现在想点击链接让我们的国际化资源生效，就需要让我们自己的Locale生效！

我们去自己写一个自己的LocaleResolver，可以在链接上携带区域信息！

修改一下前端页面的跳转连接：

@BeanpublicLocaleResolverlocaleResolver(){returnnewMyLocaleResolver();}我们重启项目，来访问一下，发现点击按钮可以实现成功切换！搞定收工！

设置指定错误页面：可以设置程序错误时转到指定的页面，只需在templates文件夹下新建error文件夹，再将指定的错误页面命名为指定错误类型，例如“404.html”，就会在出现该错误时自动转到指定页面

对于数据访问层，无论是SQL(关系型数据库)还是NOSQL(非关系型数据库)，SpringBoot底层都是采用SpringData的方式进行统一处理。SpringBoot底层都是采用SpringData的方式进行统一处理各种数据库，SpringData也是Spring中与SpringBoot、SpringCloud等齐名的知名项目。

创建测试项目测试数据源

JDBCTemplate

JdbcTemplate主要提供以下几类方法：

测试

编写一个Controller，注入jdbcTemplate，编写测试方法进行访问测试；

@RestControllerpublicclassJDBCController{@AutowiredJdbcTemplatejdbcTemplate;//查询数据库的所有信息//没有实体类，数据库中的东西，怎么获取？Map@GetMapping("/userList")publicList>userList(){Stringsql="select*fromuser";List>list_maps=jdbcTemplate.queryForList(sql);returnlist_maps;}@GetMapping("/addUser")publicStringaddUser(){Stringsql="insertintomybatis.user(id,name,pwd)values(5,'小明','123456')";jdbcTemplate.update(sql);return"addUser-ok";}@GetMapping("/updateUser/{id}")publicStringupdateUser(@PathVariable("id")intid){Stringsql="updatemybatis.usersetname=,pwd=whereid="+id;//封装Object[]objects=newObject[2];objects[0]="小明2";objects[1]="zzzzzz";jdbcTemplate.update(sql,objects);return"update-ok";}@GetMapping("/deleteUser/{id}")publicStringdeleteUser(@PathVariable("id")intid){Stringsql="deletefrommybatis.userwhereid=";jdbcTemplate.update(sql,id);return"delete-ok";}}测试请求，结果正常；

到此，CURD的基本操作，使用JDBC就搞定了。

集成Druid

Druid简介

Java程序很大一部分要操作数据库，为了提高性能操作数据库的时候，又不得不使用数据库连接池。

Druid是阿里巴巴开源平台上一个数据库连接池实现，结合了C3P0、DBCP等DB池的优点，同时加入了日志监控。

Druid可以很好的监控DB池连接和SQL的执行情况，天生就是针对监控而生的DB连接池。

Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。

SpringBoot2.0以上默认使用Hikari数据源，可以说Hikari与Driud都是当前JavaWeb上最优秀的数据源，我们来重点介绍SpringBoot如何集成Druid数据源，如何实现数据库监控。

com.alibaba.druid.pool.DruidDataSource基本配置参数如下：

配置数据源

配置Druid数据源监控

Druid数据源具有监控的功能，并提供了一个web界面方便用户查看，类似安装路由器时，人家也提供了一个默认的web页面。

配置Druidweb监控filter过滤器

//配置Druid监控之web监控的filter//WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计@BeanpublicFilterRegistrationBeanwebStatFilter(){FilterRegistrationBeanbean=newFilterRegistrationBean();bean.setFilter(newWebStatFilter());//exclusions：设置哪些请求进行过滤排除掉，从而不进行统计MapinitParams=newHashMap<>();initParams.put("exclusions","*.js,*.css,/druid/*,/jdbc/*");bean.setInitParameters(initParams);//"/*"表示过滤所有请求bean.setUrlPatterns(Arrays.asList("/*"));returnbean;}平时在工作中，按需求进行配置即可，主要用作监控！

整合测试

我们增加一个员工类再测试下，为之后做准备

安全简介

市面上存在比较有名的：Shiro，SpringSecurity！

SpringSecurity是一个功能强大且高度可定制的身份验证和访问控制框架。它实际上是保护基于spring的应用程序的标准。

从官网的介绍中可以知道这是一个权限框架。想我们之前做项目是没有使用框架是怎么控制权限的？对于权限一般会细分为功能权限，访问权限，和菜单权限。代码会写的非常的繁琐，冗余。

怎么解决之前写权限代码繁琐，冗余的问题，一些主流框架就应运而生而SpringScecurity就是其中的一种。

SpringSecurity是针对Spring项目的安全框架，也是SpringBoot底层安全模块默认的技术选型，他可以实现强大的Web安全控制，对于安全控制，我们仅需要引入spring-boot-starter-security模块，进行少量的配置，即可实现强大的安全管理！

记住几个类：

“认证”（Authentication）

身份验证是关于验证您的凭据，如用户名/用户ID和密码，以验证您的身份。

身份验证通常通过用户名和密码完成，有时与身份验证因素结合使用。

这个概念是通用的，而不是只在SpringSecurity中存在。

Swagger简介

前后端分离

产生的问题

解决方案

Swagger

SpringBoot集成Swagger

SpringBoot集成Swagger=>springfox，两个jar包

使用Swagger

要求：jdk1.8+否则swagger2无法运行

步骤：

配置Swagger

配置扫描接口

配置Swagger开关

配置API分组

实体配置

常用注解

Swagger的所有注解定义在io.swagger.annotations包下

下面列一些经常用到的，未列举出来的可以另行查阅说明：

我们也可以给请求的接口配置一些注释

@ApiOperation("狂神的接口")@PostMapping("/kuang")@ResponseBodypublicStringkuang(@ApiParam("这个名字会被返回")Stringusername){returnusername;}这样的话，可以给一些比较难理解的属性或者接口，增加一些配置信息，让人更容易阅读！

相较于传统的Postman或Curl方式测试接口，使用swagger简直就是傻瓜式操作，不需要额外说明文档(写得好本身就是文档)而且更不容易出错，只需要录入数据然后点击Execute，如果再配合自动化框架，可以说基本就不需要人为操作了。

Swagger是个优秀的工具，现在国内已经有很多的中小型互联网公司都在使用它，相较于传统的要先出Word接口文档再测试的方式，显然这样也更符合现在的快速迭代开发行情。当然了，提醒下大家在正式环境要记得关闭Swagger，一来出于安全考虑二来也可以节省运行时内存。

拓展：其他皮肤

我们可以导入不同的包实现不同的皮肤定义：

前言：

在我们的工作中，常常会用到异步处理任务，比如我们在网站上发送邮件，后台会去发送邮件，此时前台会造成响应不动，直到邮件发送完毕，响应才会成功，所以我们一般会采用多线程的方式去处理这些任务。还有一些定时任务，比如需要在每天凌晨的时候，分析一次前一天的日志信息。

@RestControllerpublicclassAsyncController{@AutowiredAsyncServiceasyncService;@GetMapping("/hello")publicStringhello(){asyncService.hello();return"success";}}定时任务项目开发中经常需要执行一些定时任务，比如需要在每天凌晨的时候，分析一次前一天的日志信息，Spring为我们提供了异步执行任务调度的方式，提供了两个接口。

两个注解：

cron表达式：

邮件发送，在我们的日常开发中，也非常的多，Springboot也帮我们做了支持

什么是分布式系统？

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。

分布式系统（distributedsystem）是建立在网络之上的软件系统。

首先需要明确的是，只有当单个节点的处理能力无法满足日益增长的计算、存储任务的时候，且硬件的提升（加内存、加磁盘、使用更好的CPU）高昂到得不偿失的时候，应用程序也不能进一步优化的时候，我们才需要考虑分布式系统。因为，分布式系统要解决的问题本身就是和单机系统一样的，而由于分布式系统多节点、通过网络通信的拓扑结构，会引入很多单机系统没有的问题，为了解决这些问题又会引入更多的机制、协议，带来更多的问题。。。

Dubbo文档

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，急需一个治理系统确保架构有条不紊的演进。

在Dubbo的官网文档有这样一张图

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。

缺点：

1、性能扩展比较难

2、协同开发问题

3、不利于升级维护

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。

缺点：公用模块无法重复利用，开发性的浪费

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)[ServiceOrientedArchitecture]是关键。

RPC【RemoteProcedureCall】是指远程过程调用，是一种进程间通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。为什么要用RPC呢？就是无法在一个进程内，甚至一个计算机内通过本地调用的方式完成的需求，比如不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用。RPC就是要像调用本地的函数一样去调远程函数；

RPC基本原理

步骤解析：

RPC两个核心模块：通讯，序列化。

Dubbo

ApacheDubbo|db|是一款高性能、轻量级的开源JavaRPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

dubbo基本概念

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者

调用关系说明

Dubbo环境搭建

点进dubbo官方文档，推荐我们使用Zookeeper注册中心

Windows下安装zookeeper

[zk:127.0.0.1:2181(CONNECTED)4]ls/[zookeeper]我们再来查看一下节点

windows下安装dubbo-admin

dubbo本身并不是一个服务软件。它其实就是一个jar包，能够帮你的java程序连接到zookeeper，并利用zookeeper消费、提供服务。

但是为了让用户更好的管理监控众多的dubbo服务，官方提供了一个可视化的监控程序dubbo-admin，不过这个监控即使不装也不影响使用。

我们这里来安装一下：

1、下载dubbo-admin

2、解压进入目录

修改dubbo-admin\src\main\resources\application.properties指定zookeeper地址

server.port=7001spring.velocity.cache=falsespring.velocity.charset=UTF-8spring.velocity.layout-url=/templates/default.vmspring.messages.fallback-to-system-locale=falsespring.messages.basename=i18n/messagespring.root.password=rootspring.guest.password=guestdubbo.registry.address=zookeeper://127.0.0.1:21813、在项目目录下打包dubbo-admin

mvncleanpackage-Dmaven.test.skip=true第一次打包的过程有点慢，需要耐心等待！直到成功！

4、执行dubbo-admin\target下的dubbo-admin-0.0.1-SNAPSHOT.jar

java-jardubbo-admin-0.0.1-SNAPSHOT.jar【注意：zookeeper的服务一定要打开！】

框架搭建

1.启动zookeeper！

2.IDEA创建一个空项目；

3.创建一个模块，实现服务提供者：provider-server，选择web依赖即可

4.项目创建完毕，我们写一个服务，比如卖票的服务；

编写接口

publicinterfaceTicketService{publicStringgetTicket();}编写实现类

publicclassTicketServiceImplimplementsTicketService{@OverridepublicStringgetTicket(){return"《狂神说Java》";}}5.创建一个模块，实现服务消费者：consumer-server，选择web依赖即可

6.项目创建完毕，我们写一个服务，比如用户的服务；

编写service

packagecom.kuang.consumer.service;publicclassUserService{//我们需要去拿去注册中心的服务}需求：现在我们的用户想使用买票的服务，这要怎么弄呢？

服务提供者

1、将服务提供者注册到注册中心，我们需要整合Dubbo和zookeeper，所以需要导包

我们从dubbo官网进入github，看下方的帮助文档，找到dubbo-springboot，找到依赖包

#当前应用名字dubbo.application.name=provider-server#注册中心地址dubbo.registry.address=zookeeper://127.0.0.1:2181#扫描指定包下服务dubbo.scan.base-packages=com.kuang.provider.service3、在service的实现类中配置服务注解，发布服务！注意导包问题

@DubboService//将服务发布出去@Component//放在容器中publicclassTicketServiceImplimplementsTicketService{@OverridepublicStringgetTicket(){return"《狂神说Java》";}}逻辑理解：应用启动起来，dubbo就会扫描指定的包下带有@component注解的服务，将它发布在指定的注册中心中！

服务消费者

1、导入依赖，和之前的依赖一样；

#当前应用名字dubbo.application.name=consumer-server#注册中心地址dubbo.registry.address=zookeeper://127.0.0.1:21813、本来正常步骤是需要将服务提供者的接口打包，然后用pom文件导入，我们这里使用简单的方式，直接将服务的接口拿过来，路径必须保证正确，即和服务提供者相同；

4、完善消费者的服务类

@DubboService//注入到容器中publicclassUserService{@Reference//远程引用指定的服务，他会按照全类名进行匹配，看谁给注册中心注册了这个全类名TicketServiceticketService;publicvoidbugTicket(){Stringticket=ticketService.getTicket();System.out.println("在注册中心买到"+ticket);}}5、测试类编写；

@RunWith(SpringRunner.class)@SpringBootTestpublicclassConsumerServerApplicationTests{@AutowiredUserServiceuserService;@TestpublicvoidcontextLoads(){userService.bugTicket();}}启动测试

1.开启zookeeper

2.打开dubbo-admin实现监控【可以不用做】

3.开启服务者

4.消费者消费测试，结果输出“在注册中心买到《狂神说Java》”，监控中心可以监控到服务者service

ok,这就是SpingBoot+dubbo+zookeeper实现分布式开发的应用，其实就是一个服务拆分的思想；