【SpringBoot实战】数据访问
前言
在开发中我们通常会对数据库的数据进行操作,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实战】数据访问的更多相关文章
- 六、SpringBoot与数据访问
六.SpringBoot与数据访问 1.JDBC spring: datasource: username: root password: 123456 url: jdbc:mysql://192.1 ...
- SpringBoot之数据访问和事务-专题三
SpringBoot之数据访问和事务-专题三 四.数据访问 4.1.springboot整合使用JdbcTemplate 4.1.1 pom文件引入 <parent> <groupI ...
- java框架之SpringBoot(9)-数据访问及整合MyBatis
简介 对于数据访问层,无论是 SQL 还是 NOSQL,SpringBoot 默认采用整合 SpringData 的方式进行统一处理,添加了大量的自动配置,引入了各种 Template.Reposit ...
- SpringBoot 之数据访问
1. Spring Boot 与 JDBC 默认使用 org.apache.tomcat.jdbc.pool.DataSource 数据源; // application.yml spring: da ...
- SpringBoot(九) -- SpringBoot与数据访问
一.简介 对于数据访问层,无论是SQL还是NOSQL,Spring Boot默认采用整合Spring Data的方式进行统一处理,添加大量自动配置,屏蔽了很多设置.引入各种xxxTemplate,xx ...
- 10分钟进阶SpringBoot - 05. 数据访问之JDBC(附加源码分析+代码下载)
10分钟进阶SpringBoot - 05. 数据访问之JDBC 代码下载:https://github.com/Jackson0714/study-spring-boot.git 一.JDBC是什么 ...
- 20、Springboot 与数据访问(JDBC/自动配置)
简介: 对于数据访问层,无论是SQL还是NOSQL,Spring Boot默认采用整合 Spring Data的方式进行统一处理,添加大量自动配置,屏蔽了很多设置.引入 各种xxxTemplate,x ...
- SpringBoot的数据访问
一.JDBC方式 引入starter. <dependency> <groupId>org.springframework.boot</groupId> <a ...
- SpringBoot与数据访问
pom依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId> ...
- springboot与数据访问之jdbc
官网的starthttps://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-starter 添加依 ...
随机推荐
- vue轻量进度条
**### vue------ mode 好玩东西+1: 轻量级进度条: 1.引入 import NProgress from 'nprogress'; // progress bar import ...
- vue3 区别于 vue2 的“与众不同”
希望本篇文章能帮你加深对 Vue 的理解,能信誓旦旦地说自己熟练Vue2/3.除此之外,也希望路过的朋友可以帮助我查漏补缺. 区别 生命周期的变化 整体来看,变化不大,只是名字大部分需要 + on ...
- CF549G题解
变菜了,一年前做这种题10min出结论,现在对着样例胡半天都没结果 首先考虑从判断无解入手. 定义两个位置 \((i,j)\),若 \(a[i]=a[j]+(j-i)\),则 \(i\) 和 \(j\ ...
- Linux kernel serial_ir_init_module()释放后重利用漏洞
受影响系统:Linux kernel < 5.1.6描述:-------------------------------------------------------------------- ...
- Docker——dockerfile
dockerFile介绍 dockerFile是用来构建docker镜像的文件!命令参数脚本! 步骤: 编写dockerFile文件 docker build构建成为一个镜像 docker run运行 ...
- Docker——容器数据卷
为什么需要容器数据卷 角度:遇到问题,尝试以朴素的道理解决问题.问题复杂化,解决的方式也变得复杂 问题的提出:docker将应用和环境打包成一个镜像,但是对于容器内的数据,如果不进行外部的保存,那么当 ...
- 淘宝 NPM 镜像站切换新域名啦
镜像下载.域名解析.时间同步请点击 阿里云开源镜像站 源起 淘宝 NPM 镜像站(npm.taobao.org)自 2014 年 正式对外服务,一开始只是想简单地做 NPM 的中国镜像站点,回馈国内前 ...
- Django安装和web框架原理
Django安装和web框架原理 在PyCharm中安装 在cmd中输入 django-admin startproject 项目名 如果报错 不是内部或外部命令,也不是可运行的程序 需要添加环境变量 ...
- python3 爬虫6--requests的使用(1)
1用requests进行网页请求与urlopen差不多,这里省略不说 2抓取网页的学习 import requests import re headers={'User-Agent': 'Mozill ...
- Delete、truncate、drop都是删除语句,它们有什么分别?
delete 属于DML语句,删除数据,保留表结构,需要commit,可以回滚,如果数据量大,很慢. truncate 属于DDL语句,删除所有数据,保留表结构,自动commit,不可以回滚,一次全部 ...