web项目开发所涉及基础内容

servlet+tomcat

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

工作模式：

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

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

结合springmvc和tomcat实现：
引入依赖spring-boot-starter-web，会内嵌tomcat以及springmvc框架；
自动配置，检测到tomcat自动配置web应用的默认环境，自动配置springmvc，以及设置dispatcherServlet为请求的前端控制器；
	DispatcherServlet，springmvc的核心组件，负责接收所有的http请求；
	请求到达Tomcat时，会转发请求给DispatcherServlet。
请求映射，DispatcherServlet解析请求链接，找到对应的处理器（Controller），通过@RequsetMapping 注解实现；
处理请求，DispatcherServlet调用响应的控制方法，可以是@Controller、@RestController、@RequestMapping注解修饰的java方法；
视图解析，

struts
struts是一个开源的web框架；

ssm架构

Spring+SpringMVC+MyBatis ，其中Maven来创建Web项目，便于管理项目中所需的依赖；
所需依赖包，包括（但不限于）：
	日志类 log4j-slf4j-impl、log4j-web 
	MySQL驱动包 mysql-connector-java
	
打包上线采用war包，并在tomcat上运行；

Spring、SpringMVC 和 MyBatis 这三个框架在Java Web开发中各自承担着不同的职责，并通过集成实现了前后端分离、业务逻辑处理和持久层操作等功能。下面分别解释每个部分的作用以及它们之间的交互方式：

作用: 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数据或其他格式）展示给用户。
这样就形成了一个完整的请求处理链路：客户端请求 -> SpringMVC -> Service -> MyBatis -> 数据库 -> 数据结果 -> Service -> 视图渲染 -> 响应给客户端。在这个过程中，Spring起到了粘合剂的作用，将各个层次紧密地联系在一起，降低了各组件之间的耦合度，提高了整体架构的可扩展性和灵活性。

其中持久层（Mapper）、业务层（Service）、控制层（Controller），采用的注解分别为：@Repository、@Service、@Controller

SpringBoot架构

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

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

tomcat

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

hibernate

Hibernate是Java领域常用的持久化框架，用于将对象关系映射（ORM）到关系型数据库。

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）切面类需要交由 Sprign 容器管理，所以类上还需要有 @Service、@Repository、@Controller、@Component  等注解，一般会和@Component一起使用
3）在切面类中自定义方法接收通知

1. filter、interceptor、aspect区别：
   filter = 作用于servlet
   interceptor = 作用于URL
   aspect = 作用的对象可以是任何一个方法

@Autowired

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

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

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

@AllargConstructor

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

@Around

环绕通知，可以说是使用最频繁的方式，会将整个方法（此方法）包围起来。
参数execution=设置此方法的调用情况。

execution（<修饰符模式>？<返回类型模式><方法名模式>（<参数模式>）<异常模式>？）
除了返回类型模式，方法名模式和参数模式外，其余都是可选填项。

修饰符模式 = 表示哪类型方法（publc、private、protected等），不写就是所有方法；
返回类型模式 = 表示返回值的类型；
包名 = 具体的包名

也就com.unicom.opn.api.core.controller…* 包及其子包都会调用@Around注释的方法。

execution(* com.unicom.opn.api.core.controller..*.*(..)))

修饰符模式 = 没有书写，说明是所有方法；
返回值类型 = * 表示全部类型
包名 = com.unicom.opn.api.core.controller 具体的包名
.. = 表示包以及包下所有子包
* = 表示全部
.*(..) = 表示全部方法

B

@Bean

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

@Builder

概念：为类生成相对复杂的构造器API。
特点：

作用于类，将其变成创建者模式；
以链的形式调用；
生成一个全参的构造方法；
自动生成的构建器会要求你为每个字段提供一个值；

缺点：
没有无参构造方法；

理解：

@Builder
public class xx1{
	private Integer a;
	private String b;
}

该方法编译后的文件为：
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容器。

@ConditionalOnMissingBean

用于判断指定的类是否在BeanFactory中；
指定的类如果在BeanFactory中，则匹配失败；不在，则匹配成功；
匹配成功则，执行方法。
当BeanFactory中没有指定的bean的时候才能匹配，主要是用来做自动配置的，当程序没有配置指定的类的时候，就会使用默认配置;

@ConditionalOnMissingBean(ObjectMapper.class)
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder)
// 当Bean工厂没有ObjectMapper的Bean，才创建jacksonObjectMapper的Bean。

@Component

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

@ComponentScan

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

@ConfigurationProperties

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

D

@Documented

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

@Data

1. 使用前提：
   在项目依赖中引入lombok，其是一个工具类库，以简化代码，提高开发效率；
2. 含义
   修饰类，提供类get、set、equals、hashCode、canEqual、toString方法。

E

@EnableWebSecurity

开启SpringSecurity的默认行为，为某些请求路径开启安全认证策略。

@EqualsAndHashCode

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

callSuper = 表示在equals、hashcode方法中是否会引用当前类的父类中的属性；

@ExceptionHandler

注在方法上，注解名后的括号=指明要捕获哪些异常，该方法 = 指明对异常进行如何处理。

@ExtendWith

概念：

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

F

G

@Getter

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

H

I

@interface

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口。

public @interface RequestJson {
    String value() default "";
}
// 其中，RequestJson是注解名，@interface表示自定义注解。
// @interface声明一个注解，定义成员变量与类型；
// 方法名 = 成员变量名；方法返回值 = 变量类型；

@Inherited

用来指定该注解可以被继承。
使用 @Inherited 注解的 Class 类，表示这个注解可以被用于该 Class 类的子类。
父类使用@Inherited注解，则子类直接继承该注解。

@Import

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

J

@ JsonInclude（xxx）

修饰类（实现Serializable），则该实体类系列化成json时，在某些策略下，某些字段不去序列化。
xxx值为如下：

JsonJsonInclude.Include.ALWAYS：
	表示总是序列化所有属性
JsonJsonInclude.Include.NON_NULL：
	表示序列化非null属性
JsonJsonInclude.Include.NON_ABSENT：
	表示序列化非null或者引用类型缺省值，例如java8的Optional类，这个选中通常与Optional一起使用
JsonJsonInclude.Include.NON_EMPTY：
	表示序列化非Empty的属性，例如空的集合不会被序列化
JsonJsonInclude.Include.NON_DEFAULT：
	仅包含与POJO属性默认值不同的值
JsonJsonInclude.Include.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);
    }
}

扫描com.unicom.opn.api.dao.mapper下的Mapper接口，编译生成对应的实现类；
SpringBoot在启动时自动扫描该路径的Mapper接口，将其注册为Spring的Bean，使得其他组件中可以直接注入。

@Mapper

定义 = 定义成一个接口interface
作用 = 将@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接口的影响；

处理场景：

在处理多个相同类型或功能的bean时尤为重要，比如多个拦截器、过滤器或后置处理器等。

注解参数：

@Order(参数)
参数值，越大，说明Bean的执行优先级越低；
参数值，越小，说明Bean的执行优先级越高；

P

@PostConstruct

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

@Primary

某种情况下，需要注册多个相同类型的Bean对象；
使用情况：

1. = Bean和primary一起使用；
   则该对象具有较高的优先级；

R

@Retention(RetentionPolicy.RUNTIME)

说明自定义注解的生命周期。
RetentionPolicy.RUNTIME = 始终不会丢弃，运行期也保留读注解。

使用

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) // 定义注解的生命周期
public @interface ServiceId {
    BusinessEnum value();
}

@RestController

@controller和@ResponseBody 的结合；
前者 = 该类是一个控制器，负责接收请求、处理请求，并返回响应。
后者=将请求响应的数据以指定的格式写入到Response的body中。

@RequestMapping

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

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

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

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

具体区别：
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容器中，自动注入才能生效

@SpringBootTest(classes = {Application.class})

表明该类是测试类。

S

@Slf4j

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

该注解使用将省略
private final Logger logger = LoggerFactory.getLogger(当前类名.class); 
这句代码，实现log.info()日志输出。

常用方法：

@Service

注解在类上，将类声明为业务逻辑组件，将其对象存入Spring容器中，表示其是一个服务层Bean。
在控制器类中，注入该组件的实例，即可调用其中的方法。

参考：
https://blog.csdn.net/juggle_gap_horse/article/details/128972813

@SpringBootApplication

组合注解，一般用于SpringBoot项目的主类上；
包含：@CompoentScan、@EnableAutoConfiguration、@Configuration组成；

@CompoentScan
指定要扫描的组件包的路径，并将其注册为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;
     }
}

T

@Target(ElementType.PARAMETER)

注解的注解，又称为元注解，用于描述注解的使用范围。
自定义注解定义及使用：

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

参数列表：

@TableName

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

@TableId

定义：用于在java中标识一个数据表的主键字段。
注解（数据表中的属性键）
数据类型 属性名 =》表示实体类中对应字段含义。

@TableFiled

定义：用来解决实体类的字段名与数据库中的字段名不匹配的问题。
注解（数据表中的属性键）
数据类型 属性名 =》表示实体类中对应字段含义。

V

@Value

动态读取配置文件中的某个系统属性；
三种使用方式：注入普通属性、注入配置文件、注入表达式并计算。

@Value(value = "${env}")  注入普通属性
@Value(value = "${server.port}") 注入服务器端口
参数来自于项目配置文件 = application.yml
spring项目读取配置文件的方式：①使用@Value；②SpringBoot中的@ConfigurationProperties；

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调度执行。

SpringBoot

Spring以及Springboot是什么

Spring目的：为了简化开发，解决企业级开发的复杂性而创建；

Spring简化开发的关键策略：

基于POJO的轻量级和最小侵入性编程；
通过控制反转（IOC），依赖注入（DI）和面向接口来实现松耦合；
基于切面（AOP）和惯例进行声明式编程；
通过切面和模板（Template）减少样式代码；

注：
POJO = 普通Java对象（Plain Old Java Object）

一些关键话语：

约定大于配置；
	“约定大于配置”（Convention Over Configuration，简称CoC）是软件工程领域的一种设计理念，尤其在现代Web框架中广泛采用，Spring Boot便是其中的典范。这一理念主张在设计框架或系统时，开发者应当遵循预设的约定，而无需进行大量显式的配置。这样做可以简化开发流程，减少配置错误，提高开发效率，让开发者能更快地专注于业务逻辑的实现。

“约定大于配置”在Spring Boot中的体现
自动配置：Spring Boot通过一系列的starter依赖和自动配置类，自动为项目添加常见的功能，如Web服务、数据库连接、安全控制等，而无需手动配置复杂的XML文件或繁琐的Java配置。例如，添加spring-boot-starter-web依赖后，Spring Boot会自动配置嵌入式Tomcat服务器、Spring MVC框架等。
默认启动类：Spring Boot应用程序通常有一个主类，标注@SpringBootApplication注解，这表明该类是应用程序的入口点。Spring Boot会扫描该类及其子包，自动发现和配置Bean。开发者不需要显式地指定每个组件的位置。
环境变量和配置文件：Spring Boot会自动读取application.properties或application.yml配置文件中的属性，以及环境变量，用于调整应用的行为，而不需要在代码中硬编码配置信息。
内置服务器：Spring Boot默认集成了Tomcat、Jetty或Undertow等内嵌服务器，开发者无需额外配置服务器即可运行应用。
日志管理：Spring Boot会自动配置日志系统，如Logback或log4j，开发者只需关注日志输出级别和格式，而不需要关心具体的日志框架配置。
健康检查和监控：Spring Boot Actuator模块提供了开箱即用的健康检查和应用监控功能，无需额外配置即可启用。
实际应用场景
假设你正在构建一个新的Spring Boot项目，按照“约定大于配置”的原则，你只需要添加必要的starter依赖，比如spring-boot-starter-data-jpa和spring-boot-starter-web，并定义一些实体类和Repository接口。Spring Boot会自动配置JPA和Web环境，包括数据库连接、事务管理、RESTful API支持等，而无需编写复杂的配置代码。

总的来说，“约定大于配置”使得Spring Boot项目更加简洁、易维护，降低了学习和使用的门槛，让开发者能够快速上手，专注于业务逻辑的实现而非框架配置的细节。
自动装载；
 需要进一步修改的内容。。。。。TODO

SpringBoot的优点：

帮助所有Spring开发者快速入门
开箱即用，提供各种默认配置来简化项目配置
内嵌容器（tomact）简化web项目
没有冗余代码生成和XML配置的要求

微服务+第一个Springboot项目

微服务：一种架构风格，将开发一个应用变成一系列小服务组合，可通过HTTP（RPC）方式互相通信。
单体应用架构，将一个应用的所有应用服务都封装在一个应用中，各个功能放在一个war包里。
微服务架构，将每个功能元素都独立出来，并将独立出来的功能元素动态组合，也就是对功能元素的复制，而不是整个应用的复制；

创建一个springboot项目
两种方式：Springboot官网版本 / IDEA自己创建（IDEA集成了这个网站) 或者 IDEA自己创建；

1. Springboot官网版本：
   中文文档：https://springdoc.cn/spring-boot/
   官网文档：https://spring.io/projects/spring-boot#learn
   最新版本是：3.2.2
   当前创建页面只支持以下图展示内容：
   
2. IDEA创建springboot项目
   文件 – 新建 – 项目 – Spring Initializr
   通过该方法java版本只有17和21 两种，jdk1.8 与java17不匹配，可以和java21匹配；

项目注意事项

@SpringbootApplication
springboot中的启动类是application，其他的类都得在该启动类的同级目录下；
启动类application，程序的主入口，本身就是Spring的一个组件；
所有springboot的依赖都采用 spring-boot-starter 这个前缀；
项目打包：package；

3. IDEA选择创建Springboot项目
创建项目遇到的问题：
java语言只有17和21版本，jdk是1.8 如何解决？
https://zhuanlan.zhihu.com/p/668876308
在新建项目的页面，修改连接；

application.properties配置修改

# web服务端口号修改
server.port = xxx
# banner修改
需要在线生成网站处理：
https://www.bootschool.net/ascii-art/search
在resource/banner.txt文件
将网站生成的图片放在该文件中。

自动配置原理分析

1 pom.xml

通过spring-boot-starter-parent →spring-boot-dependencies 该包管理的大量的jar包版本；

2 启动器

pom文件中的有大量的启动器（含有starter的包），也就是springboot的启动场景；
主程序
@SpringBootApplication 标注这个类是springboot应用；
SpringApplication.run方法 启动 springboot项目；

3 主程序

1. 主程序
@SpringBootApplication 标注这个类是springboot应用；
SpringApplication.run方法 启动 springboot项目；

2. 注解
@SpringBootConfiguration ：Springboot的配置
	@Configuration Spring配置类
	@Component 说明是Spring的一个组件
@EnableAutoConfiguration 自动配置
	@AutoConfigurationPackage 自动配置的包
		@Import({Registrar.class}) 自动装配 包注册
	@Import({AutoConfigurationImportSelector.class})  自动配置导入选择
		List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
		// 获取所有的配置

结论：
springboot所有自动配置都是在启动的时候扫描并加载:spring.factories 
所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了 对应的 start ，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功!

springboot项目启动

yaml配置文件

springboot配置文件可以写的所有内容：
https://docs.spring.io/spring-boot/docs 官网地址没有找到
https://www.cnblogs.com/tangge/p/9609165.html 博客找到了

注意内容：

1 SpringBoot采用全局配置文件，名称是固定的；
	application.properties  key=value
	application.properties  key: value
2 yaml比propreties存放对象更方便
	yaml：
	student：
		name： dahua
		age： 3
	propreties：
	student.name = dahua
	student.age = 3
3 yaml的行内写法
	student:{name,age}
4 yaml存储数组（/列表）
	pets:
		- dog
		- cat
		- pig
	行内写法：
	pets:[dog,cat,pig]
5   对空格要求极为严格
	可以注入到项目的配置类
6 yaml：可以直接给实体类赋值
	核实是@ConfigurationProperties
	@ConfigurationProperties作用:
	将配置文件中配置的每一个属性的值，映射到这个组件中;
	告诉springBoot将本类中的所有属性和配置文件中相关的配置进行绑定
	对应参数 prefix = “person” ：将配置文件中的person下面的所有属性一一对应；
	只有这个组件是容器中的组件，才能使用容器提供的@Configurationproperties功能。
7 指定特殊的配置文件，xxx.properties 而不是默认配置文件application.properties
	@PropertySource（value = “classpath：xxx.properties”）
	类的具体属性前，@Value("${配置文件中所要设置的值}")	

集成 web开发（业务核心）

集成 数据库 Druid

分布式开发：Dubbo（RPC） + zookeeper

swagger：接口文档

任务调度

SpringSecurit：Shiro

本质上是：拦截器与过滤器就可以实现安全功能；

Linux项目部署

相关内容

PrometheusConfig

参考：https://blog.csdn.net/dazhong2012/article/details/139288005

RowMapper接口

概念：

是Spring框架提供的将数据库查询封装的接口
用来把数据库中的列字段和java bean中属性对应上；
即可以将数据中的每一行数据封装成用户定义的类；

作用：

原生JDBC，从数据库查询出来的记录全都被保存在ResultSet结果集中，需要将结果集中的数据一条条地获取并设置到具体的实体类上，这时就需要RowMapper来处理；

BaseMapper接口

概念：

是Mybatis-plus中的，利用的Mybatis接口编程的实现机制，其默认提供了一系列的增删改查的基础方法，并且开发人员对于这些基础操作不需要写SQL进行处理操作。
用于操作数据库；

Filter过滤器

概念：

Filter 可以改变一个request 和 修改一个response；