SpringBoot学习笔记

zyhhsss

已于 2024-10-15 16:40:32 修改

阅读量458

点赞数 3

分类专栏：后端开发指南文章标签： spring boot 学习笔记

于 2024-08-27 16:21:55 首次发布

本文链接：https://blog.csdn.net/zyhhsss/article/details/141605968

版权

后端开发指南专栏收录该内容

5 篇文章 0 订阅

订阅专栏

SpringMVC

1.视图与html的区别

动态 vs 静态:
- 视图: 动态的，是通过代码和模板引擎生成的，可以根据用户的输入或数据的变化生成不同的内容。
- HTML: 静态的，是视图最终生成的结果。浏览器直接读取和解析 HTML 代码来显示网页。
数据绑定:
- 视图: 可以从控制器接收数据，并将数据绑定到模板中的占位符，再生成 HTML。
- HTML: 只是数据的展示方式，没有逻辑和数据绑定的能力。
编写方式:
- 视图: 通常使用模板引擎编写，包含动态内容的占位符（如 ${}）。
- HTML: 使用标准的 HTML 标签和元素，描述网页的静态内容和结构。

2.springmvc的一些基础知识

Spring Boot、Spring、Spring MVC 之间的关系可以理解为同一技术栈中的不同层次或不同的模块，它们在一起构成了一个完整的、现代化的 Java Web 开发框架。以下是它们的关系和各自的作用：

1. Spring

核心框架: Spring 是一个功能强大的 Java 开发框架，它提供了全面的基础设施支持，使得开发企业级应用变得更加容易。Spring 核心模块主要包括 IOC（控制反转）容器、AOP（面向切面编程）、数据访问、事务管理等。
作用:
- IOC: 通过依赖注入（DI）管理对象的生命周期和依赖关系，降低代码耦合度。
- AOP: 允许开发者通过切面编程添加横切关注点（如日志、事务管理）而不影响核心业务逻辑。
核心模块: Spring 是整个框架的基础，其他模块和扩展都是基于 Spring 核心来实现的。

2. Spring MVC

Web 模块: Spring MVC 是 Spring 框架中的一个子模块，用于构建基于 Web 的应用程序。它遵循 MVC（Model-View-Controller）设计模式。
作用:
- Model: 负责处理数据和业务逻辑。
- View: 负责渲染数据并返回给客户端（通常是 HTML、JSON、XML 等）。
- Controller: 负责处理请求，将 Model 和 View 连接起来。
集成性: Spring MVC 是构建 Web 应用的一个重要工具，它利用了 Spring 的 IOC 和 AOP 功能，使得 Web 开发变得更加模块化和灵活。

3. Spring Boot

快速开发框架: Spring Boot 是基于 Spring 框架的一个扩展，它的设计目标是简化 Spring 应用的配置和开发。通过约定优于配置的理念，Spring Boot 能够自动配置 Spring 应用程序，使开发者可以专注于业务逻辑，而不必关心繁杂的配置细节。
作用:
- 自动配置: 减少了大量的配置工作，Spring Boot 可以根据类路径中的库自动配置 Spring 应用。
- 内嵌服务器: Spring Boot 提供了内嵌的 Tomcat、Jetty 等服务器，使得应用可以独立运行，无需外部应用服务器。
- 简化的依赖管理: Spring Boot 提供了一套默认的依赖管理，使得依赖版本一致性得以保证。
集成性: Spring Boot 是一个高层次的框架，它集成了 Spring 和 Spring MVC，同时还能轻松集成其他 Spring 子模块，如 Spring Data、Spring Security 等。

4. 关系总结

Spring 是核心框架，提供了基础设施和容器管理功能。
Spring MVC 是 Spring 的一个模块，专注于 Web 应用的开发，是 Spring 在 MVC 模式下的具体实现。
Spring Boot 是一个快速开发框架，它基于 Spring 和 Spring MVC 提供了更高层次的抽象和自动配置，简化了开发过程。

5. 层级关系

com.example.usersystem
├── controller
│ └── UserController.java
├── service
│ └── UserService.java
├── repository
│ └── UserRepository.java
├── model
│ └── User.java
└── Application.java

UserController.java：处理用户相关的 HTTP 请求。
UserService.java：处理用户相关的业务逻辑。
UserRepository.java：执行数据库操作。
User.java：表示用户实体，对应数据库中的 users 表。

SpringBoot

一、Springboot3 配置swagger3

【SpringBoot整合系列】SpringBoot3.x整合Swagger_springboot3 swagger-CSDN博客

启动服务后，首先通过浏览器打开链接http://localhost:8080/swagger-ui/index.html

二、一些基础注解

1. `@Bean` 的原理

1.1 定义和作用

@Bean 是一个方法级别的注解，通常用于配置类（带有 @Configuration 注解的类）中。
通过 @Bean 注解标记的方法，Spring 会将该方法的返回值注册为一个 bean，放入 Spring 容器中。类似于pom.xml里面bean标签那种
这些 bean 可以在 Spring 应用上下文中作为依赖注入到其他 bean 中。

1.2 工作原理

Spring 在启动时，会扫描标有 @Configuration 的类，并处理其中的所有 @Bean 注解的方法。每个 @Bean 方法的返回值都会被注册为一个 Spring 管理的 bean，这些 bean 的生命周期由 Spring 容器管理。默认情况下，Spring 容器中的 bean 是单例的，也就是说，@Bean 方法每次都会返回同一个实例。

pom

<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="myService" class="com.example.MyServiceImpl">
        <property name="dependencyService" ref="dependencyService" />
    </bean>

    <bean id="dependencyService" class="com.example.DependencyServiceImpl" />

</beans>

springboot

@Configuration
public class AppConfig {

    @Bean
    public DependencyService dependencyService() {
        return new DependencyServiceImpl();
    }

    @Bean
    public MyService myService(DependencyService dependencyService) {
        return new MyServiceImpl(dependencyService);
    }
}

2.@RestController

@RestController 是 Spring 框架中的一个注解，它是 @Controller 和 @ResponseBody 注解的组合。它的主要作用是简化开发 RESTful Web 服务的控制器类。

@Controller：这个注解通常用于标记一个类为 Spring MVC 的控制器，用来处理 HTTP 请求。
@ResponseBody：这个注解表明控制器的方法返回的对象会直接作为 HTTP 响应的内容，而不是渲染为视图。

@RestController 的作用相当于同时应用了 @Controller 和 @ResponseBody。使用这个注解标记的类中的所有方法默认都会返回 JSON 或 XML 格式的数据，而不是视图。这样，当你开发 RESTful API 时，就不需要每次都在方法上添加 @ResponseBody 注解。

3.@GetMapping

@GetMapping("/greeting")
public String greeting(@RequestParam(name = "name", defaultValue = "World") String name) {
    return "Hello, " + name + "!";
}

在这个例子中，如果客户端访问 http://localhost:8080/greeting?name=Alice，则返回 "Hello, Alice!"。如果不传 name 参数，则使用默认值 "World"。

@GetMapping 专门用于处理 HTTP GET 请求。它简化了以往使用 @RequestMapping(method = RequestMethod.GET) 的方式。它将特定路径的 GET 请求映射到控制器中的某个方法上。

4.@RequestMapping

@RequestMapping 是 Spring 框架中用于处理 HTTP 请求的注解。它用于将 HTTP 请求映射到具体的控制器类或方法上，从而确定客户端请求将由哪个方法处理。

4.1基本功能

请求映射: @RequestMapping 可以用于指定一个 URL 路径，以便当客户端访问该路径时，Spring 框架能够将请求路由到相应的控制器方法。
多种 HTTP 方法: 可以映射 GET、POST、PUT、DELETE 等各种 HTTP 请求方法，也可以指定请求的参数、头信息、请求体等进行更加精细的匹配。

4.2 用法示例

4.2.1 映射到类上

当 @RequestMapping 注解在控制器类上时，它为该控制器下的所有方法指定一个公共的请求路径前缀。

@Controller
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") Long id, Model model) {
        // 处理用户请求逻辑
        return "userDetails";
    }

    @PostMapping
    public String createUser(@RequestBody User user) {
        // 创建用户逻辑
        return "userCreated";
    }
}

在上面的例子中，所有映射的方法都以 /users 作为请求路径的前缀。

4.2.2 映射到方法上

当 @RequestMapping 注解在方法上时，它指定了该方法处理的具体请求路径及请求方法。

@Controller
@RequestMapping("/users")
public class UserController {

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String getUser(@PathVariable("id") Long id, Model model) {
        // 处理用户请求逻辑
        return "userDetails";
    }

    @RequestMapping(value = "/create", method = RequestMethod.POST)
    public String createUser(@RequestBody User user) {
        // 创建用户逻辑
        return "userCreated";
    }
}

在这个示例中，/users/{id} 的 GET 请求将由 getUser 方法处理，/users/create 的 POST 请求将由 createUser 方法处理。

4.2.3 简化注解

Spring 4.3 之后，可以使用更具体的注解如 @GetMapping, @PostMapping, @PutMapping, @DeleteMapping 等代替 @RequestMapping，这些注解是 @RequestMapping 的特化形式。

@Controller
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") Long id, Model model) {
        // 处理用户请求逻辑
        return "userDetails";
    }

    @PostMapping
    public String createUser(@RequestBody User user) {
        // 创建用户逻辑
        return "userCreated";
    }
}

4.3 高级用法

4.3.1 请求参数

可以通过 params 属性指定请求必须包含的参数。

@RequestMapping(value = "/search", method = RequestMethod.GET, params = "name")
public String searchUserByName(@RequestParam("name") String name, Model model) {
    // 搜索用户逻辑
    return "searchResults";
}

4.3.2 请求头

可以通过 headers 属性指定请求必须包含的头信息。

@RequestMapping(value = "/info", headers = "X-API-VERSION=1")
public String getUserInfoV1() {
    // 返回版本1的用户信息
    return "userInfoV1";
}

4.3.3 消费与生成的内容类型

可以通过 consumes 和 produces 属性指定方法处理的请求体类型和返回内容类型。

@RequestMapping(value = "/create", method = RequestMethod.POST, consumes = "application/json", produces = "application/json")
public @ResponseBody User createUser(@RequestBody User user) {
    // 处理JSON格式的用户数据
    return user; // 返回创建的用户信息
}

4.3.4 总结

@RequestMapping 是 Spring 框架中用于处理 HTTP 请求的关键注解。
它可以用于类和方法上，指定请求路径、HTTP 方法、请求参数、头信息等。
随着 Spring 4.3 的引入，更推荐使用具体的注解如 @GetMapping, @PostMapping 等来简化代码。

5.@PathVariable

4.5.1 多个值传入

假设有一个 API 可以获取某个特定类别下的商品详情，路径格式为 /categories/{categoryId}/products/{productId}。

@Controller
public class ProductController {

    @GetMapping("/categories/{categoryId}/products/{productId}")
    public String getProduct(@PathVariable("categoryId") Long categoryId, 
                             @PathVariable("productId") Long productId, 
                             Model model) {
        // 使用 categoryId 和 productId 获取商品信息
        Product product = productService.findProductByCategoryAndId(categoryId, productId);
        model.addAttribute("product", product);
        return "productDetails";  // 返回视图名称
    }
}

4.5.2 简化写法

如果路径变量的名称与方法参数的名称一致，可以省略 @PathVariable 注解中的参数名称

@GetMapping("/users/{id}")
public String getUser(@PathVariable Long id, Model model) {
    // id 会自动映射为路径中的 {id}
    User user = userService.findUserById(id);
    model.addAttribute("user", user);
    return "userDetails";
}

6. `@Target`

@Target 注解用于指定自定义注解可以应用的Java元素类型。它接收一个数组，包含以下可能的值：

ElementType.TYPE: 可以应用于类、接口、枚举等。
ElementType.FIELD: 可以应用于字段或属性。
ElementType.METHOD: 可以应用于方法。
ElementType.PARAMETER: 可以应用于方法参数。
ElementType.CONSTRUCTOR: 可以应用于构造函数。
ElementType.LOCAL_VARIABLE: 可以应用于局部变量。
ElementType.ANNOTATION_TYPE: 可以应用于注解类型。
ElementType.PACKAGE: 可以应用于包声明。
ElementType.TYPE_PARAMETER: 可以应用于类型参数（Java 8+）。
ElementType.TYPE_USE: 可以应用于任何使用类型的地方（Java 8+）。

7.`@Retention`

@Retention 注解指定自定义注解的生命周期。它的参数是 RetentionPolicy 枚举，可能的值包括：

RetentionPolicy.SOURCE: 注解只在源码中保留，编译时会被忽略。
RetentionPolicy.CLASS: 注解会保留在字节码文件中，但不会在运行时保留（默认值）。
RetentionPolicy.RUNTIME: 注解会保留在运行时，可以通过反射机制读取。

8.`@Component`

作用: @Component 是一个通用的 Spring 注解，用于标记一个类作为 Spring 容器中的一个 Bean。Spring 会自动检测并将其纳入容器进行管理。
使用场景: @Component 通常用于那些需要由 Spring 自动扫描和管理的类。典型场景包括服务层、数据访问层的类（例如 @Service 和 @Repository 是 @Component 的具体化）。
自动扫描: 当你使用 @Component 标注一个类时，Spring 会在类路径扫描（通过 @ComponentScan）时自动发现这个类，并将其实例化为一个 Spring Bean。

与@Bean的区别

注解位置:
- @Component：用于类上，Spring 通过类路径扫描自动注册该类的实例为 Bean。
- @Bean：用于方法上，该方法返回的对象会被注册为 Bean。
自动化程度:
- @Component：更加自动化，Spring 自动扫描和实例化。
- @Bean：手动控制 Bean 的创建，适合需要复杂初始化逻辑的场景。
用途:
- @Component：适用于大多数情况下的简单类，例如服务类、数据访问类等。
- @Bean：适用于需要手动注册第三方类或进行复杂 Bean 配置的场景。

9.`@RequestMapping`

@RequestMapping 是 Spring MVC 中最常用的注解之一，用于将 HTTP 请求映射到处理器方法或类上。它可以用在类级别和方法级别，帮助开发者定义 Web 请求的路径、请求方法、请求参数等。

基本功能

@RequestMapping 注解的主要功能是将一个特定的 URL 或 URL 模式映射到一个控制器类或控制器方法上，使得当客户端发出相应的请求时，Spring MVC 能够将请求路由到合适的处理器进行处理。

@RestController
@RequestMapping("/api")
public class MyController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String sayHello() {
        return "Hello, World!";
    }
}

在这个例子中：

@RequestMapping("/api") 注解在类级别上，表示所有的请求路径都将以 /api 开头。
@RequestMapping(value = "/hello", method = RequestMethod.GET) 注解在方法级别上，表示当客户端发出 GET 请求到 /api/hello 时，将调用 sayHello() 方法来处理请求。

@RequestMapping 的属性

@RequestMapping 注解有多个属性，可以用于更精确地指定请求的映射规则：

value 或 path：
- value 或 path 属性用于指定 URL 路径。它们是等价的，可以选择其一使用。
- 示例：@RequestMapping(value = "/home") 或 @RequestMapping(path = "/home")。
method：
- method 属性用于指定请求的方法类型，如 GET、POST、PUT、DELETE 等。
- 示例：@RequestMapping(method = RequestMethod.POST)。
params：
- params 属性用于指定请求必须包含的参数。例如，指定请求必须包含某个特定的参数或特定参数的值。
- 示例：@RequestMapping(value = "/search", params = "query") 表示请求路径 /search 且包含 query 参数的请求将被映射。
headers：
- headers 属性用于指定请求必须包含的 HTTP 头信息。通过这个属性，你可以对请求的头信息进行匹配。
- 示例：@RequestMapping(value = "/content", headers = "content-type=text/*")。
consumes：
- consumes 属性用于指定请求所能接受的内容类型（Content-Type），例如 application/json 或 text/plain。
- 示例：@RequestMapping(value = "/json", consumes = "application/json")。
produces：
- produces 属性用于指定处理器返回的内容类型。例如，指定返回 application/json 的响应。
- 示例：@RequestMapping(value = "/json", produces = "application/json")。

类级别和方法级别的映射

类级别：当 @RequestMapping 注解用在类上时，所有的方法都继承该路径。例如，如果类级别路径为 /api，那么方法级别的路径 /hello 实际映射路径就是 /api/hello。
方法级别：方法级别的 @RequestMapping 通常用于细化请求的映射，例如对不同的 HTTP 方法、路径参数或请求体进行处理。

常见用法变体

简化写法：
- 在 Spring 4.3 之后，Spring 引入了简化的注解，如 @GetMapping、@PostMapping、@PutMapping、@DeleteMapping 等，它们是 @RequestMapping 的特定 HTTP 方法的快捷方式。例如，@GetMapping("/hello") 是 @RequestMapping(value = "/hello", method = RequestMethod.GET) 的简化形式。
组合注解：
- @RequestMapping 也常用于自定义组合注解。例如，你可以创建一个自定义注解，将 @RequestMapping 和其他注解组合在一起，以便在项目中重用。

总结

@RequestMapping 是一个功能强大且灵活的注解，允许你定义各种类型的 Web 请求映射。通过结合使用不同的属性（如 value、method、params 等），你可以非常精确地控制请求的路由逻辑，并为不同的请求提供相应的处理方法。

10.@AliasFor

起别名

@RequestMapping
public @interface GetMapping {
    @AliasFor(annotation = RequestMapping.class, attribute = "path")
    String[] value() default {};
    
    @AliasFor(annotation = RequestMapping.class, attribute = "method")
    RequestMethod[] method() default {RequestMethod.GET};
}

@GetMapping("/home")
public String home() {
    return "home";
}

保持属性一致性

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ContextMapping {
    @AliasFor("path")
    String value() default "";
    
    @AliasFor("value")
    String path() default "";
}

@ContextMapping("/context")
public void doSomething() {
    // 方法实现
}

11.@Autowired和`@Resource`

@Resource ：

用途

@Resource 是 Java EE（或 Jakarta EE）规范的一部分，主要用于依赖注入。它通过字段、构造函数或 setter 方法将依赖的对象注入到类中。

特点

依赖注入：@Resource 用于注入已经存在的 bean 到 Spring 管理的类中。它可以用来注入服务、组件或其他依赖项。
按名称注入：@Resource 默认按 bean 的名称进行注入。如果在 @Resource 上设置了 name 属性，它会按名称查找对应的 bean，否则，它会根据字段名称查找匹配的 bean。
注入点：可以用于字段、构造函数、setter 方法。
规范：@Resource 是标准 Java EE 规范的一部分，不依赖于 Spring 特定的实现，虽然 Spring 也支持它。

public class MyService {
    
    @Resource
    private SomeComponent someComponent;
    
    // 使用 someComponent 进行操作
}

@Resource：
- 用于依赖注入，将现有的 bean 注入到需要的地方。
- 默认按名称注入，可以通过 name 属性指定 bean 名称。
- 可以用于字段、构造函数或 setter 方法。
@Bean：
- 用于在 Spring 配置类中定义和创建新的 bean。
- 在 @Configuration 注解的类中定义方法，返回的对象会被注册为 Spring 容器中的 bean。
- 提供了创建和配置 bean 的灵活性。

这两个注解在 Spring 应用程序中各有其特定的用途，@Resource 更多的是用来注入依赖，而 @Bean 则用来定义和配置 bean。

区别：

@Autowired

来源：@Autowired 是 Spring 框架提供的注解。
默认行为：默认情况下，@Autowired 通过类型（byType）来查找和装配依赖。如果找到多个相同类型的bean，可以使用 @Qualifier 注解配合指定具体的bean名称。
适用范围：可以应用于字段、构造函数或方法。
必需性：可以通过设置 required=false 来表示该依赖不是必须的。如果没有合适的bean，Spring将不会抛出异常，而是忽略这个注入。

@Autowired
private MyService myService;

@Autowired
public MyClass(@Qualifier("myServiceBean") MyService myService) {
    this.myService = myService;
}

@Resource

来源：@Resource 是 Java EE (JSR-250) 提供的标准注解，由 Spring 支持。
默认行为：默认情况下，@Resource 通过名称（byName）来查找和装配依赖。它首先尝试通过名称匹配，如果找不到，则回退到通过类型匹配。
适用范围：可以应用于字段或方法。
必需性：没有直接的方式来指定依赖是否必需。如果找不到合适的bean，会抛出异常。

@Resource(name="myServiceBean")
private MyService myService;

@Resource
public void setMyService(MyService myService) {
    this.myService = myService;
}

12.@Data

@Data 提供了所有的 getter 和 setter 方法，以及 toString(), equals(), 和 hashCode() 方法。
@AllArgsConstructor 生成了一个包含所有字段的构造函数。
@NoArgsConstructor 生成了一个无参构造函数。

13.`@Builder`

生成了一个构建器类，支持链式调用创建对象。

14.@Value

@RestController
@RequestMapping("/test")
public class Test{

}

14.@Service @Controller @Repository

@Controller：
- 用于标记控制层（或表现层）的类。
- 控制器负责处理客户端请求，通常是HTTP请求，将请求映射到相应的服务层方法上，并返回响应给客户端。
- 通常与@RequestMapping、@GetMapping、@PostMapping等注解一起使用来定义请求映射。
- 在Spring MVC架构中，控制器是处理用户交互的主要入口点。
@Service：
- 用于标记业务逻辑层的类。
- 服务层包含了应用程序的核心业务逻辑。它从DAO层获取数据，执行业务规则，然后可能通过控制器将结果传递回客户端。
- 使用@Service注解的类通常是事务性的，即它可以参与到Spring事务管理中。
- 服务层经常调用多个DAO接口以完成复杂的业务操作。
@Repository：
- 用于标记数据访问层的类。
- 数据访问对象（DAO）是用来访问数据库或其他持久化存储的组件。@Repository注解表明这个类是一个数据源的访问者。
- 使用@Repository的好处之一是可以启用异常转换，使得底层的数据访问异常能够被自动转换为Spring的统一异常层次结构，便于集中处理。
- DAO层通常会直接操作数据库，进行CRUD操作。

关系：

这三个注解共同构成了Spring应用中的三层架构：@Controller位于最外层，处理外部请求；@Service位于中间层，实现业务逻辑；@Repository位于最内层，负责数据持久化。
它们之间存在依赖关系，通常情况下，@Controller会依赖于@Service，而@Service又会依赖于@Repository。这种分层设计有助于保持代码清晰，职责分明，提高系统的可维护性和可测试性。
所有这三个注解都可以通过Spring的依赖注入机制来互相引用，从而构建出一个完整的应用流程。例如，控制器可以通过构造函数注入或者字段注入的方式获得服务类的实例，服务类同样可以获得数据访问对象的实例。

15.@ContextConfiguration

加载配置类的

@RunWith(SpringRunner.class)
@ContextConfiguration(
    locations = {"classpath:applicationContext.xml"},
    classes = {MyService.class, MyRepository.class}
)
public class MyServiceTest {

    @Autowired
    private MyService myService;

    @Test
    public void testMyMethod() {
        // 测试逻辑
    }
}

16@SpringBootTest

配置Test的启动类，注意（）里的是启动类不是测试类。

@SpringBootTest(classes = SpringbootLearnApplication.class)

17 @Mapper

mybatis引入的注解，目的是创建mapper，不用写xml文件了。不写这个需要在启动类上使用

@MapperScan(basePackages = {"com.zyhlearn.springbootlearn.mapper"})

import org.apache.ibatis.annotations.Mapper;

18 @MapperScan

mybatis引入的注解，目的是确定mapper地址。

@MapperScan(basePackages = {"com.zyhlearn.springbootlearn.mapper"})

19 @PathVariable

假设你有一个处理用户请求的控制器，其中需要根据用户ID来获取用户信息。你可以使用 @PathVariable 来从URL中提取用户ID。

@GetMapping("/users/{userId}/orders/{orderId}")
public String getOrderById(@PathVariable("userId") Long userId, @PathVariable("orderId") Long orderId) {
    // 根据userId和orderId获取订单信息
    return "User ID: " + userId + ", Order ID: " + orderId;
}

三、yml文件

xml: <bean id="" class="">

properties:

bean.id =

bean.class =

yml:

spring:

xxx:

yml的特点：大小写敏感、支持字面值、对象、数组数据结构、支持复合结构、用空格分开

3.1 多环境配置

3.1.1 配置application开头的yml文件

3.1.2 配置特定的yml文件

以a.yml为例子

3.2 yml的松弛匹配

3.3 @profile指定yml文件

3.4 通过el动态绑定

3.5 读取yml文件里的数据

3.5.1 通过@ConfigurationProperties

例子2

3.5.2 通过enviroment只能读取简单的数据

三、常见的操作快捷键

crtl+f 快捷搜索

四、手写springboot的反射机制

关闭防火墙

netsh advfirewall set allprofiles state off

五、一些常见的引入

5.1 整合junit

目的：引入@Test（方便测试）

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

5.2 整合mybatis

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory><includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

5.3 创建项目常见的引用

热启动

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

web引入整合swagger

数据库 mybatis

 <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>

这里有版本号因为在springboot-parent里的dependence没有相应版本。像是mysql就会自动装填某版本

mysql

 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

六、Mybatis使用

6.1 实增删改查

entity：

Mapper：

service:

impl:

controller:

6.2 加入日志处理

6.3 分页处理

6.4 通过mapper实现数据库处理

mapper文件

xml文件

指定mapper或者配置文件

在pom.xml文件中

注意：

classpath解释：

在典型的Maven或Gradle项目结构中，类路径通常包括 src/main/resources 目录。因此，classpath:mapper/*.xml 表示所有的 .xml 文件位于 src/main/resources/mapper/ 目录下。

配置文件地址和起别名操作（就是xml文件中指定的类名不需要写完全）

合在一起：

6.5 mybatis-plus学习

快速开始 | MyBatis-Plus (baomidou.com)

十、一些常见问题

1. 我在springboot中写了一个service接口用一个impl类来实现它，我在测试类中注入 ervice接口，调用方法为什么能直接调用实现类的实际方法，这是怎么找到的

Spring根据类型安全地解析并注入对应的bean。也就是说，当Spring看到一个需要MyService接口类型的依赖时，它会寻找所有实现了MyService接口的bean，并选择合适的一个注入。如果有多个实现，则可能需要额外指定@Qualifier注解来明确指出具体哪一个实现类应当被注入。

2.mapper dao entity model有什么区别

entity、model是实体类

mapper一般是mybatis做与数据库交互的层其他的用dao就可以。

用mybatis开发的话一般分成controller service mapper entity

3.增删改查对应的操作

创建 (Create): 通常使用 POST 方法。
- 用于向服务器发送数据以创建新的资源。
- 例如，向数据库中插入一条新记录。
读取 (Read): 通常使用 GET 方法。
- 用于从服务器获取数据。
- 例如，查询数据库中的记录。
更新 (Update): 通常使用 PUT 或 PATCH 方法。
- PUT 用于完全替换现有的资源。
- PATCH 用于部分更新现有的资源。
- 例如，更新数据库中的一条记录的部分或全部字段。
删除 (Delete): 通常使用 DELETE 方法。
- 用于从服务器删除一个资源。
- 例如，从数据库中删除一条记录。