MyBatis Plus

Posted 2021-12-12 小企鹅推雪球!

文章目录

• • Service CRUD
  • Service 保存数据（save）
  • Service 保存或更新（saveOrUpdate）
  • Service 移除数据（remove）
  • Service 更新数据（update）

Service CRUD

1. MyBatis Plus 提供了通用的 Mapper 接口（即 BaseMapper 接口），该接口对应我们的 DAO 层
2. Mapper 接口中定义了我们常用的查询（select）、插入（insert）、更新（update）和删除（delete）操作。
3. 除了 BaseMapper 接口，MyBatis Plus 还提供了 IService 接口，该接口对应 Service 层。
4. MyBatis Plus 的通用 Service CRUD 实现了 IService 接口，进一步封装 CRUD。为了避免与 BaseMapper 中定义的方法混淆，该接口使用 get（查询单行）、remove（删除）、list（查询集合）和 page（分页）前缀命名的方式进行区别。
5. MyBatis Plus 使用 ServiceImpl 类实现 IService 接口，ServiceImpl 内部还是基于 BaseMapper 进行封装的

@SuppressWarnings("unchecked")
public class ServiceImpl<M extends BaseMapper<T>, T> implements IService<T> {
    protected Log log = LogFactory.getLog(getClass());
 
    @Autowired
    protected M baseMapper;
 
    @Override
    public M getBaseMapper() {
        return baseMapper;
    }
    // 忽略其他代码
}

Service 保存数据（save）

1. 使用 IServer 提供的 save 方法保存数据到数据库
2. IServer 接口 提供了如下三个 save 方法

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

3. 参数：
   1. entity：实体对象
   2. entityList：实体对象集合
   3. batchSize：插入批次数量，即每一个批次最大插入的数量
4. 保存单个实体到数据库，

@RunWith(SpringRunner.class)
@SpringBootTest
class Save1Test {
 
    @Autowired
    private UserService userService;
 
    @Test
    void contextLoads() {
        UserBean entity = new UserBean();
        entity.setUserId(9999);
        entity.setName("save-" + System.currentTimeMillis());
        entity.setSex("男");
        entity.setAge(40);
        entity.setBorthday(new Date());
        boolean flag = userService.save(entity);
        System.out.println("flag=" + flag);
    }
 
}

5. 一次保存多个实体到数据库

@RunWith(SpringRunner.class)
@SpringBootTest
class Save2Test {
 
    @Autowired
    private UserService userService;
 
    @Test
    void contextLoads() {
        List<UserBean> userBeanList = new ArrayList<>();
        userBeanList.add(new UserBean(9991, "name-9991", "女", 20));
        userBeanList.add(new UserBean(9992, "name-9992", "男", 30));
        userBeanList.add(new UserBean(9993, "name-9993", "男", 40));
        boolean flag = userService.saveBatch(userBeanList);
        System.out.println("flag=" + flag);
    }
 
}

6. 批量保存，将数据分成多个批次，每个批次数量为2

@RunWith(SpringRunner.class)
@SpringBootTest
class Save3Test {
 
    @Autowired
    private UserService userService;
 
    @Test
    void contextLoads() {
        List<UserBean> userBeanList = new ArrayList<>();
        userBeanList.add(new UserBean(9994, "name-9994", "女", 20));
        userBeanList.add(new UserBean(9995, "name-9995", "男", 30));
        userBeanList.add(new UserBean(9996, "name-9996", "女", 32));
        userBeanList.add(new UserBean(9997, "name-9997", "女", 29));
        userBeanList.add(new UserBean(9998, "name-9998", "男", 33));
        boolean flag = userService.saveBatch(userBeanList, 2);
        System.out.println("flag=" + flag);
    }
 
}

Service 保存或更新（saveOrUpdate）

1. IService 接口 提供了多个名为 saveOrUpdate 的方法

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

2. 参数说明：
   1. entity：实体对象
   2. updateWrapper：实体对象封装操作类 UpdateWrapper
   3. entityList：实体对象集合
   4. batchSize：插入批次数量
3. saveOrUpdate(T entity) 方法的实现代码

/**
 * TableId 注解存在更新记录，否插入一条记录
 *
 * @param entity 实体对象
 * @return boolean
 */
@Transactional(rollbackFor = Exception.class)
@Override
public boolean saveOrUpdate(T entity) {
    if (null != entity) {
        TableInfo tableInfo = TableInfoHelper.getTableInfo(this.entityClass);
        Assert.notNull(tableInfo, "error: can not execute. because can not find cache of TableInfo for entity!");
        String keyProperty = tableInfo.getKeyProperty();
        Assert.notEmpty(keyProperty, "error: can not execute. because can not find column for id from entity!");
        Object idVal = ReflectionKit.getFieldValue(entity, tableInfo.getKeyProperty());
        return StringUtils.checkValNull(idVal) || Objects.isNull(getById((Serializable) idVal)) ? save(entity) : updateById(entity);
    }
    return false;
}

4. 判断实体 @TableId 注解修饰的 ID 字段记录是否存在。如果不存在，则执行 save 方法，保存数据；如果存在，则执行 update 方法，更新数据。
5. 更新或新增单个实体，如果 ID 为 9991 的用户信息不存在，则新增用户信息；如果存在，则修改用户信息。

@RunWith(SpringRunner.class)
@SpringBootTest
class SaveOrUpdate1Test {
 
    @Autowired
    private UserService userService;
 
    @Test
    void contextLoads() {
        UserBean entity = new UserBean(9991, "name-update", "男", 40);
        boolean flag = userService.saveOrUpdate(entity);
        System.out.println("flag=" + flag);
    }
 
}

6. 根据 Wrapper 查询对象批量更新数据

@Test
void contextLoads() {
    UserBean entity = new UserBean();
    entity.setName("name-update");
 
    UpdateWrapper<UserBean> wrapper = new UpdateWrapper<>();
    wrapper.gt("user_id", 9992);
    wrapper.le("user_id", 9999);
 
    boolean flag = userService.saveOrUpdate(entity, wrapper);
    System.out.println("flag=" + flag);
}

7. 批量插入或更新数据

@Test
void contextLoads() {
    List<UserBean> userBeanList = new ArrayList<>();
    userBeanList.add(new UserBean(9992, "username-update"));
    userBeanList.add(new UserBean(9993, "username-update"));
    userBeanList.add(new UserBean(9994, "username-update"));
    boolean flag = userService.saveOrUpdateBatch(userBeanList);
    System.out.println("flag=" + flag);
}

8. 批量插入或更新数据，并且指定每个批次大小为 3

@Test
void contextLoads() {
    List<UserBean> userBeanList = new ArrayList<>();
    userBeanList.add(new UserBean(9992, "username-update"));
    userBeanList.add(new UserBean(9993, "username-update"));
    userBeanList.add(new UserBean(9994, "username-update"));
    userBeanList.add(new UserBean(9995, "username-update"));
    userBeanList.add(new UserBean(9996, "username-update"));
    userBeanList.add(new UserBean(9997, "username-update"));
    userBeanList.add(new UserBean(9998, "username-update"));
    userBeanList.add(new UserBean(9000, "username-save"));
    boolean flag = userService.saveOrUpdateBatch(userBeanList, 3);
    System.out.println("flag=" + flag);
}

Service 移除数据（remove）

1. IService 接口中 remove 方法用于删除数据

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

2. 参数
   1. queryWrapper：实体包装类 QueryWrapper
   2. id：主键ID
   3. columnMap：表字段 map 对象
   4. idList：主键ID列表
3. 根据 ID 删除数据

@Test
    void contextLoads() {
        boolean flag = userService.removeById(9991);
        System.out.println("flag=" + flag);
    }

4. 根据多个ID批量删除数据

@Test
void contextLoads() {
    List<Integer> ids = Arrays.asList(9000, 9992, 9993);
    boolean flag = userService.removeByIds(ids);
    System.out.println("flag=" + flag);
}

5. 根据 QueryWrapper 查询条件删除数据

@Test
void contextLoads() {
    QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
    wrapper.eq("name", "name-update");
    boolean flag = userService.remove(wrapper);
    System.out.println("flag=" + flag);
}

6. 根据 Map 条件对象删除数据

@Test
void contextLoads() {
    Map<String,Object> conditionMap = new HashMap<>();
    conditionMap.put("name", "username-update");
     
    boolean flag = userService.removeByMap(conditionMap);
    System.out.println("flag=" + flag);
}

Service 更新数据（update）

1. IService 中的 update 方法用于更新数据，可以根据 ID 进行单条数据更新，或者批量更新

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereEntity 条件，更新记录
boolean update(T entity, Wrapper<T> updateWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

2. 参数：
   1. updateWrapper：实体对象封装操作类 UpdateWrapper
   2. entity：实体对象
   3. entityList：实体对象集合
   4. batchSize：更新批次数量
3. 根据用户 ID 更新用户数据

@Test
    void contextLoads() {
        UserBean entity = new UserBean(11, "tom");
        boolean flag = userService.updateById(entity);
        System.out.println("flag=" + flag);
    }

4. 批量更新用户信息，依然根据用户ID进行更新（这里的用户ID即主键）

@Test
void contextLoads() {
    List<UserBean> entityList = new ArrayList<>();
    entityList.add( new UserBean(11, "name-update-11"));
    entityList.add( new UserBean(12, "name-update-12"));
    entityList.add( new UserBean(13, "name-update-13"));
    entityList.add( new UserBean(14, "name-update-14"));
 
    boolean flag = userService.updateBatchById(entityList);
    System.out.println("flag=" + flag);
}

5. 根据 UpdateWrapper 对象构建的条件进行更新

@Test
void contextLoads() {
    UpdateWrapper<UserBean> wrapper = new UpdateWrapper<>();
    wrapper.ge("user_id", 11);
    wrapper.le("user_id", 14);
 
    UserBean entity = new UserBean();
    entity.setName("name-" + System.currentTimeMillis());
 
    boolean flag = userService.update(entity, wrapper);
    System.out.println("flag=" + flag);
}