MyBatis Plus(二)

文章目录

BaseMapper 接口简介

BaseMapper 接口的全限定名称为 com.baomidou.mybatisplus.core.mapper.BaseMapper<T>，该接口提供了插入、修改、删除和查询接口,

定义了一个 SimpleMapper 接口

	package com.hxstrive.mybatis_plus.mapper;
	 
	import com.baomidou.mybatisplus.core.mapper.BaseMapper;
	import com.hxstrive.mybatis_plus.model.UserBean;
	 
	public interface SimpleMapper extends BaseMapper<UserBean> {
      
      
	 
	}

select 查询和 Wrapper

BaseMapper 的 select 方法
1. selectById：根据 ID 查询
2. selectBatchIds：根据 ID 批量查询，即一次传递多个 ID
3. selectOne：根据构建的 Wrapper 条件查询数据，且只返回一个结果对象
4. selectCount：根据构建的 Wrapper 条件对象查询数据条数
根据id查询

@RunWith(SpringRunner.class)
@SpringBootTest
class Select0Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        UserBean userBean = simpleMapper.selectById(1);
        System.out.println(userBean);
    }
 
}

根据 ID 进行批量查询

@RunWith(SpringRunner.class)
@SpringBootTest
class Select1Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        List<Integer> ids = Arrays.asList(1, 2, 3);
        List<UserBean> userBeanList = simpleMapper.selectBatchIds(ids);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
    }
 
}

根据构建的 Wrapper 条件（根据ID查询用户信息）对象，使用 selectOne 查询数据，且只返回一个对象

@RunWith(SpringRunner.class)
@SpringBootTest
class Select8Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.le("user_id", 1);
        UserBean userBean = simpleMapper.selectOne(wrapper);
        System.out.println(userBean);
    }
 
}

使用 Wrapper 条件过滤数据获取数据总数，

@RunWith(SpringRunner.class)
@SpringBootTest
class Select9Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        // 统计年龄大于等于 28 岁的用户数
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.gt("age", 28);
        int count = simpleMapper.selectCount(wrapper);
        System.out.println("count=" + count);
    }
 
}

select 复杂和动态查询

在 BaseMapper 中，定义了如下四个方法：

// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

上诉方法给定的 Wrapper 查询条件或者 Map 对象返回结果列表，而且列表类型可以是实体、Map<String,Object>、Object。
根据 userId、姓名和年龄查询条件创建一个 Wrapper 条件对象，查询用户列表

@RunWith(SpringRunner.class)
@SpringBootTest
class Select2Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        query(1, null, null);
        query(1, "赫仑", null);
        query(1, "赫仑", 27);
    }
 
    private void query(int userId, String name, Integer age) {
    
    
        System.out.println("\n查询数据：");
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.eq("user_id", userId);
 
        // 第一个参数为是否执行条件，为true则执行该条件
        // 下面实现根据 name 和 age 动态查询
        wrapper.eq(StringUtils.isNotEmpty(name), "name", name);
        wrapper.eq(null != age, "age", age);
 
        List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
    }
 
}

使用 Map 作为查询条件参数

@RunWith(SpringRunner.class)
@SpringBootTest
class Select3Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        query(1, null, null);
        query(1, "赫仑", null);
        query(1, "赫仑", 27);
    }
 
    private void query(int userId, String name, Integer age) {
    
    
        System.out.println("\n查询数据：");
        Map<String,Object> map = new HashMap<>();
        map.put("user_id", userId);
 
        // 第一个参数为是否执行条件，为true则执行该条件
        // 下面实现根据 name 和 age 动态查询
        if(StringUtils.isNotEmpty(name)) {
    
    
            map.put("name", name);
        }
        if(null != age) {
    
    
            map.put("age", age);
        }
 
        List<UserBean> userBeanList = simpleMapper.selectByMap(map);
        for(UserBean userBean : userBeanList) {
    
    
            System.out.println(userBean);
        }
    }
 
}

动态 select 查询:在wrapper.eq(null != age, "age", age);”语句的第一个参数是一个布尔值。当该布尔值为 true 时，则将该条件应用到结果集中。类似 XML 文件的标签，等同于下面 Mapper XML

<if test="null != age">
    and age=#{
    
    age}
</if>

根据用户ID、用户名和年龄查询数据，如果用户名为空，则不使用名称进行查询；如果 age 为 null，则不使用 age 进行查询

private void query(int userId, String name, Integer age) {
    
    
    System.out.println("\n查询数据：");
    QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
    wrapper.eq("user_id", userId);
 
    // 第一个参数为是否执行条件，为true则执行该条件
    // 下面实现根据 name 和 age 动态查询
    wrapper.eq(StringUtils.isNotEmpty(name), "name", name);
    wrapper.eq(null != age, "age", age);
 
    List<UserBean> userBeanList = simpleMapper.selectList(wrapper);
    for(UserBean userBean : userBeanList) {
    
    
        System.out.println(userBean);
    }
}

select 分页查询

BaseMapper 中的分页查询方法
1. selectPage：根据 entity 条件，查询全部记录
2. selectMapsPage：根据 Wrapper 条件，查询全部记录
在使用上面两个方法进行分页查询是，需要配置分页插件，使用的是Spring Boot 项目，需要通过 @Configuration 和 @Bean 注解来添加配置
没有配置分页插件，则不会进行分页

@Configuration
public class MybatisPlusConfig {
    
    
 
    /**
     * 分页插件。如果你不配置，分页插件将不生效
     */
    @Bean
    public MybatisPlusInterceptor paginationInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 指定数据库方言为 MYSQL
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
 
}

使用 QueryWrapper 和 Page 作为参数进行分页

@RunWith(SpringRunner.class)
@SpringBootTest
class Select6Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("user_id");
 
        // 创建分页对象（1表示第一页；4表示每页大小为4）
        Page<UserBean> page = new Page<>(1, 4);
        Page<UserBean> result = simpleMapper.selectPage(page, wrapper);
        System.out.println("page == result: " + (page == result));
        System.out.println("size: " + result.getSize());
        System.out.println("total: " + result.getTotal());
        for(UserBean userBean : result.getRecords()) {
    
    
            System.out.println(userBean);
        }
    }
 
}

page 和 selectPage 返回的 result 相等，即两者是同一个对象，可以忽略掉 selectPage 方法的返回结果，

Page<UserBean> page = new Page<>(1, 4);
simpleMapper.selectPage(page, wrapper);

selectMapsPage 和上面的使用方法一样，仅仅是返回类型不一样

@RunWith(SpringRunner.class)
@SpringBootTest
class Select7Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        // 返回的结果类型为 Map<String,Object>
        Page<Map<String,Object>> page = new Page<>(1, 4);
        simpleMapper.selectMapsPage(page, null);
        System.out.println("size: " + page.getSize());
        System.out.println("total: " + page.getTotal());
        System.out.println("pages: " + page.getPages());
        for(Map<String,Object> map : page.getRecords()) {
    
    
            System.out.println(map);
        }
    }
 
}

insert 保存数据

BaseMapper 接口中定义了insert 方法，可以使用该方法保存数据到数据表

// 插入一条记录
int insert(T entity);

entity：一个实体对象需要使用 @TableName 和 @TableId 注解指明该实体对应那张表，其中哪个字段是ID字段

@TableName("user")
public class UserBean {
    
    
   @TableId
   private Integer userId;
   private String name;
   private String sex;
   private Integer age;
   private byte[] face;
   private Float salary;
   private Date borthday;
}

将UserBean 中的内容保存到数据库，且 insert 方法将返回影响数据库记录数。如果插入成功则返回 1，否则插入失败

@RunWith(SpringRunner.class)
@SpringBootTest
class Insert1Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        UserBean userBean = new UserBean();
        userBean.setUserId(999);
        userBean.setName("insert test");
        userBean.setAge(30);
        userBean.setSex("男");
        userBean.setFace("Hello World".getBytes());
        userBean.setBorthday(new Date());
 
        int result = simpleMapper.insert(userBean);
        System.out.println("result=" + result);
    }
 
}

update 更新数据

BaseMapper 接口中定义了两个 update 方法，
1. 一：根据 ID 更新数据，每次只更新一条数据（因为 ID 为主键，唯一）。
2. 二：根据 Wrapper 条件批量更新数据

// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

entity：实体对象，updateWrapper：构造更新数据条件
根据 ID 更新数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Update1Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        UserBean userBean = new UserBean();
        userBean.setUserId(999);
        userBean.setName("insert test update");
        userBean.setAge(40);
        userBean.setSex("女");
        userBean.setFace("welcome".getBytes());
        userBean.setBorthday(new Date());
 
        int result = simpleMapper.updateById(userBean);
        System.out.println("result=" + result);
    }
 
}

根据查询条件批量更新数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Update2Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        UpdateWrapper<UserBean> wrapper = new UpdateWrapper<>();
        wrapper.ge("age", 30); // 大于等于 30
 
        UserBean userBean = new UserBean();
        userBean.setAge(80);
        int result = simpleMapper.update(userBean, wrapper);
        System.out.println("result=" + result);
    }
 
}

delete 删除数据

BaseMapper 接口中定义了四个 delete 方法

// 根据 wrapper 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap)

参数说明：
1. wrapper：删除数据的 Wrapper 条件对象
2. idList：ID 列表，一次将指定的所有ID记录的数据删除
3. id：单条数据 ID
4. columnMap：Map 类型的条件对象
根据ID删除数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Delete1Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        int result = simpleMapper.deleteById(999);
        System.out.println("result=" + result);
    }
 
}

使用 Map 类型的条件删除数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Delete2Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        Map<String,Object> map = new HashMap<>();
        map.put("sex", "女");
        int result = simpleMapper.deleteByMap(map);
        System.out.println("result=" + result);
    }
 
}

根据 Wrapper 查询对象删除数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Delete3Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
        wrapper.le("age", 30); // 小于等于30
 
        int result = simpleMapper.delete(wrapper);
        System.out.println("result=" + result);
    }
 
}

一次性删除多个ID数据

@RunWith(SpringRunner.class)
@SpringBootTest
class Delete4Test {
    
    
 
    @Autowired
    private SimpleMapper simpleMapper;
 
    @Test
    void contextLoads() {
    
    
        List<Integer> ids = Arrays.asList(2, 4, 6, 7);
        int result = simpleMapper.deleteBatchIds(ids);
        System.out.println("result=" + result);
    }
 
}

文章目录

BaseMapper 接口简介

select 查询和 Wrapper

select 复杂和动态查询

select 分页查询

insert 保存数据

update 更新数据

delete 删除数据

猜你喜欢