本章内容主要练习springboot项目创建,分别练习jar打包方式,war打包方式,普通maven转springboot方式,和基本语法,格式的使用,yml的使用

一、Spring Boot概述

1.1 什么是 SpringBoot

SpringBoot 是由 Pivotal 团队（后被 VMware 收购）于 2014 年推出的基于 Spring 框架的开源框架，它旨在简化 Spring 应用的初始搭建和开发过程。作为 Spring 生态系统的重要组成部分，SpringBoot 并非替代 Spring，而是在 Spring 基础上提供了一套约定优于配置的开发范式，使开发者能够更快速地构建生产级别的 Spring 应用。

SpringBoot 的核心思想是 "约定优于配置"（Convention over Configuration），通过提供一系列默认配置和自动化机制，减少了传统 Spring 应用中繁琐的 XML 配置和手动依赖管理工作，让开发者可以专注于业务逻辑的实现而非基础设施的配置。

1.2 SpringBoot 的发展背景

在 SpringBoot 出现之前，开发 Spring 应用需要进行大量的手动配置：

• 繁琐的 XML 配置文件
• 手动管理各种依赖及其版本兼容性
• 复杂的部署流程
• 需要手动配置 Web 服务器

这些问题导致 Spring 应用的初始化和开发效率低下，尤其对新手不够友好。为解决这些问题，SpringBoot 应运而生，它整合了 Spring 生态系统的最佳实践，提供了一套快速开发 Spring 应用的解决方案。

自 2014 年首次发布以来，SpringBoot 已成为 Java 开发领域最受欢迎的框架之一，目前最新稳定版本为 3.x（基于 Java 17 + 和 Spring Framework 6.x）。

1.3 SpringBoot 的核心特性(面试题)

1.3.1 自动配置（Auto-configuration）

SpringBoot 的核心特性之一，能够根据类路径中的依赖自动配置 Spring 应用。它会检查类路径中的 JAR 包，并基于这些依赖自动配置 Spring Bean。例如：

• 如果类路径中有spring-webmvc依赖，SpringBoot 会自动配置 DispatcherServlet
• 如果检测到 H2 数据库的依赖，会自动配置内存数据库

自动配置可以通过@EnableAutoConfiguration注解开启，而@SpringBootApplication注解已包含此注解。

1.3.2 起步依赖（Starter Dependencies）

SpringBoot 提供了一系列命名为spring-boot-starter-*的依赖模块，每个 starter 包含了特定功能所需的所有依赖。例如：

• spring-boot-starter-web：包含开发 Web 应用所需的 Spring MVC、Tomcat 等依赖
• spring-boot-starter-data-jpa：包含 Spring Data JPA 和 Hibernate 等依赖
• spring-boot-starter-security：包含 Spring Security 相关依赖

起步依赖解决了传统开发中依赖版本冲突的问题，SpringBoot 会自动管理这些依赖的版本兼容性。

1.3.3 嵌入式服务器（Embedded Servers）

SpringBoot 内置了多种嵌入式 Web 服务器，包括：

• Tomcat（默认）
• Jetty
• Undertow

这使得 SpringBoot 应用可以直接打包为可执行 JAR 文件，无需部署到外部服务器，简化了应用的部署和运行流程。

1.3.4 生产就绪特性（Production-Ready Features）

SpringBoot 提供了一系列适用于生产环境的特性：

• 应用监控（通过 Spring Boot Actuator）
• 健康检查
• 外部化配置
• 日志管理
• 应用指标收集

这些特性使开发者能够轻松构建符合生产标准的应用程序。

1.3.5 无代码生成和 XML 配置

SpringBoot 完全摒弃了 XML 配置，采用注解和 JavaConfig 的方式进行配置，同时不需要任何代码生成，保持了代码的简洁性和可维护性。

1.3.6 开箱即用（Out-of-the-box）

SpringBoot 提供了合理的默认配置，开发者可以 "开箱即用"，无需手动配置即可启动应用。同时，这些默认配置也可以根据需求进行自定义，实现了灵活性和简便性的平衡。

1.4 SpringBoot 的技术栈组成

SpringBoot 构建在 Spring 生态系统之上，并整合了多种常用技术：

1. 核心框架：Spring Framework
2. Web 框架：Spring MVC
3. 数据访问：

• • Spring Data Mybatis
  • Spring Data MongoDB
  • Spring Data Redis 等

1. 安全框架：Spring Security
2. 依赖注入：Spring IoC 容器
3. 嵌入式服务器：Tomcat、Jetty、Undertow
4. 构建工具：Maven、Gradle
5. 测试框架：JUnit、Mockito、Spring Test

1.5 SpringBoot 的应用场景

SpringBoot 适用于各种 Java 应用开发场景：

1. Web 应用开发：RESTful API、传统 Web 应用
2. 微服务架构：作为微服务的基础框架
3. 企业级应用：整合各种企业级组件
4. 数据处理应用：批处理任务、数据 ETL
5. 云原生应用：适合开发部署在云环境的应用
6. 物联网应用：设备数据采集和处理

无论是小型应用还是大型企业级系统，SpringBoot 都能提供高效的开发体验。

1.6 SpringBoot 与其他技术的关系

• 与 Spring Framework：SpringBoot 是 Spring Framework 的扩展和简化，不是替代关系
• 与 Spring Cloud：SpringBoot 是 Spring Cloud 的基础，Spring Cloud 构建在 SpringBoot 之上，提供微服务治理能力
• 与 Jakarta EE：SpringBoot 可以替代传统的 Jakarta EE 应用开发，提供更简洁的开发方式
• 与微服务：SpringBoot 是构建微服务的理想选择，但本身不是微服务框架

1.7 为什么选择 SpringBoot

1. 提高开发效率：减少配置工作，让开发者专注于业务逻辑
2. 简化部署流程：可执行 JAR 包直接运行，无需额外服务器配置
3. 降低学习成本：统一的开发范式，减少对框架细节的关注
4. 强大的社区支持：活跃的社区和丰富的文档资源
5. 良好的扩展性：可以根据需求自定义配置，扩展灵活
6. 与主流技术无缝集成：轻松整合各种开源框架和工具
7. 适合敏捷开发：快速迭代，缩短开发周期

SpringBoot 已经成为 Java 开发的事实标准之一，掌握 SpringBoot 是现代 Java 开发者的必备技能。

二、单体应用和微服务应用

单体应用是一种传统的应用架构模式，指将所有功能模块（如用户模块、订单模块、支付模块等）打包在一个应用程序中，部署在单一进程中的应用。

单体应用优缺点：

优点:

• 易开发,架构简单,技术成本低
• 易于测试:所有功能在一个项目,方便测试
• 易于部署:一个Tomcat就可以实现部署,简单方便

缺点:

• 代码臃肿不方便开发维护(代码可读性差)
• 代码编译系统启动变慢
• 系统扩展性能变差(牵一发而动全身)
• 无法针对某一个业务做扩展(集群)
• 对大数据量,高并发量的处理不占优势
• 技术选型单一
• 模块/业务耦合度高

微服务是在SOA架构上的一种发展,简单来说微服务就是把单一的应用进行差分,差分成多个微小服务,每个服务独立运行,每个服务只需要专注一个业务即可,并且每个服务都可以有自己的数据库,多个微服务之间相互配合完成整个系统的业务,这就是微服务.如果某个子系统/服务压力很大，可以单独对该子系统/服务再做集群。

三、Spring Boot入门程序

3.1 创建springboot项目可能出现的问题

错误信息如下:

解决办法:

1、打开idea最上角file选项的new->project…

2、点击spring initalizr 选择Server URL，

把值设置为：http://start.springboot.io/ 或者 http://start.aliyun.com

如果还是有问题可以参考：https://www.cnblogs.com/wangdahui/p/13501981.html

3.2 Spring Initializer快速创建Spring Boot项目（jar）

第一步： 创建项目

第二步： 加入web场景启动器依赖包到pom.xml文件

注意事项:
<!-- web项目SpringBoot启动器依赖 针对3.X.X版本使用web-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- web项目SpringBoot启动器依赖 针对4.X.X版本使用webmvc -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webmvc</artifactId>
</dependency>

第三步： 创建controller

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String helloTest(){
        return "hello springboot....";
    }

}

源码的写法和我们之前的写法定义是一样的，可以写dao，service，controller等

第四步：启动springboot项目

1. 找到带有 @SpringBootApplication 注解的主类
2. 运行 main 方法，启动 SpringBoot 应用
3. 项目启动，可以看到springboot标志

3.2.1 项目打包运行

第一步：先打包

第二步：运行包

java -jar 包名 ##就可以运行jar包

javaw -jar 包名 ##就可以后台启动

注意：在运行包时出现以上情况, 说明SpringBoot版本与JDK版本不兼容

解决方案：降低SpringBoot版本 或者 将JDK版本提高成22版本即可

将SpringBoot版本 替换成 2.6.13后，重新打包运行测试即可

第三步：访问测试

3.3 Spring Initializer快速创建Spring Boot项目（war）

第一步：创建项目

项目创建好后的结构：

项目会自动加入web模块场景启动器依赖:

第二步：项目结构解析

1. java文件夹目录结构中自动创建好指定包和Spring Boot启动主程序SpringbootApplication.class；
2. resources文件夹中目录结构

• • static：保存所有的静态资源； js css images；
  • templates：保存所有的模板页面，（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面），可以使用模板引擎（freemarker、thymeleaf）；
  • application.properties：Spring Boot应用的配置文件；可以修改一些默认设置；

第三步：查看springboot的主程序

@SpringBootApplication注解说明:这个类是SpringBoot的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot应用；并将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器,就不需要再写注解扫描器了；

第四步：编写Controller代码

package com.sy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String helloTest(){
        return "hello springboot2....";
    }

}

第五步：运行主程序并进行测试

注意：如果使用外部tomcat部署当前war类型的springboot项目要在项目中加入以下类：

建议使用springboot内置tomcat

ServletInitializer文件的主要作用是配置Servlet初始化，使得Spring Boot应用程序能够以WAR包的形式部署在外部的Servlet容器中，如Tomcat. 外部tomcat启动后，springboot项目会自动调用该类的 configure方法，并加载主程序，加载springboot初始化配置；

3.4 Maven项目转springboot项目

创建普通的Maven项目, 如果想让当前Maven项目成为springboot项目需要添加如下依赖:

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

<dependencies>
    <!-- web项目SpringBoot启动器依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- SpringBoot单元测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

HelloController类:

package com.sy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String helloTest(){
        return "maven springboot....";
    }

}

四、Spring Boot配置文件

配置文件是 SpringBoot 应用中非常重要的组成部分，它负责管理应用的各种配置信息。

SpringBoot 提供了灵活的配置机制，支持多种格式的配置文件和丰富的配置方式。

Spring Boot使用一个全局的配置文件，配置文件名是固定的，配置文件被自动读取；

默认使用以下两种格式：

• application.properties
• application.yml或者application.yaml

配置文件的作用：

• 修改SpringBoot自动配置的默认值；
• Spring Boot启动时会根据配置文件自动注册相关的应用组件；

4.1 yml / yaml 配置文件

YAML：以数据为中心，比json、xml等更适合做配置文件；

4.1.1 基本语法

– 使用缩进表示层级关系

– 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

- 键值对中间必须要有空格, k:(空格)v

4.1.2 值的写法

YAML 支持的三种数据结构:

1. 字面量：普通的值（数字、字符串、布尔）

server: 
  port: 8081

#注意：字符串默认不用加上单引号或者双引号；
#双引号：特殊符号表示转义符本身；
name01: "zhangsan \n lisi" # 输出；zhangsan 换行 lisi
#单引号；特殊字符就表示字符本身；  同级key不能重复
name02: 'zhangsan \n lisi' # 输出；zhangsan \n lisi

     2. 对象、Map（键值对）

person:
  name: zhangsan
  age: 12
#另一种行内写法：
person: {name: zhangsan,age: 12}

   3. 集合（List, Set）

hobbies:
 - singing
 - dancing
 - running
#用-（空格）值表示集合中的一个元素
#另一种行内写法：
hobbies: [singing,dancing,running]

语法格式

server:
  port: 8081

# 设置springmvc的视图解析器前缀和后缀, 默认为空  如果不设置使用时需要再返回时拼接
spring:
  mvc:
    view:
      prefix: /
      suffix: .html

#注意：字符串默认不用加上单引号或者双引号；
#双引号：特殊符号表示转义符本身；
name01: "zhangsan \n lisi" # 输出；zhangsan 换行 lisi
#单引号；特殊字符就表示字符本身；  同级key不能重复
name02: 'zhangsan \n lisi' #输出；zhangsan \n lisi

name03: true

name04: 3.14

#对象格式写法
book01:
  id: 1
  title: java学习
  price: 45.0
#或者
book02: {id:1, title:java从入门到精通, price:99.0}

#集合写法
hobbies01:
  - singing
  - dancing
  - running
#用-（空格）值表示集合中的一个元素
#另一种行内写法：
hobbies02: [singing,dancing,running]

4.1.3 配置文件值的注入

1. 构建bean对象

/**
 * 以前使用依赖注入形式
 * 现在我们使用ConfigurationProperties将本类中的所有属性和配置文件中相关的配置进行绑定；
 */
//只有spring容器中的对象才能自动进行数据绑定
@Component
// 1.如果让application.yml文件给当前Person对象中的属性赋值，要先找到当前类
// 2.我们可以通过当前类中声明的ConfigurationProperties注解的前缀prefix = "person"去寻找
@ConfigurationProperties(prefix = "person")
public class Person {
    private String pname;
    private int age;
    private boolean success;
    private Date birth;

    private Car car;
    private Map<String,Object> maps;
    private List<Object> lists;
	get/set …
}

public class Car {
    private int cid;
    private String cname;
    private double cprice;
	get/set …
}

person:
  pname: 柳岩
  age: 20
  success: true
  birth: 2025/02/20

  # 汽车对象
  car:
    cid: 1001
    cname: 宝马
    cprice: 100000

  # 给maps集合赋值
  # maps: {"name":刘涛, "age":30}
  maps:
    "name": 宝强
    "age": 20

  # 给lists集合赋值
#  lists:
#    - 抽烟
#    - 喝酒
#    - 烫头
  lists: [抽烟, 喝酒, 蹦迪]

1. 执行单元测试查看person对象的值

@SpringBootTest
class Day01Springboot04ApplicationTests {

    @Autowired
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

1. 引入配置文件处理器插件

<!--
作用：编辑配置文件时会有相关提示信息
注：如果加入pom后无法使用
加入后把项目清理打包一下会生效，不生效的话关闭idea重启
--> 
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
  <version>2.6.7</version>
</dependency>

4.2 properties 配置文件

4.2.1 properties语法

以KEY=VALue键值对的方式设置值

4.2.2 值的写法

1. 字面量：普通的值（数字，字符串，布尔）

name=张三

1. 对象、Map（属性和值）（键值对)

#指定访问当前项目的名称
server.servlet.context-path=/demo02

person.name=张三
person.age=12
maps.key1=value1
maps.key2=value2

1. 集合（List,Set）

hobbies=singing,dancing,running

4.2.3 配置文件值的注入

1. 构建bean对象

/**
 * 以前使用依赖注入形式
 * 现在我们使用ConfigurationProperties将本类中的所有属性和配置文件中相关的配置进行绑定；
 */
//只有spring容器中的对象才能自动进行数据绑定
@Component
// 1.如果让application.yml文件给当前Person对象中的属性赋值，要先找到当前类
// 2.我们可以通过当前类中声明的ConfigurationProperties注解的前缀prefix = "person"去寻找
@ConfigurationProperties(prefix = "person")
public class Person {
    private String pname;
    private int age;
    private boolean success;
    private Date birth;

    private Car car;
    private Map<String,Object> maps;
    private List<Object> lists;
    get/set …
}

public class Car {
    private int cid;
    private String cname;
    private double cprice;
	get/set …
}

1. 构建配置文件

person.pname=柳岩
person.age=20
person.success=false
person.birth=2025/02/20
person.car.cid=1001
person.car.cname=奥迪
person.car.cprice=200000
person.maps.name=刘涛
person.maps.age=22
person.lists=唱歌,跳舞,rapper

1. 执行单元测试查看person对象的值

@SpringBootTest
class Day01Springboot05ApplicationTests {

    @Autowired
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

注意：如果输出有中文乱码问题修改idea编码格式后，删除properties配置文件重新创建

多个配置文件加载顺序：

如果在项目中即存在application.yml也存在application.properties配置文件时：

1. 优先级规则

• • 如果项目中同时存在application.properties和application.yml文件，application.properties的优先级高于application.yml。
  • 这意味着，如果两个文件中都定义了相同的属性（例如: server.port），application.properties中的值会覆盖application.yml的值。

1. 加载顺序

• • SpringBoot会先加载application.properties文件中的配置文件，然后加载application.yml文件中的配置
  • 然后，由于优先级的原因，即使application.yml中的配置被加载，其值也会被application.properties中的相同属性覆盖。

多环境配置的应用场景

开发：在开发过程中，通常会使用本地数据库、调试模式和其他开发工具的配置。

测试：集成测试、单元测试等需要连接测试环境的数据库或第三方服务，并根据测试要求配置环境。

生产：生产环境通常需要更高的安全性和性能配置，比如使用外部服务、生产级数据库连接、严格的日志管理等。

如果每次切换环境都要手动修改 application.yml 中的数据库地址、端口、密钥等信息，不仅效率低下，还极易出错。

指定环境的配置方式

Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境；

1、多文件多环境形式：

格式：application-{profile}.properties/yml 其中 {profile} 表示环境标识

例如：可以在项目中创建如下主配置文件：

application-dev.properties、

application-test.properties、

application-prod.properties、

application.properties,

默认使用application.properties,可以通过配置spring.profiles.active=profile指定使用某个环境的配置文件。

2、yml支持单文件多环境形式：

例如：可以在项目中创建如下主配置文件：

application-dev.yml、

application-test.yml、

application-prod.yml、

application.yml,

默认使用application.yml,可以通过以下配置指定使用某个环境的配置文件。

spring:

profiles:

active: dev # 激活开发环境

3、激活方式：

在配置文件中指定 spring.profiles.active=dev

命令行 java -jar springboot-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev