SpringBoot基础

前言
：CSDN的小伙伴们大家好，今天跟大家分享一个经常使用到的框架——springboot，本文只分享基础部分。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧
：博客主页：空山新雨后的java知识图书馆
☁️ 今天的天气很凉爽啊。
: 脚跟立定以后，你必须拿你的力量和技能，自己奋斗。——萧伯纳
上一篇文章：SpringMVC的基础学习
欢迎大家一起学习，进步。加油

文章目录

一、什么是springboot
- 1.1、springboot的概念
- 1.2、为什么要学习springboot？
二、创建springboot项目并测试
三、springboot配置文件解析
- 3.1、springboot配置文件类型
- - 3.1.1、springboot配置文件分类
  - 3.1.2、SpringBoot配置文件类型和作用
- 3.2、yml/yaml配置文件概述
- - 3.2.1、yml配置文件简介
  - 3.2.2、yml配置文件的语法
  - 3.2.3、yml配置文件的数据格式
  - 3.2.4、yml参数引用
- 3.3、配置文件与配置类的属性映射方式
- - 3.3.1、使用注解@Value映射
  - 3.3.2、使用springboot提供的environment对象
  - 3.3.3、使用注解@ConfigurationProperties映射
四、profile
- 4.1、 profile配置方式
- 4.2、 profile激活方式
- 4.3、 profile小结
五、springboot整合其他技术的演示
- 5.1、springboot整合Junit
- 5.2、springboot整合Redis
- 5.3、springboot整合mybatis

一、什么是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文件



    4.0.0

    org.example
    spring-study-springBoot
    1.0-SNAPSHOT

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.3.RELEASE
    

    
    
        
            org.springframework.boot
            spring-boot-starter-web

第二步、编写springboot引导类

package com.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


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


@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" #这种写法会识别转义符，那么字符串就会分两行输出

演示对象的属性值的获取
注入属性

   
    @Value("${person.name}")
    private String name;

    @Value("${person.age}")
    private int age;

注入数组的属性值

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


@RestController
public class HelloController {

    
    @Value("${person.name}")
    private String name;

    @Value("${person.age}")
    private int age;


    
    @Value("${address[0]}")
    private String address;


    
    @Value("${msg1}")
    private String msg1;

    @Value("${msg2}")
    private String msg2;

    
    @Autowired
    private Environment environment;



    
    @RequestMapping("/hello")
    public String hello() {
        return"张三在此";
    }


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

        

        System.out.println("============================================");

        
        String property = environment.getProperty("person.name");
        System.out.println(property);
        
        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;




@Component

@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中的操作

 
    @Autowired
    private Person person;												
 
        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的版本


            
                org.apache.maven.plugins
                maven-resources-plugin
                
                3.1.0

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的启动器

  
            junit
            junit
            4.13.2
            test

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;


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


@RunWith(SpringRunner.class)

@SpringBootTest(classes = SpringStudyJunitApplication.class)
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testAdd() {
        userService.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;


@SpringBootTest
class SpringStudyRedisApplicationTests {

    
    @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.ymlproperties

	spring.redis.port=6379
#也可以在配置文件中修改Redis的端口号等等信息

当然在测试Redis的时候，记得把本地的Redis服务器打开。

5.3、springboot整合mybatis

添加Mybatis的启动器

 
        org.mybatis.spring.boot
        mybatis-spring-boot-starter
        2.2.2

创建实体Bean

	package com.study.springstudymybatis.domain;


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;


@Mapper
@Repository
public interface UserMapper {

    @Select("select * from user_u")
    public List 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;


@Mapper
@Repository
public interface UserMapperXml {

    public List findAll();
}

配置Mapper映射文件

	



    
        select * from User_u

在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
    @Test
    void findAll() {
        List all = userMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }

    
    @Test
    void findAll2() {
        List 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用的是注解和配置的方式两种方式，各位可以使用你们熟悉的一种方式进行测试。

SpringBoot基础

Java相关栏目本月热门文章