【Mybatis-Plus】CRUD操作_myabtisplus page -1-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_55336071/article/details/124282546

本文详细介绍了如何使用 MyBatis Plus 进行 CRUD 操作，包括 User 类和 UserMapper 接口的定义、数据库表的创建、配置文件的编写，以及插入、更新、删除和查询等操作的示例代码。通过这些例子，展示了 MyBatis Plus 的便捷性和实用性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 定义类User和UserMapper接口

package cn.itcast.mp.simple.pojo;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

package cn.itcast.mp.simple.mapper;

import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import java.util.List;

public interface UserMapper extends BaseMapper<User> {
}

2. 创建数据库表

-- 创建测试表
CREATE TABLE `tb_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_name` varchar(20) NOT NULL COMMENT '用户名',
`password` varchar(20) NOT NULL COMMENT '密码',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('1', 'zhangsan', '123456', '张三', '18', 'test1@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('2', 'lisi', '123456', '李四', '20', 'test2@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('3', 'wangwu', '123456', '王五', '28', 'test3@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('4', 'zhaoliu', '123456', '赵六', '21', 'test4@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('5', 'sunqi', '123456', '孙七', '24', 'test5@itcast.cn');

3. 编写配置文件

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:*.properties"></context:property-placeholder>
<!--    定义数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="maxActive" value="10"></property>
        <property name="minIdle" value="5"></property>
    </bean>

<!--    这里使用MP提供的sqlSessionFactory，完成了Spring与MP的整-->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

<!--    扫描mapper接口，使用的依然是Mybatis原生的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.itcast.mp.simple.mapper"/>
    </bean>
</beans>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mp?
useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
jdbc.username=root
jdbc.password=root

log4j.properties

log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

4. CRUD操作

插入操作

    /**
     * 测试插入操作
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setAge(20);
        user.setEmail("ffff@q.com");
        user.setName("法法");
        user.setUserName("leo");
        user.setPassword("123456");

        int result = this.userMapper.insert(user);
        System.out.println(result);
        System.out.println(user.getId());//自增后的id会回填到对象中

    }

记住在User的id字段上添加

@TableId(value = "id", type = IdType.AUTO) //指定id类型为自增长

@TableId(value = "id", type = IdType.AUTO) //指定id类型为自增长
private Long id;

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

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

更新操作

根据id更新：updateById

测试代码如下，将id为6的user的username更改为eva，age更改为24

    /**
     * 测试更新操作
     */
    @Test
    public void testUpdateById(){
        User user = new User();
        user.setId(6L);//主键
        user.setUserName("eva"); //更新的字段
        user.setAge(24); //更新的字段
        int result = userMapper.updateById(user);
        System.out.println(result);
    }

查看数据库

根据条件更新：update

查看BaseMapper源码，需要两个参数：entity用来表示set条件值，可以为空，updateWrapper用来封装where语句

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

测试代码如下：使用 UpdateWrapper和QueryWrapper都可以实现更新操作。

    @Test
    public void testUpdate(){
        User user = new User();
        user.setName("eva");//更新的字段
        //更新的条件
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", "6");
        int result = userMapper.update(user, queryWrapper);
/*
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", 6).set("name", "eva");
        int result = userMapper.update(null, updateWrapper);
        */
        System.out.println(result);
    }

删除操作

deleteById

比较简单

     /**
     * 测试删除操作
     */    
    @Test
    public void testDeleteById(){
        int result = userMapper.deleteById(1L);
        System.out.println(result);
    }

deleteByMap

将columnMap中的元素设置为删除的条件，多个之间为and关系

    @Test
    public void testDeleteByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("age", 21);
        columnMap.put("name", "赵六");
//将columnMap中的元素设置为删除的条件，多个之间为and关系
        int result = userMapper.deleteByMap(columnMap);
        System.out.println(result);
    }

delete

将实体对象进行包装，包装为操作条件

    @Test
    public void testDelete(){
        User user = new User();
        user.setAge(20);
        user.setName("张三");
        //将实体对象进行包装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);

        int result = userMapper.delete(wrapper);
        System.out.println(result);

deleteBatchIds 删除（根据ID 批量删除）

测试

    @Test
    public void testDeleteBatchIds(){
        //根据id集合批量删除
        int result = userMapper.deleteBatchIds(Arrays.asList(3l, 5l));
        System.out.println(result);
    }

查询操作

为了让效果更明显，我将之前删除的数据重新添加了

selectById 根据 ID 查询

测试

    /**
     * 测试查询操作
     */
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(5l);

selectBatchIds 查询（根据ID 批量查询）

测试

    @Test
    public void testSelectBatchIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1l,2l,3l));
        for (User user : users) {
            System.out.println(user);
        }
    }

selectOne 根据 entity 条件，注意只能查询一条记录而不是User集合

    @Test
    public void testSelectOne(){
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("id", 6);
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

selectCount 根据 Wrapper 条件，查询总记录数

测试

    @Test
    public void testSelectCount(){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 22);//年龄大于22岁
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }

selectList 根据 entity 条件，查询全部记录

测试，我们还是用上面的测试条件

    @Test
    public void testSelectList(){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 22);//年龄大于22岁
        List<User> users = userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }

selectByPage

创建一个mybatis配置文件mybatis-config.xml，加入分页插件 PaginationInterceptor

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <plugins>
        <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"></plugin>
    </plugins>
</configuration>

同时在applicationContext.xml中加入configLocation属性

    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    </bean>

测试

    @Test
    public void testSelectPage(){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 22);//年龄大于22岁
        Page<User> page = new Page<>(1,1);

        //根据条件查询数据
        IPage<User> iPage = 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);
        }
    }