【SpringBoot實戰】資料通路整合Mybatis和Redis

前言

在開發中我們通常會對資料庫的資料進行操作，SpringBoot對關系性和非關系型資料庫的通路操作都提供了非常好的整合支援。SpringData是spring提供的一個用于簡化資料庫通路、支援雲服務的開源架構。它是一個傘狀項目，包含大量關系型和非關系型資料庫資料通路解決方案，讓我們快速簡單的使用各種資料通路技術，springboot預設采用整合springdata方式統一的通路層，通過添加大量的自動配置，引入各種資料通路模闆Trmplate以及統一的Repository接口，進而達到簡化資料通路操作。

這裡我們分别對MyBatis、Redis進行整合。

SpringBoot整合MyBatis

mybatis作為目前操作資料庫的流行架構，spingboot并沒有給出依賴支援，但是mybaitis開發團隊自己提供了啟動器

mybatis-spring-boot-starter

依賴。

MyBatis是一款優秀的持久層架構，它支援定制sql、存儲過程、進階映射、避免JDBC代碼和手動參數以及擷取結果集。mybatis不僅支援xml而且支援注解。

環境搭建

建立資料庫

我們建立一個簡單的資料庫并插入一些資料用于我們下面的操作。

# 建立資料庫
CREATE DATABASE studentdata;
# 選擇使用資料庫
USE studentdata;
# 建立表并插入相關資料
DROP TABLE IF EXISTS `t_student`;
CREATE TABLE `t_student` (
  `id` int(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `age` int(8),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `t_student` VALUES ('1', 'hjk', '18');
INSERT INTO `t_student` VALUES ('2', '小何', '20');
           

建立項目并引入相關啟動器

按照之前的方式建立一個springboot項目，并在pom.xml裡導入依賴。我們建立一個名為springboot-01的springboot項目。并且導入阿裡的資料源

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>
           

我們可以在IDEA右邊連接配接上資料庫，便于我們可視化操作，這個不連接配接也不會影響我們程式的執行，隻是友善我們可視化。

建立Student的實體類

package com.hjk.pojo;

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    public Student(){

    }

    public Student(String name,Integer age){
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


           

在application.properties裡編寫資料庫連接配接配置。這裡我們使用druid資料源順便把如何配置資料源寫了，使用者名和密碼填寫自己的。使用其他資料源需要導入相關依賴，并且進行配置。springboot2.x版本預設使用的是hikari資料源。

## 選着資料庫驅動類型
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/studentdata?serverTimezone=UTC
## 使用者名
spring.datasource.username=root
## 密碼
spring.datasource.password=123456

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
## 初始化連接配接數
spring.datasource.druid.initial-size=20
## 最小空閑數
spring.datasource.druid.min-idle=10
## 最大連接配接數
spring.datasource.druid.max-active=100
           

然後我們編寫一個配置類，把durid資料源屬性值注入，并注入到spring容器中

建立一個config包，并建立名為DataSourceConfig類

package com.hjk.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration  //将該類标記為自定義配置類
public class DataSourceConfig {

    @Bean //注入一個Datasource對象
    @ConfigurationProperties(prefix = "spring.datasource") //注入屬性
    public DataSource getDruid(){
        return new DruidDataSource();
    }
}

           

目前整個包結構

注解方式整合mybatis

建立一個mapper包，并建立一個StudentMapper接口并編寫代碼。mapper其實就和MVC裡的dao包差不多。

package com.hjk.mapper;

import com.hjk.pojo.Student;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper  //這個注解是一個mybatis接口檔案，能被spring掃描到容器中
public interface StudentMapper {

    @Select("select * from t_student where id = #{id}")
    public Student getStudentById(Integer id) ;

    @Select("select * from t_student")
    public List<Student> selectAllStudent();

    @Insert("insert into t_student values (#{id},#{name},#{age})")
    public int insertStudent(Student student);

    @Update("update t_student set name=#{name},age=#{age} where id = #{id}")
    public int updataStudent(Student student);

    @Delete("delete from t_student where id=#{id}")
    public int deleteStudent(Integer id);
}

           

編寫測試類進行測試

package com.hjk;

import com.hjk.mapper.StudentMapper;
import com.hjk.pojo.Student;
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 Springdata01ApplicationTests {

    @Autowired
    private StudentMapper studentMapper;

    @Test
    public void selectStudent(){
        Student studentById = studentMapper.getStudentById(1);
        System.out.println(studentById.toString());
    }



    @Test
    public void insertStudent(){
        Student student = new Student("你好",16);
        int i = studentMapper.insertStudent(student);
        List<Student> students = studentMapper.selectAllStudent();
        for (Student student1 : students) {
            System.out.println(student1.toString());
        }
    }

    @Test
    public void updateStudent(){
        Student student = new Student("我叫hjk",20);
        student.setId(1);
        int i = studentMapper.updataStudent(student);
        System.out.println(studentMapper.getStudentById(1).toString());
    }

    @Test
    public void deleteStudent(){
        studentMapper.deleteStudent(1);
        List<Student> students = studentMapper.selectAllStudent();
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }


}
           

• 在這裡如果你的實體類的屬性名如果和資料庫的屬性名不太一樣的可能傳回結果可能為空，我們可以開器駝峰命名比對映射。

  在application.properties添加配置。

## 開啟駝峰命名比對映射
mybatis.configuration.map-underscore-to-camel-case=true
           

這裡使用注解實作了整合mybatis。mybatis雖然在寫一些簡單sql比較友善，但是寫一些複雜的sql還是需要xml配置。

使用xml配置Mybatis

我們使用xml要先在application.properties裡配置一下,不然springboot識别不了。

## 配置Mybatis的XML配置路徑
mybatis.mapper-locations=classpath:mapper/*.xml
## 配置XML指定實體類别名
mybatis.type-aliases-package=com.hjk.pojo
           

我們重新書寫StudentMapper類，然後使用xml實作資料通路。這裡我們就寫兩個方法，剩下的基本一樣。

package com.hjk.mapper;


import com.hjk.pojo.Student;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper  //這個注解是一個mybatis接口檔案，能被spring掃描到容器中
public interface StudentMapper {

    public Student getStudentById(Integer id) ;

    public List<Student> selectAllStudent();

}

           

我們在resources目錄下建立一個mapper包，并在該包下編寫StudentMapper.xml檔案。

我們在寫的時候可以去mybatis文檔中哪複制模闆，然後再寫也可以記錄下來，友善下次寫

<?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.hjk.mapper.StudentMapper"><!--這裡namespace寫對應mapper的全路徑名-->

    <select id="getStudentById" resultType="Student">
        select * from t_student where id = #{id}
    </select>

    <select id="selectAllStudent" resultType="Student">
        select * from t_student;
    </select>

</mapper>
           

編寫測試

package com.hjk;

import com.hjk.mapper.StudentMapper;
import com.hjk.pojo.Student;
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 Springdata01ApplicationTests {

    @Autowired
    private StudentMapper studentMapper;

    @Test
    public void selectStudent(){
        Student studentById = studentMapper.getStudentById(2);
        System.out.println(studentById.toString());
    }

    @Test
    public void selectAllStudent(){
        List<Student> students = studentMapper.selectAllStudent();
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }

}

           

注解和xml優缺點

注解友善，書寫簡單，但是不友善寫複雜的sql。

xml雖然比較麻煩，但是它的可定制化強，能夠實作複雜的sql語言。

兩者結合使用會有比較好的結果。

整合Redis

Redis是一個開源的、記憶體中的資料結構存儲系統，它可以作用于資料庫、緩存、消息中間件，并提供多種語言的API。redis支援多種資料結構，String、hasher、lists、sets、等。同時内置了複本replication、LUA腳本LUA scripting、LRU驅動時間LRU eviction、事務Transaction和不同級别的磁盤持久化persistence、并且通過Redis Sentinel和自動分區提供高可用性。

• 我們添加Redis依賴。

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

• 我們在建立三個實體類用于整合，在pojo包中。

Family類

package com.hjk.pojo;

import org.springframework.data.redis.core.index.Indexed;

public class Family {

    @Indexed
    private String type;

    @Indexed
    private String userName;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "Family{" +
                "type='" + type + '\'' +
                ", userName='" + userName + '\'' +
                '}';
    }
}

           

Adderss類

package com.hjk.pojo;

import org.springframework.data.redis.core.index.Indexed;

public class Address {

    @Indexed
    private String city;

    @Indexed
    private String country;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", country='" + country + '\'' +
                '}';
    }
}

           

Person類

package com.hjk.pojo;

import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.index.Indexed;

import java.util.List;

@RedisHash("person")
public class Person {

    @Id
    private String id;

    @Indexed
    private String firstName;

    @Indexed
    private String lastName;

    private Address address;

    private List<Family> familyList;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public List<Family> getFamilyList() {
        return familyList;
    }

    public void setFamilyList(List<Family> familyList) {
        this.familyList = familyList;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", address=" + address +
                ", familyList=" + familyList +
                '}';
    }
}

           

• RedisHash("person")用于指定操作實體類對象在Redis資料庫中的儲存空間，表示Person實體類的資料操作都儲存在Redis資料庫中名為person的存儲下
• @Id用辨別實體類主鍵。在Redis中會預設生成字元串形式的HasHKey表使唯一的實體對象id，也可以手動設定id。
• Indexed 用于辨別對應屬性在Redis資料庫中的二級索引。索引名稱就是屬性名。

接口整合

編寫Repository接口，建立repository包并建立PersonRepository類

package com.hjk.repository;

import com.hjk.pojo.Person;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.CrudRepository;

import java.util.List;

public interface PersonRepository extends CrudRepository<Person,String> {
    
    List<Person> findByLastName(String lastName);
    Page<Person> findPersonByLastName(String lastName, Pageable pageable);
    List<Person> findByFirstNameAndLastName(String firstName,String lastName);
    List<Person> findByAddress_City(String city);
    List<Person> findByFamilyList_UserName(String userName);
}
           

• 這裡接口繼承的使CurdRepository接口，也可以繼承JpaRepository，但是需要導入相關包。

添加配置檔案

在application.properties中添加redis資料庫連接配接配置。

## redis伺服器位址
spring.redis.host=127.0.0.1
## redis伺服器練級端口
spring.redis.port=6379
## redis伺服器密碼預設為空
spring.redis.password=
           

測試

編寫測試類，在測試檔案下建立一個名為RedisTests的類

package com.hjk;

import com.hjk.pojo.Address;
import com.hjk.pojo.Family;
import com.hjk.pojo.Person;
import com.hjk.repository.PersonRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.List;

@SpringBootTest
public class RedisTests {

    @Autowired
    private PersonRepository repository;

    @Test
    public void redisPerson(){

        //建立按對象
        Person person = new Person();
        person.setFirstName("王");
        person.setLastName("nihao");
        Address address = new Address();
        address.setCity("北京");
        address.setCountry("china");
        person.setAddress(address);
        ArrayList<Family> list = new ArrayList<>();
        Family family = new Family();
        family.setType("父親");
        family.setUserName("你爸爸");
        list.add(family);
        person.setFamilyList(list);

        //向redis資料庫添加資料
        Person save = repository.save(person);
        System.out.println(save);
    }

    @Test
    public void selectPerson(){
        List<Person> list = repository.findByAddress_City("北京");
        for (Person person : list) {
            System.out.println(person);
        }
    }

    @Test
    public void updatePerson(){
        Person person = repository.findByFirstNameAndLastName("王", "nihao").get(0);
        person.setLastName("小明");
        Person save = repository.save(person);
        System.out.println(save);
    }


    @Test
    public void deletePerson(){
        Person person = repository.findByFirstNameAndLastName("王", "小明").get(0);
        repository.delete(person);

    }

}

           

總結

我們分别對mybatis和redis進行整合。

mybaitis：

注解：導入依賴->建立實體類->屬性配置->編寫配置類->編寫mapper接口->進行測試。

xml：導入依賴->建立實體類->屬性配置（配置資料庫等，配置xml路徑）->mapper接口->xml實作->測試

redis：導入依賴->實體類->實作接口->配置redis屬性->測試