SpringBoot

一条小贤鱼

于 2024-07-31 12:45:39 发布

阅读量592

点赞数 15

本文链接：https://blog.csdn.net/weixin_61808639/article/details/140803826

版权

1.介绍

SpringBoot 帮我们简单、快速地创建一个独立的、生产级别的 **Spring 应用（说明：SpringBoot底层是Spring），大多数 SpringBoot 应用只需要编写少量配置即可快速整合 Spring 平台以及第三方技术！

SpringBoot的主要目标是：

- 为所有 Spring 开发提供更快速、可广泛访问的入门体验。
- 开箱即用，设置合理的默认值，但是也可以根据需求进行适当的调整。
- 提供一系列大型项目通用的非功能性程序（如嵌入式服务器、安全性、指标、运行检查等）。
- 约定大于配置，基本不需要主动编写配置类、也不需要 XML 配置文件。

总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

2.快速使用

2.1创建maven工程

这里就不需要演示了

2.2添加依赖

添加父工程坐标

SpringBoot可以帮我们方便的管理项目依赖 , 在Spring Boot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标(不需要添加版本)即可


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

添加web启动器

为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器，在 pom.xml 文件中加入如下依赖：

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

2.3创建启动类

@SpringBootApplication是一个特殊的注解，用于标识一个Spring Boot应用程序的入口类。它的主要作用是将三个常用注解组合在一起，简化了配置的过程。

具体而言，@SpringBootApplication注解包含以下三个注解的功能：

@Configuration：将该类标识为应用程序的配置类。它允许使用Java代码定义和配置Bean。 @EnableAutoConfiguration：启用Spring Boot的自动配置机制。它根据项目的依赖项自动配置Spring应用程序的行为。自动配置根据类路径、注解和配置属性等条件来决定要使用的功能和配置。

@ComponentScan：自动扫描并加载应用程序中的组件，如控制器、服务、存储库等。它默认扫描@SpringBootApplication注解所在类的包及其子包中的组件。

使用@SpringBootApplication注解，可以将上述三个注解的功能集中在一个注解上，简化了配置文件的编写和组件的加载和扫描过程。它是Spring Boot应用程序的入口点，标识了应用程序的主类，

并告诉Spring Boot在启动时应如何配置和加载应用程序。

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

2.4编写一个HellController类


@RestController
@RequestMapping("spring")
public class HelloController {
    @RequestMapping("boot")
    public String hello(){
        return "hello spring boot";
    }
}

2.5测试

2.6总结

为什么依赖不需要写版本？

- 每个boot项目都有一个父项目`spring-boot-starter-parent`
- parent的父项目是`spring-boot-dependencies`
- 父项目版本仲裁中心，把所有常见的jar的依赖版本都声明好了。
- 比如：mysql-connector-j

启动器(Starter)是何方神圣？

Spring Boot提供了一种叫做Starter的概念，它是一组预定义的依赖项集合，旨在简化Spring应用程序的配置和构建过程。Starter包含了一组相关的依赖项，以便在启动应用程序时自动引入所需的库、配置和功能。

主要作用如下：

1. 简化依赖管理：Spring Boot Starter通过捆绑和管理一组相关的依赖项，减少了手动解析和配置依赖项的工作。只需引入一个相关的Starter依赖，即可获取应用程序所需的全部依赖。
2. 自动配置：Spring Boot Starter在应用程序启动时自动配置所需的组件和功能。通过根据类路径和其他设置的自动检测，Starter可以自动配置Spring Bean、数据源、消息传递等常见组件，从而使应用程序的配置变得简单和维护成本降低。
3. 提供约定优于配置：Spring Boot Starter遵循“约定优于配置”的原则，通过提供一组默认设置和约定，减少了手动配置的需要。它定义了标准的配置文件命名约定、默认属性值、日志配置等，使得开发者可以更专注于业务逻辑而不是繁琐的配置细节。
4. 快速启动和开发应用程序：Spring Boot Starter使得从零开始构建一个完整的Spring Boot应用程序变得容易。它提供了主要领域（如Web开发、数据访问、安全性、消息传递等）的Starter，帮助开发者快速搭建一个具备特定功能的应用程序原型。
5. 模块化和可扩展性：Spring Boot Starter的组织结构使得应用程序的不同模块可以进行分离和解耦。每个模块可以有自己的Starter和依赖项，使得应用程序的不同部分可以按需进行开发和扩展。

Spring Boot提供了许多预定义的Starter，例如spring-boot-starter-web用于构建Web应用程序，spring-boot-starter-data-jpa用于使用JPA进行数据库访问，spring-boot-starter-security用于安全认证和授权等等。

使用Starter非常简单，只需要在项目的构建文件（例如Maven的pom.xml）中添加所需的Starter依赖，Spring Boot会自动处理依赖管理和配置。

通过使用Starter，开发人员可以方便地引入和配置应用程序所需的功能，避免了手动添加大量的依赖项和编写冗长的配置文件的繁琐过程。同时，Starter也提供了一致的依赖项版本管理，确保依赖项之间的兼容性和稳定性。

@SpringBootApplication注解的功效？

@SpringBootApplication添加到启动类上，是一个组合注解，他的功效有具体的子注解实现！
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {}
@SpringBootApplication注解是Spring Boot框架中的核心注解，它的主要作用是简化和加速Spring Boot应用程序的配置和启动过程。

总的来说，@SpringBootApplication注解的主要作用是简化Spring Boot应用程序的配置和启动过程。它自动配置应用程序、扫描并加载组件，并将配置和启动类合二为一，简化了开发者的工作量，提高了开发效率。

3.SpringBoot配置文件

3.1介绍说明

SpringBoot工程下，进行统一的配置管理，你想设置的任何参数（端口号、项目根路径、数据库连接信息等等)都集中到一个固定位置和命名的配置文件（`application.properties`或`application.yml`）中！

配置文件应该放置在Spring Boot工程的`src/main/resources`目录下。这是因为`src/main/resources`目录是Spring Boot默认的类路径（classpath），配置文件会被自动加载并可供应用程序访问。

功能配置参数说明：

https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties

细节总结：

- 集中式管理配置。统一在一个文件完成程序功能参数设置和自定义参数声明。
- 位置：resources文件夹下，必须命名application 后缀 .properties / .yaml / .yml 。
- 如果同时存在application.properties | application.yml(.yaml) , properties的优先级更高。

配置基本都有默认值。

3.2 properties类型的使用(不推荐)

3.2.1创建application.properties文件


# 设置端口号为80,默认是8080
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

这里我设置端口为80，到时候测试的时候就不是8080了

springboot中有很多它自己定了的功能参数，springboot会自动引入他们 server.port就是springboot自己的

我们自己也可以自定义一些功能参数，但需要我们自己引入他们

3.2.2创建对应的实体类

这里我引入了lombok依赖

@Component
@Data
public class DataSource {

    @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;

}

3.2.3创建测试的controller

    @Autowired
    private DataSource dataSource;

    @RequestMapping("properties")
    public String properties(){
        return dataSource.toString();
    }

3.2.4测试

3.3YAML配置文件 (推荐使用)

3.3.1使用说明

YAML（YAML Ain’t Markup Language）是一种基于层次结构的数据序列化格式，旨在提供一种易读、人类友好的数据表示方式。

与`.properties`文件相比，YAML格式有以下优势：

1. 层次结构：YAML文件使用缩进和冒号来表示层次结构，使得数据之间的关系更加清晰和直观。这样可以更容易理解和维护复杂的配置，特别适用于深层次嵌套的配置情况。
2. 自我描述性：YAML文件具有自我描述性，字段和值之间使用冒号分隔，并使用缩进表示层级关系。这使得配置文件更易于阅读和理解，并且可以减少冗余的标点符号和引号。
3. 注释支持：YAML格式支持注释，可以在配置文件中添加说明性的注释，使配置更具可读性和可维护性。相比之下，`.properties`文件不支持注释，无法提供类似的解释和说明。
4. 多行文本：YAML格式支持多行文本的表示，可以更方便地表示长文本或数据块。相比之下，`.properties`文件需要使用转义符或将长文本拆分为多行。
5. 类型支持：YAML格式天然支持复杂的数据类型，如列表、映射等。这使得在配置文件中表示嵌套结构或数据集合更加容易，而不需要进行额外的解析或转换。
6. 更好的可读性：由于YAML格式的特点，它更容易被人类读懂和解释。它减少了配置文件中需要的特殊字符和语法，让配置更加清晰明了，从而减少了错误和歧义。

语法说明

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

3.3.2创建application.yml文件

server:
  port: 80


  #自定义
spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/test
      username: root
      password: root




#自定义 集合
my:
  list:
    - 你好
    - 世界
    - hello
    - 明天

3.3.3创建对应的实体类(实体类中没有设置要接收的集合，集合会单独讲解)

@Component
@Data
public class DataSource {

    @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;

//    @Value("${my.list}")
//    private List<String> list;

}

这里的实体类其实和properties的一模一样

3.3.3创建对应的controller

这里就不展示了，和properties的一模一样

3.3.4执行

3.4@ConfigurationProperties注解

3.4.1集合

@Component
@Data
public class DataSource {

//    @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;

    @Value("${my.list}")
    private List<String> list;

}

执行

说明：@value接收不了多个值

3.4.2@ConfigurationProperties注解说明

@ConfigurationProperties是SpringBoot提供的重要注解, 他可以将一些配置属性批量注入到bean对象。

在类上通过@ConfigurationProperties注解声明该类要读取属性配置

prefix="spring.jdbc.datasource" 读取属性文件中前缀为spring.jdbc.datasource的值。前缀和属性名称和配置文件中的key必须要保持一致才可以注入成功

3.4.3 集合问题解决

@Component
@Data
@ConfigurationProperties(prefix = "my")
public class DataSource {

//    @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;


    private List<String> list;

}

controller类

    @Autowired
    private DataSource dataSource;

    @RequestMapping("yml")
    public String properties(){
        List<String> list = dataSource.getList();
        StringBuilder sb=new StringBuilder();
        for (String s:list
             ) {
            System.out.println(s);
            sb.append(s);
        }
      return sb.toString();
    }

执行

@ConfigurationProperties可以接受多个值

@ConfigurationProperties简化@Value的繁琐

@Component
@Data
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSource {


    private String driverClassName;
    private String url;
    private String username;
    private String password;


//    private List<String> list;

}

3.5多环境配置与使用

介绍

在Spring Boot中，可以使用多环境配置来根据不同的运行环境（如开发、测试、生产）加载不同的配置。SpringBoot支持多环境配置让应用程序在不同的环境中使用不同的配置参数，例如数据库连接信息、日志级别、缓存配置等

以下是实现Spring Boot多环境配置的常见方法：

properties和yaml的方式一样，这里就不展示了
1. YAML配置文件：与属性文件类似，可以将配置参数分离到不同的YAML文件中，每个环境对应一个文件。例如，可以创建`application-dev.yml`、`application-prod.yml`和`application-test.yml`等文件。在这些文件中，可以使用YAML语法定义各自环境的配置参数。同样，通过`spring.profiles.active`属性指定当前的环境，Spring Boot会加载相应的YAML文件。
2. 命令行参数(动态)：可以通过命令行参数来指定当前的环境。例如，可以使用`--spring.profiles.active=dev`来指定使用开发环境的配置。

通过上述方法，Spring Boot会根据当前指定的环境来加载相应的配置文件或参数，从而实现多环境配置。这样可以简化在不同环境之间的配置切换，并且确保应用程序在不同环境中具有正确的配置。

举例（yaml方式）

3.5.1创建application-dev.yml文件

spring:
  jdbc:
    data:
      a: a
      b: b
      c: c
      d: d

3.5.2创建application-test.yml文件

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///test
      username: root
      password: root

3.5.3创建application.yml文件

#环境激活
spring:
  profiles:
    active: dev,test

3.5.4分别创建接受的实体类

dev

@Component
@ConfigurationProperties(prefix = "spring.jdbc.data")
@Data
public class Dev {

    private String a;
    private String b;
    private String c;
    private String d;
}

test

@Component
@Data
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSource {


    private String driverClassName;
    private String url;
    private String username;
    private String password;


//    private List<String> list;

}

3.5.5controllert测试

    @Autowired
    private DataSource dataSource;

    @Autowired
    private Dev dev;

    @RequestMapping("test")
    public String test(){
        return dataSource.toString();
    }
    @RequestMapping("dev")
    public String dev(){
        return dev.toString();
    }

执行

test

dev

4.SpringBoot整合SpringMvc

web常用配置

# web相关的配置
# https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
server:
  # 端口号设置
  port: 80
  # 项目根路径
  servlet:
    context-path: /boot

当涉及Spring Boot的Web应用程序配置时，以下是五个重要的配置参数：

1. `server.port`: 指定应用程序的HTTP服务器端口号。默认情况下，Spring Boot使用8080作为默认端口。您可以通过在配置文件中设置`server.port`来更改端口号。
2. `server.servlet.context-path`: 设置应用程序的上下文路径。这是应用程序在URL中的基本路径。默认情况下，上下文路径为空。您可以通过在配置文件中设置`server.servlet.context-path`属性来指定自定义的上下文路径。
3. `spring.mvc.view.prefix`和`spring.mvc.view.suffix`: 这两个属性用于配置视图解析器的前缀和后缀。视图解析器用于解析控制器返回的视图名称，并将其映射到实际的视图页面。`spring.mvc.view.prefix`定义视图的前缀，`spring.mvc.view.suffix`定义视图的后缀。
4. `spring.resources.static-locations`: 配置静态资源的位置。静态资源可以是CSS、JavaScript、图像等。默认情况下，Spring Boot会将静态资源放在`classpath:/static`目录下。您可以通过在配置文件中设置`spring.resources.static-locations`属性来自定义静态资源的位置。
5. `spring.http.encoding.charset`和`spring.http.encoding.enabled`: 这两个属性用于配置HTTP请求和响应的字符编码。`spring.http.encoding.charset`定义字符编码的名称（例如UTF-8），`spring.http.encoding.enabled`用于启用或禁用字符编码的自动配置。

server:
  port: 8080
  servlet:
    context-path: /web


#修改静态资源配置静态资源文件夹webapp，默认静态资源配置静态资源文件夹是static
spring:
  web:
    resources:
      static-locations: classpath:webapp

拦截器

如果需要用到拦截器的时候,步骤如下

1.创建拦截器的声明类

首先向以前一样声明一个拦截器

创建HandlerInterceptor类（名字无所谓）

public class HandlerInterceptor implements org.springframework.web.servlet.HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor拦截器的preHandle方法执行....");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor拦截器的postHandle方法执行....");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor拦截器的afterCompletion方法执行....");
    }
}

2.将拦截器加入到配置类中

这里可以创建一个配置类，向以前一样，配置类实现WebMvcConfigurer重写addInterceptors方法

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new HandlerInterceptor());
    }
}

3.测试

SpringBoot整合Druid

1.导入依赖

springboot3需要支持druid1.2.20及以上版本依赖

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

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

2.添加druid连接池的配置


spring:
  datasource:
    # 连接池类型
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/schedule_system
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

3.创建实体类

@Data

public class User {
    private Integer uid;
    private String username;
    private String userPwd;

}

4.创建controller

@RestController
@RequestMapping("jdbc")

public class JdbcController {

    @Autowired
    private JdbcTemplate jdbcTemplate;



    @RequestMapping("list/{id}")
    public User getUser(@PathVariable int id){
        String sql = "select * from sys_user where uid = ? ; ";

        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
    }
    
}

5.测试

SpringBoot整合mybatis

1.整合步骤

1. 导入依赖：在您的Spring Boot项目的构建文件（如pom.xml）中添加MyBatis和数据库驱动的相关依赖。例如，如果使用MySQL数据库，您需要添加MyBatis和MySQL驱动的依赖。
2. 配置数据源：在`application.properties`或`application.yml`中配置数据库连接信息，包括数据库URL、用户名、密码、mybatis的功能配置等。
3. 创建实体类：创建与数据库表对应的实体类。
4. 创建Mapper接口：创建与数据库表交互的Mapper接口。
5. 创建Mapper接口SQL实现：可以使用mapperxml文件或者注解方式
6. 创建程序启动类
7. 注解扫描：在Spring Boot的主应用类上添加`@MapperScan`注解，用于扫描和注册Mapper接口。
8. 使用Mapper接口：在需要使用数据库操作的地方，通过依赖注入或直接实例化Mapper接口，并调用其中的方法进行数据库操作。

mapper的xml文件目录无需和mapper接口的目录一致

2.开始演示

2.1导入所需依赖

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

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

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

    <!-- 数据库相关配置启动器 -->
    <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.18</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>

2.2配置文件


spring:
  datasource:
    # 连接池类型
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/schedule_system
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver


mybatis:
  configuration:     #setting配置
     auto-mapping-behavior: full    #自动映射
     map-underscore-to-camel-case: true #开启驼峰命名
     log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl  #开启日志
  type-aliases-package: org.example.pojo  #别名
  mapper-locations: classpath:mappers/*.xml  #mapper文件位置

2.3编写UserMapper接口和UserMapper.xml

public interface UserMapper {
    List<User> selectAll();
}

<?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接口类的全限定名,这样实现对应 -->
<mapper namespace="org.example.mapper.UserMapper">


    <select id="selectAll" resultType="org.example.pojo.User">
        select * from sys_user
    </select>
</mapper>

2.4编写Userservice接口和它的实现类

public interface UserService {

    List<User> selectAll();
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> selectAll() {
        return userMapper.selectAll();
    }
}

2.5编写Usercontroller

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("select")
    public List<User> selectUser() {
        return userService.selectAll();
    }


}

2.6测试

声明式事务整合

1.导入依赖

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

注：SpringBoot项目会自动配置一个 DataSourceTransactionManager，所以我们只需在方法（或者类）加上 @Transactional 注解，就自动纳入 Spring 的事务管理了

2.创建测试

2.1创建一个用来测试的

@Service
public class UserService2 {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void save() {
        userMapper.delect(1);
        int i=1/0;
        System.out.println(i);
    }
}

这里mapper层的删除就不写了，没必要

2.2controller

    @Autowired
    private UserService2 user;
    @RequestMapping("select2")
    public void selectUser2() {
        user.save();
    }

测试

除0异常，数据库中的信息也没删除，事务回滚了

简而言之，加载完依赖直接使用就行

AOP整合配置

简而言之，加载完依赖直接使用就行

1.加载依赖

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

2.创建测试

@Component
@Aspect
public class LogAdvice {

    @Before("execution(* org..service.*.*(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("LogAdvice.before");
        System.out.println("joinPoint = " + joinPoint);
    }

}

执行

成功切面

SpringBoot项目打包和运行

在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点击package进行打包

可以在编译的target文件中查看jar包

可以先clean清理后，在package打包

执行打包

打包后会多出这么两个jar

打开项目目录,找到这两文件的位置

cmd进入命令界面

命令格式：java -jar [选项] [参数] <jar文件名>

1. `-D<name>=<value>`：设置系统属性，可以通过`System.getProperty()`方法在应用程序中获取该属性值。例如：`java -jar -Dserver.port=8080 myapp.jar`。
2. `-X`：设置JVM参数，例如内存大小、垃圾回收策略等。常用的选项包括：
- `-Xmx<size>`：设置JVM的最大堆内存大小，例如 `-Xmx512m` 表示设置最大堆内存为512MB。
- `-Xms<size>`：设置JVM的初始堆内存大小，例如 `-Xms256m` 表示设置初始堆内存为256MB。
3. `-Dspring.profiles.active=<profile>`：指定Spring Boot的激活配置文件，可以通过`application-<profile>.properties`或`application-<profile>.yml`文件来加载相应的配置。例如：`java -jar -Dspring.profiles.active=dev myapp.jar`。

启动测试

注意： -D 参数必须要在jar之前！否者不生效！

一条小贤鱼

关注

15
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot

为什么依赖不需要写版本？- 每个boot项目都有一个父项目`spring-boot-starter-parent`- parent的父项目是`spring-boot-dependencies`- 父项目版本仲裁中心，把所有常见的jar的依赖版本都声明好了。- 比如：mysql-connector-j启动器(Starter)是何方神圣？Spring Boot提供了一种叫做Starter的概念，它是一组预定义的依赖项集合，旨在简化Spring应用程序的配置和构建过程。
复制链接

扫一扫