mybatisplus-join与mybatis-plus

mybatisplus-join是什么框架？和mybatisplus有什么差别？

Mybatis-plus-join 是一款用于简化 Mybatis-Plus 复杂关联查询的框架。Mybatis-Plus 是一个 Mybatis 的增强工具，在 Mybatis 的基础上进行了封装，提供了更加便捷的 CRUD 操作和强大的代码生成能力。而 Mybatis-plus-join 则是在 Mybatis-Plus 的基础上增加了复杂关联查询的功能。

Mybatis-plus-join 主要的特点是：

- 支持多表联查；
- 支持链式调用，提高代码可读性；
- 支持实体类关联查询，无需手写 SQL，减少出错率；
- 支持自定义关联条件，满足各种需求。

总的来说，Mybatis-plus-join 是 Mybatis-Plus 的补充，为其增加了复杂关联查询的能力，使得开发者可以更加方便地进行 SQL 查询操作。

举例：

好的，假设我们有两张表，一张是用户表，另外一张是订单表。它们之间的关系是一对多，即一个用户可以有多个订单。现在我们需要查询用户信息以及他们的订单信息，我们可以使用 Mybatis-Plus 的 Wrapper 来实现。

Mybatis-Plus 的代码如下：

```java
QueryWrapper<User> userWrapper = new QueryWrapper<>();
userWrapper.eq("user_name", "Tom");

QueryWrapper<Order> orderWrapper = new QueryWrapper<>();
orderWrapper.eq("status", "paid");

List<User> userList = userService.list(userWrapper);
List<Order> orderList = orderService.list(orderWrapper);

Map<Long, List<Order>> orderMap = orderList.stream().collect(Collectors.groupingBy(Order::getUserId));

for (User user : userList) {
    List<Order> orders = orderMap.get(user.getId());
    user.setOrders(orders);
}

return userList;
```

使用 Mybatis-Plus-join 的代码如下：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(Order.class, JoinType.LEFT)
       .eq(Order::getStatus, "paid");

List<User> userList = userService.joinSelect(wrapper);

return userList;
```

可以看到，Mybatis-Plus-join 的代码比 Mybatis-Plus 的代码更加简洁易懂，而且使用了实体类关联查询，不需要手写 SQL，提高了代码的可读性和可维护性。

假如我想让其返回对应的vo对象呢？

如果你想让 Mybatis-plus-join 返回对应的 VO 对象，你可以在查询语句中使用 `select` 方法，指定需要查询的字段，并把结果映射到对应的 VO 类中。

例如，我们可以定义一个名为 `UserVO` 的 VO 类，它包含了用户的 id、name 和 email 字段。我们可以使用以下代码来查询用户信息以及他们的订单信息，并将结果映射到 `UserVO` 中：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(Order.class, JoinType.LEFT)
       .eq(Order::getStatus, "paid")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("order.id as orderId", "order.amount as amount");

List<UserVO> userVOList = userService.joinSelect(wrapper, UserVO.class);

return userVOList;
```

在 `select` 方法中，我们指定了需要查询的字段，并使用 `as` 关键字将字段别名为我们定义的 VO 类中对应的字段名。然后，我们将查询结果映射到 `UserVO` 类中，并返回一个 `UserVO` 类型的列表。

如果你想让 Mybatis-plus-join 返回对应的 VO 对象，你可以在查询语句中使用 `select` 方法，指定需要查询的字段，并把结果映射到对应的 VO 类中。

例如，我们可以定义一个名为 `UserVO` 的 VO 类，它包含了用户的 id、name 和 email 字段。我们可以使用以下代码来查询用户信息以及他们的订单信息，并将结果映射到 `UserVO` 中：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(Order.class, JoinType.LEFT)
       .eq(Order::getStatus, "paid")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("order.id as orderId", "order.amount as amount");

List<UserVO> userVOList = userService.joinSelect(wrapper, UserVO.class);

return userVOList;
```

在 `select` 方法中，我们指定了需要查询的字段，并使用 `as` 关键字将字段别名为我们定义的 VO 类中对应的字段名。然后，我们将查询结果映射到 `UserVO` 类中，并返回一个 `UserVO` 类型的列表。

好的，以下是一个可能的 `UserVO` 类的定义：

```java
public class UserVO {
    private Long id;
    private String name;
    private String email;
    private List<OrderVO> orders;

    // 省略 getter 和 setter 方法
}

public class OrderVO {
    private Long id;
    private BigDecimal amount;

    // 省略 getter 和 setter 方法
}
```

在 `UserVO` 类中，我们定义了需要返回的用户字段，以及一个名为 `orders` 的订单列表。`OrderVO` 则是一个辅助类，用于表示订单信息。

然后，我们可以使用以下代码来查询用户信息以及他们的订单信息，并将结果映射到 `UserVO` 中：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(Order.class, JoinType.LEFT)
       .eq(Order::getStatus, "paid")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("order.id as orders.id\ "order.amount as orders.amount");

List<UserVO> userVOList = userService.joinSelect(wrapper, UserVO.class);

return userVOList;
```

在 `select` 方法中，我们使用 `as` 关键字将订单表中的 id 和 amount 字段别名为 `orders.id` 和 `orders.amount`，以便能够将它们映射到 `UserVO` 类的 `orders` 列表中的 `id` 和 `amount` 字段。然后，我们将查询结果映射到 `UserVO` 类中，并返回一个 `UserVO` 类型的列表。

需要注意的是，如果你使用了实体类关联查询，那么在 `JoinWrapper` 中的实体类必须包含对应的关联属性，例如，在 `User` 类中必须包含一个名为 `orders` 的订单列表属性。

假如是一对一的关系呢？可以直接在vo对象直接写属性值而不嵌套对象嘛？

是的，如果是一对一的关系，你可以直接在 VO 对象中定义对应的属性，而不需要嵌套对象。

例如，如果我们有一个名为 `User` 的实体类，它包含一个名为 `profile` 的用户信息表，它们之间是一对一的关系。我们可以定义一个名为 `UserVO` 的 VO 类，它包含了用户的 id、name、email 和 profile 相关的字段。我们可以使用以下代码来查询用户信息以及他们的用户信息，并将结果映射到 `UserVO` 中：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(UserProfile.class, JoinType.LEFT)
       .eq(UserProfile::getGender, "male")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("user_profile.age as age", "user_profile.gender as gender",
               "user_profile.address as address");

List<UserVO> userVOList = userService.joinSelect(wrapper, UserVO.class);

 

好的，以下是一个可能的 `UserVO` 类的定义：

```java
public class UserVO {
    private Long id;
    private String name;
    private String email;
    private Integer age;
    private String gender;
    private String address;

    // 省略 getter 和 setter 方法
}
```

在 `UserVO` 类中，我们定义了需要返回的用户字段，包括 id、name、email、age、gender 和 address 字段。这些字段都是直接映射到实体类或关联表中的字段，而不需要嵌套对象。

然后，我们可以使用以下代码来查询用户信息以及他们的用户信息，并将结果映射到 `UserVO` 中：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(UserProfile.class, JoinType.LEFT)
       .eq(UserProfile::getGender, "male")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("user_profile.age as age", "user_profile.gender as gender",
              

假如我要返回map呢？

如果你想将查询结果转换为 Map 类型，可以使用 `joinSelectMaps` 方法。这个方法和 `joinSelect` 方法的用法基本相同，不同的是它返回一个 List<Map<String, Object>> 类型的结果，其中每个 Map 表示一条记录，键表示字段名，值表示字段值。

例如，我们可以使用以下代码来查询用户信息以及他们的订单信息，并将结果转换为 Map 类型：

```java
JoinWrapper<User> wrapper = new JoinWrapper<>(User.class);
wrapper.eq("user_name", "Tom")
       .leftJoin(Order.class, JoinType.LEFT)
       .eq(Order::getStatus, "paid")
       .select("user.id as id", "user.name as name", "user.email as email")
       .select("order.id as orderId", "order.amount as amount");

List<Map<String, Object>> resultMapList = userService.joinSelectMaps(wrapper);

return resultMapList;
```

在这个例子中，我们使用 `joinSelectMaps` 方法来查询用户信息以及他们的订单信息，并将结果转换为 Map 类型。由于返回的是一个 List<Map<String,