五，MyBatis-Plus 当中的 “ActiveRecord模式”和“SimpleQuery工具类”（详细实操）

@

目录

• 五，MyBatis-Plus 当中的 “ActiveRecord模式”和“SimpleQuery工具类”（详细实操）
• 1. ActiveRecord 模式
• 2. ActiveRecord介绍
  • 2.1 ActiveRecord实现
• 3. SimpleQuery 工具类
  • 3.1 SimpleQuery介绍
  • 3.2 list
  • 3.3 map
  • 3.4 Group
• 4. 最后：

1. ActiveRecord 模式

2. ActiveRecord介绍

ActiveRecord(活动记录，简称AR)，是一种领域模型模式，特点是一个模型类对应关系型数据库中的一个表，而模型类的一个实例对应表中的一行记录。ActiveRecord，一直广受解释型动态语言（PHP，Ruby 等）的喜爱，通过围绕一个数据对象进行 CRUD 操作。而Java作为准静态(编译型语言)，对于 ActiveRecord 往往只能感叹其优雅，所以 MP 也在 AR 道路上进行了一定的探索，仅仅需要让实体类继承 Model 类且实现主键指定方法，即可开启 AR 之旅。

2.1 ActiveRecord实现

接下来我们来看一下ActiveRecord的实现步骤

想要使用 ActiveRecord 模式，就需要让对应的实体类(Java Bean) extends(继承) Model 类。

我们可以看到，Model 类中提供了一些增删改查方法，这样的话我们就可以直接使用实体类对象调用这些增删改查方法了，简化了操作的语法，但是他的底层依然是需要 UserMapper 的，所以持久层接口不能省略。

测试 ActiveRecord 模式的增删改查。

添加数据

<code>import com.rainbowsea.bean.User;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class ActiveRecordTest {

//public class User extends Model<User>, 需要继承 extends Model<User>

// 添加操作

@Test

void activeRecordAdd() {

User user = new User();

user.setName("zhang");

user.setAge(28);

user.setEmail("zhang@rainbowsea.com");

user.insert();

}

}

删除数据

<code>

import com.rainbowsea.bean.User;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class ActiveRecordTest {

//public class User extends Model<User>, 需要继承 extends Model<User>

// 删除操作

@Test

void activeRecordDelete() {

User user = new User();

user.setId("1837781440184680449");

user.deleteById();

}

}

修改数据

<code>

import com.rainbowsea.bean.User;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class ActiveRecordTest {

//public class User extends Model<User>, 需要继承 extends Model<User>

// 修改操作

@Test

void activeRecordUpdate() {

User user = new User();

user.setId("3");

user.setAge(1);

user.updateById();

}

}

查询数据

<code>

import com.rainbowsea.bean.User;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class ActiveRecordTest {

//public class User extends Model<User>, 需要继承 extends Model<User>

// 查询操作

@Test

void activeRecordSelect() {

User user = new User();

user.setId("7");

User result = user.selectById();

System.out.println(result);

}

}

3. SimpleQuery 工具类

3.1 SimpleQuery介绍

SimpleQuery 可以对 selectList 查询后的结果用 Stream 流进行了一些封装，使其可以返回一些指定结果，简洁了 api 的调用。

3.2 list

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testList() {

List<String> list = SimpleQuery.list(new LambdaQueryWrapper<User>().eq(User::getName, "Mary"), User::getId);

System.out.println(list);

}

}

对于封装后的字段进行 lambda 操作。

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testList2() {

List<String> list = SimpleQuery.list(new LambdaQueryWrapper<User>().eq(User::getName, "Mary"), User::getName,

new Consumer<User>() {

@Override

public void accept(User user) {

Optional.of(user.getName()).map(String::toLowerCase).ifPresent(user::setName);

}

});

System.out.println(list);

}

}

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

// 使用lab表达式

@Test

void testList3() {

List<String> list = SimpleQuery.list(new LambdaQueryWrapper<User>().eq(User::getName, "Mary"), User::getName,

user -> Optional.of(user.getName()).map(String::toLowerCase).ifPresent(user::setName));

System.out.println(list);

}

}

3.3 map

将所有的对象以id,实体的方式封装为Map集合

、

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testMap() {

Map<String, User> map = SimpleQuery.keyMap(new LambdaQueryWrapper<User>(), User::getId);

System.out.println(map);

}

}

将单个对象以id,实体的方式封装为Map集合

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testMap2() {

Map<String, User> map = SimpleQuery.keyMap(new LambdaQueryWrapper<User>().eq(User::getId, 1L), User::getId);

System.out.println(map);

}

}

只想要 id 和 name 组成的 map

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testMap3() {

Map<String, String> map = SimpleQuery.map(new LambdaQueryWrapper<User>(), User::getId, User::getName);

System.out.println(map);

}

}

3.4 Group

Group 就是简单的分组效果。

<code>

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.toolkit.SimpleQuery;

import com.rainbowsea.bean.User;

import com.rainbowsea.mapper.UserMapper;

import org.junit.jupiter.api.Test;

import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.Consumer;

@SpringBootTest

public class SimpleQueryTest {

@Resource

private UserMapper userMapper;

@Test

void testGroup() {

Map<String, List<User>> map = SimpleQuery.group(new LambdaQueryWrapper<User>(), User::getName);

System.out.println(map);

}

}

4. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”