前言

在开发中我们通常会对数据库的数据进行操作,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属性->测试

【SpringBoot实战】数据访问的更多相关文章

  1. 六、SpringBoot与数据访问

    六.SpringBoot与数据访问 1.JDBC spring: datasource: username: root password: 123456 url: jdbc:mysql://192.1 ...

  2. SpringBoot之数据访问和事务-专题三

    SpringBoot之数据访问和事务-专题三 四.数据访问 4.1.springboot整合使用JdbcTemplate 4.1.1 pom文件引入 <parent> <groupI ...

  3. java框架之SpringBoot(9)-数据访问及整合MyBatis

    简介 对于数据访问层,无论是 SQL 还是 NOSQL,SpringBoot 默认采用整合 SpringData 的方式进行统一处理,添加了大量的自动配置,引入了各种 Template.Reposit ...

  4. SpringBoot 之数据访问

    1. Spring Boot 与 JDBC 默认使用 org.apache.tomcat.jdbc.pool.DataSource 数据源; // application.yml spring: da ...

  5. SpringBoot(九) -- SpringBoot与数据访问

    一.简介 对于数据访问层,无论是SQL还是NOSQL,Spring Boot默认采用整合Spring Data的方式进行统一处理,添加大量自动配置,屏蔽了很多设置.引入各种xxxTemplate,xx ...

  6. 10分钟进阶SpringBoot - 05. 数据访问之JDBC(附加源码分析+代码下载)

    10分钟进阶SpringBoot - 05. 数据访问之JDBC 代码下载:https://github.com/Jackson0714/study-spring-boot.git 一.JDBC是什么 ...

  7. 20、Springboot 与数据访问(JDBC/自动配置)

    简介: 对于数据访问层,无论是SQL还是NOSQL,Spring Boot默认采用整合 Spring Data的方式进行统一处理,添加大量自动配置,屏蔽了很多设置.引入 各种xxxTemplate,x ...

  8. SpringBoot的数据访问

    一.JDBC方式 引入starter. <dependency> <groupId>org.springframework.boot</groupId> <a ...

  9. SpringBoot与数据访问

    pom依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId> ...

  10. springboot与数据访问之jdbc

    官网的starthttps://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-starter 添加依 ...

随机推荐

  1. 番茄钟的实现(基于Xilinx EGO1学习板)

    番茄钟设计 一.总体设计 1.番茄工作法简介 番茄工作法由意大利的奇列洛创造.其内容就是:工作25分钟休息5分钟,循环四次后休息15分钟. 本项目就是基于Xilinx Ego1开发板实现一个计时器,该 ...

  2. JavaSE 千寻简学习笔记

    JavaSE 千寻简学习笔记 简介 TIOBE:编程语言排行榜 官网:https://hellogithub.com/report/tiobe/ 如何高效的学习Java 多写(代码)多写(笔记)多写( ...

  3. python之pyc

    pyc是一种二进制文件,是由py文件经过编译后,生成的文件,是一种byte code,py文件变成pyc文件后, 加载的速度有所提高,而且pyc是一种跨平台的字节码,是由Python的虚拟机来执行的, ...

  4. 拓扑排序 python

    现在你总共有 numCourses 门课需要选,记为 0 到 numCourses - 1.给你一个数组 prerequisites ,其中 prerequisites[i] = [ai, bi] , ...

  5. python 生产数据表脚本

    # -*- coding: utf-8 -*-import re"""建立相关表的字段从源表创建指定的MySQL建表脚本"""# 目标表名称 ...

  6. 昇腾CANN论文上榜CVPR,全景图像生成算法交互性再增强!

    摘要:近日,CVPR 2022放榜,基于CANN的AI论文<Interactive Image Synthesis with Panoptic Layout Generation>强势上榜 ...

  7. OpenCV基础_二

    阈值和平滑处理 cv2.threshold()二值化函数 ret,thresh = cv2.threshold(src, thresh, maxval, type[, dst]) 参数 src:所要进 ...

  8. 《前端运维》一、Linux基础--09常用软件安装

    一.软件包管理 RPM是RedHat Package Manager(RedHat软件包管理工具)类似Windows里面的"添加/删除程序".软件包有几种类型,我们一起来看下: 源 ...

  9. 使用 Docker 部署 LNMP 并搭建 wordpress

    准备 系统版本:CentOS Linux release 7.4.1708 (Core)   内核版本:3.10.0-693.el7.x86_64    IP:192.168.31.43    可访问 ...

  10. pygame.update()与pygame.flip()的区别

    flip函数将重新绘制整个屏幕对应的窗口. update函数仅仅重新绘制窗口中有变化的区域. 如果仅仅是几个物体在移动,那么他只重绘其中移动的部分,没有变化的部分,并不进行重绘.update比flip ...