SpringBoot的基本使用

1、Springboot的基本介绍

先介绍一下 Spring：Spring是于2003 年兴起的一个轻量级的Java 开源框架，Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。

Spring 框架功能很强大，但是就算是一个很简单的项目，我们也要配置很多东西。因此就有了Spring Boot框架，它的作用很简单，就是帮我们自动配置。Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用。

Spring Boot框架的核心就是自动配置，只要存在相应的jar包，Spring就帮我们自动配置。如果默认配置不能满足需求，我们还可以替换掉自动配置类，使用我们自己的配置。另外，Spring Boot还集成了嵌入式的Web服务器，系统监控等很多有用的功，让我们快速构建企业及应用程序。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

Spring Boot的主要优点：

• 为所有Spring开发者更快的入门

• 开箱即用，提供各种默认配置来简化项目配置

• 内嵌式容器简化Web项目

• 没有冗余代码生成和XML配置的要求

1.1、SpringBoot的四大特性

1. SpringBoot Starter：他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的Maven或Gradle构建中；
2. 自动配置：SpringBoot的自动配置特性利用了Spring4对条件化配置的支持，合理地推测应用所需的bean并自动化配置他们；
3. 命令行接口：（Command-line-interface, CLI）：SpringBoot的CLI发挥了Groovy编程语言的优势，并结合自动配置进一步简化Spring应用的开发；
4. Actuatir：它为SpringBoot应用的所有特性构建一个小型的应用程序。但首先，我们快速了解每项特性，更好的体验他们如何简化Spring编程模型。

1.2、使用 Springboot 的好处

回顾我们之前的 SSM 项目，搭建过程还是比较繁琐的，需要：1、配置web.xml，加载spring和spring mvc。2、配置数据库连接、配置spring事务。3、配置加载配置文件的读取，开启注解。。。配置完成之后部署tomcat 调试。

而使用 Spring Boot 来开发项目则只需要非常少的几个配置就可以搭建起来一个 Web 项目，并且利用 IDEA 可以自动生成生成，

2、使用springboot

springboot 对系统的要求：Java 8 & 兼容java14，Maven 3.3+ 。

2.1、基于maven空模板创建springboot项目

下面示例的最终目录结构：

先通过 IDEA 建立一个简单的 maven 工程，不需要使用任何 maven 模板，然后添加依赖：

<?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>org.example</groupId>
    <artifactId>springbootTest01</artifactId>
    <version>1.0-SNAPSHOT</version>


    <!-- 所有的springboot的工程都以spring父工程为父工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

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

建一个 springboot 启动类：

package start;


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

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

所有的springboot application启动类都需要在类级别上加上@SpringBootApplication注解。

在启动类的当前包或者子包下建一个测试 controller 类：

package start.controller;

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

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

注意，springboot 默认扫描的的类是在启动类当前的包和下级包，所以如果 controller 类不在启动类的当前包或者子包下，则该组件无法被扫描出来。

然后直接执行启动类的 main 方法即可。

在输出日志中可以看到已经启动了内嵌的 tomcat ，并且默认端口号为 8080。

通过访问 http://localhost:8080/hello 可以看到上面接口的输出：

springboot 集成了Tomcat和Jetty，默认使用Tomcat作为应用容器，开发者只需要将工程打成jar包直接丢到服务器上就可以执行了，不需要再单独部署到was、jboss、tomcat这些应用服务器上。

2.2、基于Spring Initializr创建springboot项目

Spring官方提供了非常方便的工具 Spring Initializr 让我们快速构建应用，可以通过 IDEA 或者官网来使用该工具创建springboot项目。

2.2.1、通过 IDEA创建项目

我们可以通过 IDEA 创建 springboot 项目，在创建项目时选择 spring initializr：

然后填写项目基本信息：

在下一步勾选 web，选中 spring web即可：

初始化项目目录结构如下：

通过运行 SpringbootdemoApplication 类的 main 方法即可启动 springboot，然后就可以通过浏览器访问 http://localhost:8080/ 来访问项目了。

有一些无用的文件可以直接删掉，比如 .mvn、mvnw、mvnw.cmd 这些。

有时候通过IDEA创建项目可能比较慢，而且可能连接超时，此时我们可以在官网来创建初始化项目。

2.2.2、通过官网创建项目

我们可以通过访问官方网站来创建一个初始化项目，然后再将该项目拷贝下来进行修改。

1. 打开 https://start.spring.io/
2. 填写项目信息，记得在右边添加spring web依赖
3. 点击”Generate Project“按钮即可生成项目

类似下图：

3、springboot项目如何打jar包

springboot 项目中默认打包是会打成 jar 包的，打成 jar 包后我们可以直接在命令行中执行该 jar 包，无需再额外安装 tomcat 等 servlet 容器。

只需要在项目的 pom.xml 文件中添加插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

然后就可以通过 idea 打包了：

在执行 package 之前可以先执行一个 clean，清空一下旧的包。

打包完成后，可以看到在 target 目录中生成了一个 jar 包：

然后就可以在命令行中直接执行该 jar 包了，例如：java -jar springbootTest01-1.0-SNAPSHOT.jar

执行后 tomcat 就被启动成功了，在浏览器中访问 http://localhost:8888/hello 可以看到接口访问正常。

我们也可以通过编写一些脚本来启动和停止应用，参考：https://blog.csdn.net/qq_34491508/article/details/91490434

4、自定义配置文件

Spring Boot在底层已经把所需要的配置都给我们自动配置好了，当然，我们也可以通过使用配置文件来修改 SpringBoot 的配置。

springboot 配置文件的文件名是固定的：application.properties 或者是 application.yml，两种文件本质是一样的，区别只是两种文件的语法不同。

示例：

下面我们通过配置文件来修改 tomcat 的默认端口，首先在 resource 目录下新建一个 application.properties 文件，然后再该文件下配置 tomcat 的端口号：

然后重新启动启动类即可。由此我们就只能通过 8888 端口来访问接口了。

我们可以通过参考官网来知道如何通过哪些语法来修改所需配置：https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#application-properties

5、springboot 运行原理

5.1、依赖管理

所有的 springboot 项目都依赖一个父项目，主要是管理项目的资源过滤及插件！

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

从该父项目点进去，你会发现还有一个父依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

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

5.2、启动器

springboot-boot-starter-xxx 就是spring-boot的某个场景的启动器。

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

如上，spring-boot-starter-web 启动器就帮我们导入了web模块正常运行所依赖的组件。

SpringBoot 将所有的功能场景都抽取出来，做成一个个的 starter （启动器），只需要在项目中引入这些 starter 即可，所有相关的依赖都会导入进来 ， 我们要用什么功能就导入什么样的场景启动器即可 ；我们未来也可以自己自定义 starter。

6、容器功能

6.1、组件添加

在 springboot 的默认配置文件 properties 中已经包含了很多的默认配置，这些默认配置能够帮我们完成大部分的配置，但是不能通过 properties 配置 bean，这个时候可以用到 Springboot 中的 @Configuration 和 @Bean 来帮我们 bean 的构建。

@Configuration注解可以达到在Spring中使用xml配置文件的作用。@Configuration 用于定义配置类，可替换 spring 的 bean xml 配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被扫描，并用于构建 bean 定义，初始化Spring容器。

• @Configuration可理解为用spring的时候的xml文件。
• @Bean可理解为用spring的时候xml里面的bean标签。

使用 spring 时，我们通常通过一个类似于 bean.xml 的配置文件来配置 bean，如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!-- 配置创建的对象-->
    <bean id="user" class="test.User"></bean>
</beans>

下面通过 springboot 的 @Configuration 来替代 spring 中配置文件的写法：

先创建一个 User 类：

package test01.entity;

public class User {
    public void say() {
        System.out.println("hello");
    }
}

通过配置类来注册 bean：

//实际上配置类也会被注册为一个组件
@Configuration
public class MyConifg {

    // 通过 @Bean 注解来注册bean。
    // 以方法名作为组件的id，返回值就是组件在容器中的实例。默认是单例模式，即scope="singleton"
    @Bean
    public User testUser() {
        return new User();
    }
}

@Configuration标注在类上，相当于把该类作为 spring 的 xml 配置文件中的<beans>，作用是配置 spring 容器(应用上下文)。

然后就可以在启动类中获取 bean 了：

@SpringBootApplication
public class SpringbootStartApplication  {
    public static void main(String[] args) {

        //这里返回的是IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootStartApplication.class, args);

        User user =(User) run.getBean("testUser");
        user.say();

        User user2 =(User) run.getBean("testUser");
        System.out.println(user == user2);  //将输出true，因为通过bean获取到的对象都是单例对象
    }
}