前言
??🎄：CSDN的小伙伴们大家好，今天跟大家分享一个经常使用到的框架——springboot，本文只分享基础部分。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
??🏡：博客主页：空山新雨后的java知识图书馆
???? 今天的天气很凉爽啊。
??📝: 脚跟立定以后，你必须拿你的力量和技能，自己奋斗。——萧伯纳📝
??📖上一篇文章：SpringMVC的基础学习📖
??👏欢迎大家一起学习，进步。加油👊
一、什么是springboot
1.1、springboot的概念
??SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布。Spring的顶级项目之一(https://spring.io)。
1.2、为什么要学习springboot？
为什么要学习springboot，那么就要从spring的缺点，和springboot本身的优点说起
1、spring的缺点
1） 配置繁琐
??虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多
XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。
Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
??所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所
以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但它要求的回报也不少
2）依赖繁琐
??项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。
2、springboot的核心功能
1） 自动配置
??Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定
Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
2） 起步依赖
??起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
??简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能
3） 辅助功能
??提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
??可以看出，Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。
二、创建springboot项目并测试
??第一种方式手动创建，和以前的创建maven项目是一样的流程，只不过引坐标的时候，去springboot官网引需要的坐标即可。
项目结构
第一步，添加springboot的启动器：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>
<groupId>org.example</groupId>
<artifactId>spring-study-springBoot</artifactId>
<version>1.0-SNAPSHOT</version>
<!--springboot工程需要继承的父工程-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.3.RELEASE</version>
</parent>
<!--springboot工程需要的起步依赖-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
第二步、编写springboot引导类
package com.study;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author wang
* @version 1.0
* @packageName com.study
* @className HelloApplication
* @date 2022/5/11 16:55
* @Description 引导类
*/
@SpringBootApplication
public class HelloApplication {
public static void main(String[] args) {
SpringApplication.run(HelloApplication.class, args);
}
}
第三步、编写controller测试
package com.study.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author wang
* @version 1.0
* @packageName com.study
* @className controller
* @date 2022/5/11 16:33
* @Description 测试springboot
*/
@RestController
public class HelloController {
@RequestMapping("/hello")
public String test() {
return "hello spring boot";
}
}
测试结果
总结：
? SpringBoot在创建项目时，使用jar的打包方式。
? SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
? 使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。
??那么第二种方式就是通过springboot自己创建的方式
选择完成之后，finish就可以了。
三、springboot配置文件解析
3.1、springboot配置文件类型
??3.1.1、springboot配置文件分类
??SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
??3.1.2、SpringBoot配置文件类型和作用
? SpringBoot提供了2种配置文件类型：properteis和yml/yaml
? 默认配置文件名称：application
? 在同一级目录下优先级为：properties > yml > yaml
3.2、yml/yaml配置文件概述
由于properties配置文件我们都很熟悉，因此这里介绍yaml文件的语法格式等等
??3.2.1、yml配置文件简介
??YAML全称是 YAML Ain’t Markup Language 。YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。YAML文件的扩展名可以使用.yml或者.yaml。
??3.2.2、yml配置文件的语法
? 大小写敏感
? 数据值前边必须有空格，作为分隔符
? 使用缩进表示层级关系
? 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。
? 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
? # 表示注释，从这个字符一直到行尾，都会被解析器忽略。
实例：
#设置端口和IP
server:
port: 8082
address: 127.0.0.1
#设置一个属性
name: zhangsan
??3.2.3、yml配置文件的数据格式
? 对象(map)：键值对的集合。
person:
name:
# 演示对象的数据格式的写法（键值对）,数据的冒号后面必须有空格，否则不会识别
person:
name: lisi
age: 22
# 演示对象的数据格式的行内写法,注意空格必须要有。而且对象名字不能重复
person2: {name: judy,age: 25}
? 数组：一组按次序排列的值
#演示数组格式的yam写法 这里数组的每个元素之前用横杠，且横杠之后必须存在空格
address:
- tianjin
- chongqing
- shanghai
#演示数组数据格式的行内写法，同样的，这个名字也不能相同，且空格必须存在，而且数据是在大括号中使用逗号隔开
address2: {beijing,shanghai}
? 纯量：单个的、不可再分的值
#演示纯量数据格式的写法，可以理解为我们之前学习的常量
msg1: 'hello \n world' #那么这种写法会忽略转义符，就会原样输出
msg2: "hello ln world" #这种写法会识别转义符，那么字符串就会分两行输出
??3.2.4、yml参数引用
就是在对象中引用定义好的参数的值
语法格式：
${参数名}
代码实例
name: zhangsan
# 演示对象的数据格式的写法（键值对）,数据的冒号后面必须有空格，否则不会识别
person:
name: ${name} #lisi 演示这种引用的方式，那么他引用的就是我们在上面定义的zhangsan
age: 22
3.3、配置文件与配置类的属性映射方式
??我们在配置文件中配置的属性，是需要拿出来用的，那么如何将存储在配置文件中的数据取出来进行使用呢？这里介绍三种方式
??3.3.1、使用注解@Value映射
配置文件
server:
port: 8080
# address: 127.0.0.1
name: zhangsan
# 演示对象的数据格式的写法（键值对）,数据的冒号后面必须有空格，否则不会识别
person:
name: ${name} #lisi 演示这种引用的方式，那么他引用的就是我们在上面定义的zhangsan
age: 22
# 演示对象的数据格式的行内写法,注意空格必须要有。而且对象名字不能重复
person2: {name: judy,age: 25}
#演示数组格式的yam写法 这里数组的每个元素之前用横杠，且横杠之后必须存在空格
address:
- tianjin
- chongqing
- shanghai
#演示数组数据格式的行内写法，同样的，这个名字也不能相同，且空格必须存在，而且数据是在大括号中使用逗号隔开
address2: {beijing,shanghai}
#演示纯量数据格式的写法，可以理解为我们之前学习的常量
msg1: 'hello \n world' #那么这种写法会忽略转义符，就会原样输出
msg2: "hello \n world" #这种写法会识别转义符，那么字符串就会分两行输出
演示对象的属性值的获取
注入属性
/**演示注入yml文件中对象的属性到name中*/
@Value("${person.name}")
private String name;
@Value("${person.age}")
private int age;
注入数组的属性值
/**演示yml文件中数组的属性的值的注入*/
@Value("${address[0]}")
private String address;
注入纯量
/**演示注入纯量*/
@Value("${msg1}")
private String msg1;
@Value("${msg2}")
private String msg2;
输出结果
zhangsan
22
tianjin
hello \n world
hello
world
??3.3.2、使用springboot提供的environment对象
代码演示
import org.springframework.core.env.Environment; /**另一种方式注入对象*/
@Autowired
private Environment environment;
输出结果
zhangsan
总代码演示
package com.study.springbootinit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author wang
* @version 1.0
* @packageName com.study.springbootinit
* @className HelloController
* @date 2022/5/12 9:15
* @Description
*/
@RestController
public class HelloController {
/**演示注入yml文件中对象的属性到name中*/
@Value("${person.name}")
private String name;
@Value("${person.age}")
private int age;
/**演示yml文件中数组的属性的值的注入*/
@Value("${address[0]}")
private String address;
/**演示注入纯量*/
@Value("${msg1}")
private String msg1;
@Value("${msg2}")
private String msg2;
/**另一种方式注入对象*/
@Autowired
private Environment environment;
/**演示springboot的访问*/
@RequestMapping("/hello")
public String hello() {
return"张三在此";
}
/**演示取出yml配置文件中的属性的值*/
@RequestMapping("/hello2")
public String hello2(){
/**演示对象的属性*/
System.out.println(name);
System.out.println(age);
/**演示数组的属性*/
System.out.println(address);
/**演示纯量*/
System.out.println(msg1);
System.out.println(msg2);
/**输出结果
* zhangsan
* 22
* tianjin
* hello \n world
* hello
* world*/
System.out.println("============================================");
/**另一种方式取出对象的属性值*/
String property = environment.getProperty("person.name");
System.out.println(property);
/**输出结果
* ============================================
* zhangsan*/
return "李四再此";
}
}
输出结果；
zhangsan
22
tianjin
hello \n world
hello
world
============================================
zhangsan
??3.3.3、使用注解@ConfigurationProperties映射
使用configurationProperties映射
??要使用这个注解开发的话，需要创建一个实体类
package com.study.springbootinit;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @author wang
* @version 1.0
* @packageName com.study.springbootinit
* @className Person
* @date 2022/5/12 11:35
* @Description person实体类 演示通过configurationProperties注解获取数据
*/
/**
* 让spring识别我们的person类
*/
@Component
/**这里加前缀是因位我们要在配置文件中去找对应的person的属性*/
@ConfigurationProperties(prefix = "person")
public class Person {
private String name;
private int age;
private String[] address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String[] getAddress() {
return address;
}
public void setAddress(String[] address) {
this.address = address;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
配置文件
# 演示对象的数据格式的写法（键值对）,数据的冒号后面必须有空格，否则不会识别
person:
name: ${name} #lisi 演示这种引用的方式，那么他引用的就是我们在上面定义的zhangsan
age: 22
address:
- tianjin
- chongqing
- shanghai
controller中的操作
/**注入person对象*/
@Autowired
private Person person;
/**演示通过configurationProperties注解获取数据*/
System.out.println(person);
String[] address = person.getAddress();
for (String s : address) {
System.out.println(s);
}
结果
Person{name='zhangsan', age=22}
tianjin
chongqing
shanghai
四、profile
??我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。
4.1、 profile配置方式
? 多profile文件方式
properties配置文件
application-dev.properties
#测试开发环境下的配置文件
server.port=8081
application-test.properties
#测试测试环境下的
server.port=8082
application-pro.properties
#测试生产环境
server.port=8083
配置好这三个文件之后，需要激活，才能在不同的环境中启用不同的配置
application.properties
#profile多文件方式-开发环境激活
#spring.profiles.active=dev
#profile多文件方式-测试环境激活
#spring.profiles.active=test
#profile多文件方式-生产环境激活
spring.profiles.active=pro
??只能选择一个环境进行激活使用。
??例如我这里选择的是Pro，那么到时候启动，选择的就是Pro生产环境的配置文件，启动服务器的时候就可以看到端口为8083
yml配置文件
application-dev.yml
#测试开发环境yml文件
server:
port: 8084
application-test.yml
#测试测试环境yml文件
server:
port: 8085
application-pro.yml
#测试生产环境yml文件
server:
port: 8086
同样的配置好三个配置文件之后，需要对配置进行激活使用
application.properties
#profile多文件方式——开发环境激活，yml文件
#spring.profiles.active=dev
#profile多文件方式——测试环境激活，yml文件
#spring.profiles.active=test
#profile多文件方式——生产环境激活，yml文件
spring.profiles.active=pro
??同样只能选择一个配置进行激活，这里选择的Pro，那么启动服务器的端口就会是8086
? yml多文档方式
配置文件：application.yml
#yml多文档开发的演示 使用---将每个部分的配置文件分隔开
---
server:
port: 8087
#给这部分的配置起一个名字,开发环境
spring:
profiles: dev
---
server:
port: 8088
#测试环境
spring:
profiles: test
---
server:
port: 8089
#生产环境
spring:
profiles: pro
---
#激活配置部分
spring:
profiles:
active: pro
注意：
- 配置文件的各个部分用—隔开
- 给每个部分的配置进行命名使用：srping.profiles:进行命名
- 激活放在最后一部分，命令是：spring:profiles:active:激活的部分
4.2、 profile激活方式
? 配置文件
配置文件的激活方式就是我们上面学习的
? 虚拟机参数
虚拟机参数的配置方法
虚拟机激活配置的命令：-Dspring.profiles.active=test
? 命令行参数
首先是idea中的命令行参数设置
固定语法
--spring.profiles.active=dev
其次是不使用idea开发工具，当打包完成之后
1、在idea中对项目进行打包
如果打包不成功，在pom.xml文件中指定maven的版本
<!--maven打包失败的解决办法-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<!--修改版本-->
<version>3.1.0</version>
</plugin>
2、得到路径后再文件夹中
3、打开powerShell窗口之后，输入命令
java -jar .\spring-sutdy-profiles-0.0.1-SNAPSHOT.jar
输到点杠的时候按tab键可以补全后面的内容
这个时候打开的项目就是你在idea中配置好的那个
例如我这里就是Pro
java -jar .\spring-sutdy-profiles-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
这一条命令就是指定新的配置方式
4.3、 profile小结
1） profile是用来完成不同环境下，配置动态切换功能的。
2） profile配置方式
? 多profile文件方式：提供多个配置文件，每个代表一种环境。
?application-dev.properties/yml 开发环境
?application-test.properties/yml 测试环境
?application-pro.properties/yml 生产环境
? yml多文档方式：
? 在yml中使用 --- 分隔不同配置
3） profile激活方式
? 配置文件： 再配置文件中配置：spring.profiles.active=dev
? 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
? 命令行参数：java –jar xxx.jar --spring.profiles.active=dev
五、springboot整合其他技术的演示
5.1、springboot整合Junit
添加Junit的启动器
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
package com.study.springstudyjunit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringStudyJunitApplication {
public static void main(String[] args) {
SpringApplication.run(SpringStudyJunitApplication.class, args);
}
}
package com.study.springstudyjunit;
import org.springframework.stereotype.Service;
/**
* @author wang
* @version 1.0
* @packageName com.study.springstudyjunit
* @className UserService
* @date 2022/5/12 17:44
* @Description 演示spring结合Junit的service
*/
@Service
public class UserService {
public void add() {
System.out.println("add方法被执行");
}
}
测试类
package com.study.UserService;
import com.study.springstudyjunit.SpringStudyJunitApplication;
import com.study.springstudyjunit.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author wang
* @version 1.0
* @packageName com.study.UserService
* @className UserServiceTest
* @date 2022/5/12 17:45
* @Description UserService测试类
*/
@RunWith(SpringRunner.class)
/*指定启动类*/
@SpringBootTest(classes = SpringStudyJunitApplication.class)
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void testAdd() {
userService.add();
/*add方法被执行*/
}
}
5.2、springboot整合Redis
package com.study.springstudyredis;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
/**该方法用于测试springboot结合Redis的使用*/
@SpringBootTest
class SpringStudyRedisApplicationTests {
/**注入RedisTemplate对象*/
@Autowired
private RedisTemplate redisTemplate;
/**测试设置数据*/
@Test
void testSet() {
redisTemplate.boundValueOps("name").set("zhangsan");
}
/**测试获取数据*/
@Test
public void testGet(){
Object name = redisTemplate.boundValueOps("name").get();
System.out.println(name);
}
}
也可以在配置文件中配置Redis的端口号等信息，application.yml\properties
spring.redis.port=6379
#也可以在配置文件中修改Redis的端口号等等信息
当然在测试Redis的时候，记得把本地的Redis服务器打开。
5.3、springboot整合mybatis
添加Mybatis的启动器
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
创建实体Bean
package com.study.springstudymybatis.domain;
/**
* @author wang
* @version 1.0
* @packageName com.study.springstudymybatis.domain
* @className User
* @date 2022/5/13 9:04
* @Description
*/
public class User {
private int id;
private String username;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
编写Mapper
注解mapper
package com.study.springstudymybatis.mapper;
import com.study.springstudymybatis.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* @author wang
* @version 1.0
* @packageName com.study.springstudymybatis.mapper
* @className UserMapper
* @date 2022/5/13 9:05
* @Description 纯注解开发
*/
@Mapper
@Repository
public interface UserMapper {
@Select("select * from user_u")
public List<User> findAll();
}
配置mapper
package com.study.springstudymybatis.mapper;
import com.study.springstudymybatis.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* @author wang
* @version 1.0
* @packageName com.study.springstudymybatis.mapper
* @className UserMapperXml
* @date 2022/5/13 9:13
* @Description 配置文件开发的接口
*/
@Mapper
@Repository
public interface UserMapperXml {
public List<User> findAll();
}
配置Mapper映射文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace命名空间用于配置，通过namespace和下面的id进行匹配，找到想要的配置如果要使用-->
<mapper namespace="com.study.springstudymybatis.mapper.UserMapperXml">
<select id="findAll" resultType="user">
select * from User_u
</select>
</mapper>
在application.properties/yml中添加mybatis的信息
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
driver-class-name: com.mysql.jdbc.Driver
username: root
password: 2395
#配置mybatis
mybatis:
mapper-locations: classpath:mapper/*Mapper.xml #映射文件地址
type-aliases-package: com.study.springstudymybatis.domain #别名地址
编写测试Controller
package com.study.springstudymybatis;
import com.study.springstudymybatis.domain.User;
import com.study.springstudymybatis.mapper.UserMapper;
import com.study.springstudymybatis.mapper.UserMapperXml;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
class SpringStudyMybatisApplicationTests {
@Autowired
private UserMapper userMapper;
@Autowired
private UserMapperXml userMapperXml;
/**测试springboot结合mybatis注解开发*/
@Test
void findAll() {
List<User> all = userMapper.findAll();
for (User user : all) {
System.out.println(user);
}
}
/**测试springboot结合mybatis配置文件进行开发*/
@Test
void findAll2() {
List<User> users = userMapperXml.findAll();
for (User user : users) {
System.out.println(user);
}
}
}
测试结果
User{id=1, username='张三', password='123456'}
User{id=2, username='lisi', password='123465'}
User{id=4, username='周瑜', password='45454545'}
User{id=5, username='周瑜', password='45454545'}
User{id=6, username='周瑜', password='45454545'}
User{id=7, username='周瑜', password='45454545'}
User{id=8, username='周瑜', password='45454545'}
User{id=9, username='周瑜', password='45454545'}
User{id=10, username='周瑜', password='45454545'}
User{id=11, username='周瑜', password='45454545'}
需要注意的是我这里使用的mybatis用的是注解和配置的方式两种方式，各位可以使用你们熟悉的一种方式进行测试。
