Mybatis-Plus通用CRUD

最新推荐文章于 2024-09-01 07:00:00 发布
最新推荐文章于 2024-09-01 07:00:00 发布
阅读量266 收藏
点赞数
分类专栏： MyBatis 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44722917/article/details/113873558
版权

通用CRUD

通过继承BaseMapper就可以获取到各种各样的单表操作

插入操作

方法定义
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);
测试用例
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert(){
        User user = new User();
        user.setAge(20);
        user.setEmail("test@sibd.cn");
        user.setName("曹操");
        user.setUserName("caocao");
        user.setPassword("123456");
        int result = this.userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
        System.out.println("result = " + result); 
        System.out.println(user.getId()); //自增后的id会回填到对象中
    }
}
生成ID类型枚举类
package com.baomidou.mybatisplus.annotation;
import lombok.Getter;

/**
* 生成ID类型枚举类
*
* @author hubin
* @since 2015-11-10
*/
@Getter
public enum IdType {
    /**
    * 数据库ID自增
    */
    AUTO(0),
    /**
    * 该类型为未设置主键类型
    */
    NONE(1),
    /**
    * 用户输入ID
    * <p>该类型可以通过自己注册自动填充插件进行填充</p>
    */
    INPUT(2),
    
    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
    * 全局唯一ID (idWorker)
    */
    ID_WORKER(3),
    /**
    * 全局唯一ID (UUID)
    */
    UUID(4),
    /**
    * 字符串全局唯一ID (idWorker 的字符串表示)
    */
    ID_WORKER_STR(5);
    
    private final int key;
    
    IdType(int key) {
    	this.key = key; 
    } 
}

修改User对象：

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
    @TableId(type = IdType.AUTO) //指定id类型为自增长
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email; 
}
@TableField

在MP中通过@TableField注解可以指定字段的一些属性，常常解决的问题有2个：

1、对象中的属性名和字段名不一致的问题（非驼峰）

​ @TableField(value = “email”) private String mail;

2、对象中的属性字段在表中不存在的问题

​ @TableField(exist = false) private String address;

其他用法，如大字段不加入查询字段：

​ @TableField(select = false) private String password;

更新操作

在MP中，更新操作有2种，一种是根据id更新，另一种是根据条件更新。

根据id更新

方法定义：

/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);

测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testUpdateById() {
        User user = new User();
        user.setId(6L); //主键
        user.setAge(21); //更新的字段
        
        //根据id更新，更新不为null的字段
        this.userMapper.updateById(user);
    } 
}
根据条件更新

方法定义：

/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> 
updateWrapper);

测试用例：

import cn.sibd.mp.mapper.UserMapper;
import cn.sibd.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import net.minidev.json.writer.UpdaterMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testUpdate() {
        User user = new User();
        user.setAge(22); //更新的字段
        //更新的条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("id", 6);
        //执行更新操作
        int result = this.userMapper.update(user, wrapper);
        System.out.println("result = " + result);
    }
}

或者，通过UpdateWrapper进行更新：

@Test
public void testUpdate() {
    //更新的条件以及字段
    UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    wrapper.eq("id", 6).set("age", 23);
    //执行更新操作
    int result = this.userMapper.update(null, wrapper);
    System.out.println("result = " + result);
}

删除操作

deleteById

方法定义：

/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);

测试用例：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testDeleteById() {
        //执行删除操作
        int result = this.userMapper.deleteById(6L);
        System.out.println("result = " + result);
	} 
}
deleteByMap
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testDeleteByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("age",20);
        columnMap.put("name","张三");
        //将columnMap中的元素设置为删除的条件，多个之间为and关系
        int result = this.userMapper.deleteByMap(columnMap);
        System.out.println("result = " + result);
    }
}
delete
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testDeleteByMap() {
        User user = new User();
        user.setAge(20);
        user.setName("张三");
        //将实体对象进行包装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        int result = this.userMapper.delete(wrapper);
        System.out.println("result = " + result);
    }
}
deleteBatchIds
/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testDeleteByMap() {
        //根据id集合批量删除
        int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
        System.out.println("result = " + result);
    }
}

查询操作

MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。

selectById
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectById() {
        //根据id查询数据
        User user = this.userMapper.selectById(2L);
        System.out.println("result = " + user);
    }
}
selectBatchIds
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectBatchIds() {
        //根据id集合批量查询
        List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
        for (User user : users) {
            System.out.println(user);
        }
    }
}
selectOne
/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectOne() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("name", "李四");
        //根据条件查询一条数据，如果结果超过一条会报错
        User user = this.userMapper.selectOne(wrapper);
        System.out.println(user);
    }
}
selectCount
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectCount() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄大于23岁
        //根据条件查询数据条数
        Integer count = this.userMapper.selectCount(wrapper);
        System.out.println("count = " + count);
    }
}
selectList
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectList() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄大于23岁
        //根据条件查询数据
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
        	System.out.println("user = " + user);
        }
    }
}
selectPage
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

配置分页插件：

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("cn.sibd.mp.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
    /**
    * 分页插件
    */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
    	return new PaginationInterceptor();
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectPage() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 20); //年龄大于20岁
        Page<User> page = new Page<>(1,1);
        //根据条件查询数据
        IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数：" + iPage.getTotal());
        System.out.println("总页数：" + iPage.getPages());
        List<User> users = iPage.getRecords();
        for (User user : users) {
        	System.out.println("user = " + user);
        }
    }
}

SQL注入的原理

前面我们已经知道，MP在启动后会将BaseMapper中的一系列的方法注册到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么样的？下面我们将一起来分析下。

在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，AbstractSqlInjector是它的实现类，

在AbstractSqlInjector中，主要是由inspectInject()方法进行注入的

@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
    Class<?> modelClass = extractModelClass(mapperClass);
    if (modelClass != null) {
        String className = mapperClass.toString();
        Set<String> mapperRegistryCache = 
        GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
        if (!mapperRegistryCache.contains(className)) {
            List<AbstractMethod> methodList = this.getMethodList();
            if (CollectionUtils.isNotEmpty(methodList)) {
                TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
                // 循环注入自定义方法
                methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
             } else {
             logger.debug(mapperClass.toString() + ", No effective injection method was found.");
             }
        mapperRegistryCache.add(className);
         }
     }
}

在实现方法中， methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass,tableInfo)); 是关键，循环遍历方法，进行注入。

最终调用抽象方法injectMappedStatement进行真正的注入：

/**
* 注入自定义 MappedStatement
*
* @param mapperClass mapper 接口
* @param modelClass mapper 泛型
* @param tableInfo 数据库表反射信息
* @return MappedStatement
*/
public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

以SelectById为例查看：

public class SelectById extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
        SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),sqlSelectColumns(tableInfo, false),tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),tableInfo.getLogicDeleteSql(true, false)), Object.class);
        return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
    }
}

可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。

小孩与狗
关注
专栏目录
通用mybatis-MySQL增删改查CRUD源码
09-30
通用mybatis-MySQL增删改查CRUD源码，不用再写增删改查了
MybatisPlus中使用通用CRUD实现插入操作示例代码
04-18
MybatisPlus中使用通用CRUD实现插入操作示例代码
Mybatis 通用Crud
weixin_34293246的博客
11-11 144
为什么80%的码农都做不了架构师？>>> ...
MyBatis-Plus中的@TableField注解：全面解析与实战指南
最新发布
xycxycooo的博客
09-01 2243
注解是MyBatis-Plus中非常重要的一个注解，通过它，MyBatis-Plus可以自动识别字段与列之间的映射关系，并进行相应的操作。本文详细讲解了注解的基本属性、使用方式、字段填充及动态SQL，并通过丰富的代码示例帮助你全面理解其工作机制。希望本文能帮助你更好地使用MyBatis-Plus，提高开发效率。如果你有任何问题或建议，欢迎在评论区留言讨论。
MyBatisPlus-3-通用CRUD
chengzhu3689的博客
09-04 253
通用CRUD 1.1 创建接口EmployeeMapper并继承BaseMapper<T> public interface EmployeeMapper extends BaseMapper<Employee> { /* * Mapper接口 ...
MyBatis_Plus 通用CRUD
蒟蒻码农的博客
06-15 1204
1.插入（insert） BaseMapper： 测试代码： @Test public void testInsert() { Employee employee = new Employee(); employee.setLastName("张三"); employee.setEmail("1256957450@qq....
Mybatis 通用Crud-设计思路
weixin_33877092的博客
11-12 174
为什么80%的码农都做不了架构师？>>> ...
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
特性：无侵入、损耗小、强大的CRUD操作，支持lambda 形势调用、支持多种数据库，支持主键自动生成、支持ActiveRecord模式，支持自定义全局通用操作、支持关键词自动转义，内置代码生成器、内置分页插件、内置性能...
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
1. **CRUD操作**：MyBatis-Plus提供了简化版的CRUD操作，通过继承BaseMapper接口，无需编写任何SQL语句，即可完成基本的数据增删改查操作。 2. **条件构造器**：它的QueryWrapper和UpdateWrapper类允许开发者通过...
mybatis-plus源码（mybatis-plus-3.5.1.tar.gz）
03-03
- MyBatis-Plus内置了通用分页插件，支持多种数据库的分页方式，如Page对象的使用，可以在查询时自动完成分页操作。 6. **Lambda表达式支持**： - 自3.x版本开始，MyBatis-Plus引入了对Java 8 Lambda表达式的支持...
mybatis-plus 源码（mybatis-plus-3.0.zip）
03-03
1. **基础概念**：MyBatis-Plus是一个轻量级的Java框架，主要功能包括自动化 CRUD（创建、读取、更新、删除）操作，支持自定义SQL、存储过程以及丰富的查询条件构造器。 2. **Entity实体类**：在MyBatis-Plus中，...
SpringBoot集成MyBatis-Plus实现国产数据库适配.docx
05-20
首先，需要在 pom.xml 文件中添加 MyBatis-Plus 依赖项，然后 configure MyBatis-Plus 的基本配置项，最后，使用 MyBatis-Plus 实现 CRUD 操作。 通过使用 SpringBoot 集成 MyBatis-Plus，可以快速实现国产数据库...
持久层开源工具MyBatis-Plus快速入门，Spring Boot整合MyBatis-Plus简化开发示例代码
06-27
`BaseModel`是MyBatis-Plus提供的基类，包含了一些通用字段如创建时间和更新时间。例如： ```java public class User extends BaseEntity { private String username; private String password; // getter & ...
MyBatis-Plus 学习笔记.pdf
08-30
它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、支持主键自动生成、支持 XML 热加载、支持 ActiveRecord 模式、支持自定义全局通用操作、支持关键词...
MyBatis-plus+达梦数据库实现自动生成代码的示例
09-07
MyBatis-Plus 是一个基于 MyBatis 的增强工具，它在 MyBatis 的基础上只做极小的封装，提供了一系列便捷的功能，如自动化 CRUD 操作、通用 Mapper、通用 Service 等，极大地提高了开发效率。在本示例中，我们将讨论...
Mybatis Plus --- 通用CRUD
Cbuc丶的博客
10-04 552
Mybatis Plus — 通用CRUD * 上一篇说到在Mybatis中集成Mybatis PlusMybatis Plus —入门初体验（集成MybatisPlus） * 这一篇主要来讲解Mybatis Plus中通用的 CRUD CRUD实现方式： 基于 Mybatis 需要编写 EmployeeMapper 接口，并手动编写 CRUD 方法 提供 EmployeeMapper.xm...
MyBatis3 通用CRUD的研究[二]
热门推荐
SoL 学习无止境
03-13 1万+
这次把代码贴全吧 首先是Mapper接口的基类 package org.sol.util.mybatis; import java.util.List; import org.apache.ibatis.annotations.DeleteProvider; import org.apache.ibatis.annotations.InsertProvider; import
mybatis的动态CRUD
太快的幸福,措手不及
05-06 780
这里至于以mysql为例： studentMapper.xml <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
SpringBoot+Mybatis-Plus 实现CRUD详解与示例
"本文将深入探讨如何使用SpringBoot与Mybatis-Plus实现内置的CRUD操作，包括Mybatis-Plus的主要特性、如何配置SpringBoot项目、引入依赖，以及如何利用其特性进行高效的数据操作。" 在Java开发中，SpringBoot框架因...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值