浅谈SpringBoot的基本概念与简单的使用与yml文件的基本使用, 整合Redis,整合MyBatis

最新推荐文章于 2024-08-20 15:58:54 发布

努力敲代码买猪脚啃

最新推荐文章于 2024-08-20 15:58:54 发布

阅读量377

点赞数

分类专栏： java 文章标签： spring boot spring

本文链接：https://blog.csdn.net/fushuaiCSDN/article/details/108197487

版权

java 专栏收录该内容

46 篇文章 1 订阅

订阅专栏

SpringBoot

什么是SpringBoot

SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布。Spring的顶级项目之一(https://spring.io)。

SpringBoot 功能

1）自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
2）起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
3）辅助功能
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

简单来说:Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

SpringBoot的简单入门(代码详细解释,yml格式文件书写方法)

SpringBoot在创建项目时，使用jar的打包方式。
SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。

构建maven项目

pom.xml

主要引入springboot父项目

    <!--    导入springboot父工程spring-boot-starter-parent,
    我们自己的的helloworld就成为springboot的子工程会自动引入父工程的依耐-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

主启动

package com.fs;

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

/*
引导类,springBoot项目的入口
放在项目的根目录就会自动@ComponentScan(启动类已经启动类下的包)
 */
@SpringBootApplication
public class HelloWorld {
    public static void main(String[] args) {
        SpringApplication.run(HelloWorld.class,args);
    }
}

springboot的配置

推荐使用yml

YAML

YAML全称是 YAML Ain’t Markup Language 。YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅
读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP
等。YML文件是以数据为核心的，比传统的xml方式更加简洁。
YAML文件的扩展名可以使用.yml或者.yaml。
在这里插入图片描述

YAML：基本语法

⚫ 大小写敏感
⚫ 数据值前边必须有空格，作为分隔符
⚫ 使用缩进表示层级关系
⚫ 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的空格数目可能不同，导致层次混乱）。
⚫ 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
⚫ # 表示注释，从这个字符一直到行尾，都会被解析器忽略。

YAML：数据格式

在这里插入图片描述

YAML：小结

1）配置文件类型
⚫ properties：和以前一样
⚫ yml/yaml：注意空格
2） yaml：简洁，以数据为核心
⚫ 基本语法
• 大小写敏感
• 数据值前边必须有空格，作为分隔符
• 使用空格缩进表示层级关系，相同缩进表示同一级
⚫ 数据格式
• 对象
• 数组: 使用 “- ”表示数组每个元素
• 纯量
⚫ 参数引用
• ${key}

读取配置文件内容

@Value
Environment：程序启动时配置的环境变量，使用此方式获取
@ConfigurationProperties(prefix = “person”) 把一组属性注入到一个对象中

代码实现

application.yml

# springboot的配置文件 springboot项目启动的时候会自动加载classes目录下的application.yml或者properties文件
# yml 简洁,以数据为核心
# 一个工程支持多个配置文件,包括properties和yml和yaml
# 当属性冲突时  会按照properties>yml>yaml 的优先级生效
# 配置tomcat的端口 不配置springboot默认配置8080
server:
  port: 80805
# 给项目起一个名称
spring:
  application:
    name: HelloWorld
  # 配置多环境配置方式1:多文件方式  (在resources下创建yml配置文件,也可以是properties,开发,测试,生产等)
  # 文件名字必须为application-环境名.yml/properties
  # 只要主配置文件中写了profiles.active: 环境名 springboot就会根据环境名去classes目录找application-环境名.yml的文件
  profiles:
    active: dev

# 配置多环境方式2:yml文档方式(了解,不建议使用)  也可以下面这样使用--- 分割文件设置多环境
#---
#server:
#  port: 8081
#spring:
#  profiles: dev # 开发环境
#---
#server:
#  port: 8082
#spring:
#  profiles: test # 测试环境
#---
#server:
#  port: 8083
#spring:
#  profiles: pro # 生产环境
#---



# yml的数据格式  定义后可以通过java代码来获取
# 定义一个参数
sex: 男

# 对象(map) 键值对的集合
person:
  name: xiaofu
  age: 18
  sex: ${sex} # 参数引用(引用的参数一定要提前定义)
# 对象的行内写法(一般不会使用,了解即可)
person2: {name: xiaohua,age: 18}

# 数组 按次排序列
address:
  - 重庆
  - 开县
#数组的行内写法(一般不会使用,了解即可)
address2: [重庆,开县]

# 纯量: 单个的
name: 'HelloWorld \n xiaofu' #单引号不会识别转义字符,会原样输出
name2: "HelloWorld \n xiaofu" # 双引号会识别转义字符

使用@ConfigurationProperties 方式注意事项

@Component
//读取配置文件中一组属性,存放在我们的person对象中
@ConfigurationProperties(prefix = "person")//注入yml配置文件配置的对象.需要指定前缀
public class Person {
    private String name;
    private Integer age;
    private String sex;
get set方法
}

测试类代码

需要在pom文件整合junit

④ 添加测试相关注解
• @RunWith(SpringRunner.class)
• @SpringBootTest(classes = 启动类.class)

package com.fs;

import com.fs.pojo.Person;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.env.Environment;
import org.springframework.test.context.junit4.SpringRunner;

/*
编写测试类
添加测试相关注解
• @RunWith(SpringRunner.class)
• @SpringBootTest(classes = 启动类.class)
编写测试方法
 */
//指定测试运行容器
@RunWith(SpringRunner.class)
//@SpringBootTest//若这个测试类的包与启动类的包是一样的,那么就可以省略classes = HelloWorld.class
@SpringBootTest(classes = HelloWorld.class)//就会去加载主启动类的配置文件以及扫描的包
class HelloWorldTest {

    //测试读取yam文件的配置
    @Value("${name}")
    private String name;

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

    //使用sprinboot对象获取yml文件属性
    @Autowired
    private Environment environment;


    //使用@ConfigurationProperties注解在实体类上自动映射
    @Autowired
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(name);//HelloWorld \n xiaofu
        System.out.println(personName);//xiaofu

        System.out.println("-----------------------------------------");
        //使用对象.getProperty方法获取
        System.out.println(environment.getProperty("person.sex"));//男
        System.out.println(environment.getProperty("address2[0]"));//重庆
        System.out.println(environment.getProperty("name2"));//这个会解析转义所以输出的HelloWorld  换行了的 xiaofu

        System.out.println("-------------------------");
        System.out.println(person);//Person{name='xiaofu', age=18, sex='男'}
    }


}

SpringBoot多环境属性配置profile

profile
我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务
器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。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程序启动时，会从以下位置加载配置文件：

file:./config/：当前项目下的/config目录下
file:./ ：当前项目的根目录
3.== classpath:/config/：classpath的/config目录==
classpath:/ ：classpath的根目录
加载顺序为上文的排列顺序，高优先级配置的属性会生效

外部配置加载顺序
通过官网查看外部属性加载顺序：
https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

SpringBoot整合Redis

① 搭建SpringBoot工程
② 引入mybatis起步依赖，添加mysql驱动
③ 编写DataSource和MyBatis相关配置
④ 定义表和实体类
⑤ 编写dao和mapper文件/纯注解开发
⑥ 测试

pomxml

<?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>
    <!--    导入springboot父工程spring-boot-starter-parent,
    我们自己的的helloworld就成为springboot的子工程会自动引入父工程的依耐-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.com.fs</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--        引入web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        引入redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--        整合junit-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>


</project>

application.yml

# 当不知道配置的参数时候,idea双击shift 输入***Properties 就可以看到有这些配置属性类
spring:
  redis:
    host: 47.112.174.148 # redis的主机名
    port: 6379 #redis端口号

主启动

package com.fs;

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

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

测试类

//注入redisTemplate 这是spring写的
//Key:value 使用原生JdkSerializationRedisSerializer的序列化,存入的字符串会乱码
@Autowired
private RedisTemplate redisTemplate;


//stringRedisTemplate这个是将对象快速的序列化到redis中
//Key:value都是字符串的序列化方式 这样序列化对象到redis中不会乱码
@Autowired
private StringRedisTemplate stringRedisTemplate;

stringRedisTemplate这个是将对象快速的序列化到redis中,Key:value都是字符串的序列化方式这样序列化对象到redis中不会乱码

package com.fs;

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.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootRedis.class)
public class SpringBootRedisTest {

    //注入redisTemplate 这是spring写的
    //Key:value 使用原生JdkSerializationRedisSerializer的序列化,存入的字符串会乱码
    @Autowired
    private RedisTemplate redisTemplate;

    //stringRedisTemplate这个是将对象快速的序列化到redis中
    //Key:value都是字符串的序列化方式 这样序列化对象到redis中不会乱码
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //测试存入
    @Test
    public void testAddRedis(){
        //存入数据
//        redisTemplate.opsForValue().set("name","xiaofu");
        stringRedisTemplate.opsForValue().set("name","xiaofu");
    }

    //测试获取
    @Test
    public void testGetRedis(){
        System.out.println("----------------------------------------");
        //取出数据
//        System.out.println(redisTemplate.opsForValue().get("name"));
        System.out.println(stringRedisTemplate.opsForValue().get("name"));
    }
}

SpringBoot整合MyBatis

① 搭建SpringBoot工程
② 引入mybatis起步依赖，添加mysql驱动
③ 编写DataSource和MyBatis相关配置
④ 定义表和实体类
⑤ 编写dao和mapper文件/纯注解开发
⑥ 测试
在这里插入图片描述

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>
    <!--    导入springboot父工程spring-boot-starter-parent,
    我们自己的的helloworld就成为springboot的子工程会自动引入父工程的依耐-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.com.fs</groupId>
    <artifactId>springboot-MyBatis</artifactId>
    <version>1.0-SNAPSHOT</version>



    <dependencies>
        <!--        引入web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        引入MyBatis-->
        <!--        MyBatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--        druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
<!--        整合junit-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>
</project>

application.yml

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://47.112.174.148:3306/health
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource #自定义数据源

# 配置MyBatis文件路径
mybatis:
  mapper-locations: classpath:com/fs/dao/*Dao.xml # dao映射路径
  type-aliases-package: com.fs.pojo

主启动

package com.fs;

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

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

dao Mapper 接口

package com.fs.mapper;

import com.fs.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;
/*
注解的方式
 */
@Mapper
public interface UserMapper {

    @Select("select * from t_user")
    public List<User> findAll();
}

package com.fs.mapper;

import com.fs.pojo.User;
import org.apache.ibatis.annotations.Mapper;

//xml方式
@Mapper
public interface UserDao {

    User findById(Integer id);
}

Mapper.xml映射文件

<?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" >
<mapper namespace="com.fs.mapper.UserDao">

<!--    查询用户byid-->
    <select id="findById" resultType="com.fs.pojo.User" parameterType="integer">
        select * from `t_user` where id = #{id}
    </select>

</mapper>

pojo

public class User implements Serializable{
    private Integer id; // 主键
    private Date birthday; // 生日
    private String gender; // 性别
    private String username; // 用户名，唯一
    private String password; // 密码
    private String remark; // 备注
    private String station; // 状态
    private String telephone; // 联系电话

get set
}

测试类

package com.fs;

import com.fs.mapper.UserDao;
import com.fs.mapper.UserMapper;
import com.fs.pojo.User;
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;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootMyBatis.class)
public class SpringBootMyBatisTest {

    //注入我们的注解方式
    @Autowired
    private UserMapper userMapper;

    //注入xml的
    @Autowired
    private UserDao userDao;

    @Test
    public void findAll() {
        List<User> all = userMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }

    @Test
    public void findById() {
        User byId = userDao.findById(1);
        System.out.println(byId);
    }
}