Springboot基础介绍

1.快速上手SpringBoot

• 1.创建一个springboot项目（太简单了省略）

• 2.开发控制器类（基于Rest模式的开发控制器）–（建立一个controller层，新建BookController类）

//Rest模式
@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping
    public String getById(){
        System.out.println("控制器会显示这行");
        return "网页上会显示这行";
    }
}

入门案例制作的SpringMVC的控制器基于Rest风格开发，当然此处使用原始格式制作SpringMVC的程序也是没有问题的，上例中的**@RestController与@GetMapping注解是基于Restful**开发的典型注解。（Restful是SpringMVC的知识）

• 3.运行自动生成的Application类

注意：Tomcat服务器没有配置，Spring也没有配置，什么都没有配置竟然能运行！这就是SpringBoot技术的强大之处。关于内部工作流程后面再说，先专心学习开发过程

注意这张图片信息：运行的信息中包含了8080的端口，Tomcat这种熟悉的字样，难道这里启动了Tomcat服务器？是的，这里已经启动了。那服务器没有配置，哪里来的呢？后面再说。现在你就可以通过浏览器访问请求的路径，测试功能是否工作正常了

访问路径： http://localhost:8080/books

但是我们目前只能看到两个文件：pom.xml和Application类（pom.xml后面再说）

Application类：

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

这个类功能很简单，就一句代码，前面运行程序就是运行的这个类。

通过上面的制作，我们不难发现，SpringBoot程序简直太好写了，几乎什么都没写，功能就有了，这也是SpringBoot技术为什么现在这么火的原因，和Spirng程序相比，SpringBoot程序在开发的过程中各个层面均具有优势。

总结

1. 开发SpringBoot程序可以根据向导进行联网快速制作
2. SpringBoot程序需要基于JDK8以上版本进行制作
3. SpringBoot程序中需要使用何种功能通过勾选选择技术，也可以手工添加对应的要使用的技术（后期讲解）
4. 运行SpringBoot程序通过运行Application程序入口进行

2.教你一招：在Idea中隐藏指定文件/文件夹（很实用）

创建SpringBoot工程时，使用SpringBoot向导也好，阿里云也罢，其实都是为了一个目的，得到一个标准的SpringBoot工程文件结构。这个时候就有新的问题出现了，标准的工程结构中包含了一些未知的文件夹，在开发的时候看起来特别别扭，这一节就来说说这些文件怎么处理。

处理方案无外乎两种，如果你对每一个文件/目录足够了解，没有用的完全可以删除掉，或者不删除，但是看着别扭，就设置文件为看不到就行了。删除不说了，直接Delete掉就好了，这一节说说如何隐藏指定的文件或文件夹信息。（要么删要么隐藏）

• 打开设置，【Files】→【Settings】

• 打开文件类型设置界面，【Editor】→【File Types】→【Ignored Files and Folders】，忽略文件或文件夹显示（我用的是中文版都一样）

• 添加你要隐藏的文件名称或文件夹名称，可以使用*号通配符，表示任意，设置完毕即可。到这里就做完了，其实就是Idea的一个小功能。

总结：Idea中隐藏指定文件或指定类型文件

1. 【Files】→【Settings】
2. 【Editor】→【File Types】→【Ignored Files and Folders】
3. 输入要隐藏的名称，支持*号通配符
4. 回车确认添加

3.SpringBoot简介

3.1Springboot介绍

SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

说到springboot，其实就是对spring进行了简化。

---

• Spring程序缺点：

1.依赖设置繁琐：以前写Spring程序，使用的技术都要自己一个一个的写，现在不需要了，如果做过原始SpringMVC程序的小伙伴应该知道，写SpringMVC程序，最基础的spring-web和spring-webmvc这两个坐标时必须的，就这还不包含你用json啊等等这些坐标，现在呢？一个坐标搞定。

2.配置繁琐：以前写配置类或者配置文件，然后用什么东西就要自己写加载bean这些东西，现在呢？什么都没写，照样能用

• SpringBoot程序的核心功能及优点：

1.起步依赖（简化依赖配置）：依赖配置的书写简化就是靠这个起步依赖达成的

2.自动配置（简化常用工程相关配置）：配置过于繁琐，使用自动配置就可以做响应的简化，但是内部还是很复杂的，后面具体展开说

3.辅助功能（内置服务器，……）：除了上面的功能，其实SpringBoot程序还有其他的一些优势，比如我们没有配置Tomcat服务器，但是能正常运行，这是SpringBoot程序的一个可以感知到的功能，也是SpringBoot的辅助功能之一。一个辅助功能都能做的这么6，太牛了

---

​ 下面结合入门程序来说说这些简化操作都在哪些方面进行体现的，一共分为4个方面

• parent
• starter
• 引导类
• 内嵌tomcat

3.2parent（类似一个规则）

SpringBoot关注到开发者在进行开发时，往往对依赖版本的选择具有固定的搭配格式，并且这些依赖版本的选择还不能乱搭配。比如A技术的2.0版与B技术的3.5版可以合作在一起，但是和B技术的3.7版合并使用时就有冲突。其实很多开发者都一直想做一件事情，就是将各种各样的技术配合使用的常见依赖版本进行收集整理，制作出了最合理的依赖版本配置方案，这样使用起来就方便多了。

3.3starter（类似一个组合）

SpringBoot关注到开发者在实际开发时，对于依赖坐标的使用往往都有一些固定的组合方式，比如使用spring-webmvc就一定要使用spring-web。每次都要固定搭配着写，非常繁琐，而且格式固定，没有任何技术含量。

SpringBoot一看这种情况，看来需要给开发者带来一些帮助了。安排，把所有的技术使用的固定搭配格式都给开发出来，以后你用某个技术，就不用一次写一堆依赖了，还容易写错，我给你做一个东西，代表一堆东西，开发者使用的时候，直接用我做好的这个东西就好了，对于这样的固定技术搭配，SpringBoot给它起了个名字叫做starter。

3.4starter与parent的区别（这两个都是配置）

朦朦胧胧中感觉starter与parent好像都是帮助我们简化配置的，但是功能又不一样，梳理一下。

parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的

starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的

个人理解（大白话）：比如一个矿泉水瓶，由瓶子和水组成，parent相当于定义500ml的瓶子，和500ml的水，正好装满，别人600ml的水就多了。（减少依赖冲突）starter相当于直接到超市买了一瓶水，瓶子和水已经是正好合适的。（减少依赖配置的书写量）

实际开发应用方式

​ SpringBoot官方给出了好多个starter的定义，方便我们使用，而且名称都是如下格式

命名规则：spring-boot-starter-技术名称

​ 所以以后见了spring-boot-starter-aaa这样的名字，这就是SpringBoot官方给出的starter定义。那非官方定义的也有吗？有的，具体命名方式到整合章节再说

总结

1. 开发SpringBoot程序需要导入坐标时通常导入对应的starter
2. 每个不同的starter根据功能不同，通常包含多个依赖坐标
3. 使用starter可以实现快速配置的效果，达到简化配置的目的

3.5引导类（推导bean）

配置说完了，我们发现SpringBoot确实帮助我们减少了很多配置工作，下面说一下程序是如何运行的。目前程序运行的入口就是SpringBoot工程创建时自带的那个类了，带有main方法的那个类，运行这个类就可以启动SpringBoot工程的运行

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

SpringBoot本身是为了加速Spring程序的开发的，而Spring程序运行的基础是需要创建自己的Spring容器对象（IoC容器）并将所有的对象交给Spring的容器管理，也就是一个一个的Bean。那SpringBoot加速开发Spring程序，这个容器还在吗？这个疑问不用说，一定在。当前这个类运行后就会产生一个Spring容器对象，并且可以将这个对象保存起来，通过容器对象直接操作Bean。

@SpringBootApplication
public class Springboot0101QuickstartApplication { 
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(Springboot0101QuickstartApplication.class, args);
        BookController bean = ctx.getBean(BookController.class);//拿bean有四种类型，getbean我们这次按类型拿，分别有1.名字2.类型3.名字+类型4.名字+赋值
        System.out.println("bean======>" + bean);
    }
}

​ 通过上述操作不难看出，其实SpringBoot程序启动还是创建了一个Spring容器对象。这个类在SpringBoot程序中是所有功能的入口，称这个类为引导类

​ 作为一个引导类最典型的特征就是当前类上方声明了一个注解**@SpringbootApplication**

总结

1. SpringBoot工程提供引导类用来启动程序
2. SpringBoot工程启动后创建并初始化Spring容器

思考

​ 程序现在已经运行了，通过引导类的main方法运行了起来。但是运行java程序不应该是执行完就结束了吗？但是我们现在明显是启动了一个web服务器啊，不然网页怎么能正常访问呢？这个服务器是在哪里写的呢？

3.6内嵌tomcat

当前我们做的SpringBoot入门案例勾选了Spirng-web的功能，并且导入了对应的starter。

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

SpringBoot发现，既然你要做web程序，肯定离不开使用web服务器，这样吧，帮人帮到底，送佛送到西。我帮你搞一个web服务器，你要愿意用的，直接使用就好了，干脆我再多给你几种选择，你随便切换。万一你不想用我给你提供的，也行，你可以自己搞。

由于这个功能不属于程序的主体功能，可用可不用，于是乎SpringBoot将其定位成辅助功能，别小看这么一个辅助功能，它可是帮我们开发者又减少了好多的设置性工作。

下面就围绕着这个内置的web服务器，也可以说是内置的tomcat服务器来研究几个问题

1. 这个服务器在什么位置定义的
2. 这个服务器是怎么运行的
3. 这个服务器如果想换怎么换？虽然这个需求很垃圾，搞得开发者会好多web服务器一样，用别人提供好的不香么？非要自己折腾

3.6.1内嵌Tomcat定义位置

说到定义的位置，我们就想，如果我们不开发web程序，用的着web服务器吗？肯定用不着啊。那如果这个东西被加入到你的程序中，伴随着什么技术进来的呢？肯定是web相关的功能啊，没错，就是前面导入的web相关的starter做的这件事。

说到定义的位置，我们就想，如果我们不开发web程序，用的着web服务器吗？肯定用不着啊。那如果这个东西被加入到你的程序中，伴随着什么技术进来的呢？肯定是web相关的功能啊，没错，就是前面导入的web相关的starter做的这件事。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>//点击这行
</dependency>

​ 打开查看web的starter导入了哪些东西

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>//点击这行
      <version>2.5.4</version>
      <scope>compile</scope>
  </dependency>

​ 第三个依赖就是这个tomcat对应的东西了，居然也是一个starter，再打开看看

<dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-websocket</artifactId>//看这行
        <version>9.0.52</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-annotations-api</artifactId>
                <groupId>org.apache.tomcat</groupId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

这里面有一个核心的坐标，tomcat-embed-core，叫做tomcat内嵌核心。就是这个东西把tomcat功能引入到了我们的程序中。目前解决了第一个问题，找到根儿了，谁把tomcat引入到程序中的？spring-boot-starter-web中的spring-boot-starter-tomcat做的。之所以你感觉很奇妙的原因就是，这个东西是默认加入到程序中了，所以感觉很神奇，居然什么都不做，就有了web服务器对应的功能，再来说第二个问题，这个服务器是怎么运行的

3.6.2内嵌Tomcat运行原理

Tomcat服务器是一款软件，而且是一款使用java语言开发的软件，熟悉的小伙伴可能有印象，tomcat安装目录中保存有jar，好多个jar。

下面的问题来了，既然是使用java语言开发的，运行的时候肯定符合java程序运行的原理，java程序运行靠的是什么？对象呀，一切皆对象，万物皆对象。那tomcat运行起来呢？也是对象。

如果是对象，那Spring容器是用来管理对象的，这个对象能不能交给Spring容器管理呢？把呢去掉，是个对象都可以交给Spring容器管理，行了，这下通了。tomcat服务器运行其实是以对象的形式在Spring容器中运行的，怪不得我们没有安装这个tomcat，而且还能用。闹了白天这东西最后是以一个对象的形式存在，保存在Spring容器中悄悄运行的。具体运行的是什么呢？其实就是上前面提到的那个tomcat内嵌核心

<dependencies>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>//tomcat内嵌核心
        <version>9.0.52</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

那既然是个对象，如果把这个对象从Spring容器中去掉是不是就没有web服务器的功能呢？是这样的，通过依赖排除可以去掉这个web服务器功能。不要的东西都可以用exclusions排除掉。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>//不要的东西都可以用exclusions排除掉
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

上面对web-starter做了一个操作，使用maven的排除依赖去掉了使用tomcat的starter。这下好了，容器中肯定没有这个对象了，重新启动程序可以观察到程序运行了，但是并没有像之前那样运行后会等着用户发请求，而是直接停掉了，就是这个原因了。

更换内嵌Tomcat

​ 那根据上面的操作我们思考是否可以换个服务器呢？必须的嘛。根据SpringBoot的工作机制，用什么技术，加入什么依赖就行了。SpringBoot提供了3款内置的服务器

• tomcat(默认)：apache出品，粉丝多，应用面广，负载了若干较重的组件

• jetty：更轻量级，负载性能远不及tomcat

• undertow：负载性能勉强跑赢tomcat

  想用哪个，加个坐标就OK。前提是把tomcat排除掉，因为tomcat是默认加载的。

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

​ 现在就已经成功替换了web服务器，核心思想就是用什么加入对应坐标就可以了。如果有starter，优先使用starter。

总结

1. 内嵌Tomcat服务器是SpringBoot辅助功能之一
2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理
3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器
4. Tomcat内嵌三款服务器：tomacat、jetty、undetow（小知识）

大白话总结：我们在依赖里加了（排除），把这个tomcat类似踢出去了。不要这个服务器了。但是还有备胎。不止一个服务器。我们再复制tomacat 的代码。把tomacat换成其他的服务器，比如jetty服务器，这样就可以去除现有服务器，添加全新的服务器。

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

---

到这里第一章快速上手SpringBoot就结束了，这一章我们学习了两大块知识

1. 使用了4种方式制作了SpringBoot的入门程序，不管是哪一种，其实内部都是一模一样的
2. 学习了入门程序的工作流程，知道什么是parent，什么是starter，这两个东西是怎么配合工作的，以及我们的程序为什么启动起来是一个tomcat服务器等等

第一章到这里就结束了，再往下学习就要去基于会创建SpringBoot工程的基础上，研究SpringBoot工程的具体细节了。

4.REST开发（SpringMVC的知识）

4.1REST简介

REST（Representational State Transfer）表现形态状态转换

• 传统风格资源描述形式（比如查一个用户的信息）

  http://localhost/user/getById?id=1 //问号传个id为1得到信息

  http://localhost/user/saveUser //现在对资源做个保存，就可以通过post提交，把表单提交给后台，也可以对资源进行操作，注意get和save。

• REST风格描述形式

  http://localhost/user/1 //比第一个简化好多，User资源id是1

  http://localhost/user //有人就奇怪了，这怎么能代表保存呢，因为通过post提交，外面看不到这个数据了。既保存又能修改。

优点：

• 隐藏资源的访问行为，无法通过地址得知对资源是何种操作（重要）
• 书写简化

4.2REST风格简介

按照REST风格访问资源时使用行为动作区分对资源进行了何种操作

• http://localhost/users //查询全部用户信息 GET（查询）

• http://localhost/user/1 //查询指定用户信息 GET（查询）

• http://localhost/users //添加用户信息 POST（新增/保存）

• http://localhost/users //修改用户信息 PUT（修改/更新）

• http://localhost/users/1 // 删除用户信息 DELETE（删除）

• • 根据REST风格对资源进行访问称为RESTFUL

1和3和4、2和5路径都是一样的，那我们怎么区分，就要看到后面的请求方式get、post、put、delete进行区分。

注意事项：上述行为是约定方式，约定不是规范，可以打破，所以被称为REST风格，而不是REST规范，描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users、books、accounts….(类似一个指导思想，所以叫做风格，但经过长时间，风格也慢慢成了规范。)

总结：

4.3REST案例

1.设定http请求动作（动词）

2.设定请求参数（路径变量）

4.4注解

@RequstMapping

• 名称：**@RequstMapping**
• 类型：方法注解
• 位置：SpringMVC控制器方法定义上方
• 作用：设置当前控制器方法请求访问路径
• 范例：

• 属性：
• • value（默认）：请求访问路径
  • method：http请求动作，标准动作（GET/POST/PUT/DELETE）

@PathVariable

• 名称：**@PathVariable**
• 类型：形参注解
• 位置：SpringMVC控制器方法形参定义前面
• 作用：绑定路径参数与处理器方法形参间的关系，要求路径参数名一一对应
• 范例：

4.5@RequestBody、@RequestParam、@RequestParam关系（接收参数三种方式）

@RequestBody：****接我们请求体参数，也就是json用它来传

@RequestParam：接我们路径参数，包括表单提交都用它

@PathVariable：接我们路径变量的

区别：

• @RequestParam用于接收url地址传参或表单传参
• @RequestBody用于接收json数据
• @PathVariable用于接收路径参数，使用（参数名称）描述路径参数

应用：

• 后期开发中，发送请求参数超过1个小时，以json为主，@RequestBody应用较广
• 如果发送非json格式数据，选用@RequestParam接收请求参数
• 采用RESTful进行开发，当参数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值

4.6RESTful快速开发（简化开发）

@RestController

• 名称：RestController
• 类型：类注解
• 位置：基于SpringMVC的RESTful开发控制器类定义上方
• 作用：设置当前控制器类为RESTful风格，等于@Controller+@ResponseBody两个注解组合功能
• 范例：

• 属性
  • value(默认)：请求访问路径