1.SpringBoot简介

1.1 原有Spring优缺点分析

1.1.1 Spring的优点分析

Spring是Java企业版（Java Enterprise Edition，javeEE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

1.1.2 Spring的缺点分析

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。
不论是一开始的基于XML的配置，还是Spring2.5引入的基于注解的组件扫描，还是Spring 3.0引入的基于Java的配置，这些都代表了开发时的额外损耗。
因为在思考Spring配置和解决业务问题之间需要进行思维切换，甚至还带来了何种方式配置更好的无谓争论，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

1.2. SpringBoot的概述

SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

1.2.1. SpringBoot的特点

● SpringBoot不是对Spring功能上的增强，而是提供了一种快速构建Spring的方式
● 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
● 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器（嵌入Tomcat，无需部署WAR文件）、安全、指标，健康检测、外部配置等

1.2.2. SpringBoot的核心功能

● 起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
● 自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

2.SpringBoot实例

2.1.创建SpringBoot简单实例

2.1.1.创建工程

项目类型: Maven
名称: springboot
修改pom.xml文件
增加以下代码

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!-- Spring Web (包含 Spring MVC 和 RESTful 支持) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 开发工具，用于提升开发效率，比如实现热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Lombok (简化 Java 代码，自动生成 Getter/Setter 等) -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

2.1.2.工程主启动类

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

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

注意：

1. @SpringBootApplication注解指定该类为SpringBoot的程序入口类。
2. SpringBoot项目的Bean默认扫描规则是：根据启动类所在包位置从上往下扫描。
   例如：如果启动类所在的包为：com.neuedu.springboot；那么就会自动扫描com.neuedu.springboot 包及其所有子包，否则不会被扫描！
   所以，mapper、service、controller所在包是启动类所在包的子包。
3. SpringApplication类中的run方法会对当前SpringBoot工程进行启动。

2.1.3.创建Controller

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
    public class HelloController {
        @GetMapping("/hello")
        public String say(){          //可以直接返回对象或集合，客户端将接收到json数据
            return "hello...";
        }
    }

2.1.4.测试

执行启动类中的run方法就会启动当前的SpringBoot工程。

Tomcat started on port(s): 8080 (http) with context path ''
Started SpringbootApplication in 2.44 seconds (process running for 3.598)

发送请求测试 url

http://localhost:8080/hello

注意：SpringBoot内嵌了Tomcat，所以只需要运行SpringBoot工程的主启动类即可。

2.2.SpringBoot的跨域处理

SpringBoot还给我们提供了两种跨域处理方式：
1.使用 @CrossOrigin 注解配置某一个 Controller 允许跨域AJAX请求。

//只要在此Controller上使用@CrossOrigin注解就可实现跨域访问，并可配置允许跨域的url
@CrossOrigin("*") 
@RestController
public class DeptController { }

2.定义MVC配置类实现 WebMvcConfigurer 接口中的 addCorsMappings 方法，在此方法中配置全局跨域处理。

import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@Configuration
@EnableWebMvc
public class WeMvcConfig implements WebMvcConfigurer {
    /**
     * 跨域访问设置
     */
    public void addCorsMappings(CorsRegistry registry) {
        /*
         * addMapping：配置可以被跨域的路径，可以任意配置，可以具体到直接请求路径。
         * allowedOrigins：允许访问的url，可以固定单条或者多条内容
         * allowedMethods：允许的请求方式，如：POST、GET、PUT、DELETE等。
         * allowedHeaders：允许的请求header，可以自定义设置任意请求头信息。
         */
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("*")
                .allowedHeaders("*")
                .exposedHeaders("*");
    }
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        StringHttpMessageConverter converter = new StringHttpMessageConverter();
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> list = new ArrayList<MediaType>();
        list.add( MediaType.APPLICATION_JSON);
        converter.setSupportedMediaTypes(list);
        converters.add(converter);
        converters.add( new MappingJackson2HttpMessageConverter() );
    }
}

2.3.SpringBoot热部署

配置 IDEA 自动编译（IDE 基础设置）
即使添加了 DevTools，IDEA 默认也不会自动编译修改后的代码，需要手动开启自动编译：
步骤 1：开启“自动构建项目”
打开 IDEA 配置：文件 → 设置 → 构建, 执行, 部署 → 编译器
勾选-自动构建项目
点击 应用 保存设置
步骤 2：允许运行时自动编译
这一步是让 IDEA 在应用运行时也能自动编译，避免“应用启动后[修改代码]
打开 IDEA 配置：文件 → 设置 → 高级设置
搜索: 自动 make
勾选 即使开发的应用程序当前正在运行，也允许自动 make 启动
点击 应用 保存设置
步骤 3：调试模式运行项目

3.SpringBoot原理分析

一、核心设计思想：约定优于配置 (Convention over Configuration)
这是 Spring Boot 的灵魂。它意味着：
传统Spring的痛苦： 开发人员需要花费大量时间配置 XML 或 JavaConfig 来定义 Bean、数据源、MVC 等，虽然灵活但繁琐。
SpringBoot的解决方案： Spring Boot 预先定义好了一套“约定俗成”的默认配置。例如：

• 默认内嵌 Tomcat 服务器。
• 默认的配置文件名为 application.properties 或 application.yml。
• 默认的日志配置（使用 Logback）。

好处： 开发者如果遵循这些约定，就可以用极少的配置（甚至零配置）快速启动和运行项目。如果你不想用约定，也可以通过自定义配置轻松覆盖它们。
二、核心原理：四大核心
Spring Boot 的魔法主要源于以下四个核心特性：

1. 自动配置 (Auto-Configuration)
   这是 Spring Boot 最神奇、最核心的功能。
   Spring Boot 会在启动时自动扫描项目的 Classpath，根据你引入的依赖（JAR 包），自动为你配置 Spring 应用程序的 Bean。

• 例子当你引入了 spring-boot-starter-web 依赖，Spring Boot 会判断：“用户想要开发一个Web应用”，于是它自动配置内嵌的 Servlet 容器、DispatcherServlet、CharacterEncodingFilter 等 Web 开发必需的 Bean。
• 如何实现：
  @SpringBootApplication 注解中的 @EnableAutoConfiguration 是关键。
  Spring Boot 在 spring-boot-autoconfigure Jar 包下预先定义了大量自动配置类（如 DataSourceAutoConfiguration ）。
  流程： 应用启动 -> 检查 Classpath -> 如果存在 DataSource.class 且没有用户自己配置的 DataSource Bean -> 则执行 DataSourceAutoConfiguration 来创建一个默认的 DataSource Bean。

@SpringBootConfiguration：等同与@Configuration，既标注该类是Spring的一个配置类@EnableAutoConfiguration：SpringBoot自动配置功能开启 @ComponentScan：定义扫描路径，从中找出标识了需要装配的类，并自动装配到spring容器中

@AutoConfiguration(before = SqlInitializationAutoConfiguration.class)
//标识这是一个自动配置类，并可指定它在其他配置（如SQL初始化）之前执行
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
//核心条件：只有当类路径下存在 DataSource 和 EmbeddedDatabaseType 这两个类时，该配置类才会生效。这保证了项目中有 JDBC 相关的依赖
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
//如果容器中不存在 io.r2dbc.spi.ConnectionFactory 类型的 Bean，配置才生效。
@EnableConfigurationProperties(DataSourceProperties.class)
//启用 DataSourceProperties 配置属性类，将 application.properties 中以 spring.datasource 为前缀的配置绑定到该类上，供后续使用
public class DataSourceAutoConfiguration {
    // ... 配置类
}

2. 起步依赖 (Starter Dependencies)
   自动配置的基础，解决了依赖管理噩梦。

• 是一系列预定义好的依赖描述符（POM文件）。每个 Starter 都集成了开发某个功能所需的所有依赖库，并且这些库的版本都经过了严格的兼容性测试。
• 例子： 你不需要自己去找 Spring MVC、Tomcat、Jackson 的库并担心它们的版本兼容问题。只需引入一个 spring-boot-starter-web，它就帮你把所有东西都管理好了。
• 好处： 极大简化了 Maven/Gradle 配置，避免了“依赖地狱”（Jar包冲突）。

3. Actuator (监控管理)
   Spring Boot 为生产环境运行的项目提供了一套开箱即用的监控和管理功能。

• 通过引入 spring-boot-starter-actuator 依赖，你的应用会暴露一系列预定义的 HTTP 端点（Endpoints），如 /health（健康检查）， /info（应用信息）， /metrics（性能指标）， /env（环境变量）等。
• 价值： 让你能深入了解应用程序的运行状态，非常适合做监控和运维。
• 默认暴露的端点很少：出于安全考虑，Actuator 默认只暴露了 /health HTTP 端
  例如:访问健康检查的地址是 http://localhost:8080/actuator/health
  通过配置文件来开放更多端点，例如：

# 开放所有端点（生产环境请谨慎使用）
management.endpoints.web.exposure.include=*
# 或者只开放指定的几个端点
management.endpoints.web.exposure.include=health,info,metrics,env

4. 嵌入式容器 (Embedded Container)
   改变了Java Web应用的部署方式。

• Spring Boot 应用不再需要将项目打包成 WAR 包并部署到外部的 Tomcat/ Jetty等服务器中。而是将服务器（Tomcat, Jetty, Undertow）作为库直接嵌入到最终的可执行 Jar 包中。
• 好处：
  1.简化部署： 只需要一条命令 java -jar yourapp.jar 即可启动一个完整的 Web 应用。
  2.应用自包含： 所有东西都在一个Jar包里，便于分发和云原生部署。
  3.统一性： 解决了“在我的环境是好的，为什么线上不行？”这类因环境差异导致的问题。

4.SpringBoot工程配置文件

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用SpringBoot配置文件进行配置。
SpringBoot配置文件有两种：properties文件形式、yml文件形式。SpringBoot默认会从Resources目录下加载application.properties或application.yml文件。

4.1.application.properties配置文件

下面是一个 application.properties 配置文件实例：

## 修改服务器启动端口
server.port=8080
## 设置应用程序访问上下文路径
server.servlet.context-path=/test
## 设置SpringBoot日志输出级别（error、warn、info、debug）
logging.level.org.springframework=debug

4.2.application.yml配置文件

YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。
YML文件的扩展名可以使用.yml或者.yaml。
下面是一个 application.yml 配置文件实例：

server:
    port: 8765
    servlet:
        context-path: /springboot

yml文件基本语法：

1. 大小写敏感
2. 使用缩进表示层级关系（缩进的空格数并不重要，只要相同层级的元素左对齐即可）
3. 缩进不允许使用tab，只允许空格
4. 冒号后必须要有一个空格
5. 使用 # 作为注释

4.3.SpringBoot配置信息的查询

4.3.1.@Value注解

我们可以通过@Value注解，将配置文件中的值映射到一个Spring管理的Bean的属性上。

@RestController
public class HelloController {
    //server.port 就是SpringBoot配置文件中的一个值
    @Value("${server.port}")
    private int port;
    @GetMapping("/value")
    public String hello(){
         return "hello端口："+port;
    }
}

5.SpringBoot日志使用

5.1. 核心概念：Spring Boot 与 Logback

Spring Boot 默认使用 SLF4J 作为日志门面（API接口），并内置了 Logback 作为其默认的日志实现框架。这意味着你无需额外添加任何依赖即可开始使用。
SLF4J: 提供统一的日志接口，让你的代码与具体的日志实现解耦。
Logback: 是 Log4j 的继任者，性能更好，功能更强大。

5.2. 快速开始：基本使用

在任何需要记录日志的类中，按以下步骤操作：
1.导入 SLF4J 的 Logger 和 LoggerFactory
2.获取 Logger 实例（通常以当前类名命名）
3.使用不同级别的方法记录日志
示例

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    // 获取Logger实例
    private static final Logger logger = LoggerFactory.getLogger(HelloController .class);
    @GetMapping("/hello")
    public String sayHello() {
        // 记录不同级别的日志
        logger.trace("This is a TRACE log - very detailed");
        logger.debug("This is a DEBUG log - debugging info");
        logger.info("This is an INFO log - business process info");
        logger.warn("This is a WARN log - warning, but not an error");
        logger.error("This is an ERROR log - an error occurred");
        return "Hello World!";
    }
}

日志级别 (从低到高):
TRACE < DEBUG < INFO < WARN < ERROR < OFF
默认情况下，Spring Boot 的日志级别是 INFO，所以 TRACE 和 DEBUG 级别的日志不会输出。
使用 Lombok 简化代码:
如果项目使用了Lombok，可以用 @Slf4j 注解省略创建 Logger 的代码。
示例

@Slf4j // 自动注入一个名为 'log' 的 Logger
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        log.info("This is done with Lombok!"); // 直接使用 log
        return "Hello";
    }
}

5.3. 日志基础配置

在application.yml中配置
1.设置日志级别

logging:
  level: # 设置日志级别
    root: INFO # 设置根日志级别
    com.neuedu.springboot: DEBUG # 设置特定包的日志级别（常用于调试）

2.日志输出到文件

logging:
  file:
    name: logs/app.log  # 日志文件路径

3.设置日志格式

logging:
  pattern:
   console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" # 控制台输出模式
   file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" # 文件输出模式

常用格式符说明:

• %d: 日期时间
• %thread: 线程名
• %-5level: 日志级别（左对齐，固定5字符宽度）
• %logger{36}: Logger 当前日志输出类名（最长36字符）
• %msg: 日志消息
• %n: 换行符

RESTful API

RESTful API 是目前最主流的 Web API 设计规范。它本质上是一套设计风格和约定，核心是“以资源为中心”，通过统一的接口URL和 HTTP 方法（GET、POST、PUT、DELETE）来操作资源。
核心原则

• 资源 (Resources)：将一切数据抽象为资源，每个资源通过一个唯一的 URI（统一资源标识符）来标识。例如，一个用户资源的 URI 可以是 /user/123。

• HTTP 方法 (Methods)：使用标准的 HTTP 方法表达对资源的操作意图：
  GET：获取资源
  POST：创建资源
  PUT：完整更新资源（或创建）
  DELETE：删除资源

• HTTP 状态码 (Status Codes)：使用标准的 HTTP 状态码来表示请求的结果，如 200 (OK)、201 (Created)、400 (Bad Request)、404 (Not Found)、500 (Internal Server Error) 等。

• 无状态 (Stateless)：服务器端不保存客户端的会话状态。每次请求都是独立的），这使得 API 易于水平扩展。

创建响应结果封装类

在 Spring Boot 开发中，响应结果封装类通常是一个包含固定字段（如状态码、消息、数据）的 Java Bean，用于统一 API 的返回格式。这样做可以规范前后端的数据交互，提升开发和维护效率。

Result

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class Result<T> {
    private int code;       // 状态码
    private String msg;     // 消息
    private T data;         // 数据

    // 成功静态方法
    public static <T> Result<T> success(T data) {
        return Result.<T>builder()
                .code(200)
                .msg("操作成功")
                .data(data)
                .build();
    }

    // 失败静态方法
    public static <T> Result<T> error(int code, String msg) {
        return Result.<T>builder()
                .code(code)
                .msg(msg)
                .build();
    }
}

基础样例：用户资源 CRUD
最经典的RESTful 设计，围绕“用户”这个资源进行增删改查。