SpringBoot体系知识点整理

一.什么是SpringBoot

        Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

1. SpringBoot的特性

        SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。 

（1）可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；

（2）内嵌Tomcat或Jetty等Servlet容器；

（3）提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；

（4）尽可能自动配置Spring容器；

（5）提供准备好的特性，如指标、健康检查和外部化配置；

（6）绝对没有代码生成，不需要XML配置。

（7）全部采用注解化的方式配置

二.为什么要使用SpringBoot框架

1. 提高开发效率

        内部整合了SSM之间的xml配置，只需要在POM文件里导入所需要的依赖即可，能够帮助我们程序员快速整合第三方框架原理（封装Maven依赖方式实现），从程序员的使用角度大大提高了开发效率。

        SpringBoot框架默认的情况下spring-boot-starter-web已经帮助我们整合好SpringMVC框架。

2. 与SpringCloud之间的关系

        2.1 SpringCloud

                SpringCloud微服务解决框架，微服务技术解决方案

                SpringCloud RPC远程调用feign客户端

                接口协议采用Http协议

               SpringCloud依赖于SpringBoot默认情况下已经整合好的SpringMVC，可以使用SpringMVC来编写接口

三.SpringBoot依赖导入介绍

创建好项目，可以在一级项目中的POM文件中导入：

在官方文档中，对spring-boot-starter-parent作用有描述：

在pom.xml中引入spring-boot-starter-parent，spirng官方的解释叫starter poms，它可以提供dependency management，也就是说依赖管理，引入以后再声明其他dependency的时候就不需要version版本号了。

碎碎念Section

一些刚入职场的同学们，可能会听到老板对你说："小罗啊，你自己先按照这个需求写个接口"

内心：“接口？？interface吗？只是一个interface可以满足这个需求？？我学的假编程？？”

比如一般的小小项目，有（持久层）Mapper层、Repository层、（业务层）Service层、（视图层）Controller层，那么这3-4层的一个项目就属于是接口了（也就是API接口）。

四.注解系列

1.Spirng里的注解

（1）@ComponentScan

添加在配置类上，开启组件扫描。
如果没有配置包名，则扫描当前配置类所在的包，
如果配置了包名，则扫描所配置的包及其子孙包

（2）@Component

添加在类上，标记当前类是组件类，可以通过参数配置Spring Bean名称

（3）@Controller

添加在类上，标记当前类是控制器组件类，用法同@Component

（4）@Repository

添加在类上，标记当前类是数据访问组件类，用法同@Component

（5）@Service

添加在类上，标记当前类是业务逻辑组件类，用法同@Component

（6）@Autowired

添加在属性上，使得Spring自动装配此属性的值
添加在构造方法上，使得Spring自动调用此构造方法
添加在Setter方法上，使得Spring自动调用此方法

（7）@Resource

此注解是javax包中的注解，
添加在属性上，使得Spring自动装配此属性的值，
通常不推荐使用此注解

（8）@Value

添加在属性上，或添加在被Spring调用的方法的参数上，用于读取Environment中的属性值，为对象的属性或方法的参数注入值

（9）@Lazy

添加在组件类上，或添加在已经添加了@Bean注解的方法上，
用于指定作用域，当Spring Bean是单例时，注解参数为true（默认）时为“懒加载”，注解参数为false时为“预加载”

（10）@Scope

添加在组件类上，或添加在已经添加了@Bean注解的方法上，
用于指定作用域，注解参数为singleton（默认）时为“单例”，注解参数为prototype时为“非单例”

（11）@Qualifier

添加在属性上，或添加在方法的参数上，
配合自动装配机制，用于指定需要装配的Spring Bean的名称

（12）@Bean

（在非自定义的情况下使用）添加在方法上，标记此方法将返回某个类型的对象，
且Spring会自动调用此方法，并将对象保存在Spring容器中

（13）@Configuration

添加在类上，仅添加此注解的类才被视为配置类，通常不配置注解参数

2.SpringBoot里的注解

（1）@SpringBootApplication

添加在类上，用于标记此类是Spring Boot的启动类，每个Spring Boot项目应该只有1个类添加了此注解

（2）@SpringBootConfiguration

通常不需要显式的使用，它是@SpringBootApplication的元注解之一

（3）@SpringBootTest

添加在类上，用于标记此类是加载Spring环境的测试类

3.SpringMVC里的注解

（1）@ResponseBody

添加在方法上，标记此方法是“响应正文”的，
添加在类上，标记此类中所有方法都是“响应正文”的

（2）@RestController

添加在类上，标记此类是一个“响应正文”的控制器类

（3）@RequestMapping

添加在类上，也可以添加在处理请求的方法上，
通常用于配置请求路径

（4）@GetMapping

添加在方法上，是将请求方式限制为GET的@RequestMapping

（5）@PostMapping

添加在方法上，是将请求方式限制为POST的@RequestMapping

（6）@DeleteMapping

添加在方法上，是将请求方式限制为DELETE的@RequestMapping

（7）@PutMapping

添加在方法上，是将请求方式限制为PUT的@RequestMapping

（8）@RequestParam

添加在请求参数上，可以：
1. 指定请求参数名称
2. 要求必须提交此参数
3. 指定请求参数的默认值

（9）@PathVariable

添加在请求参数上，用于标记此参数的值来自URL中的占位符，如果URL中的占位符名称与方法的参数名称不同，需要配置此注解参数来指定URL中的占位符名称

（10）@RequestBody

添加在请求参数上，用于标记此参数必须是对象格式的参数，如果未添加此注解，参数必须是FormData格式的

（11）@ExceptionHandler

添加在方法上，标记此方法是处理异常的方法，可以通过配置注解参数来指定需要处理的异常类型，如果没有配置注解参数，所处理的异常类型取决于方法的参数列表中的异常类型

（12）@ControllerAdvice

添加在类上，标记此类中特定的方法将作用于每次处理请求的过程中

（13）@RestControllerAdvice

添加在类上，是@ControllerAdvice和@ResponseBody的组合注解

4.Mybatis里的注解

（1）@MapperScan

添加在配置类上，用于指定Mapper接口的根包，Mybatis将根据此根包执行扫描，以找到各Mapper接口

（2）@Mapper

添加在Mapper接口上，用于标记此接口是Mybatis的Mapper接口，如果已经通过@MapperScan配置能够找到此接口，则不需要使用此注解

（3）@Param

添加在Mapper接口中的抽象方法的参数上，用于指定参数名称，当使用此注解指定参数名称后，SQL中的#{} / ${}占位符中的名称必须是此注解指定的名称，通常，当抽象方法的参数超过1个时，强烈建议在每个参数上使用此注解配置名称

（4）@Select

添加在Mapper接口的抽象方法上，可以通过此注解直接配置此抽象方法对应的SQL语句（不必将SQL语句配置在XML文件中），用于配置SELECT类的SQL语句，但是，非常不推荐这种做法

（5）@Insert

同上，用于配置INSERT类的SQL语句

（6）@Update

同上，用于配置UPDATE类的SQL语句

（7）@Delete

同上，用于配置DELETE类的SQL语句

5.SpringJDBC里的注解

@Transactional

推荐添加的业务接口上，用于标记此接口中所有方法都是事务性的，或业务接口中的抽象方法上，用于此方法是事务性的

还可以配置几个属性，来控制回滚：

• rollbackFor：指定根据哪些异常回滚，取值为异常类型的数组，例如：@Transactional(rollbackFor = {NullPointerException.class, NumberFormatException.class})
• rollbackForClassName：指定根据哪些异常回滚，取值为异常类型的全限定名的字符串数组，例如：@Transactional(rollbackForClassName = {"java.lang.NullPointerException", "java.lang.NumberFormatException"})
• noRollbackFor：指定对于哪些异常不执行回滚，取值为异常类型的数组
• noRollbackForClassName：指定对于哪些异常不执行回滚，取值为异常类型的全限定名的字符串数组

注意：无论怎么配置，@Transactional只会对RuntimeException或其子孙类异常进行回滚！

6.SpringSecurity里的注解

（1）@EnableGlobalMethodSecurity

添加在配置类上，用于开启全局的方法级别的权限控制

（2）@PreAuthorize

添加在方法上，用于配置权限

（3）@AuthenticationPrincipal

添加在方法的参数上，且此参数应该是SecurityContext中的认证信息中的当事人类型，用于为此参数注入值

7.SpringValidation里的注解

（1）@Valid

添加在方法的参数上，标记此参数需要经过Validation框架的检查

（2）@Validated

添加在方法的参数上，标记此参数需要经过Validation框架的检查；添加在类上，并结合方法上的检查注解（例如@NotNull等）实现对未封装的参数的检查

（3）@NotNull

添加在需要被检查的参数上，或添加在需要被检查的封装类型的属性上，用于配置“不允许为null”的检查规则

（4）@NotEmpty

使用位置同@NotNull，用于配置“不允许为空字符串”的检查规则（这里的相当于既不能是null也不能是空字符串，适合用于检查String类的）

（5）@NotBlank

使用位置同@NotNull，用于配置“不允许为空白”的检查规则

（6）@Pattern

使用位置同@NotNull，用于配置正则表达式的检查规则

（7）@Range

使用位置同@NotNull，用于配置“数值必须在某个取值区间”的检查规则

8.Lombok里面的注解

（1）@Data

添加在类上，将在编译期生成此类中所有属性的Setter、Getter方法，及hashCode()、equals()、toString()方法

（2）@Setter

添加在类上，将在编译期生成此类中所有属性的Setter方法，也可以添加在类的属性上，将在编译期生成此属性的Setter方法

（3）@Getter

添加在类上，将在编译期生成此类中所有属性的Getter方法，也可以添加在类的属性上，将在编译期生成此属性的Getter方法

（4）@EqualsAndHashcode

添加在类上，将在编译期生成基于此类中所有属性的hashCode()、equals()方法

（5）@ToString

添加在类上，将在编译期生成基于此类中所有属性的toString()方法

（6）@NoArgConstructor

添加在类上，将在编译期生成此类的无参数构造方法

（7）@AllArgsConstructor

添加在类上，将在编译期生成基于此类中所有属性的全参构造方法

9.Knife4j里面的注解

（1）@Api

添加在控制器类上，通过此注解的tags属性配置API文档中的模块名称

（2）@ApiOperation

添加在控制器类中处理请求的方法上，用于配置业务名称

（3）@ApiOperationSupport

添加在控制器类中处理请求的方法上，通过此注解的order属性配置业务显示在API文档中时的排序序号

（4）@ApiModelProperty

添加在封装的请求参数类型中的属性上，用于配置请求参数的详细说明，包括：名称、数据类型、是否必须等

（5）@ApiImplicitParams

添加在控制器类中处理请求的方法上，如果需要通过@ApiImplicitParam注解配置的参数超过1个，则必须将多个@ApiImplicitParam注解作为此注解的参数

（6）@ApiImplicitParam

添加在控制器类中处理请求的方法上，用于配置请求参数的详细说明，包括：名称、数据类型、是否必须等

（7）@ApiIgnore

添加在请求参数上，用于标记API文档中将不关心此参数

五.SpringBoot启动方式

1.在Controller控制器类名上方加@RestController

ps：如果只是添加@Controller的话，会报404，“Whitelable Error Page”，这是因为要转发到相关页面，需要用到@ResponseBody的注解。

2.在Controller控制器类名上方添加@EnableAutoConfiguration

3.在Controller控制器类名上方还需要添加@ComponentScan("xxx.xxx")

ps：规定扫描路径可以确定为当前启动类的同级包或者子包

4.在启动类上添加@SpringBootApplication

ps：可以理解为@SpringBootApplication是@EnableAutoConfiguration和@ComponentScan的组合注解

六.SpringBoot整合静态资源访问

在我们开发Web应用的时候，需要引用大量的JS、CSS、图片等静态资源。

1.默认配置

SpringBoot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：

/static

/public

/resources

/META-INF/resources

eg:在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/D.jpg。如能显示图片，则配置成功。

2.前后端分离

前端：Vue+Axios/...

后端：SpringBoot(+SpringMVC)+Mybatis+...

3.动静分离

部署在CDN上，因为CDN减少带宽距离传输。

七.yml和properties配置文件

在SpringBoot整合配置文件，分成两大类：

application.properties   application.yml（后加载；可以用来定义应用级别的，应用程序特有的配置信息，可以用来配置后续各个模块中需使用的公共参数等）

或者是 bootstrap.properties  bootstrap.yml（先加载；用于应用程序上下文的引导阶段，由父SpringApplicationContext加载；一旦被加载，则不会被覆盖；可以理解成系统级别的一些参数配置，这些参数一般不会变动的）

1.语法

这是properties配置文件的语法：

这是yml配置文件的语法：

相比来说，yml的配置的语法还是轻松不少。

2.properties转换为yml格式

网址：在线yaml转properties-在线properties转yaml-ToYaml.com

当然也可以从yml转换为properties格式

3.使用@Value注解读取配置文件

语法：@Value("${baidu.name}")

ps：如果这里需要调用配置类文件的参数，那么很多属性的前缀都一致，恰好在相关controller控制器或者service层实现类需要调用，那么一个一个属性都要老老实实写配置文件对应的路径名真的很累....

4.使用@ConfigurationProperties

语法：@ConfigurationProperties(prefix="xxx.xxx")，该注解用在实体类对象

eg：如果你要调用配置文件中的 baidu.load.name，你需要在该注解的prefix属性里填写“baidu.load”，则不需要@Value，那么在相关实体类里的属性也要名字对应：private String name

ps：可在POM文件添加该依赖

5.配置文件占位符

在SpringBoot配置文件中，我们可以使用SpringBoot提供的一些随机数

${random.value}、${random.int}、${random.long}

${random.int(10)}、${random.int[1024,65536]}

${app.name:默认值}来制定找不到属性时的默认值

6.多环境配置

在Spring Boot中，你可以使用环境配置文件来设置多个环境配置。这样，你可以根据需要设置不同的配置，如开发环境、测试环境、生产环境等。下面是如何在Spring Boot项目中配置多环境的一些基本步骤：

（1）创建多个配置文件：你可以在项目的src/main/resources目录下创建多个配置文件，如application-dev.properties，application-prod.properties等。

（2）在application.properties或application.yml中添加必要的配置：根据你的需要，设置你的应用程序需要的所有配置。例如，你可能需要设置数据库连接信息，服务器端口等。

（3）使用Spring Boot的Environment类获取当前环境：在你的代码中，你可以使用Environment类获取当前的环境信息。这样，你就可以根据当前的环境选择正确的配置文件。

​（4）那么在该项目中具体要使用哪个环境，需要在application主配置文件中配置：

spring:
  profiles:
    active: dev

八.SpringBoot整合ftl模板引擎

1.使用Freemarker模板引擎渲染web视图

pom文件引入：

eg：在controller控制器类上添加@Controller注解，写一个方法，在方法上添加@RequestMapping("/xxx")，在resources文件夹下创建一个templates目录，然后在该目录下添加xxx.ftl文件，添加需要显示的参数，如有显示，则配置成功。

2.flt模板引擎条件判断用法

{if condition}
    // 条件为真时执行的代码块
{elseif other_condition}
    // 其他条件为真时执行的代码块
{else}
    // 如果所有条件都不满足时执行的代码块
{/if}

（1）确保将条件放在正确的位置，以便与代码块的开始和结束进行匹配。可以使用{if}标记开始条件语句，使用{/if}标记结束条件语句。

（2）使用逻辑运算符（如&&和||）来组合多个条件。您还可以使用比较运算符（如>、<、>=、<=和!=）来检查值之间的比较关系。

（3）如果条件为真，则执行相应的代码块。可以使用大括号{}将代码块括起来，以确保语法正确。

（4）如果条件为假或没有指定其他条件，可以使用{else}标记来指定当所有条件都不满足时要执行的代码块。

（5）使用{elseif}标记来指定其他条件，以便根据不同的条件执行不同的代码块。

3.使用Thymeleaf来渲染页面

Thymeleaf是一种用于Java和HTML5的模板引擎，它可以帮助您快速创建动态网页。使用Thymeleaf可以轻松地在页面中插入动态内容，并使用条件判断、循环等语法来控制页面的渲染。

pom文件引入：

在上面的代码中，th:if是Thymeleaf的指令，它用于条件判断。如果条件满足（即 \${condition} 为真），则渲染

元素中的内容。否则，该元素将被忽略。

还可以使用其他Thymeleaf指令来控制页面的渲染，例如th:each用于循环渲染列表或其他集合中的元素，th:ifnot用于与th:if相反的条件判断等。

Thymeleaf在yml文件的配置：

4.解决Thymeleaf误报问题

在对应的thymeleaf.html里调用配置类文件的参数，可能出现报错（下划红线）的情况

那么在相关的Controller的参数中，就把HttpServletRequest换成Map，在html文件里调用配置类文件时输入对应路径名称会出现提示，那么就解决了误报问题

九.SpringBoot整合JdbcTemplate

（1）添加依赖

在你的Spring Boot项目的pom.xml文件中，添加Spring Data JPA和JdbcTemplate的依赖。

    
    
        org.springframework.boot
        spring-boot-starter-data-jpa
    
    
    
        org.springframework.boot
        spring-boot-starter-jdbc
    

（2）配置数据源

在application.properties或application.yml文件中配置数据源信息，包括数据库连接URL、用户名和密码等。

例如，在application.properties文件中：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root_password
spring.jpa.hibernate.ddl-auto=update

（3）创建数据模型和实体类

创建与数据库表相对应的数据模型和实体类。实体类继承自JpaRepository接口，以便Spring Data JPA提供自动化的CRUD操作。

eg：创建一个名为User的实体类：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // 其他属性...
}

（4）创建JdbcTemplate对象并执行查询和更新操作

在需要使用JdbcTemplate的地方，创建一个JdbcTemplate对象，并使用它来执行查询和更新操作。例如，执行一个简单的SELECT查询：

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT * FROM users WHERE name = ?";
List users = jdbcTemplate.query(sql, new Object[] { "John" }, new UserRowMapper());

或者执行一个INSERT操作：

jdbcTemplate.update("INSERT INTO users (name) VALUES (?)", "John");

这样，就可以在Spring Boot应用中使用JdbcTemplate来执行数据库操作了。

十.SpringBoot整合Mybatis框架

（1）添加依赖

在pom.xml文件中添加MyBatis和Spring Boot Data JPA的依赖，确保已经正确引入。

    
        org.springframework.boot
        spring-boot-starter-data-jpa
    
    
        org.mybatis.spring.boot
        mybatis-spring-boot-starter
        2.1.4
    

（2）配置数据源

在application.properties或application.yml文件中配置数据源信息，包括数据库连接地址、用户名和密码等。

spring.datasource.url=jdbc:mysql://localhost:3306/testdb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

（3）创建实体类

创建一个实体类，用于映射数据库中的表。实体类需要使用注解进行标识，例如@Entity和@Table等。

（4）创建Mapper接口

创建一个Mapper接口，用于定义与数据库交互的方法。可以使用@Mapper和@MapperScan注解将Mapper接口自动扫描到Spring Boot中。

（5）编写SQL语句

在Mapper接口中定义SQL语句，可以使用MyBatis提供的XML标签或注解方式编写SQL语句。

（6）配置MyBatis插件

在Spring Boot中，可以使用MyBatis插件来简化与数据库的交互。可以在配置类中添加MyBatis插件的配置。

（7）启动应用并测试

启动Spring Boot应用，并使用MyBatis提供的API进行数据库操作，例如使用SqlSessionFactoryBean获取SqlSession对象，并调用Mapper接口中的方法进行数据库操作。同时可以打印日志或使用断言进行测试。

十一.SpringBoot整合devtools工具

devtools是一个用于开发环境自动化的工具，它可以帮助开发者更快速地开发和调试代码。

在开发过程中，通常会对一段业务代码不断地修改测试，在修改之后往往需要重启服务，有些服务需要加载很久才能启动成功，这种不必要的重复操作极大地降低了程序开发效率。为此，Spring Boot框架专门提供了进行热部署的依赖启动器，用于进行项目热部署，而无需手动重启项目。

如果你想在SpringBoot项目中整合devtools工具，你可以按照以下步骤进行操作：

（1）在你的SpringBoot项目中添加devtools的依赖。在pom.xml文件中添加以下依赖：

    org.springframework.boot
    spring-boot-devtools
    true

ps：true表示devtools是可选的，如果你不想使用它，可以将其设置为false。

（2）运行你的SpringBoot应用程序时，确保使用一个IDE（如IntelliJ IDEA或Eclipse）来运行它。这是因为devtools需要IDE的支持才能正常工作。

（3）启用IDE中的热重载功能。在IDE中，你需要确保启用Spring Boot DevTools的热重载功能。具体步骤可能因IDE而异，但通常可以通过设置或配置来启用。

（4）在你的代码中，使用Lombok库来简化代码。Lombok库提供了一组注解，可以帮助你自动生成getter、setter、equals、hashCode和toString方法等常见的方法，从而简化代码编写。

十二.整合lombok简化代码

Lombok是一个Java库，它可以帮助我们简化Java代码的编写，减少代码量。Lombok通过注解的方式为类、字段和方法添加了一些基本的 getter、setter、equals、hashCode、toString 等方法，从而大大简化了我们的代码。

// 使用 @Data 注解为一个类添加 getter、setter、equals、hashCode 和 toString 方法
@Data
public class Person {
    private String name;
    private int age;
    private String email;
}

在上面的例子中，我们只需要写三个字段（name、age和email），而不需要写出 getter、setter、equals、hashCode 和 toString 方法。这大大简化了代码的编写。

但是，Lombok也有一些缺点，比如它可能会引起一些编译错误，因为它改变了代码的结构。此外，一些IDE可能无法正确地识别Lombok生成的代码，这可能会影响代码的自动补全和错误检查。

为了解决这些问题，你可以考虑以下几种方法：

（1）使用IDE的Lombok插件：大多数现代的IDE（如IntelliJ IDEA和Eclipse）都提供了Lombok插件，这些插件可以自动处理Lombok生成的代码，并解决一些可能出现的编译错误。

（2）使用Java的注解处理器（Annotation Processor）：有一些工具可以处理Lombok注解，并生成相应的代码。你可以使用这些工具来生成你的代码，从而避免手动编写这些代码。

（3）使用Java配置文件（Java Configuration File）：Lombok提供了使用Java配置文件来配置你的项目的选项。你可以将Lombok配置添加到你的项目中，并在其中定义需要生成哪些方法和字段等。这可以减少Lombok产生的无用代码量。

十三.AOP

1.AOP定义

AOP（面向切面编程）是一种编程范式，它允许开发者定义横切关注点（如日志、事务处理、性能统计等）并将其整合到应用程序的代码中，从而实现代码的解耦。

2.AOP的应用

要使用AOP统一打印日志信息，您可以使用支持AOP的框架（如Spring AOP）来实现。以下是一个简单的示例：

（1）定义切面（Aspect）：创建一个Java类，用于定义打印日志的切面。可以使用AOP框架提供的注解或XML配置来定义切面。

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.myapp.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        String className = joinPoint.getSignature().getDeclaringClass().getName();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Entering " + className + "." + methodName);
    }
}

上述代码定义了一个名为LoggingAspect的切面，使用@Before注解指定在执行方法之前执行的通知。execution(* com.example.myapp.*(..))表示该通知适用于com.example.myapp包下所有类的所有方法。

（2）配置代理：使用AOP框架提供的配置方法，将定义的切面配置为对目标对象的代理。这通常需要在Spring配置文件中完成。

上述代码将LoggingAspect配置为对所有符合com.example.myapp包下所有类的所有方法的代理，并在执行方法之前执行beforeAdvice方法。

十四.SpringBoot如何整合异步的线程

在SpringBoot中，我们可以使用@Async注解来实现异步操作。当一个方法被@Async注解标记后，SpringBoot会将其包装成一个异步任务，并交给ExecutorService执行。这样，我们就可以在方法内部执行一些耗时的操作，而不会阻塞主线程。

接下来，我们可以通过定义一个切面来拦截方法调用，并在通知中执行异步操作。具体步骤如下：

（1）创建一个切面类，并在类上使用@AspectJ注解进行标注。

@Aspect
@Component
public class AsyncAspect {
    // 定义通知
}

（2）在切面类中定义一个advice注解的方法，该方法将在方法调用前、后或异常时被执行。在这个方法中，我们可以使用ExecutorService来执行异步操作。

@Before("execution(* com.example.demo.service.*.*(..))")
public void before(JoinPoint joinPoint) {
    // 获取方法参数
    Object[] args = joinPoint.getArgs();
    // 执行异步操作
    CompletableFuture.runAsync(() -> {
        // 在这里执行异步操作
    });
}

（3）在SpringBoot的配置文件中启用AOP和异步功能。通常需要配置spring.aop.enabled和spring.async.enabled属性为true。

spring.aop.enabled=true
spring.async.enabled=true

（4）配置ExecutorService来执行异步任务。可以在SpringBoot的主类上使用@EnableAsync注解来启用异步支持，并配置一个ExecutorServiceBean来执行异步任务。

@Configuration
@EnableAsync
public class AppConfig {
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 设置线程池大小
        executor.setMaxPoolSize(10); // 设置最大线程数
        executor.setQueueCapacity(25); // 设置队列容量
        executor.initialize();
        return executor;
    }
}

如何解决@Async失效问题

@Async注解是Spring框架提供的一个注解，用于标记一个方法为异步方法，即该方法在执行时不会阻塞当前线程，而是会立即返回，将执行任务交由线程池处理。如果@Async注解失效，可能存在以下几种情况：

1. 配置问题：检查是否正确配置了Spring的异步任务配置，包括异步任务组、线程池大小、线程池的名称等。
2. 方法被锁定：检查该方法是否有其他地方进行了锁定，导致方法无法执行。
3. 方法本身存在问题：方法内部的代码逻辑是否正确，是否有抛出异常等。

解决这些问题的步骤如下：

1. 检查Spring的异步任务配置是否正确。确认Spring Boot项目中是否包含了对应的@EnableAsync注解，并且异步任务组是否已经正确配置。
2. 检查该方法是否有其他地方进行了锁定。如果有，需要解除锁定或者重新设计代码逻辑。
3. 检查方法内部的代码逻辑是否正确。如果有异常抛出，需要捕获异常或者修改代码逻辑以避免异常。

如果以上步骤都无法解决问题，可以尝试使用调试工具进行调试，查看方法是否真的被异步执行了。如果方法没有被执行，可能是由于线程池中的线程数量不足或者线程池已经被其他任务占满导致的。此时需要调整线程池的大小或者优化代码逻辑以减少任务的并发数。

十五.SpringBoot整合全局捕获异常

首先，需要在Spring Boot的主配置类（通常是@SpringBootApplication注解的类）中添加一个@ControllerAdvice注解，该注解表示这是一个全局控制器。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@SpringBootApplication
@ControllerAdvice
public class GlobalExceptionHandler {

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

    @ExceptionHandler(value = Exception.class) // 这将捕获所有的Exception类型
    public String handleException(Exception e) {
        return "Error: " + e.getMessage(); // 在这里你可以自定义你的错误信息
    }
}

上述代码中，@ControllerAdvice注解告诉Spring Boot这是一个全局控制器，并且它将处理所有的异常。@ExceptionHandler注解指定了当发生异常时应该执行的处理器方法。在这个例子中，处理器方法会捕获所有的异常（包括继承自Exception的异常），并且返回一个包含错误信息的字符串。

也可以根据需要为特定的异常类型指定特定的处理器方法。例如，如果只想捕获特定的MyCustomException异常，可以这样写：

@ExceptionHandler(value = MyCustomException.class)
public String handleMyCustomException(MyCustomException e) {
    // 自定义处理逻辑
}j

ps：如果希望在控制器级别捕获特定异常，而不是全局异常处理，那么可以使用@ControllerAdvice和@ExceptionHandler注解在控制器级别。在这种情况下，只有那些被标记为异常处理方法的控制器方法才会被捕获和处理。

十六.SpringBoot整合Knife4j日志

（1）添加依赖项：

在项目的pom.xml文件中，添加Knife4j和相关依赖项的声明。您可以使用Maven或Gradle等构建工具来管理依赖项。

Maven依赖示例：

    
    
        org.knife4j
        knife4j-core
        版本号
    
    
        org.knife4j
        knife4j-spring-boot-starter
        版本号
    

确保将正确的版本号替换为可用的最新版本。

（2）配置Knife4j：

创建一个名为logback-spring.xml的文件，并使用Knife4j提供的日志配置样板进行配置。在配置文件中，可以自定义日志级别、输出格式、输出位置等。以下是一个基本的配置示例：

    
        
        
            %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
        
    
    
        
    
    
    
        
    

确保将com.example替换为您要配置的包名或类名。
（3）配置Spring Boot应用：

在Spring Boot应用的配置文件（例如application.properties或application.yml）中，配置Knife4j的相关设置。例如，可以设置日志级别和输出格式。以下是一个示例：

logging.level.com.example=DEBUG
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

确保将com.example替换为您要配置的包名或类名。
（4） 使用Knife4j日志：

现在，您可以在Spring Boot应用中使用Knife4j日志了。通过在代码中添加适当的日志记录语句，您将能够看到Knife4j提供的日志输出。确保在配置文件中正确配置了日志级别和输出格式，以便正确显示日志信息。

十七.SpringBoot整合定时任务

步骤一：添加依赖
首先，确保你的项目中已经添加了Spring Boot定时任务相关的依赖。你可以在项目的pom.xml文件中添加以下依赖：

    
    
        org.springframework.boot
        spring-boot-starter
    
    
    
        org.springframework.boot
        spring-boot-starter-scheduling
    

步骤二：配置定时任务属性
在application.properties或application.yml文件中配置定时任务的属性，例如任务名称、执行间隔时间等。

# application.properties
spring.scheduler.enabled=true
spring.scheduler.task-scheduler=org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
spring.scheduler.pool-size=10
spring.scheduler.repeat-interval=5000 # 执行间隔时间，单位为毫秒

步骤三：创建定时任务类
创建一个类，并使用@Scheduled注解来定义定时任务的执行逻辑。在类中，你可以注入所需的依赖并编写具体的业务逻辑。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component // 声明为Spring组件，以便Spring容器能够识别并注入所需的依赖
@Scheduled(fixedRate = 5000) // 指定定时任务的执行间隔时间，单位为毫秒
public class ScheduledTasks {
    private static final Logger logger = LoggerFactory.getLogger(ScheduledTasks.class);

    // 定时任务执行的逻辑...
}

步骤四：实现定时任务逻辑
在定时任务类中，你可以根据实际需求编写定时任务的逻辑。例如，你可以使用@Autowired注解注入所需的依赖，或者使用其他方法获取数据或执行操作。以下是一个简单的示例：

import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.concurrent.*;

@Component // 声明为Spring组件，以便Spring容器能够注入所需的依赖
public class ScheduledTasks {
    private static final Logger logger = LoggerFactory.getLogger(ScheduledTasks.class);
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 日期格式化器
    private static final ExecutorService executorService = Executors.newSingleThreadExecutor(); // 创建单线程执行器线程池
    private static final ConcurrentHashMap> taskMap = new ConcurrentHashMap<>(); // 用于存储任务的map结构，避免重复执行同一任务或死锁等问题。键为任务名称，值为任务对象Future实例。
    private final YourService yourService; // 注入所需依赖... // 示例中为YourService对象，用于执行具体的业务逻辑。具体根据实际情况替换为所需依赖。
    // ...其他代码... // TODO: 根据实际情况添加其他代码。// TODO: 根据实际情况替换为所需依赖和业务逻辑。// TODO: 根据实际情况添加其他代码。// TODO: 根据实际情况添加其他代码和注释。// TODO: 根据实际情况添加注释和代码。// TODO: 根据实际情况替换为所需业务逻辑和依赖。// TODO: 根据实际情况添加其他代码和注释。// TODO: 根据实际情况添加注释和代码的注释。// TODO: 根据实际情况处理错误和异常情况。// TODO: 补充其他代码和注释的说明和注释的说明。// TODO: 根据实际情况添加相关代码注释说明。// TODO: 完成所有注释和代码的说明。// TODO: 其他未完成的工作或任务。// TODO: 其他相关操作或流程。// TODO: 其他需要补充的内容或信息。// TODO: 其他未提及的内容或信息。// TODO: 其他相关事项或注意事项。// TODO: 其他需要处理的问题或异常情况的处理方法或解决方案。// TODO: 其他需要补充的文档或资料。// TODO: 其他需要进行的操作或测试等后续工作。// TODO: 其他未提及的操作或测试等后续工作。// TODO: 其他未提及的内容或信息，需要补充说明

在SpringBoot项目中，可以直接调用相关注解。

在Java的Quartz调度库中，@Scheduled注解的fixedRate和fixedDelay属性分别用于指定定时任务的执行方式和间隔时间。

fixedRate属性用于指定固定速率执行模式，即任务每隔指定的时间间隔就会执行一次，时间间隔是不受其他任务影响的。fixedRate的值是以毫秒为单位的时间间隔，表示每次任务执行之间的时间间隔。例如，如果fixedRate的值为3000毫秒，那么任务每隔3秒就会执行一次。

fixedDelay属性用于指定固定延迟执行模式，即在任务被触发后，会等待指定的时间间隔后再执行下一次任务。fixedDelay的值也是以毫秒为单位的时间间隔，表示等待时间加上第一次执行的时间间隔的总和。例如，如果fixedDelay的值为5000毫秒，那么任务在被触发后，会等待5秒再加3秒（第一次执行的时间间隔）后执行下一次任务。

需要注意的是，fixedRate和fixedDelay属性只能选择其中一个使用，不能同时使用。具体使用哪个属性取决于你的需求和场景。

定时任务的Quartz表达式

可在该网站quartz/Cron/Crontab表达式在线生成工具-BeJSON.com，根据选择直接生成，不需要手打代码了。

十八.打包运行发布

要将SpringBoot项目发布打包，可以按照以下步骤进行操作：

1. 确保项目已经成功构建并生成了可执行的JAR文件。
2. 将JAR文件复制到目标服务器或本地计算机上。
3. 在目标服务器上安装Java运行时环境（JRE）和必要的依赖库。
4. 配置服务器上的环境变量，包括CLASSPATH和JAVA_HOME等，以确保可以正确运行JAR文件。
5. 打开终端或命令提示符，并使用以下命令将JAR文件部署到服务器上：

java -jar your-project-name.jar

这将启动应用程序并开始运行。

如果需要将应用程序部署到容器中，例如Docker或Kubernetes，可以使用相应的工具和配置来将JAR文件打包成容器镜像，并将镜像部署到容器中。具体的步骤会因容器平台而异，请参考相应平台的文档。

需要注意的是，在部署应用程序之前，请确保已备份代码和数据，并在生产环境中进行充分的测试和验证。同时，需要关注日志和监控系统，以确保应用程序在运行过程中稳定、可靠、安全。