前言
🎄: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用的是注解和配置的方式两种方式,各位可以使用你们熟悉的一种方式进行测试。