Java研学-SpringBoot(二)

二 Spring Boot 介绍

1 简介

Spring Boot是由Pivotal团队提供的全新框架，主要目标是简化Spring应用程序的配置和部署过程，减少开发者在项目搭建和配置上的工作量，让开发者能够更专注于业务逻辑的实现。它使用特定的方式来进行配置，使开发人员不再需要定义样板化的配置，致力于在快速应用开发领域成为领导者。

2 特点

简化的配置：采用约定优于配置的方式，通过自动化配置和默认设置来简化开发者的配置工作，减少了繁琐的配置代码。

内嵌的Web容器：内置了多种常用的Web容器，如Tomcat、Jetty、Undertow等，使构建独立的Web应用程序变得更加简单。

自动化依赖管理：通过提供一系列的“starter”依赖，自动管理应用程序的依赖关系，从而简化了依赖管理的工作。

强大的开发者工具：提供了丰富的开发者工具，如热部署、自动重启、自动配置报告等，提高了开发效率。

外部化配置：支持使用外部配置文件来配置应用程序的属性，如数据库连接、日志配置等，使应用程序的配置更加灵活和可管理。

此外，Spring Boot还提供了健康检查和监控功能，可以监控应用程序的运行状态和性能指标，并确保应用程序在生产环境中的稳定性和可靠性。

总体而言，Spring Boot使得开发者可以更快速、更便捷地构建和部署Java应用程序，提高开发效率和项目的可维护性。它适用于各种类型的应用程序，包括Web应用、RESTful服务、批处理作业等。如需更多关于Spring Boot的详细信息，可以查阅Spring Boot的官方文档或相关教程。

三 Spring Boot 入门

1 创建 Spring Boot 工程

Spring Boot官方提供的工具来快速构建项目。IDEA 自带该功能，但需要联网使用。注意：官方提供的构建工具默认只能选择固定的版本，有些版本之间的差异非常大，所以如果需要选择某个版本可以自行在 pom.xml 文件中修改版本。
官网创建

IDEA创建

在这里插入图片描述

2 选定所需依赖

        <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>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

3 创建 HelloController

@Controller
@RequestMapping("hello")
public class HelloController {
    @RequestMapping
    @ResponseBody
    public String hello(){
        System.out.println("springboot!");
        return "springboot!";
    }
}

4 运行主启动类

SpringBoot不需配置xml文件与tomcat也可以访问http://localhost:8080/，启动类其实本质也是一个配置类

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

5 自动生成测试类

测试类贴有 @SpringBootTest 注解，可以通过通过注解属性指定加载的配置类，若没有指定，默认加载的是贴 @SpringBootApplication 注解的配置类

@SpringBootTest
class BootDemoApplicationTests {
    @Autowired
    private MyDatasource myDatasource;
    @Test
    void test1() {
        System.out.println(myDatasource);
    }
}

6 父工程启动器

springboot于pom中引用了父工程启动器，因为他的存在，导入大量的Maven依赖，简化开发，可通过追踪 spring-boot-starter-parent 到 spring-boot-dependencies 查看统一依赖版本管理(依赖传递)

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

7 阿里云脚手架

阿里云提供的脚手架，使用方式相同，更换地址即可

IDEA

8 手动创建 springboot

1. 创建Maven项目
2. 导入所需依赖
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
3. 编写Controller
@Controller
public class HelloController {
    @RequestMapping("/hi")
    @ResponseBody
    public String hi() {
        return "Hi Spring Boot";
    }
}
4. 编写启动类 启动类位置必须在后台所有项目的同一级或上一级(扫描当前包以及子包)
@SpringBootApplication
// 该注解包含 @ComponentScan 进行扫描
// 该注解包含 @SpringBootConfiguration 中的 @Configuration 故为配置类
public class BootApplication {
    public static void main(String[] args) {
        SpringApplication.run(BootApplication .class, args);
    }
}

9 父子工程

Spring Boot 提供了一个名为 spring-boot-starter-parent 的工程，其中对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，解决依赖的版本问题，需要什么依赖，直接引入坐标即可
继承是 Maven 中很强大的一种功能，继承使得子模块 pom 可以获得 parent 中的部分配置（groupId，version，dependencies，build，dependencyManagement 等），可以对子 pom 进行统一的配置和依赖管理。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
</parent>

parent(继承：父工程标签) 项目中的 dependencyManagement 里的声明的依赖，只具有声明的作用，并不实现引入，因此子项目需要显式的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且 version 和 scope 都读取自父 pom；另外若子项目中指定了版本号，那么会使用子项目中指定的 jar 版本。
parent 项目中的 dependencies 里声明的依赖会被所有的子项目继承。artifactId表示依赖的项目名称

于项目中单击Module即可创建子工程，父工程的pom文件中会生成子模块的标签(告诉父亲儿子是谁)
在这里插入图片描述

 <!--当前父工程的所有子工程模块-->
  <modules>
    <module>child01</module>
    <module>child02</module>
  </modules>

需在子工程pom中引入父工程标签，(告诉儿子父亲是谁)，此后父工程引用的依赖，子工程也能够使用

 <!--设置当前模块的父工程-->
 <parent>
     <groupId>cn.tj</groupId>
     <artifactId>parent</artifactId>
     <version>1.0-SNAPSHOT</version>
 </parent>

可通过dependencyManagement 标签，对子工程引用父工程依赖做限制，只让一部分子工程可以使用父工程中的依赖

<!--依赖管理：在父工程中定义需要子工程引用的所有依赖 及版本 可以给其做选择性的引入-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

子工程需声明父工程的依赖才能够使用

	<!--从父工程引入已经管理的依赖的时候不需要设置版本，因为父工程已经统一管理了版本-->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
      </dependency>

10 启动器 Spring Boot Starter

Spring Boot提供了很多以 spring-boot-starter-* 开头的 starter 启动器（依赖包），在使用 Spring Boot 来搭建一个项目时，只需要引入官方提供的 starter，就可以直接使用，免去了各种配置。（一个启动器中含有多个jar包）
有关 Spring Boot Starter 命名规范，官方发布的 Starter 都遵循以下命名模式：spring-boot-starter-，其中 * 指特定的应用程序代号或名称。任何第三方提供的 Starter 都不能以 spring-boot 作为前缀，应该将应用程序代号或名称作为前缀，譬如 mybatis-spring-boot-starter。

spring-boot-starter：核心启动器，提供了自动配置，日志和 YAML 配置支持。

spring-boot-starter-aop：支持使用 Spring AOP 和 AspectJ 进行切面编程。

spring-boot-starter-freemarker：支持使用 FreeMarker 视图构建 Web 应用。

spring-boot-starter-test：支持使用 JUnit，测试 Spring Boot 应用。

spring-boot-starter-web：支持使用 Spring MVC 构建 Web 应用，包括 RESTful 应用，使用 Tomcat 作为默认的嵌入式容器。

spring-boot-starter-actuator：支持使用 Spring Boot Actuator 提供生产级别的应用程序监控和管理功能。

spring-boot-starter-logging：提供了对日志的支持，默认使用 Logback。

11 Web 启动器

SpringBoot 提供的 Web 启动器，是一个快速集成 Web 模块的工具包，包含 Spring MVC，Jackson 相关的依赖，以及嵌入了 Tomcat9 服务器，默认端口 8080，Spring Boot 根据 spring-boot-starter-web 这个依赖自动引入，而且所有的版本都已经管理好，不会出现冲突。

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

12 打包独立运行

Spring Boot 项目无论是普通应用还是 Web 应用，其打包方式都是 jar 即可（Web 应用也能打 war 包但需要额外添加许多插件）默认的 Maven 打包方式是不能正常的打包 Spring Boot 项目的，需要额外的引入打包插件，才能正常的对 Spring Boot 项目打包，以后只要拿到该 jar 包就能脱离 IDE 工具独立运行了。

<!-- pom.xml 中添加插件 -->
<build>
    <plugins>
        <!-- Spring Boot 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

<!-- 使用 maven 的 package 命令进行打包 -->
<!-- 使用命令 `java -jar xxx.jar` 运行 jar 包（--server.port=80）可更改端口号 -->

四 Spring Boot 参数配置

1 参数来源

命令行启动项目时传入的参数，如：java -jar xxx.jar --server.port=80（改端口，默认8080）；
application.properties 或者 application.yml 文件，只有application开头的才是叶子图标
自定义配置 properties 文件
关于其中的参数配置都可以在官方文档中找到

2 application.properties

若项目中properties与yml文件同时存在，properties优先级更高

server.port=80
server.session-timeout=30
server.tomcat.uri-encoding=UTF-8

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm
spring.datasource.username=root 
spring.datasource.password=admin

3 application.yml

yml中的层级缩进代表父子关系，不能够随意删减，：后的空格也不能删

server:  
  port: 80
  session-timeout: 30  
  tomcat.uri-encoding: UTF-8  
  
spring:  
  datasource:  
    url: jdbc:mysql://localhost:3306/crm  
    username: root  
    password: admin  
    driverClassName: com.mysql.jdbc.Driver

4 配置优先级

项目中可以有多个配置文件存放在不同目录中，此时会遵循固定的优先级来处理有冲突的属性配置，优先级由高到底，高优先级的配置会覆盖低优先级的配置。下面文件优先级由高到低排序为：

项目/config/application.properties (项目目录下与src同级)
项目/application.properties
classpath:config/application.properties (resources目录下)
classpath:application.properties (一般在这里做配置)

5 参数属性绑定 – 自定义 properties

① 参数配置在自定义的 properties，XML方式配置

# db.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=admin

<!--自定义的 properties-->
<context:property-placeholder location="classpath:db.properties" system-properties-mode="NEVER"/>

② JavaConfig 方式配置@PropertySource （等同上面的xml配置）+ @Value （通过key获取对应的值）从配置文件中获取数据

 // 生成配置类 自动加载 读取配置文件 获取其中的参数 创建Bean对象
@Configuration
@PropertySource("classpath:db.properties")/*替代原来读取外部配置文件的xml语句项目启动自动加载*/
public class SpringConfig {
    /*通过value注解取出db文件中key对应的value值该方法需要上面的读取外部配置文件语句配合*/
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    /*Bean对象 MyDatasource 为实体类*/
    @Bean
    public MyDatasource myDatasource(){
        MyDatasource datasource=new MyDatasource();/*对象创建后是空值需要set赋值*/
        datasource.setDriverClassName(driver);
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        return datasource;
    }
}

③ 实体类

public class MyDatasource {
    private String driverClassName;
    private String url;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    @Override
    public String toString() {
        return "MyDatasource{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

④ 单元测试查看是否获取成功

@SpringBootTest
class BootDemoApplicationTests {
    @Autowired
    private MyDatasource myDatasource;
    @Test
    void test1() {
        System.out.println(myDatasource);
    }
}

6 参数属性绑定 – application.properties

① application.properties 中设置参数

# application.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=admin

② 获取数据

// 放入spring容器 省略上面的@Bean
@Component
public class MyDatasource {
    // 为参数赋值 直接从application.properties中获取
    //@Value("${jdbc.driverClassName}")
    private String driverClassName;
    //@Value("${jdbc.url}")
    private String url;
    //@Value("${jdbc.username}")
    private String username;
    //@Value("${jdbc.password}")
    private String password;

    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    @Override
    public String toString() {
        return "MyDatasource{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

③ 批量获取数据 – @ConfigurationProperties 绑定对象属性
可以把application.properties中参数的前缀编写到 @ConfigurationProperties 属性上，并且设置类属性与需要绑定的参数名相同，可实现自动绑定。
若是使用测试类加载贴有 @Configuration 的配置类，则需要在配置类中添加@EnableConfigurationProperties 注解；若是使用测试类加载贴有 @SpringBootApplication 的配置类，则不需要。

// @ConfigurationProperties(prefix = "jdbc") 注解告诉 Spring Boot 从配置文件中查找以 jdbc为前缀的属性，并将它们绑定到这个类的字段上。
@Component  
@ConfigurationProperties(prefix = "jdbc") 
public class MyDatasource {
    private String driverClassName;
    private String url;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    @Override
    public String toString() {
        return "MyDatasource{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

要启用配置属性的自动绑定，需要在 Spring Boot 的主类或配置类上添加 @EnableConfigurationProperties 注解，并传入你的属性类的 Class 对象。但在上述示例中，已经使用了 @Component，所以这一步是可选的。Spring Boot 会自动发现并绑定标记为 @Component 的 @ConfigurationProperties 类。

7 Environment 对象绑定属性

当要绑定的参数过多时，直接在配置类中注入 Spring 的 Environment 对象，这样就不需要贴上在字段或者形参上太多的 @Value 注解。从 Environment 对象中可以获取到 application.properties 里面的参数，也可以获取到 @PropertySource 中的参数(但 application.properties 的优先级比 @PropertySource 高)

@Configuration
public class SpringConfigEnv {
    /*内置对象 继承了属性解析器*/
    @Autowired
    private Environment environment;
    @Bean
    public MyDatasource myDatasource(){
        MyDatasource datasource=new MyDatasource();
        // 通过environment对象获取key对应的参数
        datasource.setDriverClassName(environment.getProperty("jdbc.driverClassName"));
        datasource.setUrl(environment.getProperty("jdbc.url"));
        datasource.setUsername(environment.getProperty("jdbc.username"));
        datasource.setPassword(environment.getProperty("jdbc.password"));
        return datasource;
    }
}