Springboot项目基础开发模式+注解

web项目开发涉及基础

servlet+tomcat

Servlet：

Servlet容器是Java Web应用程序的核心组件，负责接收HTTP请求，并将请求路由到相应的Servlet进行处理。
Servlet，使用java编写的服务器端程序，主要功能是交互式地浏览和修改数据，生成动态地web页面。狭义上讲，是Java语言实现的接口；广义上讲，是实现Servlet接口的类。
Servlet需要由Servlet容器进行管理，tomcat就是一个免费开源的Servlet容器；

Tomcat：

1. Tomcat是常见的免费web服务器。
2. 是否使用tomcat打开html的区别：
使用：则可以通过 http://12306.com/index.html 形式打开网站；
不使用：则需要通过 file:d:/test.html  形式 打开本地网站；
3. 8080 是tomcat的默认端口号

工作模式：

执行过程：
	客户端发送请求到服务器
	→服务器启动并调用Servlet，Servlet根据请求生成响应返回给服务器
	→服务器将响应返回给客户端

没有定义Servlet也可以处理HTTP请求：
	Springboot默认处理机制，依赖于SpringMVC框架，其内嵌了一套请求和响应的逻辑；

默认处理方式：结合Springmvc和Tomcat实现；
	1. 引入依赖spring-boot-starter-web，会内嵌Tomcat以及Springmvc框架；
	2. 自动配置，检测到Tomcat自动配置web应用的默认环境，自动配置Springmvc，以及设置dispatcherServlet为请求的前端控制器；
		DispatcherServlet，Springmvc的核心组件，负责接收所有的http请求；
	3. 请求到达Tomcat时，会转发请求给DispatcherServlet。
		请求映射，DispatcherServlet解析请求链接，找到对应的处理器（Controller），通过@RequsetMapping 注解实现；
		处理请求，DispatcherServlet调用响应的控制方法，可以是@Controller、@RestController、@RequestMapping注解修饰的java方法；
	4. 视图解析，Controller方法执行后，返回一个视图名称或模型数据；DispatcherServlet根据返回值解析为具体的视图；
		Controller方法通过Model对象添加数据，再将其传递到视图中；
	5. 视图渲染，根据解析得到的视图名称，DispatcherServlet委托给视图解析器来找到渲染视图。常见的视图解析器有JSP、Thymeleaf、FreeMarker等；
	6. 返回响应，渲染完成后，生成的HTML内容作为响应体返回给客户端；
	7. 客户端渲染，客户端（浏览器）接收到响应后，将渲染并显示页面给用户；
	
	其余过程：
		1. 资源处理，静态资源请求，如CSS、JavaScript文件和图片等，SpringMVC可以配置静态资源的映射路径，由DispatcherServlet处理这些资源的请求；
		2. 异常处理，请求处理过程中出现异常，Spring MVC异常解析器（HandlerExceptionResolver）将捕获这些异常，并将其映射到错误处理视图；
		3. 日志记录，SpringMVC可以配置日志记录器，记录处理过程，以便于调试和监控；

struts

定义：
	是一个开源的web框架；
缺点：
	1. form表单处理；
		处理复杂，需要在ActionForm中定义与HTML表单元素对应的属性，并实现相应的getter和setter方法。
	2. action单态模式；
		对于网站并发性的处理有影响；
		Struts1中的Action是单例模式的，这意味着对于所有的请求，服务器内存中只有一个Action类实例来处理

ssm架构

概念：
	ssm = Spring+SpringMVC+MyBatis ，其中Maven来创建Web项目，便于管理项目中所需的依赖；
	所需依赖（包括但不限于）：日志类 log4j-slf4j-impl、log4j-web； MySQL驱动包 mysql-connector-java
	打包一般采用war包，并在tomcat上运行
	
三框架介绍：
	Spring、SpringMVC 和 MyBatis 这三个框架在Java Web开发中各自承担着不同的职责，并通过集成实现了前后端分离、业务逻辑处理和持久层操作等功能。
Spring：
	Spring 是一个轻量级的企业级 Java 应用框架，它的核心功能包括依赖注入（DI, Dependency Injection）和面向切面编程（AOP, Aspect Oriented Programming）。Spring 负责管理整个应用程序的对象生命周期和依赖关系，使得对象之间的耦合度降低，便于测试和维护。同时，Spring 提供了事务管理、数据访问抽象层（如JDBC模板、Hibernate模板等）、以及对其他各种第三方框架的良好集成能力。
mybatis：
	MyBatis 是一个优秀的持久层框架，专注于SQL映射和动态SQL生成。它负责数据库的操作，包括增删改查（CRUD）等，程序员可以编写原生SQL语句并通过Mapper接口进行调用，MyBatis会自动处理结果集映射到Java对象的过程，简化了数据库访问层的开发。
springMVC：
	SpringMVC 是Spring框架的一个模块，用于构建Web应用程序的模型-视图-控制器（MVC）架构。它负责接收HTTP请求，解析参数，调用相应的Service处理业务逻辑，最后返回响应给客户端。具体流程包括：DispatcherServlet作为前端控制器接收请求，通过HandlerMapping映射到Controller处理方法，Controller调用Service完成业务逻辑，Service再调用DAO（Data Access Object）执行数据库操作（通过MyBatis），返回结果后由Controller组织视图数据并选择合适的视图渲染给用户。

业务逻辑：
	整合后的系统中，Spring容器统一管理所有的Bean，包括Service层的类、MyBatis中的Mapper接口和数据源等。
	==》当用户发起HTTP请求时，请求会被SpringMVC的DispatcherServlet捕获并根据配置分发给对应的Controller；
	==》Controller在接收到请求后，会调用Service层的方法处理业务逻辑，这些Service对象是由Spring容器创建并注入进来的；
	==》Service层在执行业务逻辑过程中，如果涉及到数据库操作，则会进一步调用已由Spring管理的MyBatis Mapper接口，MyBatis会执行预编译的SQL语句并返回结果给Service；
	==》Service层处理完成后，将结果返回给Controller，Controller再决定如何组装视图数据并转发至指定的视图（可能是HTML页面、JSON数据或其他格式）展示给用户；
	其中持久层（Mapper）、业务层（Service）、控制层（Controller），采用的注解分别为：@Repository、@Service、@Controller
	完整请求链：
		客户端请求 -> SpringMVC -> Service -> MyBatis -> 数据库 -> 数据结果 -> Service -> 视图渲染 -> 响应给客户端。在这个过程中，Spring起到了粘合剂的作用，将各个层次紧密地联系在一起，降低了各组件之间的耦合度，提高了整体架构的可扩展性和灵活性。

Springboot架构

概念：
	SpringBoot简化了Spring应用的创建、运行、调试、部署等，依赖“约定大于配置”的理念，不需要过多关注XML配置，使开发者更多的关注于应用的开发；
	通过基础的POM文件，就可以实现Maven配置；
	可支持独立的jar包运行；
	内嵌Servlet容器，即免费的tomcat服务；
	能够快速整合第三方框架，基本原理是：Maven的依赖关系，maven的集成，完全注解化，简化XML配置，内嵌tomcat，以java应用程序执行。

注解：
	@Controller controller层 注入服务
	@Service 注入dao
	@repository 实现dao
	@component 标注一个类为Spring容器的Bean

已了解项目：

spingboot + mybatisPlus + zookeeper + redis + xxljob 这种构建方式；
	项目整体搭建springboot，mybatisPlus持久化操作，zookeeper分布式协调服务，redis缓存，xxljob分布式任务调度；

Springboot项目构建

位于domain文件夹下
	DTO 主要用于接口之间的数据传递，尤其是在服务层和控制器层之间；
	Vo 是值对象（Value Object）的缩写，通常用于表示一个不可变的对象，常用于前端页面的数据展示；
	response 是接口返回结果的封装对象，通常用于统一接口的响应格式。
config

constants

controller

dao
	xxxReponstity 封装数据库的操作；
exception
handler
service
	impl实现
	接口
utils

Springboot注解

A

@Aspect

定义：
	切面 = 将那些影响了多个类的公共行为抽取到一个可重用模块里；
使用：
	常用于记录日志、异常集中处理、权限验证、Web 参数校验、事务处理等等。

@Aspect
@Component 
// 需要与Component一起使用
public class LogsAspect {
        @Around("(execution(* com.unicom.opn.api.core.controller.*.*(..))))")
        // 标注使用范围
        // 环绕通知：目标方法执行前后分别执行一些代码，类似拦截器，可以控制目标方法是否继续执行。
        public Object aroundMethod(ProceedingJoinPoint pjp) throws Throwable {}
        // 标记切点
}

使用三步走：
1）在类上使用 @Aspect 注解使之成为切面类
2）切面类需要交由 Spring 容器管理，所以类上还需要有 @Service、@Repository、@Controller、@Component  等注解，一般会和@Component一起使用
3）在切面类中自定义方法接收通知

@Autowired

可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。

1. 注解修饰成员属性，则无需使用set方法，就可以实现对属性的设置。

public class 当前类{
	@Autowired 
	private 接口 对象名;
}
// 表示将对象名 引入 当前类；
// 成员属性，会根据成员类型匹配对应的bean进行装配；如果类型是接口，那么会自动装配接口的实现类对象；
// 本质采用的是java的反射机制实现，将成员对象Bean注入到具体对象。

@AllargConstructor

注在类上，提供类的全参数构造函数；

@Around

定义：
	环绕通知，是使用最频繁的方式，会将整个方法（此方法）包围起来。
使用：
	@Around（execution（[修饰符模式]？<返回类型模式><方法名模式>（<参数模式>）[异常模式]？））
	// 参数execution =设置此方法的调用情况。
	// 除了返回类型模式，方法名模式和参数模式外，其余都是可选填项。
	修饰符模式 = 表示哪类型方法（publc、private、protected等），不写就是所有方法；
	返回类型模式 = 表示返回值的类型；
	方法名模式 = 具体的包名
案例：
	@Around(execution(* com.unicom.opn.api.core.controller..*.*(..))))
	// 修饰符模式 = 没有书写，说明是所有方法；
	// 返回值类型 = * 表示全部类型
	// 方法名模式 = com.unicom.opn.api.core.controller 具体的包名
		// .. = 表示包以及包下所有子包
		// * = 表示全部
		// .*(..) = 表示全部方法

@ApiResponses @ApiResponse

作用：
	描述API可能的响应状态码及其含义，帮助开发者理解API在不同情况下的行为。
使用位置：
	通常在处理HTTP请求的方法上使用，配合@Operation一起使用。
参数：
	@ApiResponses：一个容器，可以包含多个@ApiResponse。
	@ApiResponse：每个实例描述一个HTTP状态码及其含义。
		responseCode：HTTP状态码，如"200"、"400"等。
		description：对状态码的详细描述，说明在什么情况下返回该状态码。

B

@Bean

定义:
	修饰方法的注解，告诉方法，产生一个Bean对象，并交由Spring管理。

@Builder

概念：
	为类生成相对复杂的构造器API。
特点：
	作用于类，将其变成创建者模式；
	以链的形式调用；
	生成一个全参的构造方法；
	自动生成的构建器会要求你为每个字段提供一个值；
缺点：
	没有无参构造方法；

理解：

// 定义
@Builder
public class xx1{
	private Integer a;
	private String b;
}
// .class文件
// 该方法编译后的文件为：
public class xx1 {
    private Integer a;
    private String b;

    xx1(final Integer id, final String name, final Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public static xx1.xx1Builder builder() {
        return new xx1.xx1Builder();
    }

    public static class xx1Builder {
        private Integer a;
        private String b;

        FatherBuilder() {
        }

        public xx1.xx1Builder a(final Integer a) {
            this.a = a;
            return this;
        }

        public xx1.xx1Builder b(final String b) {
            this.b = b;
            return this;
        }

        public Father build() {
            return new Father(this.a, this.b);
        }

        public String toString() {
            return "xx1.xx1Builder(a=" + this.a + ", b=" + this.b + ")";
        }
    }
}

// 使用:
public xx1 function1(String salt){
	return xx1.builder()
			.a(this.a)
			.b(function2(salt))
			.build();
}

C

@Configuration

定义：
	用于定义配置类，可替换xml配置文件；
	被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

解释“用于定义配置文件，可替换xml配置文件”

基于xml的配置，该文件通常位于src/main/resources目录中；
在xml文件中，可以配置bean和配置其他组件；

<!-- 具体案例是：-->
<!-- applicationContext.xml -->
<?xml version="1.0" encoding="UTF-8"?>
// 标准的xml申明，指明版本号以及编码类型；
<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">
<!-- beans根元素 -->
<!-- xmlns：定义xml文件使用的命名空间 -->
<!-- xmlns：xsi 指定xml schema实例的命名空间-->
<!-- xsi：schemaLocation 指定xml wchema文件的位置 -->
    <bean id="myService" class="com.example.MyServiceImpl">
        <!-- 配置属性 -->
        <property name="property" value="value"/>
    </bean>
    // bean 定义spring管理的bean
    // id 该bean的唯一标识符
    // class 该bean的实现类
    // 标签property 该bean的属性定义，其中属性名是property 值是value

    <!-- 可以添加更多的bean定义 -->
</beans>

@ConditionalOnMissingBean

定义：
	用于判断指定的类是否在BeanFactory中；
	指定的类如果在BeanFactory中，则匹配失败；反之，则匹配成功，则执行方法；
	当BeanFactory中没有指定的bean的时候才能匹配，主要是用来做自动配置的，当程序没有配置指定类的时候，就会使用默认配置;
案例：
	@ConditionalOnMissingBean(ObjectMapper.class)
	public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder)
	// 当Bean工厂没有ObjectMapper的Bean，才创建jacksonObjectMapper的Bean。

@Component

定义：
	修饰类，表示将该类交由Spring管理，即标注该类为Spring容器的bean。

@ComponentScan

定义：
	用于类或接口上，主要是指定扫描路径；
作用：
	spring会把指定路径下带有指定注解的类自动装配到bean容器里。
	指定注解包括：@Controller、@Service、@Component、@Repository等注解标注的类。

@ConfigurationProperties

定义：
	@ConfigurationProperties（prefix="main"）
	最适用于所有具有相同前缀的分层属性，用于将配置文件中mail开头的属性绑定到POJO中

@CrossOrigin

理解：
	前后端分离项目，需要跨域，当前前端可以用JSONP解决，java端通过@CrossOrigin实现；
	跨域：
		浏览器出于安全性考虑，不执行其他网站的脚本；由于其同源策略造成的；	
作用：
	用来处理跨源资源共享（CORS）的注解；
	跨源资源共享（CORS），是由大多数浏览器实现的W3C规范，允许对跨域请求进行灵活授权，用来代替IFRAME或JSONP等非正规实现方式；
举例：
	当前端应用尝试从不同的域名、端口或协议请求数据时，浏览器为了安全按考虑会阻止这种请求，除非服务器明确允许；
	--》不添加@CrossOrigin
	意味着来自不同源的AJAX请求可能会被浏览器阻止。前端运行在http://localhost:3000 而后端运行在http://localhost:8080，那么前端发起的请求可能会因为跨域问题而失败；也就是相同的域名地址，不同的port，表示不同的域；
	--》添加@CrossOrigin
	希望允许特定来源的前端应用访问服务的REST API，可以在控制器方法或类级别使用该注解，显式得开启CORS支持；

@Controller

定义：
	是一个通用的控制器注解，用于标记一个类作为 Spring MVC 的控制器。
	它通常与视图解析器（如 InternalResourceViewResolver）配合使用，返回视图名称（如 JSP 文件路径），并渲染 HTML 页面。
案例：
	@GetMapping("/hello")
    public String hello() {
        return "hello"; // 返回视图名称，例如 /WEB-INF/views/hello.jsp
    }
    // 默认情况下，@Controller 返回的是视图名称（字符串），需要通过视图解析器解析为实际的视图文件（如 JSP、Thymeleaf 模板等）。

D

@Documented

定义：
	用于指示编译器将被它修饰的注解信息是否要包含在生成的API文档中，该注解存在-被记录；反之，不被记录。

@Data

🍇 概述

使用前提：
	在项目依赖中引入lombok，其是一个工具类库，以简化代码，提高开发效率；
	idea开发工具中，需要下载lombok插件；
作用：
	修饰类，提供类get、set、equals、hashCode、canEqual、toString方法。

🍇 案例

// java类
@Data
public class Xxx{
	private String id;
}
// .class文件
public class Xxx{
	private String id;
	// get/set方法
	public void setId(String id){this.id=id;}
	public String getId(){return id;}
	// toString
	@Override
	public String toString(){
		return "Xxx{"+"Id"+id+"}";
	}
	@Override
	public boolean equals(Object o){...}
	@Override
	public int hashCode(){...}
}

E

@EnableWebSecurity

定义：
	是 Spring Security 提供的一个注解，用于启用基于 Spring MVC 或 Spring WebFlux 的应用程序的安全性支持。
	修饰类，会自动配置一些默认的安全行为，同时允许你通过配置类来定制安全策略。
注意：
	在 Spring Security 5.x 及以上版本中，通常需要扩展 WebSecurityConfigurerAdapter 类来提供安全配置；

案例：

@Configuration
@EnableWebSecurity
public class WebAPISecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(WebSecurity web) throws Exception {
web.ignoring().antMatchers("/xx1/**","/xx2/**","/xx3/**","/html/oauth/protocol.html","/html/oauth/protocol2.html","/html/oauth/protocol3.html","/html/oauth/protocol4.html");
    }
    // web.ignoring().antMatchers()指定不需要保护的url模式；

    @Override
    protected void configure(HttpSecurity http) throws Exception {
    // 配置http安全性；
        http.csrf().disable() // 禁用了CSRF保护，通常见于开发环境，生产环境中谨慎使用
                .authorizeRequests() 
                .anyRequest().permitAll() // 任何请求都不需要认证，都被允许访问；
                .and().logout().permitAll() // 登出端点对所有用户开放；
                .and().headers().xssProtection(); // 启用XSS防护，通过响应头X-XSS-Protection字段实现；
    }
}

@EqualsAndHashCode

定义：
	注在类上，提供对应的equals和hashCode方法；
注解属性介绍：
	of = 表示在equals、hashcode方法中是否会使用of数组中指定的属性；of属性值只能填写子类中的属性
	callSuper = 表示在equals、hashcode方法中是否会引用当前类的父类中的属性；

@ExceptionHandler

定义：
	@ExceptionHandler(异常类.class)
	public 返回值 funtion(){}
	注在方法上，注解名后的括号=指明要捕获哪些异常，该方法function = 指明对异常进行如何处理。

@ExtendWith

定义：
	注解告诉JUnit使用指定的扩展（Extension）来增强测试类的行为;
案例：
	@ExtendWith(SpringExtension.class)
	// SpringExtension是Spring提供的一个测试扩展，它允许你使用Spring的测试支持框架，例如@SpringBootTest，@WebMvcTest，@DataJpaTest等注解来自动配置Spring环境，从而更容易地测试Spring应用程序。

Entity

定义：
	标记一个类为 JPA 实体类，表示该类映射到数据库中的一张表。
	是 JPA（Java Persistence API）规范中的一个注解，定义在 javax.persistence 包中。
使用：
	默认情况下，会将Xxx类对应xxxx表；
	如果不具有对应关系，则通过@TableName实现；	

F

G

@Getter

定义：
	注在类上，提供该类所有属性的get方法；
	注在属性上，提供该属性的get方法。

@GeneratedValue

来源：
	是 JPA 规范中的一个注解，定义在 javax.persistence 包中。
作用：
	指定主键的生成策略，告诉 JPA 如何生成主键值。
属性：
	strategy==》定义了主键生成的方式，如下是属性值：
	GenerationType.IDENTITY：主键由数据库自动生成（通常是自增列）。
	GenerationType.AUTO：让 JPA 自动选择适合的策略（默认值）。
	GenerationType.SEQUENCE：使用数据库序列生成主键。
	GenerationType.TABLE：使用一张专门的表来模拟主键生成。

H

I

@interface

定义：
	自定义注解，且自动继承java.lang.annotation.Annotation接口。
	@interface声明一个注解，定义成员变量与类型；
案例：
	public @interface RequestJson {
    	String value() default "";
	}
	// 其中，RequestJson是注解名，@interface表示自定义注解。
	// 方法名 = 成员变量名；方法返回值 = 变量类型；
	// 成员变量是value，类型是String

@Inherited

定义：
	元注解，用来注解该注解可以被继承，通常与@interface一起使用；
使用：
	只能应用于类级别（如类、接口、枚举）的注解；
案例：
	@Inherited
	public @interface xxAnnotation{
		String value() defalut "";
	}

	@xxAnnotation("father")
	public class fatherClass{}

	public class childClass extends fatherClass{}
	// 上述情况中，childClass继承fatherClss，并自动继承xxAnnotation注解；

@Import

定义：
	用来导入配置类或者一些需要前置加载的类。

@Id

定义：
	标记实体类中的某个字段为主键（Primary Key），表示该字段唯一标识数据库表中的每一行。
来源：
	是 JPA 规范中的一个注解，定义在 javax.persistence 包中。

J

@ JsonInclude（xxx）

定义：
	修饰类（实现Serializable），则该实体类序列化成json时，在某些策略下，某些字段不去序列化。
xxx值介绍如下：
	JsonJsonInclude.Include.ALWAYS：
	表示总是序列化所有属性 always
	JsonJsonInclude.Include.NON_NULL：
	表示序列化非null属性   non_null
	JsonJsonInclude.Include.NON_ABSENT： non_absent
	表示序列化非null或者引用类型缺省值，例如java8的Optional类，这个选中通常与Optional一起使用
	JsonJsonInclude.Include.NON_EMPTY： non_empty
	表示序列化非Empty的属性，例如空的集合不会被序列化
	JsonJsonInclude.Include.NON_DEFAULT： non_default
	仅包含与POJO属性默认值不同的值
	JsonJsonInclude.Include.CUSTOM： custom
	由{@link JsonInclude＃valueFilter}指定值本身，或由{@link JsonInclude＃contentFilter}指定结构化类型的内容，由过滤器对象的equals方法进行序列化，返回true则会被排除，返回false会被序列化
	JsonJsonInclude.Include.USE_DEFAULTS：使用默认值 

K

L

@Log4j

定义：
	注在类上，提供对应的Logger对象，其变量名为log

M

@MapperScan

定义：
	指定包下面的所有接口，在编译之后生成相应的实现类。
	该注解可以告诉MyBatis框架在哪里扫描Mapper接口，并将其注册为一个Spring的Bean，使得Mapper接口可以被自动注入到其他组件中，便于省略手动配置Mapper接口实现类的步骤。

案例：
	@MapperScan("com.unicom.opn.api.dao.mapper")
	@ComponentScan("com.unicom")
	@SpringBootApplication
	public class App {
	    public static void main(String[] args) {
	        SpringApplication.run(App.class, args);
	    }
	}

@Mapper

定义:
	注解一个接口
作用:
	@Mapper将定义的接口交给Spring进行管理；
	不用写Mapper.xml文件；为这个接口生成对应的实现类，让别的类引用。

@MockBean

作用：
	将Mock对象添加到Spring上下文中；
	被注解修饰的对象，将替换Spring上下文中任何相同类型的现有bean，如果没有定义相同类型的bean，将添加一个新的bean。

N

@NoArgsConstructor

作用：
	注在类上，提供无参构造方法。

@Nullable

作用：
	可以注在方法、属性、参数上，分别表示方法的返回值为空、属性值为空、参数值为空。

O

@Overrride

定义：
	是Java5的元数据，自动加上去的一个标志；
	表示被修饰的方法是：从父类/接口 继承过来的，需要重写一次；

@Order(参数)

定义：
	定义Spring IOC容器中Bean的执行顺序的优先级，而不是定义Bean的加载顺序，Bean的加载顺序不受@Order或Ordered接口的影响；
参数设置：
	@Order(参数)
	参数值，越大，说明Bean的执行优先级越低；
	参数值，越小，说明Bean的执行优先级越高；
处理场景：
	在处理多个相同类型或功能的bean时尤为重要，比如多个拦截器、过滤器或后置处理器等。

@Operation

作用 ：
	为具体的API操作提供详细描述，帮助说明该API的功能和用途。
使用位置 ：
	通常在处理HTTP请求的方法上使用。
参数 ：
	summary：简短的操作说明，通常是一句话概括API的功能。
	description：详细的操作描述，可以包含更多细节，如请求参数、返回值等。
	tags：指定该操作所属的标签，可以与@Tag配合使用。
案例：
@Operation(summary = "获取用户信息", description = "根据用户ID获取用户详细信息", tags = "用户相关接口")
@GetMapping("/{userId}")
public ResponseEntity<User> getUserById(@PathVariable String userId) {
    // 获取用户信息的逻辑
}

P

@PostConstruct

定义：
	被@PostConstruct注解的方法在项目启动的时候执行这个方法，即在spring容器启动的时候执行。

@Primary

定义：
	当有多个相同类型的bean时，使用@Primary来赋予bean更高的优先级；
使用:
	@Bean和@Primary一起使用，说明该对象具有较高的优先级；	

R

@Retention(RetentionPolicy.RUNTIME)

定义：
	说明自定义注解的生命周期。
	RetentionPolicy.RUNTIME = 始终不会丢弃，运行期也保留该注解。
使用：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) // 定义注解的生命周期
public @interface ServiceId {
    BusinessEnum value();
}

@RestController

定义：
	@controller和@ResponseBody 的结合
	前者 = 该类是一个控制器，负责接收请求、处理请求，并返回响应；
	后者 = 将请求响应的数据以指定的格式写入到Response的body中。
作用：
	默认情况下，@RestController 的所有方法都会将返回值直接写入 HTTP 响应体中，无需额外添加 @ResponseBody。
	它适用于构建 RESTful API，返回 JSON 或 XML 数据，而不是视图。

@RequestMapping

定义：
	将任意HTTP请求 映射到控制器方法上来。
	将请求和处理请求的控制器方法关联起来，建立映射关系。
	即可修饰类，也可以修饰⽅法，当修饰类和方法时，访问该方法的Url地址是：类 + 方法。

1. @GetMapping和@PostMapping
@GetMapping = 用于将HTTP get请求映射到特定处理程序；
	@GetMapping = @RequestMapping（method = RequestMapping.GET）
@PostMapping = 用于将HTTP post请求映射到特定处理程序；
	@PostMapping = @RequestMapping（method = RequestMapping.POST）

2. Post请求和get请求
get请求将参数放在链接上，即xxx?参数1=值1&参数2=值2
post请求将参数放在请求体中；

3. get请求比post请求更快？
浏览器请求服务器需要经过固定的三次握手连接过程，但是在数据传输方面两者存在差异；
post请求会发送两次数据，一次是请求头，得到服务返回的100 continue回复；第二次是数据，得到服务器返回的200 OK响应。
而get请求，数据只会传送一次；

4. get/post请求区别：
post比get更安全，get会被浏览器缓存，进而提高重复内容的检索效率；
post比get传输的数据更多，数据类型更多；
post比get慢；
post一般用于修改和写入数据，get一般用于检索或筛选之类的。

@ResponseBody

定义：
	将controller的方法返回的对象，通过合适的转换器，转换为指定的格式，写入到response对象的body区（响应体中），通常用来返回JSON或XML。

@RestControllerAdvice

定义：
	用于定义全局异常处理和全局数据绑定的类；
	被应用于带有@Controller和@RestController注解的类上，即包括类中的方法被前两个注解修饰；
	用于统一处理这些类中抛出的异常，并对返回的数据进行统一处理。

@ResponseStatus

用法：①加在自定义异常类上；②加在目标方法上。
属性：code、value、reason。
加在目标方法上：
	value = 设置异常的状态；
	reason = 异常的描述；
加在@ExceptionHandler下方：
	捕获异步请求异常 = 当方法捕获到异常后，返回HTTP响应的状态码为@ResponseStatus指定的状态码；

参考：
https://blog.csdn.net/ITWANGBOIT/article/details/103718926
	不加ResponseStatus，则抛出自定义异常，以500的HTTP状态码响应到浏览器；
	加ResponseStatus，抛出自定义异常的同时，以指定的HTTP状态和指定的reason响应到浏览器。

@RequestParam

作用：将请求中指定名字的参数 赋值给控制器中的形参；

public Double xhjTestRisk(@RequestParam("mobile") String mobile,@RequestParam("mobile1") String mobile1,@RequestParam("tableName") String tableName){}

@RunWith（SpringRunner.class）

作用：
	表明Test测试类要使用注入的类。
案例：
	比如@Autowired注入的类，有了@RunWith(SpringRunner.class)这些类才能实例化到spring容器中，自动注入才能生效

@RequestHeader

定义：
	用于从 HTTP 请求头（Headers）中提取指定的字段值，并将其绑定到方法的参数上。
使用：
	如果没有指定字段名，是不是默认将header中所有字段，绑定到方法的参数上；
	@RequestHeader Map<String,String> headerMap 会将所有请求头字段及其对应参数绑定到map中；
注解方法：
	public @interface RequestHeader {
	// 指定要绑定的请求头字段的名
	@AliasFor("name") // @AliasFor 实现互为别名
	String value() default "";
	// 要绑定请求头字段名对应的值
	@AliasFor("value")
	String name() default "";
	// 请求头字段是否为必需的；
	boolean required() default true;
	// 用于指定默认值，没找到对应字段，则使用默认值；
	String defaultValue() default ValueConstants.DEFAULT_NONE;
	// 提供defaultValue，则required被隐式设置为false
}

@RequestJson

定义：
	非官网注解，通常用于将 HTTP 请求体（Body）中的 JSON 数据直接反序列化为 Java 对象；
	Spring官方注解是@RequestBody

@RequestBody

定义：
	通常用于将 HTTP 请求体（Body）中的 JSON 数据直接反序列化为 Java 对象；
案例：
	

@RequiredArgsConstructor

🍇 概述

定义：
	是 Lombok 提供的一个注解，用于自动生成类的构造函数。
	主要作用是为类中所有的 final 字段 或 带有 @NonNull 注解的字段 自动生成一个构造函数。

🍇 案例

// java类
@RequiredArgsConstructor
public class User {
    private final String username; // final 字段
    private final String email;   // final 字段
    private String address;       // 普通字段，不会包含在构造函数中

    @NonNull
    private String phoneNumber;   // 带有 @NonNull 注解的字段
}

// 生成的.class文件
public class User {
    private final String username; // final 字段
    private final String email;   // final 字段
    private String address;       // 普通字段，不会包含在构造函数中

    @NonNull
    private String phoneNumber;   // 带有 @NonNull 注解的字段
    // 🍐 自动生成构造有参构造方法
	public User(String username, String email, String phoneNumber) {
	    this.username = username;
	    this.email = email;
	    this.phoneNumber = phoneNumber;
	}
}

S

@SpringBootTest(classes = {Application.class})

定义：
	表明该类是测试类。
参数：
	classes =  指定一个类数组，这些类将会被包含在测试的Spring Boot应用上下文中。如果未指定，将默认使用测试类所在的类路径。

@Slf4j

定义：
	注在类上，提供对应的Logger对象，变量名为log，用作日志输出。
	可以在该类中直接使用log对象。

private final Logger logger = LoggerFactory.getLogger(当前类名.class); 
// 这句代码，实现log.info()日志输出。

常用方法：

方法名	含义
.error	打印错误信息，详细到栈跟踪信息
.log(Level level,String msg)	输出日志，参数（日志级别，日志信息）
.info	日志记录方式，用于记录程序的运行状态、事件或重要信息

@Service

定义：
	注解在类上，将类声明为业务逻辑组件，将其对象存入Spring容器中，表示其是一个服务层Bean。
使用：
	注入等于通过@AutoWired修饰控制类的成员属性；
	在控制器类中，注入该组件的实例，即可调用其中的方法。
参考：
	https://blog.csdn.net/juggle_gap_horse/article/details/128972813

@SpringBootApplication

定义：
	组合注解，一般用于SpringBoot项目的启动类上；
	包含：@ComponentScan、@EnableAutoConfiguration、@Configuration组成；
成员注解含义：
@ComponentScan
指定要扫描的组件包的路径，并将其注册为Spring容器的组件；

@EnableAutoConfiguration
根据应用程序的类路径和所声明的依赖来决定自动配置的内容，并将其添加到容器中；

@Configuration
表示该类是配置类，声明了一个或多个bean的定义，该多个bean被注解到Spring容器，供应用程序使用。

@Setter

定义：
	注在属性上，提供set方法；

@SneakyThrows

作用：
	只作用于方法或构造函数之上；
出现原因：
	普通的Exception类，即受检异常或Checked Exception会强制要求抛出它的声明throws，调用者显示的处理这个异常；
	大多数情况下，处理该种情况会变成在外面包一层RuntimeException，接着往上丢；
例如：
try {
	// 业务代码
} catch(Exception e) {
	throw new RuntimeException(e);
}
使用@SneakyThrows可以消除这样的模板代码，不需要担心Exception处理，该注解会自动处理。

例如：
原始的run方法为：
@Override
    @SneakyThrows
    public void run() {
        throw new Throwable();
    }

其.class文件为：
public void run() {
     try {
         throw new Throwable();
     } catch (Throwable var2) {
         throw var2;
     }
}

@Size

定义：
	是 JSR 380（Bean Validation 2.0）规范中的一个标准注解，用于验证字符串、集合、数组等类型的长度或大小是否符合要求。
案例：
	@Size(min = 6, max = 20, message = "长度6-20位")
	// 校验该参数的长度；

T

@Target(ElementType.PARAMETER)

定义：
	注解的注解，又称为元注解，用于描述注解的使用范围。
使用：
@Target(ElementType.METHOD) // 表示该注解用于描述方法
@Retention(RetentionPolicy.RUNTIME)
public @interface ServiceId {
    BusinessEnum value();
}
使用注解：
authSwap(HttpServletRequest request, HttpServletResponse response, @RequestJson BaseParams baseParams)

参数列表：

参数名	含义
ElementType.PARAMETER	该注解只能声明在一个方法参数前，即只能用于描述参数。
ElementType.METHOD	用于描述方法

@TableName(表名)

定义：
	MyBatis-Plus框架中的注解，用于标识实体类对应的数据库表名。

@TableId（属性）

定义：
	用于在java中标识一个数据表的主键字段。
使用：
	@TableId("xxx_t")
	// 注解（数据表中的属性键）
	private 类型 xxxT；
	// 数据类型 属性名  =》表示实体类中对应字段含义。

@TableFiled

定义：
	用来解决实体类的字段名与数据库中的字段名不匹配的问题。
使用：
	@TableFiled("yyy")
	// 注解（数据表中的属性键）
	private 类型 xxx；
	// 数据类型 属性名  =》表示实体类中对应字段含义。

@Test

定义：
	注解在某个方法上，标识测试方法；

@Transactional

定义：
	@Transactional(rollbackOn = Exception.class) 是一个注解，通常用于 Java 的 Spring 框架中，用来管理事务（Transaction）。它的作用是声明某个方法或类需要在事务的上下文中执行，并且可以指定在哪些异常发生时回滚事务。
使用：
	开启事务 ：当方法被调用时，Spring 会自动开启一个事务。
	提交事务 ：如果方法成功执行完毕且没有抛出异常，事务会被提交。
	回滚事务 ：如果方法执行过程中抛出了异常，事务会被回滚。
rollbackOn属性：
	如果方法抛出的是 unchecked exception （即继承自 RuntimeException 的异常）或 Error ，事务会被回滚。
	如果方法抛出的是 checked exception （即普通的 Exception），事务不会自动回滚。
其他属性：
	propagation ：定义事务的传播行为（如是否开启新事务、是否加入现有事务等）。
	isolation ：定义事务的隔离级别（如读未提交、读已提交等）。
	timeout ：定义事务的超时时间。
	readOnly ：标记事务是否为只读。

@Tag

作用:
	用于对API接口进行分类，帮助组织和管理相关的API操作。
使用位置:
	通常在控制器类上使用。
参数 ：
	name：标签的名称，用于分类API。
	description：对标签的详细描述，帮助理解该分类的用途。
案例：
	@Tag(name = "用户相关接口", description = "处理用户注册、登录等操作")
	@RequestMapping("/api/users")
	public class UserController {
    	// 控制器方法
	}	

V

@Value

🍇 概述

定义：
	动态读取配置文件中的某个系统属性；
使用：
	三种使用方式：注入普通属性、注入配置文件、注入表达式并计算。
	@Value(value = "${env}")  注入普通属性
	@Value(value = "${server.port}") 注入服务器端口
	参数来自于项目配置文件 = application.yml
	spring项目读取配置文件的方式：①使用@Value；②SpringBoot中的@Configuration；
表达方式：
	@Value("${env}")
	@Value(value = "${env}")

@Validated @Valid

🍇 Validate 概述

定义：
	 是 Spring 框架中的一个注解，主要用于方法级别的参数校验 或类级别的分组校验；
作用：
	启用校验功能 ：在类或方法上标注 @Validated 后，Spring 会对标注了校验注解（如 @Valid 或约束注解）的参数进行校验。
	支持分组校验 ：可以通过定义校验组来实现对不同场景下的字段进行差异化校验。
	适用于 Spring Bean ：@Validated 通常用于 Spring 管理的 Bean（如 Controller、Service 等）。
区别：
	@Valid ：
		是 JSR 380 规范中的标准注解。
		通常用于方法参数或嵌套对象的校验。
		不支持分组校验。
	@Validated ：
		是 Spring 提供的扩展注解。
		支持分组校验。==》 根据不同场景对相同字段进行差异化校验；
		可以直接用于类或方法级别，适用于 Spring Bean。

W

@WebMvcTest

定义：
	是 Spring Boot 提供的一个测试注解，用于对 Web 层（主要是控制器层）进行单元测试。
	它会自动配置一个模拟的 Spring MVC 环境，而不会启动整个 Spring 应用上下文，这样可以更快地运行测试并且专注于 Web 层的功能。
案例：
	@WebMvcTest(value = {xxx.class}, properties = {"task.enabled=false","prometheus.enabled=false"})
	// 理解：
	// value = {xxx.class} --》 指定要测试的控制器类；
	// properties = {"task.enabled=false","prometheus.enabled=false"} --》这个属性列表允许在测试期间覆盖应用的默认属性。

X

@Xxljob

定义：
	注解一个方法或类，表示是一个XXL-JOB任务执行的入口；
使用：
	注解在类上，表示该类中所有的方法都可以被xxl-job调度执行；
	注解在方法上，表示该方法可以被xxl-job调度执行。

思考

1 Component和Bean的异同

相同点：
	他们都是创建Bean，并交由Spring管理
不同点：
	用法不同：
		@Component修饰类，@Bean修饰方法；
		@Bean书写有两种情况，一种是配置类，一种是非配置类；具体的区别后续？
	用途不同：
		控制Bean的实例化过程不同；
			@Bean：实现方式：new xxxObject(); 创建匿名对象；创建动态代理对象；
			@Component：通过反射，调用无参构造方法实现；
		控制第三方jar包里面的Bean；
			@Bean：可以实现；
			@Component：不能去修改第三方jar包里面方法的注解；

最后