持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第17天，点击查看活动详情

SpringBoot简介

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

那么它在哪里进行了简化呢？

让我们来回顾一下SpringMVC的开发：

1. 创建工程，并在 pom.xml 配置文件中配置所依赖的坐标

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
      
    <!--TODO 做springmvc开发的时候 web容器要用的 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
  <dependencies>

2. 编写 web3.0 的配置类
用于告诉Spring容器我的配置类在哪

package com.kaf.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;
import java.nio.charset.CharacterCodingException;

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
/* TODO 小知识点：getRootConfigClasses：根配置, getServletConfigClasses：专门应对Web请求的处理
ServletConfig造出来的容器对象 与 RootConfig造出来的容器对象 不是同一个对象。
但是SpringMVC的容器能访问Spring的容器，而Spring的容器不能访问SpringMVC的容器 （父子容器）

如果不想要有这中麻烦的话，直接把SpringConfig配置类放到 getServletConfigClasses()中
 */
    @Override
    // 加载Spring配置类
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    // 加载SpringMVC配置类
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    // 设置SpringMVC请求地址拦截规则
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    // 设置post请求中文乱码过滤器
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

3. 编写 SpringMVC 的配置类

package com.kaf.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Component // 标识该类为配置类
@ComponentScan({"com.kaf.controller", "com.kaf.config"}) //扫描Controller所在的包, 扫描config包下的SpringMvcSupport
@EnableWebMvc // 开启SpringMVC注解支持
public class SpringMvcConfig {
}

4. 编写 Controller 类

package com.kaf.controller;

import com.kaf.domain.Book;
import com.kaf.exception.BusinessException;
import com.kaf.exception.SystemException;
import com.kaf.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//TODO 统一每一个控制器方法的返回值 ==> 为了实现 表现层与前端数据传输间的统一格式
@RestController // @Controller + @ResponseBody
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) { // book从提交过来的json数据中获取 所以用 @RequestBody
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK : Code.SAVE_ERR, flag);
    }
}

前三步都是在搭建环境，而且这三步基本都是固定的，而SpringBoot 就是对这三步进行简化了。

1、SpringBoot快速入门

注意：在创建好的SpringBoot工程中并不需要创建配置类

1. 创建一个 Controller 控制类来实验一下（该项目并没有创建配置类）

package com.kaf.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // @Controller + @ResponseBody（不进行跳转）
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> " + id);
        return "hello, spring boot";
    }
}

2. 启动服务器 运行 SpringBoot 工程不需要使用本地的 Tomcat 和插件，只需要运行项目com.kaf 包下的 Application 类，我们就可以在控制台看出如下信息

通过上面的入门案例我们可以看到使用 SpringBoot进行开发，使整个开发变得很简单，那它是如何做到的呢？

Applicaion.java

package com.kaf;

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

@SpringBootApplication
public class Application {

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

}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	
	<!--指定了一个父工程，父工程中的东西在该工程中可以继承过来使用-->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.kaf</groupId>
	<artifactId>19_springboot_quick</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<!--TODO 作用：仅仅是取代上面的<artifactId>标签-->
	<name>19_springboot_quick</name>
	<description>Demo project for Spring Boot</description>

	<!--JDK 的版本-->
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<!--该依赖就是我们在创建 SpringBoot 工程勾选的那个 Spring Web 产生的-->
		<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>

我们代码之所以能简化，就是因为指定的父工程（因为子工程继承于父工程）和 Spring Web 依赖实现的。

3. Spring程序与SpringBoot程序对比

类/配置文件	Spring	SpringBoot
pom文件中的坐标	手工添加	勾选添加
web3.0配置类	手工制作	无
Spring/SpringMVC配置类	手工制作	无
控制器	手工制作	手工制作

注意：基于Idea的 Spring Initializr 快速构建 SpringBoot 工程时需要联网。

4. 快速启动SpringBoot工程 我们后端可以将 SpringBoot 工程打成 jar 包，该 jar 包运行不依赖于 Tomcat 和 Idea 这些工具也可以正常运行，只是这个 jar 包在运行过程中连接和我们自己程序相同的 Mysql 数据库即可。

那该如何打包呢？

首先先明确一点：任何的maven程序都可以执行package指令，也可以打成jar包。但是以前我们做的maven工程的jar包并不能使用java -jar指令进行快速启动程序。

然后，SpringBoot这个工程却可以，为什么呢？主要依赖于下面那个插件（1. 该插件不仅把我们的程序打成了jar包还把这个程序要用的jar包也都打包进去了（也就是：这个jar包包含其他jar包）。2. 该插件还设置了一个入口程序（也就是执行jar包时，走哪个类去运行））

由于我们在构建 SpringBoot 工程时已经在 pom.xml 中配置了如下插件

	<build>
		<plugins>
			<!-- 打包时需要用到的依赖 -->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

所以我们只需要使用 Maven 的 package 指令打包就会在 target 目录下生成对应的 Jar 包。

注意：该插件必须配置，不然打好的 jar 包也是有问题的。

如何启动呢？
进入 jar 包所在位置，在命令行窗口（cmd）中输入如下命令： jar -jar jar包名称

2、起步依赖

我们使用 Spring Initializr 方式创建的 Maven 工程的的 pom.xml 配置文件中自动生成了很多包含 starter 的依赖。 （即带有starter的依赖）

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<!--指定了一个父工程，父工程中的东西在该工程中可以继承过来使用-->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.kaf</groupId>
	<artifactId>19_springboot_quick</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<!--TODO 作用：仅仅是取代上面的<artifactId>标签-->
	<name>19_springboot_quick</name>
	<description>Demo project for Spring Boot</description>


	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<!--该依赖就是我们在创建 SpringBoot 工程勾选的那个 Spring Web 产生的-->
		<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>

由于我们的父工程里已经把所有的依赖全部都添加进去了，这就是为什么我们的工程不需要添加version的原因（因为SpringBoot帮我们处理好了）

结论：以后需要使用技术，只需要引入该技术对应的起步依赖即可

小结：

starter
- SpringBoot 中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的
parent
- 所有 SpringBoot 项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的
实际开发
- 使用任意坐标时，仅书写GAV中的G（groupid）和A（artifactId），V（version）由SpringBoot提供
- 如发生坐标错误，再指定version（要小心版本冲突)

PS：并不是用最新的SpringBoot就是最好的。每个版本的SpringBoot的依赖坐标都不同！要根据项目需要来确定SpringBoot的版本（如根据所需的Spring坐标来确定SpringBoot版本）

引导类

package com.kaf;

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

@SpringBootApplication
public class Application {

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

}

Application.java 即为引导类也叫启动类

注意：

SpringBoot 在创建项目时，采用jar的打包方式
SpringBoot 的引导类是项目的入口，运行 main 方法就可以启动项目 因为我们在 pom.xml 中配置了 spring-boot-starter-web 依赖，而该依赖，又依赖于 tomcat 。所以运行 main 方法就可以使用 tomcat 启动咱们的工程。

3. 切换web服务器 将SpringBoot内置的tomcat服务器排除出去

<dependencies>
		<!--该依赖就是我们在创建 SpringBoot 工程勾选的那个 Spring Web 产生的-->
		<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>

添加要切换的服务器

		<!-- 添加jetty的起步依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jetty</artifactId>
		</dependency>

由上述可知：如果想切换服务器，只需要在 SpringBoot 中导入该技术的起步依赖即可

SpringBoot学习笔记一之SpringBoot简介

SpringBoot简介

1、SpringBoot快速入门

2、起步依赖