关于mybatis-plus:MybatisPlus详解一篇带入了解底层原理

50次阅读

共计 6687 个字符，预计需要花费 17 分钟才能阅读完成。

一. MP 简介

咱们晓得，Mybatis 属于一个半自动的 ORM 框架。之所以说 Mybatis 是一个半自动的 ORM 框架，起因是它还须要咱们本人在注解或是映射文件中编写 SQL 语句，并没有实现齐全的自动化。SQL 语句的编写，尽管减少了我的项目和业务需要实现的灵活性，但对一些根本表的操作而言，无疑减少了数据库操作的复杂度，显得没有那么不便。

而 Mybatis-Plus 则是全自动的 ORM 框架，依照开闭准则，在不影响 Mybatis 现有性能的状况下，实现了对 Mybatis 的性能加强。如果你之前有过 Mybatis 的应用教训，当初学习 Mybatis-Plus 几乎就是手到擒来。

明天就带大家来学习一下 Mybatis-Plus 框架的根本应用，请掏出小本本吧。

二. Mybatis-Plus 特点 MP 具备如下根本特点：通过在实体类中与数据库表进行映射；无需编写 SQL 语句，简化了 CRUD 操作；通常实用于单表。

三. MP 应用

接下来会在 SpringBoot 我的项目环境中，带着大家一起应用 Mybatis-Plus。

1、新建 SpringBoot 我的项目创立 SpringBoot 我的项目的过程，在这里就给大家省略了，如果有不相熟的同学，能够参考之前对于 SpringBoot 的教程文章

2、增加外围依赖咱们在 SpringBoot 我的项目中增加须要用到的外围依赖包。

<dependencies>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- MySql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1.tmp</version>
</dependency>
<!-- 连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
<!-- 简化 bean 代码的工具包 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
    <version>1.18.4</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.4</version>
</dependency>

</dependencies>

 所以，实体类中就能够省去 CRUD 办法的代码实现。package com.qf.pro.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.qf.pro.pojo.User;

public interface UserDao extends BaseMapper<User> {

//BaseMapper<User> 默认封装了 CRUD 办法，通过泛型制订了所操作的实体类及表

}

  1. 编写配置类这样当 SpringBoot 启动时，就能够扫描到 dao 层代码所在的包。package com.qf.mp2103.dao;

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

@Configuration
@MapperScan(“com.qf.mp2103.dao”)
public class MybatisPlusConfig {

@Bean
public PaginationInterceptor paginationInterceptor(){return new PaginationInterceptor();
}

}

  1. 业务实现咱们要在业务逻辑层里调用各种 CRUD 办法，这也是 Mybatis-Plus 比拟外围、重要的点，MybatisPlus 会依据之前的配置主动生成 SQL 语句。package com.qf.mp2103.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qf.mp2103.dao.UsersDao;
import com.qf.mp2103.pojo.Users;
import com.qf.mp2103.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class UserServiceImpl implements UsersService {

@Autowired
private UsersDao usersDao;

@Override
public List<Users> findUsers() {
    //mybatisplus 主动生成 / 提供的查询方法
    // 因为是无条件查问，参数 null
    return usersDao.selectList(null);
}

@Override
public List<Users> findUsersByCondition(String name) {
    // 创立 QueryWrapper 对象
    QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    // 通过 wrapper 对象来设置查问条件
    // 参数 1：字段表名
    // 参数 2：所赋值
    //eq  等于
    wrapper.eq("name",name);

    return usersDao.selectList(wrapper);
}

@Override
public List<Users> findUsersByCondition2(int startAge, int endAge) {QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    // 年龄的范畴
    wrapper.between("age",startAge,endAge);
    return usersDao.selectList(wrapper);
}

@Override
public List<Users> findUsersByCondition3(Users users) {
    // 多条件查问
    QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    //where name='' and age <=

// wrapper.eq(true,”name”,users.getUserName());
//// wrapper.le(true,”age”,users.getAge());

    //where name='' or age >=
    wrapper.eq(true,"name",users.getUserName());
    wrapper.ge(false,"age",users.getAge());
    return usersDao.selectList(wrapper);
}

@Override
public List<Users> findUsersByCondition4(Users users) {
    // 含糊查问
    QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    //% 关键字 %
    wrapper.like("name",users.getUserName());
    //% 明
    //wrapper.likeLeft()
    // 李 %
    //wrapper.likeRight();
    return usersDao.selectList(wrapper);
}

// 排序查问
@Override
public List<Users> findUsers2() {QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    // 设置排序条件
    wrapper.orderByDesc("id");

    return usersDao.selectList(wrapper);
}

@Override
public List<Users> findUsersByPage(int page, int size) {
    // 用于分页查问
    //select * from users  limit X,X
    QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    int start=(page-1)*size;
    // 拼接
    wrapper.last("limit"+start+","+size);
    return usersDao.selectList(wrapper);
}

@Override
public List<Users> findUsers3() {
    // 查问指定列
    QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    // 设置查问的列
    wrapper.select("id","email");

    return usersDao.selectList(wrapper);
}

@Override
public boolean addUser(Users users) {
    // 增加用户
    int result=usersDao.insert(users);
    return result==1;
}

@Override
public boolean deleteUser(int id) {
    // 删除用户 -- 单个删除
    int result=usersDao.deleteById(id);
    // 批量删除
    //usersDao.deleteBatchIds(List<Integer> list);
    return result==1;
}

@Override
public boolean updateUser(Users users) {
    // 要求表中的主键列是 id 的名字，应用 id 列作为条件
    int result=usersDao.updateById(users);
    // 如果主键列的名字不是 id, 或者条件不是主键 id

// QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
// wrapper.eq(“email”,users.getEmail());
// int result2=usersDao.update(users,wrapper);

    return result==1;
}

@Override
public Users findUersById(int id) {
    // 依据主键 id 查问单个对象
    return usersDao.selectById(id);
}

@Override
public List<Users> findUsersByIds(List<Integer> list) {
    // 依据 id 批量查问
    return usersDao.selectBatchIds(list);
}

@Override
public Map<String,Object> findUsersByPage2(int page, int size) {
    // 如果还有其余条件查问，申明条件结构器进行

    // 创立分页插件对象
    // 参数 1：显示第几页数据
    // 参数 2：每页显示几条数据
    Page<Users> page1=new Page<Users>(page,size);
    // 依据分页插件对象里的分页条件查问数据
    IPage<Users> iPage=usersDao.selectPage(page1,null);

    Map<String,Object> map=new HashMap<String, Object>();
    // 获取总记录数  iPage.getTotal()
    map.put("totalCount",iPage.getTotal());
    // 获取总页数 iPage.getPages()
    map.put("totalPage",iPage.getPages());
    // 获取分页数据
    map.put("data",iPage.getRecords());
    return map;
}

@Override
public List<Users> findUsers4(int age1, int age2, String email) {QueryWrapper<Users> queryWrapper=new QueryWrapper<Users>();
    queryWrapper.ge("age",age1).le("age",age2).or().likeRight("email",email);

    return usersDao.selectList(queryWrapper);
}

@Override
public Users findUsers5(int id) {
    // 创立实体类对象
    Users user=new Users();
    user.setId(id);
    // 申明对象接管查问返回的后果
    Users getUser=user.selectById(id);
    return getUser;
}

@Override
public void addUsers2(Users users) {
    // 增加办法
    users.insert();}

@Override
public void updateUsers2(Users users) {
    // 依据主键更新
    users.updateById();}

@Override
public void deleteUsers2(Users users) {
    // 依据主键删除
    users.deleteById();}

public Users findOne(String name){
    // 依据其余条件查问单个数据，如果多于 1 条数据，则报异样
    // 条件结构器
    QueryWrapper queryWrapper=new QueryWrapper();
    queryWrapper.eq("name",name);
    return usersDao.selectOne(queryWrapper);
}
// 查问总记录数
public int getUserCount(){
    // 能够申明条件结构器
    return usersDao.selectCount(null);
}

}
这样通过以上几个步骤，咱们就学会了 Mybatis-Plus 的根本应用，心愿明天的文章能够教会大家如何应用 Mybatis-Plus。如果你还有纳闷，能够留言我哦。

正文完
mybatis-plus
发表至： mybatis-plus
2023-04-10
 0
关于mybatis-plus:Be-Extra-Careful-about-Pitfalls-of-MyBatisPlus-2x
关于mybatis-plus:mybatis批量插入自动生成主键跟日期
关于mybatis-plus:mybatis-plus-看这篇就够了一发入魂
关于mybatis-plus:底层到底做了什么-mybatisplus的一次select调用过程