【SpringBoot 框架】- SpringBoot 整合 Mybatis、Junit、Redis

我就是我 2021-09-20 23:32 444阅读 0赞

> ### SpringBoot 系列： ###
> 
> [【SpringBoot 框架】- 入门——环境搭建、工程热部署、idea快捷创建SpringBoot项目][SpringBoot _- _idea_SpringBoot]  
> [【SpringBoot 框架】- SpringBoot 原理分析][SpringBoot _- SpringBoot]  
> [【SpringBoot 框架】- SpringBoot 配置文件][SpringBoot _- SpringBoot 1]  
> [【SpringBoot 框架】- SpringBoot 整合 Mybatis、Junit、Redis][SpringBoot _- SpringBoot _ Mybatis_Junit_Redis]

**目录**

零、前言

一、SpringBoot 整合 Mybatis

1、快捷创建 SpringBoot 工程

2、添加Mybatis的起步依赖

3、添加数据库驱动坐标

4、添加数据库连接信息

5、创建数据库

6、创建实体Bean

7、编写Mapper

8、配置映射关系

9、配置 mybatis 信息

10、编写测试Controller

二、SpringBoot 整合 Junit

1、添加Junit的起步依赖

2、编写测试类

三、SpringBoot 整合 Redis

1、添加 Redis 的起步依赖

2、配置 Redis 的连接信息

3、注入 RedisTemplate 测试 Redis

--------------------

# 零、前言 #

> 在我们的实际开发中，使用关系型数据库可以方便的在一个表以及多个表之间做非常复杂的数据查询，但是其查询速率和拓展性远不及NOSQL，这就不适合大规模数据集合多重数据种类的应用场景，尤其是大数据应用。因此，有些时候会将关系型数据库和 NOSQL 结合起来使用，所以就使用 SpringBoot整合 Mybatis、Redis，Junit 是测试用的。整合步骤如下：
> 
> 1.  快捷创建 SpringBoot 工程
> 2.  SpringBoot 整合 Mybatis
> 3.  SpringBoot 整合 Junit
> 4.  SpringBoot 整合 Redis

# 一、SpringBoot 整合 Mybatis #

## 1、快捷创建 SpringBoot 工程 ##

【1】点击：文件--->模块，选择 Spring Initializr，直接点击下一个

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70][]

【2】填写相关选项，点击下一个

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 1][]

【3】选择 Web，然后点击下一步

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 2][]

【4】保存路径，点击完成

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 3][]

## 2、添加Mybatis的起步依赖 ##

在 pom.xml 中添加Mybatis的起步依赖

<dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.1.1</version>
    </dependency>

## 3、添加数据库驱动坐标 ##

在 pom.xml 中添加数据库驱动坐标

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

## 4、添加数据库连接信息 ##

在 resources 文件夹下面的 application.properties 文件里添加数据库连接信息

#DB Configuration:
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC
    spring.datasource.username=root
    spring.datasource.password=123456

## 5、创建数据库 ##

> CREATE DATABASE test;
> 
> use test;
> 
> CREATE TABLE \`user\` (  
>   \`id\` int(11) NOT NULL AUTO\_INCREMENT,  
>   \`username\` varchar(50) DEFAULT NULL,  
>   \`password\` varchar(50) DEFAULT NULL,  
>   \`name\` varchar(50) DEFAULT NULL,  
>   PRIMARY KEY (\`id\`)  
> ) ENGINE=InnoDB AUTO\_INCREMENT=10 DEFAULT CHARSET=utf8;
> 
> INSERT INTO \`user\` VALUES ('1', 'oneStar', '123', '一颗星');  
> INSERT INTO \`user\` VALUES ('2', 'twoStar', '123', '两颗星');

## 6、创建实体Bean ##

在java目录下创建：cn.star.domain.User

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 4][]

package cn.star.domain;
    /**
     * 〈一句话功能简述〉<br> 
     * 〈实体bean〉
     *
     * @author OneStar
     * @create 2019/11/21
     * @since 1.0.0
     */
    public class User {
        // 主键
        private Long id;
        // 用户名
        private String username;
        // 密码
        private String password;
        // 姓名
        private String name;
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long 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;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

## 7、编写Mapper ##

在 java 目录下创建 mapper 接口：cn.star.mapper.UserMapper

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 5][]

package cn.star.mapper;
    import cn.star.domain.User;
    import org.apache.ibatis.annotations.Mapper;
    import java.util.List;
    /**
     * 〈一句话功能简述〉<br> 
     * 〈mapper接口〉
     *
     * @author OneStar
     * @create 2019/11/21
     * @since 1.0.0
     */
    @Mapper
    public interface UserMapper {
        public List<User> queryUserList();
    }

## 8、配置映射关系 ##

在 resources 文件夹下创建 mapper 目录，在 mapper 目录下创建 UserMapper.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="cn.star.mapper.UserMapper">
        <select id="queryUserList" resultType="user">
            select * from user
        </select>
    </mapper>

## 9、配置 mybatis 信息 ##

在application.properties中添加mybatis的信息

#spring集成Mybatis环境
    #pojo别名扫描包
    mybatis.type-aliases-package=cn.star.domain
    #加载Mybatis映射文件
    mybatis.mapper-locations=classpath:mapper/*Mapper.xml

## 10、编写测试Controller ##

在 java 目录下创建 controller：cn.star.controller.MybatisController

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 6][]

package cn.star.controller;
    import cn.star.domain.User;
    import cn.star.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import java.util.List;
    /**
     * 〈一句话功能简述〉<br> 
     * 〈测试controller〉
     *
     * @author OneStar
     * @create 2019/11/21
     * @since 1.0.0
     */
    @Controller
    public class MybatisController {
        @Autowired
        private UserMapper userMapper;
    
        @RequestMapping("/queryUser")
        @ResponseBody
        public List<User> queryUser(){
            List<User> users = userMapper.queryUserList();
            return users;
        }
    }

运行工程，查询到数据库中数据则整合成功！

![20191121204556597.png][]

# 二、SpringBoot 整合 Junit #

SpringBoot 工程可以通过 SpringBootApplication 来启动，当然，也可以使用 Junit 测试来启动，来看一下 SpringBoot 是如何整合 Junit 的

## 1、添加Junit的起步依赖 ##

使用 idea 快捷创建SpringBoot工程可以不用执行这一步骤，因为 idea 会自动给你在 pom.xml 中导入这个依赖

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

## 2、编写测试类 ##

在 test 目录下的 java 文件夹下创建 MybatisTest 测试类：cn.star.MybatisTest

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 7][]

package cn.star;
    import cn.star.domain.User;
    import cn.star.mapper.UserMapper;
    import org.junit.jupiter.api.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;
    /**
     * 〈一句话功能简述〉<br> 
     * 〈Junit测试类〉
     *
     * @author OneStar
     * @create 2019/11/21
     * @since 1.0.0
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = SpringbootmybatisApplication.class)
    public class MybatisTest {
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void test() {
            List<User> users = userMapper.queryUserList();
            System.out.println(users);
        }
    }

运行测试类可以看到数据库数据，说明整合成功！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 8][]

# 三、SpringBoot 整合 Redis #

使用 SpringBoot 整合 Redis 可以分为以下几个步骤

*  添加 Redis 的起步依赖
 *  配置 Redis 的连接信息
 *  编写测试类：注入RedisTemplate测试Redis操作
    
    1.  判断 Redis 中有没有数据
    2.  没有的就查询关系型数据库中获取数据 
    3.  将数据转换成json格式字符串
    4.  将数据存储到 Redis 中，下次在查询直接从 Redis 中获得数据，不用在查询数据库

## 1、添加 Redis 的起步依赖 ##

在 pom.xml 中添加 Redis 的起步依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

## 2、配置 Redis 的连接信息 ##

在 application.properties 配置文件中添加配置 Redis 的连接信息

#Redis
    spring.redis.host=127.0.0.1
    spring.redis.port=6379

## 3、注入 RedisTemplate 测试 Redis ##

修改 MybatisTest 测试类，修改后如下：

package cn.star;
    import cn.star.domain.User;
    import cn.star.mapper.UserMapper;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    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.test.context.junit4.SpringRunner;
    import java.util.List;
    /**
     * 〈一句话功能简述〉<br> 
     * 〈Junit测试类〉
     *
     * @author OneStar
     * @create 2019/11/21
     * @since 1.0.0
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = SpringbootmybatisApplication.class)
    public class MybatisTest {
        @Autowired
        private UserMapper userMapper;
    
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        @Test
        public void test() throws JsonProcessingException {
            //List<User> users = userMapper.queryUserList();
            //System.out.println(users);
    
            //从redis缓存中获得指定的数据
            String userListData = redisTemplate.boundValueOps("user.findAll").get();
            //如果redis中没有数据的话
            if(null==userListData){
                //查询数据库获得数据
                List<User> all = userMapper.queryUserList();
                //转换成json格式字符串
                ObjectMapper om = new ObjectMapper();
                userListData = om.writeValueAsString(all);
                //将数据存储到redis中，下次在查询直接从redis中获得数据，不用在查询数据库
                redisTemplate.boundValueOps("user.findAll").set(userListData);
                System.out.println("===============从数据库获得数据===============");
            }else{
                System.out.println("===============从redis缓存中获得数据===============");
            }
            System.out.println(userListData);
        }
    }

第一次运行是从数据库中获取数据，测试结果如下：

![20191128232345337.png][]

第二次运行时，由于已经从数据库中获取了数据并存入了 Redis 缓存中，测试结果如下：

![20191128232859807.png][]

--------------------

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 9][]

[SpringBoot _- _idea_SpringBoot]: https://blog.csdn.net/One_L_Star/article/details/103033571
[SpringBoot _- SpringBoot]: https://blog.csdn.net/One_L_Star/article/details/103056583
[SpringBoot _- SpringBoot 1]: https://blog.csdn.net/One_L_Star/article/details/103100964
[SpringBoot _- SpringBoot _ Mybatis_Junit_Redis]: https://blog.csdn.net/One_L_Star/article/details/103133772
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70]: /images/20210920/f104a31c73df4bb086bb3c91bb72e7bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 1]: /images/20210920/3be13e65e8274f5b8136d25c973b9751.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 2]: /images/20210920/e3d5eba29bd146a89b452dd7974da12b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 3]: /images/20210920/7a648fae8da943d38454057ddf75c0ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 4]: /images/20210920/b17567bbea96429dbe22c0e59f56b579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 5]: /images/20210920/570b584045a54f9a9ee7eea5ab83ccb5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 6]: /images/20210920/57f710a2c51b4a84a02f6af9ee079a0c.png
[20191121204556597.png]: /images/20210920/7dc9b3d671954d99a59fd7f1a486b810.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 7]: /images/20210920/0532702a995e43818d4cf74da42fa9e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 8]: /images/20210920/2a29c34035c74554a2f4540bf475c18b.png
[20191128232345337.png]: /images/20210920/51b86bfcfb894c89a803a3acaf3d3963.png
[20191128232859807.png]: /images/20210920/8510781d1cf6432d9cb4e92ff14756a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 9]: /images/20210920/0be1db78fee645be88be99d9215fba7b.png