MyBatis-Plus（九）Service的CRUD接口1：基本查询

本是古典何须时尚 2023-03-01 08:50 48阅读 0赞

# Service的CRUD接口1：基本查询 #

### 1、准备工作 ###

1.  假设我们有如下用户信息表 **user\_info**：

![在这里插入图片描述][20200723092700541.jpg]

1.  首先创建对应的实体类 **UserInfo**：

@Data
    public class UserInfo { 
        private Integer id;
        private String userName;
        private String passWord;
        private Integer age;
    }

1.  接着创建 **UserInfoMapper** 接口，并继承 **BaseMapper** 接口，就可以使用 **Mapper** 的各种 **CRUD** 方法了。

public interface UserInfoMapper extends BaseMapper<UserInfo> { }

1.  最后我们继承 **IService** 创建 **Service** 接口，并创建对应的实现类，这样便可以使用 **Service** 的各种 **CRUD** 方法了：

*  **UserInfoService** 接口代码如下：

public interface UserInfoService extends IService<UserInfo> { }

*  **UserInfoServiceImpl** 实现类代码如下：

@Service
    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（使用查询构造器，查询一条记录） ###

// 查询条件：名字中包含'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();

1.  **list** 方法也可以传入查询条件构造器进行查询：

*  前面编写完条件构造语句后需要要将对象传递给 **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);

1.  **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();
    });

1.  **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);

1.  **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);

### 12、添加自己定义的方法 ###

1.  假设我们 **UserInfoService** 接口中需要增加一个返回所有年轻人的方法：

public interface UserInfoService extends IService<UserInfo> { 
        List<UserInfo> getAllYoungPeople();
    }

1.  对应的实现类 **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();
        }
    }

1.  如果需要使用其他的 **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();
        }
    }

[点击跳转至原文地址][Link 1]

\--------------最后感谢大家的阅读，愿大家技术越来越流弊！--------------

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1phY2tfdHpo_size_16_color_FFFFFF_t_70]

\--------------也希望大家给我点支持，谢谢各位大佬了！！！--------------

[20200723092700541.jpg]: /images/20230209/6dab35c95b2643a196c1fa49ddd0ded7.png
[Link 1]: https://www.hangge.com/blog/cache/detail_2916.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1phY2tfdHpo_size_16_color_FFFFFF_t_70]: /images/20230209/7f4401d72c764b2f86b8c74b17bcb8ba.png