1. Toy模板网首页
  2. > Toy博客

Mybatis-plus 使用

7月前 作者：beitian_china 分类：Toy博客 阅读(31) 违法举报

这篇具有很好参考价值的文章主要介绍了Mybatis-plus 使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1. 注解使用

        mybatis-plus提供了 ·@TableName·, @TableId, @TableField, @TableLogic 四种注解，其含义分别为：

 @TableName

         @TableName("SPF_Require_Vehicle")    用于声明当前class所对应数据库中的表，如果class的名字和表的名字完全相同，则不需要添加该注解，如果不一样，则需要用该注解进行声明。

 @TableId

        @TableId(value = "SPF_UID", type = IdType.AUTO)     用于声明主键， value指定数据库中主键的名称，type为主键的生成类型，支持 Assign（雪花算法，java字段需要是Long）、Auto（数据库字段需要声明为auto_increment）， uuid

  @TableField

        @TableField("SPF_Name")  用于声明当前字段对应的表中的字段

  @TableLogic

        @TableLogic(value = "0", delval = "1")   用于软删除，value是默认值，delval表示软删除后的值。

@TableName("SPF_Require_Vehicle")
@Data
public class Employee {
    /**
     * 指定主键名称为SPF_uid, 类型为自增，即数据库的字段必须是auto_increment
     */
    @TableId(value = "SPF_UID", type = IdType.AUTO)
    private Long id;

    /**
     * 指定数据库中对应的字段是 Part_PartSap
     */
    @TableField("Part_PartSap")
    private String partSap;

    @TableField("Part_PlateSap")
    private String plateSap;

    @TableField("SPF_Name")
    private String name;

    /**
     * 逻辑删除
     */
    @TableLogic(value = "0", delval = "1")
    @TableField("IsActvie")
    private Boolean active;
}

@EnumValue

        代码简洁性考虑：许多时候需要用到Enum，例如0表示男1表示女、0表示关闭1表示打开，and so on

  1.          在数据库表中增加字段gender： 0表示男，1表示女
  2.           定义枚举类， @EnumValue注解表示该字段是向数据库中插入的值，@JsonValue表示读取的时候对外展示的值        
@Getter
public enum SexEnum {
    SEX_MALE(0, "男"),
    SEX_FEMALE(1, "女");

    /**
     * 表示当前字段是执行insert时向数据库中插入的字段
     */
    @EnumValue
    private int sexVal;

    /**
     * 表示从数据库读取的时候对外显示的值
     */
    @JsonValue
    private String sexName;

    SexEnum(int sexVal, String sexName) {
        this.sexVal = sexVal;
        this.sexName = sexName;
    }

    /**
     * 配合 @JsonValue使用
     * @return 返回展示的值
     */
    @Override
    public String toString() {
        return this.sexName;
    }
}

        3.  使用处

                Mybatis-plus 使用,mybatis 

                Mybatis-plus 使用,mybatis

         插入的值为枚举注释的值

Mybatis-plus 使用,mybatis        读取的是 @JsonValue注释的值

        Mybatis-plus 使用,mybatis 

2. IService使用

2.1 批量插入

boolean saveBatch(Collection<T> entityList, int batchSize);
@Test
    public void baseBatchInsertTest() {
        List<Employee> list = new ArrayList<>();
        for (int i = 20; i < 30; i++) {
            Employee employee = new Employee();
            employee.setName("zhagnsan" + i);
            employee.setPartSap("123425-" + i);
            employee.setPlateSap("312342-" + i);
            list.add(employee);
        }
        // 批量插入，service提供了两个函数，可以带第二个参数，也可以不带，不带的情况下默认是1000
        // 批量插入实际也是一条一条的插入，不同的是底层启动了同一个session，插入完成后关闭，不需要每次都开启关闭
        this.service.saveBatch(list, 10);
    }

2.2 批量插入修改

        如果主键Id已经在表中存在则修改，如果不存在则插入一条新数据

 // 第二个参数选填，默认是1000

boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
@Test
    public void testBatchInsertOrUpdate() {
        List<Employee> list = new ArrayList<>();
        Employee e1 = new Employee();
        // 1L已经存在，会指定update
        e1.setId(1L);
        // 只添加了一个字段，也就是只修改一个字段
        e1.setName("车轱辘");
        Employee e2 = new Employee();
        // id在表中不存在，则新增
        e2.setId(50L);
        e2.setName("车顶");
        e2.setPartSap("123142314-00");
        e2.setPlateSap("423414-09");
        list.add(e1);
        list.add(e2);
        this.service.saveOrUpdateBatch(list,2);
    }

2.2 单个插入修改

       // 如果id存在则修改，否则插入

boolean saveOrUpdate(T entity);

2.3 单个删除

default boolean removeById(Serializable id)
default boolean removeById(T entity)
@Test
    public void testRemoveSingle01() {
        /**
         * id如果存在则删除，返回ture，否则返回false
         */
        boolean b = this.service.removeById(9);
        System.out.println("b:" + b);
    }


/*
* 有的时候，前端传过来的是一个类，此时可以直接调用该函数删除
*/
@Test
    public void testRemoveSignle02() {
        Employee employee = new Employee();
        employee.setId(8L);
        this.service.removeById(employee);
    }

2.4 有条件删除 

        实际中很多情况并不是根据Id进行删除而是根据实际需要进行删除， service也提供了该功能

removeByMap
default boolean removeByMap(Map<String, Object> columnMap)

        

/*
* 下面代码执行的语句如下
* UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE Part_PlateSap = ? AND Part_PartSap = ? AND IsActvie=0
*/
@Test
    public void testRemoveByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("Part_PartSap", "123425-0");
        map.put("Part_PlateSap", "312342-0");
        this.service.removeByMap(map);
    }
remove（可根据条件批量删除）

 也可以根据wrapper进行删除，删除的时候使用的是QueryWrapper， Wrapper的用法有很多种，此处只展示in的用法，其他用法下文进行介绍

default boolean remove(Wrapper<T> queryWrapper)
@Test
    public void testRemove03() {
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        List<Long> list = new ArrayList<>();
        list.add(2L);
        list.add(3L);
        list.add(4L);
        wrapper.in(list != null && !list.isEmpty(), "SPF_UID", list);
        /**
         * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE IsActvie=0 AND (SPF_UID IN (?,?,?))
         */
        this.service.remove(wrapper);
    }

2.5 批量删除

根据主键批量删除

removeByIds
default boolean removeByIds(Collection<?> list)
@Test
    public void testRemoveByIds() {
        List<Long> list = new ArrayList<>();
        list.add(2L);
        list.add(3L);
        list.add(5L);
        /**
         * 根据Ids批量删除
         * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
         */
        this.service.removeByIds(list);
    }
removeBatchByIds

采用jdbc批量删除，底层使用for循环逐个删除，这点是和上面函数的区别

default boolean removeBatchByIds(Collection<?> list, int batchSize)
@Test
    public void testremoveBatchByIds() {
        List<Long> list = new ArrayList<>();
        list.add(2L);
        list.add(3L);
        list.add(5L);
        /**
         * UPDATE SPF_Require_Vehicle SET IsActvie=1 WHERE SPF_UID=? AND IsActvie=0
         */
        this.service.removeBatchByIds(list, list.size());
    }

2.6 单个修改：根据Id修改

default boolean updateById(T entity)
@Test
    public void testupdateById() {
        Employee employee = new Employee();
        employee.setId(8L);
        employee.setName("doris");
        /**
         * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
         */
        this.service.updateById(employee);
    }

2.7 有条件修改：根据wrapper修改

default boolean update(Wrapper<T> updateWrapper)
@Test
    public void testupdate() {
        Integer minId = 9;
        Integer maxId = 14;
        String name = "doris";
        String nName = "wangshun";
        LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
        wrapper.gt(minId != null, Employee::getId, minId)
                .lt(maxId != null, Employee::getId, maxId)
                .or()
                .like(name != null && !name.isEmpty(), Employee::getName, name);
        wrapper.set(nName != null && !nName.isEmpty(), Employee::getName, nName);
        /**
         * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE IsActvie=0 AND (SPF_UID > ? AND SPF_UID < ? OR SPF_Name LIKE ?)
         */
        this.service.update(wrapper);
    }

2.8 批量修改：根据Id修改

这个方法很使用，实际工作中，都是根据前端传过来的结构体进行修改

boolean updateBatchById(Collection<T> entityList, int batchSize)
@Test
    public void testupdateBatchById() {
        List<Employee> list = new ArrayList<>();
        Employee e1 = new Employee();
        e1.setId(1L);
        e1.setName("wangwu");
        Employee e2 = new Employee();
        e2.setId(2L);
        e2.setName("wangbaochuan");
        list.add(e1);
        list.add(e2);
        /**
         * UPDATE SPF_Require_Vehicle SET SPF_Name=? WHERE SPF_UID=? AND IsActvie=0
         */
        this.service.updateBatchById(list, list.size());

    }

2.9 单个查询

        根据Id单个查询

        getById
@Test
    public void testgetById() {
        /**
         * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID=? AND IsActvie=0
         */
        Employee byId = this.service.getById(1);
        System.out.println(byId);
    }
        getOne

          // 根据条件查找时：如果有多个则会抛出异常

        default T getOne(Wrapper<T> queryWrapper)

        

@Test
    public void testgetOne() {
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        String plateSap = "312342-6";
        wrapper.eq(plateSap != null && !plateSap.isEmpty(), Employee::getPlateSap, plateSap);
        /**
         * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
         *  FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (Part_PlateSap = ?)
         */
        Employee one = this.service.getOne(wrapper);
        System.out.println(one);
    }

        

2.10 批量查询

        listByIds

        

@Test
    public void testlistByIds() {
        List<Long> list = new ArrayList<>();
        list.add(1L);
        list.add(2L);
        list.add(3L);
        List<Employee> employees = this.service.listByIds(list);
        /**
         * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active FROM SPF_Require_Vehicle WHERE SPF_UID IN ( ? , ? , ? ) AND IsActvie=0
         */
        employees.forEach(System.out::println);
    }
list

         

@Test
    public void testList() {
        List<Employee> list = this.service.list();
        /**
         * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active
         *  FROM SPF_Require_Vehicle WHERE IsActvie=0
         */
        list.forEach(System.out::println);
    }

2.11 有条件批量查询

        listByMap

        default List<T> listByMap(Map<String, Object> columnMap)

@Test
    public void testlistByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("SPF_Name", "wangshun");
        map.put("Part_PlateSap", "312342-20");
        /**
         * SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active 
         *  FROM SPF_Require_Vehicle WHERE Part_PlateSap = ? AND SPF_Name = ? AND IsActvie=0
         */
        List<Employee> employees = this.service.listByMap(map);
        employees.forEach(System.out::println);
    }
list
default List<T> list(Wrapper<T> queryWrapper)
@Test
    public void testList() {
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Employee::getName, "wangshun");
        List<Employee> list = this.service.list(wrapper);
        /**
         *  SELECT SPF_UID AS id,Part_PartSap AS partSap,Part_PlateSap AS plateSap,SPF_Name AS name,IsActvie AS active 
         *      FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
         */
        list.forEach(System.out::println);
    }

2.12 查询指定列

getmap

        // 如果查询出过个，则只取第一个

Map<String, Object> getMap(Wrapper<T> queryWrapper);
@Test
    public void testSelectMap() {
        String name = "wangshun";
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(!name.isEmpty(), Employee::getName, name);
        /**
         * 只查询这两列，如果同时查询出多行，则只取第一行
         * SELECT Part_PlateSap AS plateSap,Part_PartSap AS partSap FROM SPF_Require_Vehicle WHERE IsActvie=0 AND (SPF_Name LIKE ?)
         */
        wrapper.select(Employee::getPlateSap, Employee::getPartSap);
        Map<String, Object> map = this.service.getMap(wrapper);
        System.out.println(map);
    }
listMap

        可查询多行

@Test
    public void testlistMaps() {
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Employee::getName, "wangshun");
        /**
         * 只显示这三列
         */
        wrapper.select(Employee::getPartSap, Employee::getPlateSap, Employee::getName);
        List<Map<String, Object>> maps = this.service.listMaps(wrapper);
        for (Map<String, Object> map : maps) {
            System.out.println(map);
        }
    }

        

default List<Map<String, Object>> listMaps()  如果不见条件则查询所有的行

2.13 个数查询      

// 查询表中国有效的总行数
default long count()
// 根据条件查询行数
default long count(Wrapper<T> queryWrapper)

2.14 分页查询

        分页查询需要首先注册mybatis-plus的拦截器，配置如下

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor getIntercepter() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return mybatisPlusInterceptor;
    }
}
@Test
    public void testPage01() {
        Page<Employee> page = new Page<>(2, 4);
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Employee::getName, "wangshun");
        this.service.page(page, wrapper);
        System.out.println(page);
        // 查询到的内容
        System.out.println("records: " + page.getRecords());
        // 总页数
        System.out.println("pages: " + page.getPages());
        // 当前页数
        System.out.println("current: " + page.getCurrent());
        // 总条目数
        System.out.println("total: " + page.getTotal());
    }

2.15 SQL分页查询

        许多时候需要手写语句实现分页查询，例如同时从多张表中查询数据，这个时候需要自己写条件。

01. 在 application.yml中指定mybatis-plus的相关配置，尤其要指定xml的路径，默认在mapper下，本人仍习惯指明位置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 指定mapper.xml所在的位置
  mapper-locations: classpath:/mapper/*.xml

02. 在Mapper中增加声明

 /**
     * 手写语句实现分页查询
     * @param page 拦截器使用，当前sql中不需要
     * @param employee 查询对象
     * @return 查询结果
     */
    Page<Employee> getEmployeeInfoByPage(@Param("page") Page<Employee> page, @Param("employee") Employee employee);

03. 添加Mapper对应的xml文件并增加对应的函数

<?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.ssm01.mapper.EmployeeMapper">
    <resultMap id="baseResultMap" type="com.ssm01.pojo.Employee">
        <result column="SPF_UID" property="id"/>
        <result column="Part_PartSap" property="partSap"/>
        <result column="Part_PlateSap" property="plateSap"/>
        <result column="SPF_Name" property="name"/>
    </resultMap>
    <select id="getEmployeeInfoByPage" resultMap="baseResultMap">
        select * from SPF_Require_Vehicle where SPF_Name = #{employee.name} and IsActvie = 0
    </select>
</mapper>

04. 在自己的service中增加相应的方法，调用mapper中的函数文章来源地址https://www.toymoban.com/news/detail-728319.html

到了这里，关于Mybatis-plus 使用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • SpringBoot（整合MyBatis + MyBatis-Plus + MyBatisX插件使用）

    SpringBoot（整合MyBatis + MyBatis-Plus + MyBatisX插件使用）

    1.需求分析 2.数据库表设计 3.数据库环境配置 1.新建maven项目 2.pom.xml 引入依赖 3.application.yml 配置数据源 数据库名 用户名 密码 驱动是mysql8的（因为上面使用了版本仲裁） 4.Application.java 编写启动类 5.测试 6.配置类切换druid数据源 7.测试数据源是否成功切换 4.Mybatis基础配置 1

    2024年03月20日
    浏览(38)

  • Mybatis-Plus使用方法

    MyBatis-Plus 提供了丰富的增强版的 CRUD 方法，使得开发者能够更简洁、高效地进行数据库操作。以下是如何使用 MyBatis-Plus 自带的增强版 CRUD 方法的基本步骤： 添加依赖 首先，确保你的 Maven 项目中已经添加了 MyBatis-Plus 的相关依赖，包括核心依赖和数据库驱动依赖。 xml复制代

    2024年04月11日
    浏览(34)

  • Mybatis-plus框架使用配置

    MyBatis-Plus（简称 MP）是一个基于 MyBatis 的增强工具，它对 Mybatis 的基础功能进行了增强，但未做任何改变。使得我们可以可以在 Mybatis 开发的项目上直接进行升级为 Mybatis-plus，正如它对自己的定位，它能够帮助我们进一步简化开发过程，提高开发效率。 Mybatis-Plus 其实可以看

    2024年02月09日
    浏览(30)

  • mybatis-plus的一些使用案例

    （1）需求分析 在创建和修改的时候，需要判断库名是否重复，而库名是全英文，所以要忽略字母大小写，大小写不同被认为是相同的字母 （2）解决思路 把数据库里的字段，还有要查的条件字段，都转成小写或者大写，然后再判断是否相同 （3）代码案例 （1）Api接口层 参数

    2024年02月13日
    浏览(28)
  • 使用Mybatis-Plus问题解答

    使用Mybatis-Plus问题解答

    我们使用一个新的框架难免会遇到各种问题，当然使用这款国产的优秀的Mybatis-Plus框架也不例外，下面我就给大家列举一下使用Mybatis-Plus可能遇到的一些问题，并做一下一一的解答。 1：如何排除非表的字段 （这个问题一定要注意，我们Java中写的Entity类的属性是和表的字段一

    2024年02月08日
    浏览(30)
  • mybatis-plus使用updateBatchById小记

    mybatis-plus使用updateBatchById小记

    过程  staff_info表里，我通过sql把entry_time字段先设置成2，然后再通过代码设置成0，设置成2的时候一共有483条数据，然后通过代码修改的时候，我把number=0132791的数据设置成null，即更新这一条数据肯定会报错，通过debug我知道number=2这条数据在更新的list中处于index=141的位置，所

    2024年02月12日
    浏览(28)
  • Mybatis-Plus 使用隐患，太坑了！

    Mybatis-Plus 使用隐患，太坑了！

    作者：糊涂码 链接：https://juejin.cn/post/7156428078061895710 MP 从出现就一直有争议 感觉一直 都存在两种声音 很方便啊 通过函数自动拼接Sql 不需要去XML 再去使用标签 之前一分钟写好的Sql 现在一秒钟就能写好 简直不要太方便 侵入Service层 不好维护 可读性差 代码耦合 效率不行

    2024年02月05日
    浏览(72)

  • 使用Mybatis-plus清空表数据

    方法一：  方法二： 直接使用自带的remove接口 ，同时使用QueryWrapper参数如： 引申一下 Mybatis-plus这个好用的框架： 我们知道 MyBatis 是一个基于 java 的持久层框架，它内部封装了 jdbc，极大提高了我们的开发效率。 但是使用 Mybatis 开发也有很多痛点： 每个 Dao 接口都需要自己

    2023年04月09日
    浏览(26)

  • springboot使用Mybatis-plus分页插件

    在  pom.xml   文件中添加 MyBatis Plus 和分页插件的依赖： 注意替换  {mybatis-plus-version}  为对应的版本号。 在 Spring Boot 的配置文件  application.yml   中添加分页插件的配置参数： 注意代码中的注释，其中   PaginationInterceptor  表示使用 MyBatis Plus 提供的分页插件。 在接口层使用

    2024年02月07日
    浏览(32)
  • 【Java系列】Mybatis-Plus 使用方式介绍

    【Java系列】Mybatis-Plus 使用方式介绍

    Mybatis-Plus 提供了多种方式来执行 SQL，包括使用注解、XML 映射文件和 Lambda 表达式等。其中，使用 Lambda 表达式是 Mybatis-Plus 推荐的方式，因为它更加直观和类型安全。 以下是一个使用 Lambda 表达式执行 SQL 的示例，现在我们有一个名为  User  的实体类，其中包含  id 、 name  

    2024年02月07日
    浏览(75)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包