Springboot整合持久层框架

最新推荐文章于 2023-12-24 08:54:13 发布
最新推荐文章于 2023-12-24 08:54:13 发布
阅读量482 收藏
点赞数 1
文章标签： mysql 数据库

## 一、持久层框架

Mybaits 、Hibernate 、`Mybatis-plus`、`Spring Data JPA`(基于hibernate)，这些都属于ORM框架

## 二、mybaits-plus框架

mybaits-plus只对mybatis进行增强，不对mybaits做修改

## 三、Springboot整合mybaits-plus

### 1.整合mybatis-plus的步骤

#### （1）导入依赖

```xml
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
```

#### （2）配置数据源 application.yml

springboot默认采用的数据源是什么？HikariCP、Druid、common-pooled、c3p0等

springboot默认使用hikariCP，性能比较强

```yaml
#配置连接数据库使用的数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/lanqiao
    username: root
    password: root
#给实体类起了别名
mybatis-plus:
  type-aliases-package: org.lanqiao.entity
#日志,只监控org.lanqiao.mapper包下的
logging:
  level: 
    org:
      lanqiao:
        mapper: debug
```

#### （3）创建数据库和实体类

可以通过正向工程或逆向工程 。  

正向工程：java程序===》生成数据库  

逆向工程：数据库的信息===》java程序

```java
package org.lanqiao.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("tb_student")
public class Student {
    //让数据库来处理自增字段，否则mybaits-plus会自动生成一个字符串类型id插入到数据库中
    @TableId(type = IdType.AUTO)
    private Integer id;
    //@TableField("user_name")
    private String userName;
    private Integer age;
}
```

#### (4)mapper层接口

```java
package org.lanqiao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.lanqiao.entity.Student;
@Mapper
public interface StudentMapper extends BaseMapper<Student> {
}
```

#### (5)service层

```java
package org.lanqiao.service;

import org.lanqiao.entity.Student;

import java.util.List;

public interface StudentService {
    int addStudent(Student student);
    int deleteStudent(Integer id);
    int updateStudent(Student student);

    Student getStudentById(Integer id);
    List<Student> getAllStudents();
}

```

```java
package org.lanqiao.service.impl;

import org.lanqiao.entity.Student;
import org.lanqiao.mapper.StudentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class StudentService implements org.lanqiao.service.StudentService {
    @Autowired
    StudentMapper studentMapper;
    @Override
    public int addStudent(Student student) {
        return studentMapper.insert(student);
    }

    @Override
    public int deleteStudent(Integer id) {
        return 0;
    }

    @Override
    public int updateStudent(Student student) {
        return 0;
    }

    @Override
    public Student getStudentById(Integer id) {
        return null;
    }

    @Override
    public List<Student> getAllStudents() {
        return null;
    }
}
```

#### (6)配置类

```java
package org.lanqiao.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

@Configuration
//假如mapper接口中使用了@Mapper就可以不需要扫描，但是使用spring的注解@Repository，必须扫描
@MapperScan("org.lanqiao.mapper")
public class AppConfig {
}
```

#### (7)单元测试

```java
package org.lanqiao.test_springboot_02;

import org.junit.jupiter.api.Test;
import org.lanqiao.entity.Student;
import org.lanqiao.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class TestSpringboot02ApplicationTests {
    @Autowired
    StudentService studentService;

    @Test
    void contextLoads() {
        int i = studentService.addStudent(new Student(null, "john", 23));
        System.out.println(i);
    }
}
```

#### （8）restful风格的controller

```java
package org.lanqiao.controller;

import org.lanqiao.entity.Student;
import org.lanqiao.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class StudentController {
    @Autowired
    StudentService studentService;
    @PostMapping("/student/save")
    public String insert(@RequestBody Student student){
        int i = studentService.addStudent(student);
        if(i >= 1) return "ok";
        else return "fail";
    }
    @DeleteMapping("/student/{id}")
    public String delete(@PathVariable("id") Integer id){
        int i = studentService.deleteStudent(id);
        if(i >= 1) return "ok";
        else return "fail";
    }
    @PutMapping("/student/save")
    public String update(Student student){
        int i = studentService.updateStudent(student);
        if(i >= 1) return "ok";
        else return "fail";
    }
    @GetMapping("/student/{id}")
    public Student getOne(@PathVariable("id") Integer id){
        return studentService.getStudentById(id);
    }
    @GetMapping("/student")
    public List<Student> getAll(){
        return studentService.getAllStudents();
    }
}
```

### 2.mybatis-plus条件查询

Wrapper   QueryWrapper

```java
    @Override
    public List<Student> getStudentsByAge(Integer age) {
        QueryWrapper<Student> wrapper = new QueryWrapper<>();
        wrapper.ge("age",age);
        return studentMapper.selectList(wrapper);
    }

    @Override
    public List<Student> getStudentByName(String userName) {
        QueryWrapper<Student> wrapper = new QueryWrapper<>();
        wrapper.like("user_name",userName);
        wrapper.gt("age",22);
        return studentMapper.selectList(wrapper);
    }
```

### 3.mybatis-plus提供的分页插件

#### (1)提供分页拦截器(配置类)

```java
package org.lanqiao.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("org.lanqiao.mapper")
public class AppConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //创建mybatisplus拦截器总管
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //添加一个分页拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

```

#### （2）在service层实现分页

分页有2种：

一种叫做逻辑分页（假分页）

会把数据库表中的所有数据一次性都查出来，返回给前端页面，前端页面通过js进行分页

一种叫做物理分页（真分页）

每次查询只查询一页的数据，下一页又要到数据库再次查询

IPage   Page<Student>

mysql分页sql：  select * from student limit  startRecord,pageSize

```java
    @Override
    public IPage<Student> getAllStudents(Page<Student> page) {
        IPage<Student> iPage = studentMapper.selectPage(page,null);
        return iPage;
    }
```

```java
 @Test
    void contextLoad9() {
        Page<Student> page = new Page<>();
        //设定每页显示2条记录
        page.setSize(2);
        //设置查询第二页
        page.setCurrent(2);
        IPage<Student> iPage = studentService.getAllStudents(page);
        //获取总数
        System.out.println("总数:"+iPage.getTotal());
        //获取总页数
        System.out.println(iPage.getPages());
        //查询当前页码
        System.out.println(iPage.getCurrent());
        //获取每页多少条记录
        System.out.println(iPage.getSize());
        List<Student> list = iPage.getRecords();
        //使用了lanmda表达式
        list.forEach(e-> System.out.println(e));
        //students.forEach(System.out::println);
    }
```

### 4.自定义方法（实现多表查询）

假如mybatis-plus的BaseMapper没有提供我们想要的方法，我可以仍然使用mybatis的用法

```java
package org.lanqiao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.lanqiao.entity.Student;
import org.springframework.stereotype.Repository;

import java.util.List;

//@Mapper
@Repository
public interface StudentMapper extends BaseMapper<Student> {
    @Select("select * from tb_student where user_name = #{name}")
    public Student selectStudentsByName(String name);
}
```

mybatis-plus的BaseMapper没有提供很好多表查询的方式，所以大部分多表查询需要自定义

### 5.使用事务

配置类上添加注解

```java
package org.lanqiao.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@MapperScan("org.lanqiao.mapper")
//<aop:aspectj-autoproxy/>启用aop的注解
@EnableAspectJAutoProxy
// <tx:annotation-driven  transaction-manager="transactionManager"/>启用事务的注解
@EnableTransactionManagement
public class AppConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //创建mybatisplus拦截器总管
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        //添加一个分页拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

```

```java
    @Transactional
    public int updateStudent(Student student) {
        return studentMapper.updateById(student);
    }
```

小陌-
关注
04. SpringBoot整合持久层技术
03-20
SpringBoot整合持久层技术是Java开发中的重要环节，它简化了传统的数据访问配置，使得开发者可以更加专注于业务逻辑。在SpringBoot中，我们通常会利用其内置的数据访问框架，如JPA（Java Persistence API）和MyBatis...
Springboot与持久层框架
weixin_53227829的博客
04-20 391
整体架构图。
关于springboot数据持久化框架选型，mybatis，mybatis-plus，jpa对比
shuaidiaoa的博客
08-02 1万+
介绍 目前java后台项目多使用持久性框架，目前有mybatis，mybatis-plus，jpa，使用的最多的还是mybatis。 mybatis比较接近原生sql，需要较强的sql功底，具体用法自行百度，jpa呢是对hibernate的封装，提取了很多通用方法，满足比较常用的增删改查，具体底层是hibernate，所以要使用的话原理必须要深究一下，不然出问题很难搞定（经历过的都懂），mybat...
[Spring Boot 2]整合持久层技术
JacinLee的博客
09-22 1615
Spring Boot 2 整合持久层技术！
基于Spring Boot重构项目的持久层
最新发布
tuyuji的博客
12-24 376
Spring Data JPA是Spring提供的一种简化和抽象化的持久层解决方案，可以极大地简化数据库访问和操作。最后，建议参考相关文档和最佳实践指南，以了解更多关于Spring Boot和Spring Data JPA的详细信息，并根据项目需求进行适当的调整和定制。数据库迁移：如果在重构过程中对数据库结构进行了更改，确保进行适当的数据库迁移和数据迁移操作，以保持数据的完整性和一致性。测试和验证：在重构完成后，进行全面的测试和验证，确保新的持久层能够正确地与数据库交互，并保持与原有功能的一致性。
SpringBoot整合持久层技术之搭建并整合Spring Data JPA项目
06-17
SpringBoot整合Spring Data JPA是现代Java开发中的常见实践，它极大地简化了数据库操作，让开发者可以更加专注于业务逻辑而不是繁琐的数据访问层实现。本文将详细介绍如何使用Spring Boot搭建一个基于Spring Data ...
springboot整合持久层：JdbcTemplate、Mybatis、jpa
05-12
SpringBoot 整合持久层：JdbcTemplate、Mybatis、JPA SpringBoot 作为一个流行的 Java 框架，提供了多种持久层整合方案，其中包括 JdbcTemplate、Mybatis 和 JPA。这些方案都可以用来实现数据持久化，下面我们将...
springboot整合Mybatis小案例框架整合
12-29
SpringBoot简化了Spring应用的初始搭建以及开发过程，而Mybatis则是一个轻量级的持久层框架，专注于SQL映射，使得开发者可以直接编写SQL来操作数据库。现在，我们将深入探讨如何将这两个框架整合在一起，构建一个...
springboot整合各大常用框架
08-24
MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。SpringBoot可以和MyBatis无缝集成，通过Mapper接口和XML配置文件，实现灵活的数据库操作。结合MyBatis-Plus，可以进一步简化CRUD操作，...
持久层框架JPA与Mybatis该如何选型
字母哥博客
11-04 2745
一、现状描述 目前java 持久层ORM框架应用最广泛的就是JPA和Mybatis。JPA只是一个ORM框架的规范, 对该规范的实现比较完整就是Spring Data JPA（底层基于Hibernate实现），是基于Spring的数据持久层框架，也就是说它只能用在Spring环境内。Mybatis也是一个优秀的数据持久层框架，能比较好的支持ORM实体关系映射、动态SQL等。 笔者在学习这两个框架的...
SpringBoot——整合持久层技术(一)
qq_43070052的博客
02-20 894
SpringBoot整合持久层技术一、整合JdbcTemplate 持久层是Java EE中访问数据库的核心操作，SpringBoot中对常见的持久层框架都提供了自动化配置例如JdbcTemplate、JPA等，MyBatis的自动化配置则是MyBatis官方提供的。 一、整合JdbcTemplate JdbcTemplate是Spring提供的一套JDBC模板框架，利用AOP技术来解决直接使用JDBC时大量重复代码的问题。JdbcTemplate虽然没有MyBatis那么灵活，但是比直接使用JDBC要
SpringBoot项目拥抱Mybatis-Plus持久层框架实践
heshengfu1211的博客
12-05 2413
SpringBoot项目拥抱Mybatis-Plus持久层框架实践，全面提升数据库层面开发效率！
JPA、Hibernate、Spring data jpa之间的关系，终于明白了
weixin_34306676的博客
06-12 779
2019独角兽企业重金招聘Python工程师标准>>> ...
一起来学SpringBoot（七）持久层框架
fulinlin的博客
10-06 5188
springboot具有非常棒的持久层框架支持，下面我将介绍我用过的三种持久层框架进行简述使用。 由于这里操作的都是一张表，这里贴出通用的yml和建表语句 切记这里使用的是mysql8 ，5.8之前的朋友请修改后缀去掉com.mysql.cj.jdbc.Driver 中的cj。 DROP TABLE IF EXISTS `Test`; CREATE TABLE `Test` ( `id`...
SpringBoot整合数据源Druid和持久层框架Mybatis
weixin_47251999的博客
04-23 875
准备 一、pom.xml引入依赖 1、SpringBoot有第三方starter：mybatis-spring-boot-starter 2、具体数据库驱动需要自己引入（这里使用自定义版本，而不是parent控制版本） <!--数据库操作框架--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-sprin
Redis——SpringBoot整合、持久化、集群（主从、哨兵、分片）
m0_63544124的博客
07-06 1171
1.2 自定义RedisTemplate 1.2.1 传递对象的两种方式 1.pojo序列化——jdk默认的序列化 2.手动转json 1.2.2 配置序列化方式 RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为RDB文件，默认是保存在当前运行目录。RDB持久化在四种情况下会执行: （1
【SpringBoot】76、SpringBoot中使用JPA作为数据持久化框架
热门推荐
Asurplus
03-16 9万+
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
框架ssm,延展springboot构架，mybatisplus和jpa做数据持久化
qq_37018378的博客
09-18 354
Spring全称 SpringFramework，其功能有：IOC-控制反转，轻松实现层间解耦AOP- 面向切面编程，轻松实现公共代码抽取MVC - 开发web应用程序事务 - 无需编写代码，即可实现数据库事务管理测试 - 与测试框架集成、web 单元测试SpringBoot对Spring的改善和优化，它基于约定优于配置的思想，提供了大量的默认配置和实现。使用SpringBoot之后，程序员只需按照它规定的方式去进行程序代码的开发即可，而无需再去编写一堆复杂的配置。
Springboot整合jdbcTemplate教程
尽管现代项目更倾向于使用如MyBatis这样的灵活持久层框架，但理解如何在Spring Boot中集成JdbcTemplate仍具有学习价值。 一、JdbcTemplate简介 JdbcTemplate虽然在现代应用中使用较少，但它仍然是Spring框架中的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值