SpringBoot3学习

一、SpringBoot简介

springboot框架简化了SSM框架。之前使用SSM框架时，我们需要导入大量的依赖，和配置许多配置类及其相应的注解，太过于繁琐，不好记，而springboot极大的减轻了这些操作，把这些操作都封装了起来，提高开发效率。

二、快速启动

2.1 创建Maven工程

重新创建一个Maven工程，要求无父工程。

2.2 继承 spring-boot-starter-parent

在项目的pom文件中添加如下的继承语句。

<parent>
    <!--继承springboot父工程-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
</parent>

2.3 添加web启动依赖 spring-boot-starter-web

整合了spring-webmvc,servlet,jackson等依赖

不需要指定版本号，上面的父工程已经帮我们指定好了。

<!--导入web启动器依赖即可-->
<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2.4 创建一个Main类

@SpringBootApplication是启动类的注解

而SpringApplication.run(Main.class, args)是固定的启动类配置语句。

SpringBoot不需要我们在IDEA里配置tomcat，它已经封装好了，当我们运行main方法时，tomcat就会自己启动。而且它还会自己创建ioc容器和进行包扫描，扫描范围为当前Main类所在的包下的所有类，包括了包下包的类。

/*
查看@SpringBootApplication源码可知有如下注解功能
    1.@SpringBootConfiguration 声明配置类
    2.@EnableAutoConfiguration 自动加载其他配置类
    3.@ComponentScan 包扫描，默认是当前所在的包
* */
@SpringBootApplication //启动类注解
public class Main {
    public static void main(String[] args) {
        //自动创建ioc容器，启动tomcat服务软件
        SpringApplication.run(Main.class, args);
    }
}

2.5 创建HelloController类

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

2.6 启动运行

网址开头默认是localhost:8080

由快速入门可见，springboot相比于SSM实在是太过于方便了，省去了许多麻烦的配置。

三、配置文件

3.1 统一配置管理概述

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

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

3.2 快速案例

springboot规定了读取的配置文件名称，application.properties是其中之一，所以我们在resources文件夹下创建application.properties文件即可，它会自动读取该配置文件。

1.application.properties

# 使用springboot提供的配置类来修改参数，key是固定的，有需要则查阅官方文档
# server.port指定了服务器开启的端口号
server.port=80
# server.servlet.context-path指定虚拟目录
server.servlet.context-path=/sb

# 自定义配置key=value
ldy.name=ldy
ldy.age=19

2.controller层设置访问

@RestController
@RequestMapping("boot")
public class HelloController {

    @Value("${ldy.name}")
    private String name;
    @Value("${ldy.age}")
    private int age;
    @GetMapping("hello")
    public String hello(){
        return "hello Springboot";
    }

    @GetMapping("ldy")
    public String ldy(){
        return "name="+name+",age="+age;
    }
}

3.启动并访问

3.3 yml(ymal)配置文件

传统的properties因为key不能重复，所以对key使用多层次的命名方法 如 server.servlet.context-path.每次写都要加上许多相同的前缀，如 server。

yml相比于properties化繁为简显得更加有层次。

# 语法如下,要求每一层进行一次缩进，然后赋值时需要 :空格value,不能忘记冒号后面先加个空格
server:
  port: 80
  servlet:
    context-path: /sb
ldy:
  name: ldy
  age: 19

此外，yaml还支持集合赋值

ldy:
  user:
    name: ggbone
    age: 11
    hbs:
      - game
      - sleep
      - eat

3.4配置文件读取

之前在SSM框架的学习中，学会了使用@Value注解，而在springboot中有着更加简便使用的**@ConfigurationProperties**注解。可以进行批量配置以及读取集合。以下是快速案例。

1.User类

/*
* 读取配置文件的方式1：@Value
*   1.直接在属性上添加@Value
*   2.@Value(key的全名)
*   3.不能读取集合并赋值
* 方式2：@ConfigurationProperties
*   优点：1.添加在类上，批量配置
*        2.可以给集合赋值
* */
@Data
@ConfigurationProperties(prefix = "ldy.user")
public class User {
//    @Value("${ldy.user.name}")
    private String name;
//    @Value("${ldy.user.age}")
    private int age;
//    @Value("${ldy.user.hbs}") //报错，不能读取集合
    private List<String> hbs;
}

2.UserController

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    User user;
    @GetMapping("info")
    public User user(){
        return user;
    }
}

3.启动并访问

3.5多环境配置和激活

当我们把所有配置信息都塞到application.yaml配置文件时，该文件会显得相当冗杂，所以，我们可以进行多环境的配置和激活，将应用程序的配置参数分离到不同的属性文件中，每个环境对应一个属性文件。只需要在application.yaml文件里指定激活的配置文件即可。

激活方式见下application.yaml文件。

要求，其他配置文件的命名规范为application-xxx.yaml。

1.application.yaml

ldy:
  user:
    name: ggbone
    age: 11
    hbs:
      - game
      - sleep
      - eat
#激活方式：
spring:
  profiles:
    active: druid

2.application-druid.yaml

druid:
  password: root
  username: root
ldy:
  user:
    name: bk201
    age: 25

当激活的配置文件的key和application的key有重复时，以激活的配置文件的value值为主。如下图所示。

四、SpringMvc整合

前面的已经介绍过，springboot整合了springmvc大部分的注解和配置。下面是某些其他springmvc功能的设置。

4.1 静态资源访问

使用Spring Boot做开发时 , 项目中没有webapp目录 , 我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？springboot给我们配置好了默认的静态资源访问路径。只需要把静态资源创建在相应的路径下即可访问。在maven工程中，classpath指的是main/java/resources。创建文件如下所示

1.默认路径

默认的静态资源路径为：

· classpath:/META-INF/resources/

· classpath:/resources/

· classpath:/static/

· classpath:/public/

2.自定义路径

指定路径的语法格式为 classpath:/xxx。指定多个时，仅需加逗号写同样的格式。不能是classpath:/webapps, web。无法访问web下面的静态资源，因为我试过。

spring:
  web:
    resources:
      static-locations: classpath:/webapps, classpath:/web #自定义静态资源访问路径
      #注意，配置静态资源地址后,会覆盖默认值

4.2 拦截器设置

拦截器的设置没什么变化，都是要创建一个实现HandlerInterceptor接口的类

然后，在Main类所在的包下创建一个配置类

1.添加@Configuration注解，springboot会自动进行配置类扫描

2.实现WebMvcConfigurer接口

3.重写addInterceptor方法，添加自定义的拦截器类对象即可

五、Druid连接池配置

5.1 添加相应的依赖

druid-spring-boot-3-starter目前1.2.20即以上版本已经兼容springboot3了。1.2.20以下版本需要额外配置。

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

5.2 配置application.yaml

druid连接池配置相应信息的固定格式如下

# druid连接池配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  # 使用druid连接池
    druid:
      url: jdbc:mysql://localhost:3306/test
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

5.3 实现

1.实体类

@Data
public class Schedule {
    private int id;
    private String title;
    private boolean completed;
}

2.Controller类

因为添加了jdbcTemplate的相应依赖，springboot会自动把JdbcTemplate对象添加到ioc容器里，所以直接用@Autowired获取即可。

@RestController
@RequestMapping("sche")
public class ScheduleController {
    @Autowired
    JdbcTemplate template;
    @GetMapping("info")
    public List<Schedule> info(){
        String sql = "select * from schedule";
        List<Schedule> query = template.query(sql, new BeanPropertyRowMapper<>(Schedule.class));
        return query;

    }
}

3.启动类

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

4.启动并访问

六、Mybatis整合

6.1Mybatis整合步骤

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接口的动态代理对象到ioc容器。
8. 使用Mapper接口：在需要使用数据库操作的地方，通过依赖注入或直接实例化Mapper接口，并调用其中的方法进行数据库操作。

以下是快速案例

6.2依赖导入

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--mybatis依赖-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.1</version>
</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.20</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>

6.3 配置application.yaml文件

# druid连接池配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/test
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
# mybatis配置， 彻底抛弃mybatis-config.xml文件
mybatis:
  mapper-locations: classpath:/mapper/*.xml  #指定mapper的xml文件的位置
  type-aliases-package: com.ldy.bean  #设置实体类别名
  configuration: # setting设置
    auto-mapping-behavior: full #自动映射，full表示可以嵌套映射
    map-underscore-to-camel-case: true #开启驼峰式命名法
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl #开启日志输出

6.4 类和接口

实体类

@Data
public class Schedule {
    private int id;
    private String title;
    private boolean completed;
}

Mapper接口

public interface ScheduleMapper {
    public List<Schedule> selectAll();
    public int delete(int id);
}

Controller

@RestController
@RequestMapping("sche")
public class ScheduleController {
    @Autowired
    ScheduleMapper mapper;
    @GetMapping("info")
    public List<Schedule> info(){
        List<Schedule> schedules = mapper.selectAll();
        return schedules;
    }
}

记得在Main中开启mapper包扫描

@SpringBootApplication
@MapperScan("com.ldy.mapper") //mapper包扫描,会把接口的代理对象放到ioc容器
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

七、其他SSM功能实现

1.aop切面管理

知识点：切点表达式，在之前文章里有总结。

依赖导入:

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

对比

ssm要在配置类中开启Aspcetj注解支持:

而springboot不需要。直接创建advice类添加@Aspect注解即可使用。

创建一个advice包用于存储各种Advice类。别忘了在类上添加@Aspect和@Component注解

也可以单独创建一个切点表达式的包用于存放切点信息。

2.tx事务管理

依赖导入:

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

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

具体使用如下

@RestController
@RequestMapping("sche")
public class ScheduleController {
    @Autowired
    ScheduleMapper mapper;
    //自定义异常
    @Transactional
    @GetMapping("delete")
    public String delete(@RequestParam int id){
        int flag = mapper.delete(id);
        //id大于20时制造异常，进行事务回滚
        if(id > 20){
            int b = 1/0;
        }
        if(flag > 0){
            return "删除成功";
        }
        return "删除失败";
    }
}

其中@Transactional的属性propagation的各种参数具体功能可以参考如下博客

Spring事务的传播：PROPAGATION_REQUIRED_propagation.required-CSDN博客

八、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>

6.2 执行打包

在idea点击package进行打包

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

6.3 命令启动和参数说明

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

命令格式：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之前！否者不生效！

以上，即为springboot的快速入门学习，总的来说确实比ssm省事多了。