留言首页
  • 当前位置：
    首页
    >
    编程社区
    >
    SpringBoot / Cloud
    > SpringBoot - MyBatis-Plus使用详解9（Service的CRUD接口1：基本查询）

    SpringBoot - MyBatis-Plus使用详解9（Service的CRUD接口1：基本查询）

    2020-05-18 发布：hangge 阅读：12077
        通常来说，我们会将具体的业务逻辑封装在 service 层中（一般会有个 interface 类以及具体的实现）。而 MyBatis-Plus 为我们提供了个 IService 接口，里面封装了通用 Service CRUD 操作。
    （1）为了避免混淆，Service 与 Mapper 的 CRUD 方法前缀有所区别：
    • Mapper 的方法前缀是：select（查询）、insert（插入）、update（更新）、delete（删除）
    • Service 的方法前缀是：get（查询单行）、list（查询集合）、page（分页查询）、save（插入）、update（更新）、remove（删除）
    （2）同时 Service 还提供了一些批量方法（批量插入、批量更新数据），这是 Mapper 没有的。

    九、Service 的 CRUD 接口1：基本查询

    1，准备工作

    （1）假设我们有如下用户信息表 user_info：

    （2）首先创建对应的实体类 UserInfo：
    @Data
public class UserInfo {
    private Integer id;
    private String userName;
    private String passWord;
    private Integer age;
}

    （3）接着创建 UserInfoMapper 接口，并继承 BaseMapper 接口，就可以使用 Mapper 的各种 CRUD 方法了。 
    public interface UserInfoMapper extends BaseMapper<UserInfo> {
}

    （4）最后我们继承 IService 创建 Serivice 接口，并创建对应的实现类，这样便可以使用 Servive 的各种 CRUD 方法了：

    • UserInfoService 接口代码如下： 
    public interface UserInfoService extends IService<UserInfo> {
}

    • UserInfoServiceImpl 实现类代码如下： 
    @Service("userInfoService")
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo>
        implements UserInfoService {
}

    2，getById（根据 id 查询一条记录） 

    @RestController
public class HelloController {

    @Autowired
    UserInfoService userInfoService;

    @RequestMapping("/test")
    public UserInfo test(){
        // 根据id查询数据
        UserInfo user = userInfoService.getById(1);
        return user;
    }
}

    3，getOne（使用查询构造器，查询一条记录）

        关于查询条件构造器（QueryWrapper、LambdaQueryWrapper、LambdaQueryChainWrapper）的详细用法可以参考我之前写的文章：
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询符合的单条记录（如果满足条件的记录有多条，那就不能用这个方法，会报错。）
UserInfo user = userInfoService.getOne(queryWrapper);

    • 前面编写完条件构造语句后需要要将对象传递给 service 的 getOne 方法，比较麻烦。我们同样可以通过链式的方式进行调用： 
    UserInfo user = userInfoService.lambdaQuery()
        .like(UserInfo::getUserName,"ha")
        .lt(UserInfo::getAge,40)
        .one();

    4，getMap（使用查询构造器，查询一条记录，返回的是 Map）

        getMap 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getMap 返回的是一个 Map，而不是实体类对象：
    注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询符合的单条记录（如果满足条件的记录有多条，那就不能用这个方法，会报错。）
Map<String, Object> user = userInfoService.getMap(queryWrapper);

    5，getObj（使用查询构造器，查询一条记录，返回这条记录的第一个字段值）

        getObj 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getObj 返回的是一个字段值（该方法第二个参数是转换函数，必填）： 
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询符合的单条记录的第一个字段值
Integer id = userInfoService.getObj(queryWrapper, (o) -> {
    return Integer.parseInt(o.toString());
});
System.out.println(id);

    6，listByIds（根据 ID 批量查询，返回一个 List）

    List<UserInfo> users = userInfoService.listByIds(Arrays.asList(1,2,3));

    7，listByMap（通过 Map 封装的条件查询，返回一个 List）

    注意：map 写的是数据表中的列名，而非实体类的属性名。比如属性名为 userName，数据表中字段为 user_name，这里应该写的是 user_name。
    Map<String,Object> columnMap = new HashMap<>();
columnMap.put("user_name", "hangge");
columnMap.put("age", 22);
List<UserInfo> users = userInfoService.listByMap(columnMap);

    8，list（使用查询构造器，返回一个 List）

    （1）list 方法如果参数为空，则查询所有的数据： 
    // 查询所有数据
List<UserInfo> users = userInfoService.list();

    （2）list 方法也可以传入查询条件构造器进行查询：
        关于查询条件构造器（QueryWrapper、LambdaQueryWrapper、LambdaQueryChainWrapper）的详细用法可以参考我之前写的文章：
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询
List<UserInfo> users = userInfoService.list(queryWrapper);

    • 前面编写完条件构造语句后需要要将对象传递给 service 的 list 方法，比较麻烦。我们同样可以通过链式的方式进行调用： 
    List<UserInfo> users = userInfoService.lambdaQuery()
        .like(UserInfo::getUserName,"ha")
        .lt(UserInfo::getAge,40)
        .list();

    9，listMaps（使用查询构造器，返回一个 List）

        listMaps 的用法和上面的 list 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 listMaps 返回的 List 里面是 Map。
        注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
    （1）listMaps 方法如果参数为空，则查询所有的数据： 
    List<Map<String, Object>> users = userInfoService.listMaps();
System.out.println(users);

    （2）listMaps 方法也可以传入查询条件构造器进行查询： 
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询
List<Map<String, Object>> users = userInfoService.listMaps(queryWrapper);

    10，listObjs（使用查询构造器，返回一个 List<object>）

        listObjs 的用法和前面的 list 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 listObjs 返回的 List 里面只有返每条结果的第一个字段值。
    （1）listObjs 方法如果参数为空，则查询所有的数据： 
    List<Object> users = userInfoService.listObjs();
System.out.println(users);

    • 我们还可以传入个自定义的转换函数： 
    List<Object> users = userInfoService.listObjs((o) -> {
    return "用户" + o.toString();
});

    （2）listObjs 方法也可以传入查询条件构造器进行查询： 
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询
List<Object> users = userInfoService.listObjs(queryWrapper);

    • 我们同样可以再传入个自定义的转换函数： 
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
// 开始查询
List<String> users = userInfoService.listObjs(queryWrapper,(o) -> {
    return "用户" + o.toString();
});

    11，count（使用查询构造器，查询总记录数）

    （1）count 方法如果参数为空，则查询所有数据的记录数： 
    Integer count = userInfoService.count();
System.out.println(count);

    （2）count 方法也可以传入查询条件构造器进行查询： 
    // 查询条件：名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<UserInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,"ha").lt(UserInfo::getAge,40);
//开始根据条件查询总记录
Integer count = userInfoService.count(queryWrapper);
System.out.println(count);

    附：添加自己定义的方法

    （1）假设我们 UserInfoService 接口中需要增加一个返回所有年轻人的方法： 
    public interface UserInfoService extends IService<UserInfo> {
    List<UserInfo> getAllYoungPeople();
}

    （2）对应的实现类 UserInfoServiceImpl 中内容如下。注意：由于该 Service 本身对应的 Mapper 就是 UserInfoMapper，我们直接使用 baseMapper 接口进行查询即可： 
    @Service("userInfoService")
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo>
        implements UserInfoService {
    public List<UserInfo> getAllYoungPeople() {
        return new LambdaQueryChainWrapper<>(baseMapper)
                .lt(UserInfo::getAge,40)
                .list();
    }
}

    （3）如果需要使用其他的 Mapper 的话，我们就需要先注入在使用了： 
    @Service("bookService")
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo>
        implements UserInfoService {

    @Resource
    private AreaMapper areaMapper;

    public List<UserInfo> getAllYoungPeople() {
        return new LambdaQueryChainWrapper<>(baseMapper)
                .lt(UserInfo::getAge,40)
                .list();
    }
}
    上一篇SpringBoot - MyBatis-Plus使用详解8（Mapper的CRUD接口5：增删改操作） 下一篇SpringBoot - MyBatis-Plus使用详解10（Service的CRUD接口2：分页查询）
    打赏支持
    评论（0）