温馨提示

文章中创建目录时用的组名使用的是我的如cn.xnj，替换成你自己的如：com.xxx即可。

使用Springboot目的：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

技术&工具	版本（or later）
springboot	3.0.5
maven	3.6.3 or later 3.6.3 或更高版本
Tomcat	10.0+
Servlet	9.0+
JDK	17+

快速创建一个SpringBoot项目

在idea中创建一个空项目如：springboot-project
在该项目下新建一个模块如：springboot-quickstart
在这里声明group如：cn.xnj jdk版本：17 构建系统：maven

构建springboot起步依赖和项目结构

在pom.xml中:1.继承spring-boot为父工程2.导入对应的启动器需要联网

<parent>
    <!-- 1.spring-boot为父工程，所有springboot项目都必须继承自 spring-boot-starter-parent -->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.5</version>
</parent>


<!--这里是你的组名，项目名，版本号-->
<groupId>cn.xnj</groupId>
<artifactId>springboot-quickstart-01</artifactId>
<version>1.0-SNAPSHOT</version>


<!-- 2.导入对应的启动器即可，web开发就是spring-boot-starter-web -->
<dependencies>
    <!-- spring-boot-starter-web 为web开发的起步依赖   -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

创建启动类：在类上加@SpringBootApplication注解，在main方法下加上SpringApplication.run(该类名.class,args);

@SpringBootApplication //启动类
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);//自动创建ioc容器，启动tomact服务器软件(默认)
    }
}

验证：创建一个controller来验证项目创建成功：
注意：请在启动类的同包或者子包下方写Ioc和Di才能生效

package cn.xnj.controller;

@RestController
@RequestMapping("/hello")
public class HelloController {

    //访问测试： http://localhost:8080/hello
    @GetMapping
    public String hello(){
        return "hello springboot";
    }
}

右键启动类，运行即可启动springboot项目了，web项目默认8080端口

创建总结

父项目依赖：每个boot项目都有一个父项目spring-boot-starter-parent，parent的父项目是spring-boot-dependencies，里面已经对各种常用依赖的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标(不需要添加版本)即可！
启动器：一个场景启动器Starter就包含了对应场景下的各种依赖和配置，比如web启动器spring-boot-starter-web就包含了【spring-web,spring-webmvc,tomcat,json处理,servlet的jakarta.annotation-api,logback,slf4j..】等web下的所有依赖和配置。更多预定义Starter请看官网： https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
启动器官方提供的场景：命名为：spring-boot-starter-* 第三方提供场景：命名为：*-spring-boot-starter
@SpringBootApplication注解：要理解它导入的以下三个注解：
- @SpringBootConfiguration：配置类
- @EnableAutoConfiguration：自动加载其他的配置类
- @ComponentScan：扫描当前启动类所在的包
  - 它会自动扫描当前包及其子包，这就是为什么我们要在启动类所在包下创建ioc/di的原因！！！

SpringBoot3配置文件

统一配置文件

统一配置文件
SpringBoot工程下，进行统一的配置管理，你想设置的任何参数（端口号、项目根路径、数据库连接信息等等)都集中到一个固定位置和命名的配置文件（application.properties或application.yml）中。
存放目录
目录为src/main/resources是Spring Boot默认的类路径（classpath），配置文件会被自动加载并可供应用程序访问。
官网功能参数配置说明
https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties
application.properties
1
2
3
4
#端口
server.port=80
#根路径
server.servlet.context-path=/test

属性配置文件使用

配置文件

# application.properties 为统一配置文件
# 内部包含: 固定功能的key,自定义的key
# 此处的配置信息,我们都可以在程序中@Value等注解读取

# 固定的key
# 启动端口号
server.port=80 

# 自定义
spring.jdbc.datasource.driverClassName=com.mysql.cj.jdbc.driver
spring.jdbc.datasource.url=jdbc:mysql:///springboot_01
spring.jdbc.datasource.username=root
spring.jdbc.datasource.password=root

读取配置文件

@Component
public class DataSourceProperties {

    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;

    @Value("${spring.jdbc.datasource.url}")
    private String url;

    @Value("${spring.jdbc.datasource.username}")
    private String username;

    @Value("${spring.jdbc.datasource.password}")
    private String password;

    // 生成get set 和 toString方法

}

YAML配置文件使用

YAML文件使用缩进和冒号来表示层次结构，使得数据之间的关系更加清晰和直观。这样可以更容易理解和维护复杂的配置，特别适用于深层次嵌套的配置情况。

语法说明：
- 数据结构用树形结构呈现，通过缩进来表示层级，
- 连续的项目（集合）通过减号 ” - ” 来表示
- 键值结构里面的key/value对用冒号 ” : ” 来分隔。
- YAML配置文件的扩展名是yaml 或 yml

示例：

#有层次，可以继承的配置文件格式
#key1:
#两个空格key2:  ->key.key
server:
  port: 80
  servlet:
    context-path: /

#自定义属性
#user.name=xnj
#user.age=18
#user.hobby=篮球,足球
#user.account.username=xnj
#user.account.password=root
user:
  name: xnj #key:空格value
  age: 18
    hobby: #@Value只能读取单个的值，所以不能用@Value()List来接收
      - game
      - sing
  account:
    username: xnj
    password: root

读取配置文件

/**
 * 读取配置的方式
 * 方式一：@Value("${key}")
 *      直接在属性上使用@Value注解，将配置文件中的值注入到属性中
 *      注意:@Value(key路径要写全)
 *      并且:@Value只能读取单个的值,不能读取集合
 *
 * 方式二批量配置读取：@ConfigurationProperties(prefix = "通用前缀")
 *      实体类：属性名 = 最后一位key的值
 *      即 prefix + 属性名 = 全路径key的值(${xxx.xxx.xxx})
 *      可以给集合赋值
 */
@Component
@Data  //需要在pom.xml中添加lombok依赖 <version>1.18.30</version>
@ConfigurationProperties(prefix = "user.account")
public class User {
    //@Value("${user.account.username}")
    private String username;

    //@Value("${user.account.password}")
    private String password;

    //@Value("${user.hobby}")//会报错，因为list类型不能直接注入
    private List<String> hobby;
}

多环境配置

方法一：多配置文件

springboot的配置文件命名支持：application-别名.文件后缀【application或yaml或yml】的格式。

如现在有多个生产环节使用的配置文件：

application.yml
开发环境配置：application-dev.yml
测试环境配置：application-test.yml

也可以将不同配置分开写：

durid连接池配置：application-durid.yml
mybatis配置：application-mybatis.yml

我们在application.yml配置文件中通过spring.profiles.active来指定激活哪些外部配置文件

spring:
  profiles:
#    active: dev # 指定单个生效：开发环境
    active: dev,mybatis,durid # 指定多个生效

当外部配置和内部配置有相同key时，外部配置覆盖内部配置生效

方式二：单文件配置

使用--- 分隔不同环境的配置
spring.config.activate.on-profile 配置所属的环境
spring.profiles.active 激活环境

# 通用信息，指定生效的环境
#多环境下的共性属性
# 如果特点环境的配置和通用配置冲突，以特点环境的为准
spring:
  profiles:
    active: dev # 当前为开发环境
server:
  servlet:
    context-path: /
---
#开发环境
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 8081
---
#生产环境
spring:
  config:
    activate:
      on-profile: prod
server:
  port: 9999

---
#测试环境
spring:
  config:
    activate:
      on-profile: test
server:
  port: 8082

SpringBoot3整合SpringMVC

项目创建

因为流程同上面演示的：2.快速创建一个SpringBoot项目所以下面只简单讲一些流程关键词来快速回忆

依赖
- 父工程：spring-boot-starter-parent
- web起步依赖:spring-boot-starter-web
启动类
- 注解：@SpringBootApplication //启动类
- 启动方法：SpringApplication.run(启动类类名.class,args);
创建controller并启动测试
- @RestController,@RequestMapping("/xxx")
- 运行启动类，打开浏览器访问即可

application.yml

# springmvc相关的web配置
server:
  port: 80 #端口号
  servlet:
    context-path: /boot #设置项目根路径
    encoding:   #这两个属性用于配置HTTP请求和响应的字符编码
      charset:  # 定义字符编码的名称（例如UTF-8）
      enabled:  # 用于启用或禁用字符编码的自动配置。

spring:
  mvc:
    view:       #这两个属性用于配置视图解析器的前缀和后缀。
      prefix:   #前缀
      suffix:   #后缀
  web: 
    resources: 
      static-locations: classpath:/wabapp #配置静态资源的位置
      # 一旦指定自定义路径后，原本默认的将不再生效：public static resources

静态资源处理

默认的静态资源路径为：【classpath指的就是src/main/resources】
· classpath:/META-INF/resources/
· classpath:/resources/
· classpath:/static/
· classpath:/public/
我们只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。我们习惯会把静态资源放在classpath:/static/ 目录下。在resources目录下创建index.html文件，启动项目，打开浏览器访问:localhost:8080/index.html即可

覆盖路径:spring.web.resources.static-locations=classpath:/自定义静态文件夹

全局异常处理器

引入依赖
全局异常处理由mvc提供

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

创建一个全局异常管理类
类名上加上注解：
- @ControllerAdvice或@RestControllerAdvice
- RestControllerAdvice注解内包含了@ResponseBody注解
- 如果给方法上加@ResponseBody注解,则方法中的返回值将作为接口发生异常的返回值。
  类中的方法接收异常的同时添加注解：
- @ExceptionHandler(Exception.class)
- 注解中为处理指定的异常

示例代码

//@ControllerAdvice // 可以返回逻辑视图 转发和重定向的
@RestControllerAdvice // @RessponseBody，并且返回json数据
public class GlobalExceptionHandler {

    // 当发生算术异常会触发此方法!
    @ExceptionHandler(ArithmeticException.class)
    public Object handlerArithmeticException(ArithmeticException e){
        String msg = e.getMessage();
        System.out.println("msg:"+msg);
        return msg;
    }

    //空指针异常
    @ExceptionHandler(NullPointerException.class)
    public Object handlerNullPointerException(NullPointerException e){

        return null;
    }

    //HTTP 消息不可读异常
    @ExceptionHandler(HttpMessageNotReadableException.class)
    public Object handlerJsonDateException(HttpMessageNotReadableException e){

        return null;
    }


    /**
     * 所有异常都会触发此方法!但是如果有具体的异常处理Handler!
     * 具体异常处理Handler优先级更高!
     * 例如: 发生NullPointerException异常!
     *       会触发handlerNullException方法,不会触发handlerException方法!
     */
    @ExceptionHandler(Exception.class)
    public Object handlerException(Exception e){

        return null;
    }
}

自定义拦截器

定义拦截器【创建类，实现HandlerInterceptor接口，重写preHandle方法】

package cn.xnj.interceptor;

public class MyInterceptor implements HandlerInterceptor{

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,  Object handler) throws Exception {
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,    Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,   Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

注册拦截器【创建配置类，注册自定义的拦截器】

package cn.xnj.config;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    // 注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
    }
}

项目情景示例
一个SpringBoot微头条项目，对文章发布相关的内容(请求以headline开头的)全部拦截，必须先检测登录和token是否过期，下面是它的拦截器实现和注册部分

package cn.xnj.interceptor;
@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtHelper jwtHelper;//生成，解析，检验token的工具类

    @Override
    public boolean preHandle(HttpServletRequest request,    HttpServletResponse response, Object handler) throws Exception {
        //获取请求头
        String token = request.getHeader("token");
        
        //检测token是否过期 true 过期  false 未过期
        boolean expiration = jwtHelper.isExpiration(token);

        //未过期放行
        if (!expiration) {
            return true;
        }

        //过期拦截 返回504的json数据
        Result result =  Result.build(null, ResultCodeEnum.NOTLOGIN);

        //设置响应体
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(result);
        response.getWriter().print(json);
        //拦截
        return false;
    }
}


package cn.xnj.config;
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor).addPathPatterns("/ headline/**");
    }
}

SpringBoot3整合Durid数据源

前言
目前durid只支持springboot2，兼容springboot3需要自己写一点配置

引入依赖pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/ maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
    </parent>

    <groupId>cn.xnj</groupId>
    <artifactId>springboot-durid-02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--  web开发的场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 数据库相关配置启动器 jdbctemplate 事务相关-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- druid启动器的依赖  -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-3-starter</artifactId>
            <version>1.2.22</version>
        </dependency>

        <!-- 驱动类-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
        </dependency>

    </dependencies>

</project>

启动类

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

配置文件application.yml

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  #使用durid连接池
    #username: root   #用户名 如果是springboot2可以这么写，springboot3不行
    #password: 123456
    # Druid的其他属性配置 springboot3整合情况下,数据库连接信息必须在Druid属性下!
    druid:
      url: jdbc:mysql://localhost:3306/studb
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
      # 初始化时建立物理连接的个数
      initial-size: 5
      # 连接池的最小空闲数量
      min-idle: 5
      # 连接池最大连接数量
      max-active: 20
      # 获取连接时最大等待时间，单位毫秒
      max-wait: 60000
      # 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery  检测连接是否有效。
      test-while-idle: true
      # 既作为检测的间隔时间又作为testWhileIdel执行的依据
      time-between-eviction-runs-millis: 60000
      # 销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接(配置连接在池中的最 小生存时间)
      min-evictable-idle-time-millis: 30000
      # 用来检测数据库连接是否有效的sql 必须是一个查询语句(oracle中为 select 1 from dual)
      validation-query: select 1
      # 申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      test-on-borrow: false
      # 归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      test-on-return: false
      # 是否缓存preparedStatement, 也就是PSCache,PSCache对支持游标的数据库性能提升巨大，比如说  oracle,在mysql下建议关闭。
      pool-prepared-statements: false
      # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在   Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
      max-pool-prepared-statement-per-connection-size: -1
      # 合并多个DruidDataSource的监控数据
      use-global-data-source-stat: true

pojo和controller

@Data
public class Student {
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String className;
}



@RestController
@RequestMapping("/stu")
public class StudentController {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GetMapping
    public List<Student> getAll(){
        String sql = "select * from students";
        List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<> (Student.class));
        return studentList;
    }
}

运行测试总结问题
这里使用的druid-spring-boot-3-starter1.2.22 已经能完美运行
如果druid-spring-boot-3-starter使用的是更低的版本，将会报以下错误：
- Cannot load driver class: org.h2.Driver
- 原因是缺少了自动装配的文件
解决办法为：手动在resources目录下创建META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，文件内容如下!
1
com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure

SpringBoot3整合MyBatis

快速整合Mybatis步骤

创建项目引入依赖【pom.xml】【对比上面druid只是加了一个mybatis-spring-boot-starter启动依赖】

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.5</version>
</parent>

<groupId>cn.xnj</groupId>
<artifactId>springboot-mybatis-03</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
    <!--  web开发的场景启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 数据库相关配置启动器 jdbctemplate 事务相关-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- mybatis 启动器 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>

    <!-- druid启动器的依赖  -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-3-starter</artifactId>
        <version>1.2.22</version>
    </dependency>

    <!-- 驱动类-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>


    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.30</version>
    </dependency>
</dependencies>

配置【application.yml】

# druid连接池配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/studb?useUnicode=true&characterEncoding=utf-8&   useSSL=false&serverTimezone=GMT%2B8
      username: root
      password: 123456


# mybatis配置  不再需要 mybatis-config.xml配置文件了
# mapperxml文件位置  settings的配置 别名的配置.....
mybatis:
  mapper-locations: classpath:/mapper/*.xml  #指定mapperxml文件位置
  type-aliases-package: cn.xnj.pojo  #别名的配置
  configuration:
    map-underscore-to-camel-case: true  #开启驼峰命名规则
    auto-mapping-behavior: full  #开启自动映射
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl  #开启日志

启动类，实体类，controller
启动类Main：cn.xnj

//@MapperScan("cn.xnj.mapper")//mapper接口所在位置 这样的话 就不用在每个mapper接口上加上  @Mapper注解了
@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

实体类Student：cn.xnj.pojo

@Data
public class Student {
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String className;
}

StudentController：cn.xnj.controller

@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudentMapper studentMapper;

    @GetMapping
    public List<Student> getAll(){
        return studentMapper.getAll();
    }
}

mapper和mapper.xml
StudentMapper：cn.xnj.mapper

//如果启动类使用了@MapperScan("cn.xnj.mapper")注解这里就可以不写@Mapper注解
@Mapper
public interface StudentMapper {

    //@Select("select * from students") 简单的sql也可以直接用注解
    List<Student> getAll();
}

StudentMapper.xml：resources/cn/xnj/mapper
注意：前面配置文件中如果指定了mapperxml文件位置mapper-locations: classpath:/mapper/*.xml,那这里包路径可以按配置文件来。 resources/mapper

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace=接口类的全限定名,这样实现对应 -->
<mapper namespace="cn.xnj.mapper.StudentMapper">

    <select id="getAll" resultType="student">
        select * from students
    </select>
</mapper>

声明式事务的整合

导入依赖【pom.xml】【上述整合mybatis步骤中已经导入】

<!-- 数据库相关配置启动器 jdbctemplate 事务相关-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

使用@Transactional注解即可

@Service
public class StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Transactional// 开启事务
    public int deleteById(Integer id){
        int rows = studentMapper.deleteById(id);
        int i = 1/0;// 模拟异常  报错 / by zero  事务回滚
        return rows;
    }
}

AOP整合配置

导入依赖【pom.xml】

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

创建一个类直接在里面使用aop注解即可【cn.xnj.advice】

@Component
@Aspect
//@Order(1)// 配置优先级
public class MyAdvice {

    @Pointcut("execution(* cn.xnj.service.*.*(..))")
    public void pt(){}

    @Before("pt()")// 前置通知
    public void before(JoinPoint joinPoint){
        // joinPoint = execution(List cn.xnj.service.StudentService.getAll())
        System.out.println("joinPoint = "+ joinPoint);
        String className = joinPoint.getTarget().getClass().getSimpleName();
        String methodName = joinPoint.getSignature().getName();
        System.out.println(className+"::"+methodName+"开始执行了");

    }
}

定时任务

SpringBoot内置了定时任务，具体实现如下。

启动定时任务
在springboot启动类上加上@EnableScheduling注解,如下

package com.xnj.web;

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

编写定时逻辑
创建com.xnj.web.schedule.ScheduledTasks类，内容如下

@Component
public class ScheduleTask {
    
    //注释里的cron值表示每秒都执行方法内的逻辑
    @Scheduled(cron = "* * * * * *")
    public void test(){
        System.out.println("test");
    }
}

知识点
SpringBoot中的cron表达式语法如下

┌───────────── second (0-59)
│ ┌───────────── minute (0 - 59)
│ │ ┌───────────── hour (0 - 23)
│ │ │ ┌───────────── day of the month (1 - 31)
│ │ │ │ ┌───────────── month (1 - 12) (or JAN-DEC)
│ │ │ │ │ ┌───────────── day of the week (0 - 7)
│ │ │ │ │ │          (0 or 7 is Sunday, or MON-SUN)
│ │ │ │ │ │
* * * * * *

异步执行方法注解

在实现接口的方法上加上@Async注解，启动类上添加@EnableAsync注解即可，这样当执行该方法时，springboot会帮我们自动创建一个新的线程来异步执行该方法
应用场景如，添加浏览历史

SpringBoot3项目打包和运行

添加打包插件

在Spring Boot项目中添加spring-boot-maven-plugin插件是为了支持将项目打包成可执行的可运行jar包。如果不添加spring-boot-maven-plugin插件配置，使用常规的java -jar命令来运行打包后的Spring Boot项目是无法找到应用程序的入口点，因此导致无法运行

<!--    SpringBoot应用打包插件-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

执行打包

在idea中点击侧边栏maven，选择要打包的项目，点击生命周期中的package即可
打包完成后，在项目的target目录下即可看到打包好的jar包

项目/target/项目名-版本号.jar

命令启动和参数声明

java -jar命令用于在Java环境中执行可执行的JAR文件。下面是关于java -jar命令的说明：

在你jar包存放的位置打开cmd输入
命令格式：java -jar [选项] [参数] <jar文件名>
在运行的窗口按： Ctrl + c停止

设置系统属性 -D<name>=<value>：可以通过System.getProperty()方法在应用程序中获取该属性值。例如：java -jar -Dserver.port=8888 springboot-mybatis-03-1.0-SNAPSHOT.jar。
设置JVM参数，例如内存大小、垃圾回收策略等 -X。常用的选项包括：
- -Xmx<size>：设置JVM的最大堆内存大小，例如 -Xmx512m 表示设置最大堆内存为512MB。
- -Xms<size>：设置JVM的初始堆内存大小，例如 -Xms256m 表示设置初始堆内存为256MB。
指定Spring Boot的激活配置文件 -Dspring.profiles.active=<profile>：
可以通过application-<profile>.properties或application-<profile>.yml文件来加载相应的配置。例如：java -jar -Dspring.profiles.active=dev myapp.jar。
多个配置直接使用空格隔开就好
- 例如：java -jar -Dserver.port=8080 -Dspring.profiles.active=dev myapp.jar
注意： -D 参数必须要在jar之前！否者不生效！