框架-SpringBoot

一、基础使用

1、创建SpringBoot项目

创建一个空项目。

  1. 首先修改maven版本

    File -> Settings -> maven

  2. 创建一个springboot模块

    这里也可以选择阿里云提供的 https://start/aliyun.com

    Settings -> Editor -> File Types

2、pom文件

1
2
3
4
5
6
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.4</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

SpringBoot项目都需要继承spring-boot-starter-parent，spring-boot-starter-parent中定义了若干个依赖管理，对有些依赖的版本管理，当在我们的这个项目中引入这个依赖，就不需要指定它的版本，这样可以避免多个依赖使用相同技术时出现的依赖版本冲突。

start包含了若干个依赖信息，我们只需要导入start就可以，来减少以来配置。

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

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

3、引导类

这是Spring的容器，是整个boot工程的执行入口。

springboot工程运行后初始化Spring容器，扫描引导类所在包加载bean

扫描引导类所在包及其子包的类

1
2
3
4
5
6
7
8
9
@SpringBootApplication
public class Springboot0101QuickstartApplication {

	public static void main(String[] args) {
        //这个的返回类型就是Applicationcontext
		SpringApplication.run(Springboot0101QuickstartApplication.class, args);
	}

}

4、内嵌的tomcat服务器

内嵌的Tomcat工作原理是将tomcat服务器作为对象运行，并将该对象交给Spring容器管理。

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

中的

1
2
3
4
5
6
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.7.4</version>
    <scope>compile</scope>
</dependency>

中的

1
2
3
4
5
6
7
8
9
10
11
12
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
    <version>9.0.65</version>
    <scope>compile</scope>
    <exclusions>
        <exclusion>
            <artifactId>tomcat-annotations-api</artifactId>
            <groupId>org.apache.tomcat</groupId>
        </exclusion>
    </exclusions>
</dependency>

tomcat-embed-co re是tomcat核心

二、yml配置文件详解

1、不同后缀

.properties

springboot中默认配置文件application.properties，通过键值对配置对应属性。

1
2
3
server.port=8080
#显示日志的级别
logging.level.root=info

配置规则信息可以在https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties这里看

.yml

这是springboot使用的主流模式。

application.yml

冒号后面要有空格

1
2
server:
	port: 80

.yaml

application.yaml

1
2
3
4
5
6
7
8
9
10
11
server:
	port: 80
	
#对象数组
user:
  -
    name: zhangsan
    age: 12
  -
    name: lisi
    age: 45

区别

如果这三个文件都存在的话，优先级：.properties > .yml > .yaml

并且他们的不同属性共存叠加，相同的属性相互覆盖。

常用的是yml

如果你创建的yml文件图标不是绿色的，写属性的时候没有提示，说明springboot不认为它是一个配置文件，需要我们手动设置。

2、yaml读取配置文件中的数据

1、读取单个属性值

使用@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名}

最后一个用String接收就可以，不用写成字符串数组String[]的形式。

yaml文件中的变量引用

使用Environment对象封装全部配置信息，使用Autowired自动装配数据到Environment队长中。

1
2
3
#yaml中
server:
  port: 8080

如何读取？

1
2
3
4
5
6
7
8
9
10
//Controller层
@Autowired
private Environment environment;

@GetMapping("h")
public String hahh(){
    //括号里的内容和上面用${}中的一样
    String port = environment.getProperty("server.port");
    return "haha";
}

2、方法一：@ConfigurationProperties 绑定一个bean

将yaml指定属性封装为一个java对象，同时里面的值就是yaml的属性值。

对象属性名要与yaml中的属性名一致。

1
2
3
4
5
6
7
8
9
@Component				// prefix的值是yaml的属性值名字
@ConfigurationProperties(prefix = "datasources")
public class MyDataSources {
    //类的属性名要与yaml中的一致
    private String driver;
    private String url;
    private String username;
    private String password;
}

配置文件中：

1
2
3
4
5
datasource:
  driver: com.mysql.jdbc.Driver
  url: jdbc:mysql://localhost/springboot_db
  username: root
  password: 123456

使用的时候加上@Autowired即可

3、方法二：@EnableConfigurationProperties

也可以使用这种方式将yml中的属性值注入到对象中。在用到的时候写Enable这个注解，实体类上不需要再写Component注解

出现这个问题，引入这个依赖就可以了

4、自定义配置文件名称

比如配置文件名为server.yml

Edit Configurations ->Program arguments

  • 通过启动参数加载配置文件

    --spring.config.name=server

  • 通过启动参数加载指定文件路径下的配置文件

    --spring.config.location=classpath:/server.yml

5、多环境开发的yml文件配置

最上面是当前选择启动环境

设置环境推荐这个4行的。

下面就是当前环境具体的参数设定。

也可以创建多个yml文件，将这几个环境分开。

application-dev.yml开发环境

application-pro.yml生产环境

application-test.yml测试环境

application.yml是主配置文件，指定运行哪个配置文件。

主配置文件中设置公共配置（全局)
环境分类配置文件中常用于设置冲突属性（局部)

include中后面的配置文件会覆盖前面的相同的属性。

6、宽松绑定

yml属性中的名无论大小写，加不加下划线，中划线，都会被匹配成功。类中也是这样

也就是注解@ConfigurationProperties(prefix = “datasources”)里面的prefix中的值不能有大写

三、SpringBoot整合第三方技术

1、整合JUint

  1. 导入测试对应的starter，一般在创建的SpringBoot项目中都自动有这个依赖

    1
    2
    3
    4
    5
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

  2. 测试类使用@SpringBootTest修饰

  3. 使用自动装配的形式添加要测试的对象。

如果对应的类不在引导类在的包及其子包下的话，这个测试类就不会被扫描到，需要在注解@SpringBootTest中指定引导类是谁

@SpringBootTest(classes = Springboot0101QuickstartApplication.class)

1
2
3
4
5
6
7
8
@SpringBootTest
class Springboot0101QuickstartApplicationTests {

   @Test
   void contextLoads() {
   }

}

2、整合MyBatis

创建一个全新的工程，记得在这一步选择MyBatis需要的模块，这样的话创建的工程会自动导入相关的依赖。

1
2
3
4
5
6
7
8
9
10
11
12
<!-- 导入对应的start -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

第二步：设置数据源参数（在yml文件中配置）

1
2
3
4
5
6
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    username: root
    password: 111111

第三步：创建实体类对象。要与表结构对应

1
2
3
4
5
6
public class Student {
    private Long id;
    private String name;
    private Integer age;
    private String address;
}

第四步：数据库SQL映射需要添加@Mapper被容器识别到。

1
2
3
4
5
@Mapper
public interface StudentMapper {
    @Select("select * from tb_student where id = #{id}")
    public Student getById(Integer id);
}

3、整合MyBatis-Plus

直接创建一个SpringBoot项目，创建时只添加MySQL Driver

第一步：引入依赖

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.2</version>
</dependency>

将spring-boot-starter依赖删除

第二步：创建实体类对象

第三步：创建Mapper接口

1
2
3
@Mapper
public interface StudentMapper extends BaseMapper<Student> {
}

第四步：yml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://xxznzhs.top:3306/test?serverTimezone=UTC
    username: root
    password: 196131

#设置表前缀
#数据库中是tb_student，实体类名字为Student,mybatis-plus默认会去找student，所以要加上前缀
mybatis-plus:
  global-config:
    db-config:
      table-prefix: tb_
      id-type: auto

4、整合Redis

1、导入对应的依赖

redis 是保存在缓存中的。

2、在yml中进行相关的配置。

配置redis所在服务器的IP地址，端口号

3、注入对象RedisTemplate redisTemplate

redisTemplate.opsForValue();操作key value键值对

常用的是

注入对象StringRedisTemplate stringRedisTemplate

stringRedisTemplate.opsForValue();

SpringBoot整合Redis客户端的选择：默认是lettuce

四、日志

1
2
3
logging:
  level: 
	root: info #输出info及以上的日志

指定启动项目时输出的日志级别

日志级别由低到高：debug -> info -> warn -> error

1
2
3
4
5
6
7
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
    <scope>provided</scope>
</dependency>

导入lombok依赖，然后直接在项目中使用@Slf4j，使用的时候直接log.info(“…”)

自定义日志输出格式可以在yml文件中配置

日志也可以输出在指定文件中，在yml中配置

1
2
3
4
5
6
7
logging:
  file:
    name: server.log
  logback:
    rollingpolicy:
      max-file-size: 2KB #文件大小，超过后重新创建文件
      file-name-pattern: server.%d{yyyy-MM-dd}.%i.log #文件名,i是循环的数

与模块是同级的。

五、原理

1、bean的加载方式

（1）xml方式

第一步：导入依赖

1
2
3
4
5
6
<!--        spring的基础配置需要导入spring核心包，这里导入了一个大的-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>

第二步：创建实体类

第三步：创建spring配置文件

第四步：

1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dog1" class="com.vickkkyz.Dog"></bean>
    
</beans>

第五步：

1
2
3
4
5
public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext1.xml");
    Object dog1 = applicationContext.getBean("dog1");
    System.out.println(dog1);
}

也可以加载第三方bean

（2）注解方式

第一个方法是自定义bean

第一步：在实体类上加注解@Component("dog1")

第二步：指定要加载的bean的位置 <context:component-scan base-package="com.vickkkyz"/>

组件扫描

基于注解的方式如何加载第三方bean？因为不能直接在第三方bean的源码上添加注解。

需要创建一个类，需要将这个类配置为Bean，里面的方法返回在方法体中创建的第三方bean，方法上加@Bean注解，这样第三方bean就可以被spring管理了。xml文件中需要加载这个类的路径，让它可以扫描到。

（3）用注解方式声明配置类（配置类不再是xml）

这个类就相当于xml配置文件。

（4）@Import注解

这样被定义的bean的名称是类的全路径名称

这个类定义的bean也会被加载到容器中

（5）手工加载bean

注册bean的时候同名的被留下。最后的结果只有第三行那个tom bean

如何选择性加载bean

@ConditionalOnBean(name=”jerry”)表示如果有这个bean加载，就加载cat类

2、自动配置

====

3、SpringBoot启动核心原理

https://www.bilibili.com/video/BV15b4y1a7yG?p=168&vd_source=c1b40fa5b4df055a1cae36a0ac4e1d21

六、补充

1、REST风格

目的是隐藏资源的访问行为，无法通过地址得知对资源是何种操作。

用不同的请求方法来区分不同的controller

http://localhost:8080/users POST请求

http://localhost:8080/users/1 DELETE请求

使用@PathVariable注解可以获取路径中的内容，在value="/users/{id}"来指定取出来的对应值给id

2、@RestController

类注解

@RestController = @Controller + @ResponseBody

@ResponseBody 表示该方法的返回结果直接写入HTTP response body 中，即将返回的java对象变成json。每个方法都要写，所以直接加载类上。

@Controller表示Controller层类的bean配置，这样当容器启动时才可以将这个类放到容器中给spring管理。所以也是要写在类上。

因此就将二者合二为一了。

3、@RequestMapping

标志方法的请求路径，在类上和方法上都可以写

@RequestMapping("/user",method=RequestMethod.GET)等同于@GetMapping("/user")

4、项目打包，部署到服务器

在服务器的/usr/local目录下，创建一个目录app，将这个jar包放app目录下

要保证服务器jdk版本不低于打包时使用的jdk版本

启动项目：java -jar 项目名

后台启动：nohup java -jar 项目名 > server.log 2>&1 &

后台启动如何关：ps -ef | grep “java-jar”

找到进程pid，kill -9 进程pid

5、两个级别的配置文件

第一个的优先级高于第二个

如果两个中配置了同样的属性，则第一个覆盖第二个。否则是叠加。第一个文件一般是项目打包到服务器时的配置，第二个是本地测试使用的，有时候配置可能不同

工程目录的同级的yml文件的配置会覆盖开发的yml

6、开启bean数据校验

要对哪个bean做校验，就在哪个bean上添加@Validated注解，在具体的字段上添加校验规则，当添加的属性值不满足这个规则时，就会报错。

7、数据源

SpringBoot提供了3种内嵌的数据源对象供开发者选择

  • HikariCP：默认内置数据源对象
  • Tomcat提供DataSource： HikariCP不可用的情况下，且在web环境中，将使用tomcat服务器配置的数据源对象。
  • Commons DBCP： Hikari不可用，tomcat数据源也不可用，将使用dbcp数据源

比如

1
2
3
4
5
6
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    username: root
    password: 111111

如果没有引入driud依赖，使用的就是默认的Hikari数据源。

8、自定义拦截器

创建拦截器

注册拦截器

FrameWork
#总结 #框架 #SpringBoot
框架-SpringBoot
https://vickkkyz.fun/2022/09/26/Java/framework/springboot/
作者
Vickkkyz
发布于
2022年9月26日
许可协议