还在用MyBatis写CRUD?这款神器帮你5分钟写后台管理

发表于

一、MyBatis回顾

1.1、回顾MyBatis

1.1.1、建库建表

1
2
3
4
5
6
mysql复制代码CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

1.1.2、引入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
xml复制代码<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>
 
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

1.1.3、application.properties

1
2
3
4
properties复制代码spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql:///db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
spring.datasource.druid.username=root
spring.datasource.druid.password=123456

1.1.4、编写Mapper接口

1
2
3
java复制代码public interface UserMapper {
    List<Employee> selectAll();
}

1.1.5、编写Mapper.xml

1
2
3
4
xml复制代码  <select id="selectAll" resultMap="BaseResultMap">
    select id,username,password
    from user
  </select>

1.1.6、MyBatis存在的缺点

我们可以发现传统的MyBatis存在很致命的问题，每个实体表对应一个实体类，对应一个Mapper.java接口，对应一个Mapper.xml配置文件每个Mapper.java接口都有重复的crud方法，每一个Mapper.xml都有重复的crud的sql配置。如果想解决这个问题，**唯一的办法就是使用MyBatis-Plus**。

二、了解Mybatis-Plus

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

image-20210402092420460

2.1、代码以及文档

文档地址：mybatis.plus/guide/
源码地址：github.com/baomidou/my…

2.2、特性

  1. 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。
  2. 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作。
  3. 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求。
  4. 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错。
  5. 支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多种数据库。
  6. 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题。
  7. 支持 XML 热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动。
  8. 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操
    作。
  9. 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）。
  10. 支持关键词自动转义：支持数据库关键词（order、key……）自动转义，还可自定义关键词。
  11. 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，
    支持模板引擎，更有超多自定义配置等您来使用。
  12. 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List查询。
  13. 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询。
  14. 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作。
  15. 内置 Sql 注入剥离器：支持 Sql 注入剥离，有效预防 Sql 注入攻击。

2.3、快速开始

2.3.1、导入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
xml复制代码<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
      <exclusion>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <!--简化代码的工具包-->
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
  </dependency>
  <!--mybatis-plus的springboot支持-->
  <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.1</version>
  </dependency>
  <!--mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
  </dependency>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
  </dependency>

2.3.2、log4j.properties

1
2
3
4
properties复制代码og4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

2.3.3、编写实体类

1
2
3
4
5
6
7
8
9
java复制代码@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
  private Integer id;
  private String username;
  private String password;
  private String type;
}

2.3.4、编写mapper

1
2
3
java复制代码// 直接继承Myabtis-Plus的BaseMapper即可，泛型表示实体类
public interface UserMapper extends BaseMapper<User> {
}

2.3.5、编写启动类

1
2
3
4
5
6
7
8
java复制代码@SpringBootApplication
// 设置mapper接口扫描包
@MapperScan("cn.linstudy.mapper")
public class DemoApplication {
  public static void main(String[] args) {
    SpringApplication.run(DemoApplication.class, args);
  }
}

2.3.6、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
  @Autowired
  private UserMapper userMapper;
  @Test
  public void testSelect() {
    List<User> userList = userMapper.selectList(null);
    for (User user : userList) {
      System.out.println(user);
    }
  }
}

2.4、架构

image-20210406113556258

三、常用注解

3.1、@TableName

MyBatis-Plus中默认表名是跟实体类名一致，当我们实体类的类名和表名不一致的时候，MyBatis-Plus就会报错，但是我们实际上又有这种需求的时候，我们就需要使用`@TableName`这个注解，来指定当前实体类映射哪张数据库表。
1
2
3
4
5
6
7
8
9
10
java复制代码@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User {
  private Integer id;
  private String username;
  private String password;
  private String type;
}

3.2、@TableId

我们在使用insert方法的时候会发现一个很奇怪的现象。他生成的ID格外长，这是因为他使用的算法是使用雪花算法生成的ID，我们想要的是自增的ID，所以我们需要设置主键增长的策略。

image-20210406154041215
我们可以使用@TableId这个注解。他的作用是主键注解，标记当前属性映射表的主键，其中type是属性指定的主键类型，他有这几个值：

  1. IdType.AUTO：数据库ID自增。
  2. IdType.NONE：无状态,该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)。
  3. IdType.INPUT：insert前自行set主键值。
  4. IdType.ASSIGN_ID：分配ID(主键类型为Number(Long和Integer)或String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法)。
  5. 分配UUID,主键类型为String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认default方法)

3.3、@TableField

我们有些时候，数据库的字段名和实体类的名字可能会不一样，或者是说实体类中有的字段而数据库中却没有，我们需要用`@TableField`这个注解。
`@TableField`注解用于标记非主键字段，他的作用是指定当前属性映射数据库表哪一列， 默认是跟属性名一致。常用于解决以下两个问题：
  1. 对象中的属性名和字段名不一致的问题（非驼峰）
  2. 对象中的属性字段在表中不存在的问题

image-20210426183433467
他还有另一种用法，就是指定某个字段不加入查询。

image-20210426183636523

image-20210426183720166

四、通用CRUD

我们之前学过，使用MyBatis-Plus的时候，Mapper接口里面的方法不需要我们再自己写了，只需要继承BaseMapper接口即可获取到各种各样的单表操作。

image-20210426184057266

4.1、插入操作

4.1.1、方法定义

MyBatis-Plus中对于insert的方法定义是：
1
2
3
4
5
6
java复制代码/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);

4.1.2、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
java复制代码package cn.linstudy.test

import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

  @Autowired
  private UserMapper userMapper;

  @Test
  public void testInsert() {
    User user = new User();
    user.setAge(20);
    user.setEmail("test@itcast.cn");
    user.setName("曹操");
    user.setUserName("caocao");
    user.setPassword("123456");
    int result = this.userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
    System.out.println("result = " + result);
    System.out.println(user.getId()); //自增后的id会回填到对象中
  }
}

4.2、更新操作

4.2.1、updateById

4.2.1.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);

4.2.1.2、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
java复制代码

	// 需求： 将id=1用户名字修改为xiaolin

    @Test

    public void testUpdateById(){

        Employee employee = new Employee();
        employee.setId(1L);
        employee.setName("xiaolin");
        employeeMapper.updateById(employee);

    }

	// 注意： 拼接sql时，所有非null 字段都进行set 拼接

	// UPDATE employee SET name=?, age=?, admin=? WHERE id=?

	// 改进的方法是先查，再替换，最后更新

	// 需求： 将id=1用户名字修改为xiaolin

    @Test

    public void testUpdateById2(){

        Employee employee = employeeMapper.selectById(1L);

        employee.setName("xiaolin");

        employeeMapper.updateById(employee);

    }

4.2.2、update

4.2.2.1、方法定义

1
2
3
4
5
6
7
8
java复制代码  /**
   * 根据 whereEntity 条件，更新记录
   *
   * @param entity        实体对象 (set 条件值,可以为 null)
   * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
   */
  int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T>
      updateWrapper);

4.2.2.2、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
java复制代码public class UserMapperTest {

  @Autowired
  private UserMapper userMapper;

  // 方法一：使用QueryWrapper
  @Test
  public void testUpdate() {
    User user = new User();
    user.setAge(22); //更新的字段
	//更新的条件
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("id", 6);
	//执行更新操作
    int result = this.userMapper.update(user, wrapper);
    System.out.println("result = " + result);
  }
    
   //方法二： 通过UpdateWrapper进行更新
    @Test
	public void testUpdate(){
		//更新的条件以及字段
    	UpdateWrapper<User> wrapper=new UpdateWrapper<>();
    	wrapper.eq("id",6).set("age",23);
		//执行更新操作
    	int result=this.userMapper.update(null,wrapper);
    	System.out.println("result = "+result);
    }
}

4.2.2.3、使用建议

  1. 知道id，并且所有更新使用updateById
  2. 部分字段更新，使用update

4.3、删除操作

4.3.1、deleteById

4.3.1.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);

4.3.1.2、测试

1
2
3
4
5
6
java复制代码@Test
public void testDeleteById() {
	//执行删除操作
	int result = this.userMapper.deleteById(6L);
	System.out.println("result = " + result);
}

4.3.2、deleteByMap

4.3.2.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

4.3.2.2、测试

1
2
3
4
5
6
7
8
9
java复制代码@Test
public void testDeleteByMap() {
	Map<String, Object> columnMap = new HashMap<>();
	columnMap.put("age",20);
	columnMap.put("name","张三");
	//将columnMap中的元素设置为删除的条件，多个之间为and关系
	int result = this.userMapper.deleteByMap(columnMap);
	System.out.println("result = " + result);
}

4.3.3、delete

4.3.3.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

4.3.3.2、测试

1
2
3
4
5
6
7
8
9
10
java复制代码@Test
public void testDeleteByMap() {
	User user = new User();
	user.setAge(20);
	user.setName("张三");
	//将实体对象进行包装，包装为操作条件
	QueryWrapper<User> wrapper = new QueryWrapper<>(user);
	int result = this.userMapper.delete(wrapper);
	System.out.println("result = " + result);
}

4.3.4、deleteBatchIds

4.3.4.1、方法定义

1
2
3
4
5
6
7
java复制代码/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);

4.3.4.2、测试

1
2
3
4
5
6
java复制代码@Test
public void testDeleteByMap() {
	//根据id集合批量删除
	int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
	System.out.println("result = " + result);
}

4.4、查询操作

MyBatis-Plus提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。

4.4.1、selectById

4.4.1.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);

4.1.1.2、测试

1
2
3
4
5
6
java复制代码@Test
public void testSelectById() {
	//根据id查询数据
	User user = this.userMapper.selectById(2L);
	System.out.println("result = " + user);
}

4.4.2、selectBatchIds

4.4.2.1、方法定义

1
2
3
4
5
6
7
java复制代码/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);

4.2.2.2、测试

1
2
3
4
5
6
7
8
java复制代码@Test
public void testSelectBatchIds() {
	//根据id集合批量查询
	List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
	for (User user : users) {
	System.out.println(user);
	}
}

4.4.3、selectOne

4.4.3.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

4.4.3.2、测试

1
2
3
4
5
6
7
8
java复制代码@Test
public void testSelectOne() {
	QueryWrapper<User> wrapper = new QueryWrapper<User>();
	wrapper.eq("name", "李四");
	//根据条件查询一条数据，如果结果超过一条会报错
	User user = this.userMapper.selectOne(wrapper);
    System.out.println(user);
}

4.4.4、selectCount

4.4.4.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

4.4.4.2、测试

1
2
3
4
5
6
7
java复制代码@Test
public void testSelectCount() {
	QueryWrapper<User> wrapper = new QueryWrapper<User>();
	wrapper.gt("age", 23); //年龄大于23岁
    Integer count = this.userMapper.selectCount(wrapper);
	System.out.println("count = " + count);
}

4.4.5、selectList

4.4.5.1、方法定义

1
2
3
4
5
6
java复制代码/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

4.4.5.2、测试

1
2
3
4
5
6
7
8
9
10
java复制代码@Test
public void testSelectList() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
    //根据条件查询数据
	List<User> users = this.userMapper.selectList(wrapper);
	for (User user : users) {
	System.out.println("user = " + user);
	}
}

4.4.6、selectPage

4.4.6.1 方法定义

1
2
3
4
5
6
7
java复制代码/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

4.4.6.2、配置分页插件

1
2
3
4
5
6
7
8
9
10
11
java复制代码@Configuration
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
	}
}

4.4.6.3、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
java复制代码@Test
public void testSelectPage() {
	QueryWrapper<User> wrapper = new QueryWrapper<User>();
	wrapper.gt("age", 20); //年龄大于20岁
	Page<User> page = new Page<>(1,1);
	//根据条件查询数据
	IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
	System.out.println("数据总条数：" + iPage.getTotal());
	System.out.println("总页数：" + iPage.getPages());
	List<User> users = iPage.getRecords();
	for (User user : users) {
	System.out.println("user = " + user);
	}
}

4.4.7、SQL注入原理

MP在启动后会将BaseMapper中的一系列的方法注册到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么样的？


在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，AbstractSqlInjector是它的实现类，实现关系如下：

image-20210428142720554

在AbstractSqlInjector中，主要是由inspectInject()方法进行注入的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
java复制代码@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?>
mapperClass) {
	Class<?> modelClass = extractModelClass(mapperClass);
	if (modelClass != null) {
		String className = mapperClass.toString();
		Set<String> mapperRegistryCache =
		GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
	if (!mapperRegistryCache.contains(className)) {
		List<AbstractMethod> methodList = this.getMethodList();
		if (CollectionUtils.isNotEmpty(methodList)) {
			TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant,
modelClass);
			// 循环注入自定义方法
			methodList.forEach(m -> m.inject(builderAssistant, mapperClass,
modelClass, tableInfo));
		} else {	
            logger.debug(mapperClass.toString() + ", No effective injection method
was found.");
			}
			mapperRegistryCache.add(className);
		}
	}
}

image-20210428164123430

以SelectById为例查看：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码public class SelectById extends AbstractMethod {
	@Override
	public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?>
modelClass, TableInfo tableInfo) {
		SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
		SqlSource sqlSource = new RawSqlSource(configuration,
String.format(sqlMethod.getSql(),
		sqlSelectColumns(tableInfo, false),
		tableInfo.getTableName(), tableInfo.getKeyColumn(),
		tableInfo.getKeyProperty(),
		tableInfo.getLogicDeleteSql(true, false)), Object.class);
		return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(),
sqlSource, modelClass, tableInfo);
	}
}
可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。

image-20210428164932955

五、条件构造器

条件构造器可以简单理解为条件拼接对象，用于生成 sql 的 where 条件。

5.1、继承体系

在MyBatis-Plus中，Wrapper接口的实现类关系如下：

image-20210428172222929

  1. AbstractWrapper： 用于查询条件封装，生成 sql 的 where 条件。
  2. QueryWrapper： Entity 对象封装操作类，不是用lambda语法。
  3. UpdateWrapper： Update 条件封装，用于Entity对象更新操作。
  4. AbstractLambdaWrapper： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
  5. LambdaQueryWrapper：看名称也能明白就是用于Lambda语法使用的查询Wrapper。
  6. LambdaUpdateWrapper： Lambda 更新封装Wrapper。

5.2、更新操作

5.2.1、普通更新

1
2
3
4
5
6
7
java复制代码@Test
    public void testUpdate(){
        Employee employee = new Employee();
        employee.setId(1L);
        employee.setName("xiaolin");
        employeeMapper.updateById(employee);
    }
这种更新会导致数据的丢失，因为我只想更新部分的字段。

5.2.2、UpdateWrapper更新

5.2.2.1、set

如果说我们需要更新部分的字段可以选择UpdateWrapper进行更新。他的方法主要是有两个：
  1. set(String column, Object val)
  2. set(boolean condition, String column, Object val)
1
2
3
4
5
6
7
8
9
10
java复制代码// 需求：将id=1的员工name改为xiaolin
	@Test
    public void testUpdate2(){
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 1L);
        // 相当于sql语句中的set name = xiaolin
        wrapper.set("name", "xiaolin");
        employeeMapper.update(null, wrapper);

    }

5.2.2.2、

MyBatis-Plus还提供了另一种方式来修改，那就是可以利用setSql直接写入sql语句。
1
2
3
4
5
6
7
8
9
java复制代码	// 需求：将id=1的用户name改为xiaolin 
	@Test
    public void testUpdate3(){
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 1L);
        wrapper.setSql("name='xiaolin'");
        employeeMapper.update(null, wrapper);

    }

5.2.3、LambdaUpdateWrapper更新

我们还可以利用JDK8的新语法配合LambdaUpdateWrapper来进行操作。
1
2
3
4
5
6
7
8
java复制代码   // 需求：将id=1的用户name改为xiaolin 
   @Test
    public void testUpdate4(){
        LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Employee::getId, 1L);
        wrapper.set(Employee::getName, "xiaolin");
        employeeMapper.update(null, wrapper);
    }

5.2.4、开发建议

推荐使用LambdaUpdateWrapper更新。

5.3、查询操作

5.3.1、普通查询

1
2
3
4
5
6
7
8
9
java复制代码  // 需求：查询name=xiaolin， age=18的用户
    @Test
    public void testQuery1(){
        Map<String, Object> map = new HashMap<>();
        map.put("name", "xiaolin");
        map.put("age", 18);
        System.out.println(employeeMapper.selectByMap(map));

    }

5.3.2、QueryWrapper查询

1
2
3
4
5
6
7
java复制代码  // 需求：查询name=xiaolin， age=18的用户
    @Test
    public void testQuery2(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "xiaolin").eq("age", 18);
        System.out.println(employeeMapper.selectList(wrapper));
    }

5.3.3、LambdaQueryWrapper查询

1
2
3
4
5
6
7
8
java复制代码  //需求：查询name=xiaolin， age=18的用户
    @Test
    public void testQuery3(){
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Employee::getName, "xiaolin").eq(Employee::getAge, 18);
        System.out.println(employeeMapper.selectList(wrapper));

    }

5.3.4、开发建议

推荐使用LambdaUpdateWrapper更新

5.4、高级查询

5.4.1、列投影

所谓的烈投影就是指定查询后返回的列。我们利用的是select方法进行实现的。他有三个重载方法：
  1. select(String… sqlSelect) ：参数是指定查询后返回的列。
  2. select(Predicate predicate)：参数是Predicate 函数，满足指定判定逻辑列才返回。
  3. select(Class entityClass, Predicate predicate)：参数1是通过实体属性映射表中列，参数2是Predicate 函数， 满足指定判定逻辑列才返回。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
java复制代码  // 需求：查询所有员工， 返回员工name， age列
    @Test
    public void testQuery4(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.select("name", "age");
        employeeMapper.selectList(wrapper);

    }

  // 需求：查询所有员工， 返回员工以a字母开头的列
    @Test
    public void testQuery4(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.select(Employee.class, tableFieldInfo->tableFieldInfo.getProperty().startsWith("a"));
        employeeMapper.selectList(wrapper);

    }

5.4.2、排序

5.4.2.1、orderByAsc/orderByDesc

排序分为两种，等价SQL: select ..from table **ORDER BY 字段, ... ASC**;
  1. orderByAsc： 正序排序。
  2. orderByDesc：倒序排序。
1
2
3
4
5
6
7
8
java复制代码  // 需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
    @Test
    public void testQuery5(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("age", "id");
        employeeMapper.selectList(wrapper);

    }

5.4.2.2、orderBy

如果官方写好的排序不适用于我们的话，我们可以使用定制排序-order by。等价SQL：**select ..from table ORDER BY 字段**;


`orderBy(boolean condition, boolean isAsc, R... columns)`：参数1：控制是否进行排序，参数2：控制是不是正序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
java复制代码  // 需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
    @Test
    public void testQuery5(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        // orderBy(true, true, "id", "name")等价于order by id ASC,name ASC
        //apper.orderByAsc("age", "id");
        //等价于：
        wrapper.orderBy(true, true, "age", "id");
        employeeMapper.selectList(wrapper);

    }

  // 需求：查询所有员工信息按age正序排， 如果age一样， 按id倒序排
    @Test
    public void testQuery7(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.orderByAsc("age");
        wrapper.orderByDesc("id");
        employeeMapper.selectList(wrapper);

    }

5.5、条件查询

5.5.1、allEq（全等匹配）

5.5.1.1、方法

1
2
3
java复制代码allEq(Map<R, V> params) // params : key为数据库字段名,value为字段值	
allEq(Map<R, V> params, boolean null2IsNull) // 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
`null2IsNull`这个参数的意思是为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的。例如：
  1. allEq({id:1,name:”老王”,age:null})—>id = 1 and name = ‘老王’ and age is null
  2. allEq({id:1,name:”老王”,age:null}, false) —> id = 1 and name = ‘老王’

5.5.1.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
java复制代码  // 需求：查询name=xiaolin， age=18的员工信息
    @Test
    public void testQuery8(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        Map<String, Object> map = new HashMap<>();
        map.put("name", "xiaolin");
        map.put("age", 18);
        wrapper.allEq(map);
        employeeMapper.selectList(wrapper);
    }

	@Test
    public void testQuery8(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        Map<String, Object> map = new HashMap<>();
        map.put("name", "xiaolin");
        map.put("age", 18);
		map.put("dept_id", null);
        wrapper.allEq(map, true);
        employeeMapper.selectList(wrapper);
    }

5.5.2、allEq（全等匹配带条件过滤的）

5.5.2.1、方法

1
2
3
java复制代码allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
`filter` : 过滤函数,是否允许字段传入比对条件中 params 与 null2IsNull同上，例如：
  1. allEq((k,v) -> k.indexOf(“a”) >= 0, {id:1,name:”老王”,age:null})—>name = ‘老王’ and age is null
  2. allEq((k,v) -> k.indexOf(“a”) >= 0, {id:1,name:”老王”,age:null}, false)—>name = ‘老王’

5.5.2.2、范例

1
2
3
4
5
6
7
8
9
10
java复制代码   // 需求：查询满足条件员工信息， 注意传入的map条件中， 包含a的列才参与条件查询
    @Test
    public void testQuery9(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        Map<String, Object> map = new HashMap<>();
        map.put("name", "xiaolin");
        map.put("age", 18);
        wrapper.allEq((k, v)-> k.contains("m"), map);
        employeeMapper.selectList(wrapper);
    }

5.5.3、eq

我们可以使用eq来判断单个参数判断是否相等。eq("name", "老王")等价于name = '老王'。

5.5.3.1、方法

1
2
java复制代码eq(R column, Object val)
eq(boolean condition, R column, Object val) // 相较于上一个方法，多了一个条件，当前面的条件成立时，才拼接后面语句，常用于判断当某个值不为空的时候进行拼接。

5.5.3.2、范例

1
2
3
4
5
6
7
java复制代码  // 需求：查询name=xiaolin员工信息
    @Test
    public void testQuery10(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "xiaolin");
        employeeMapper.selectList(wrapper);
    }

5.5.4、ne

我们可以使用ne来判断某个参数是否不相等。 ne("name", "老王")等价于name != '老王'。
1
2
3
4
5
6
7
8
java复制代码  // 需求：查询name !=xiaolin员工信息
    @Test
    public void testQuery11(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.ne("name", "xiaolin");
        employeeMapper.selectList(wrapper);

    }

5.5.5、gt

gt表示大于。gt("age", 18)等价于age > 18

5.5.5.1、方法

1
2
java复制代码gt(R column, Object val)
gt(boolean condition, R column, Object val)

5.5.5.2、范例

1
2
3
4
5
6
7
java复制代码  // 需求：查询age > 12 员工信息
    @Test
    public void testQuery12(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.gt("age", "12");
        employeeMapper.selectList(wrapper);
  }

5.5.6、ge

ge表示大于等于。ge("age", 18)等价于age > =18

5.5.6.1、方法

1
2
java复制代码ge(R column, Object val)
ge(boolean condition, R column, Object val)

5.5.6.2、范例

1
2
3
4
5
6
7
java复制代码  // 需求：查询age >= 12 员工信息
    @Test
    public void testQuery12(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.ge("age", "12");
        employeeMapper.selectList(wrapper);
  }

5.5.7、lt

lt表示小于1。lt("age", 18)等价于age < 18

5.5.7.1、方法

1
2
java复制代码lt(R column, Object val)
lt(boolean condition, R column, Object val

5.5.7.2、范例

1
2
3
4
5
6
7
java复制代码  // 需求：查询age < 12 员工信息
    @Test
    public void testQuery12(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.lt("age", "12");
        employeeMapper.selectList(wrapper);
  }

5.5.8、le

le表示小于等于。le("age", 18)等价于age <= 18。
1
2
java复制代码le(R column, Object val)
le(boolean condition, R column, Object val)

5.5.9、between、notBetween

我们使用between/notBetween来表示介于/不介于两者之间。


between("age", 18, 30)等价于age between 18 and 30。


notBetween("age", 18, 30)等价于age not between 18 and 30

5.5.9.1、方法

1
2
3
4
5
6
7
java复制代码// between ： BETWEEN 值1 AND 值2
between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)
   
// notBetween ： NOT BETWEEN 值1 AND 值2
notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

5.5.9.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求：查询年龄介于18~30岁的员工信息
    @Test
    public void testQuery13(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.between("age", 18, 30);
        employeeMapper.selectList(wrapper);
    }

  // 需求：查询年龄小于18或者大于30岁的员工信息【用between实现】
    @Test
    public void testQuery13(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.notBetween("age", 18, 30);
        employeeMapper.selectList(wrapper);
    }

5.5.10、isNull、isNotNull

我们可以使用isNull/isNotNull来表示为空/不为空。


isNull("name")等价于name is null。


isNotNull("name")等价于name is not null。

5.5.10.1、方法

1
2
3
4
5
6
7
java复制代码// isNull :  字段 IS NULL
isNull(R column)
isNull(boolean condition, R column)
    
// isNotNull :  字段 IS NOT NULL
isNotNull(R column)
isNotNull(boolean condition, R column)

5.5.10.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求： 查询dept_id 为null 员工信息
	@Test
    public void testQuery16(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.isNull("dept_id");
        employeeMapper.selectList(wrapper);
    }

  // 需求： 查询dept_id 为不为null 员工信息
	@Test
    public void testQuery16(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("dept_id");
        employeeMapper.selectList(wrapper);
    }

5.5.11、in、notIn

我们可以使用in/notIn来表示值在/不在这里面。


in("age",{1,2,3})--->age in (1,2,3)


notIn("age",{1,2,3})--->age not in (1,2,3)

5.5.11.1、方法

1
2
3
4
5
6
7
java复制代码// in : 字段 IN (value1, value2, ...)
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

// notIn : 字段 NOT IN  (value1, value2, ...)
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

5.5.11.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求： 查询id为1， 2 的员工信息
	@Test
    public void testQuery18(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.in("id", 1L, 2L);
        employeeMapper.selectList(wrapper);
    }

  // 需求： 查询id不为1，2 的员工信息
    @Test
    public void testQuery19(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.notIn("id", 1L, 2L);
        employeeMapper.selectList(wrapper);
    }

5.5.12、inSql、notInSql

与上一个不同的是，他的格式是：字段 IN ( sql语句 ) / 字段 NOT IN ( sql语句 )，接的是SQL语句片段。

5.5.12.1、方法

inSql("age", "1,2,3,4,5,6")等价于age in (1,2,3,4,5,6)


notInSql("id", "select id from table where id < 3")--->id not in (select id from table where id < 3)
1
2
3
4
5
6
7
java复制代码// inSql ： 字段 IN ( sql语句 )
inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

// 	notInSql ： 字段 NOT  IN ( sql语句 )
notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

5.5.12.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求： 查询id为1， 2 的员工信息
    @Test
    public void testQuery20(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.inSql("id", "1,2");
        employeeMapper.selectList(wrapper);
    }

  // 需求： 查询id不为1，2 的员工信息
    @Test
    public void testQuery21(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.notInSql("id", "1,2");
        employeeMapper.selectList(wrapper);
    }

5.6、模糊查询

5.6.1、like、notLike

5.6.1.1、方法

1
2
3
4
5
6
7
8
9
java复制代码// like: LIKE '%值%':like("name", "王")等价于name like '%王%'
like: LIKE '%值%'
like(R column, Object val)
like(boolean condition, R column, Object val)

// notLike("name", "王")--->name not like '%王%'
notLike : NOT LIKE '%值%'
notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

5.6.1.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求： 查询name中含有lin字样的员工
    @Test
    public void testQuery14(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.like("name", "lin");
        employeeMapper.selectList(wrapper);
    }

  // 需求： 查询name中不含有lin字样的员工
    @Test
    public void testQuery14(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.notLike("name", "lin");
        employeeMapper.selectList(wrapper);
    }

5.6.2、likeLeft、likeRight

5.6.2.1、方法

1
2
3
4
5
6
7
8
9
java复制代码// likeLeft("name", "王")--->name like '%王'
likeLeft ： LIKE '%值'
likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

// likeRight("name", "王")--->name like '王%'
likeRight ： LIKE '值%'
likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

5.6.2.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码  // 需求： 查询name以lin结尾的员工信息
    @Test
    public void testQuery15(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.likeLeft("name", "lin");
        employeeMapper.selectList(wrapper);
    }

  // 需求： 查询姓王的员工信息
    @Test
    public void testQuery16(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.likeRight("name", "王");
        employeeMapper.selectList(wrapper);
    }

5.7、逻辑运算符

5.7.1、or

5.7.1.1、方法

1
2
3
4
5
6
7
8
9
java复制代码// eq("id",1).or().eq("name","老王")--->id = 1 or name = '老王'
or ： 拼接 OR
or()
or(boolean condition)
    
// or还可以嵌套使用
// or(i -> i.eq("name", "李白").ne("status", "活着"))--->or (name = '李白' and status <> '活着')
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)
**主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)**

5.7.1.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
java复制代码  // 需求： 查询age = 18 或者 name=xiaolin 或者 id =1 的用户
    @Test
    public void testQuery24(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("age", 18)
                .or()
                .eq("name", "xiaolin")
                .or()
                .eq("id", 1L);
        employeeMapper.selectList(wrapper);
    }

  // 需求：查询name含有lin字样的，或者 年龄在18到30之间的用户
    @Test
    public void testQuery25(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.like("name", "lin")
                .or(wr -> wr.le("age", 30).ge("age", 18));
        employeeMapper.selectList(wrapper);
    }

5.7.2、and

5.7.2.1、方法

1
2
3
java复制代码// 嵌套and：
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

5.7.2.2、范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
java复制代码  // 需求：查询年龄介于18~30岁的员工信息
    @Test
    public void testQuery26(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.le("age", 30).ge("age", 18);
        employeeMapper.selectList(wrapper);
    }

  // 需求：查询name含有lin字样的并且 年龄在小于18或者大于30的用户
    @Test
    public void testQuery27(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.like("name", "lin")
                .and(wr -> wr.le("age", 30)
                        .or()
                        .ge("age", 18));
        employeeMapper.selectList(wrapper);
    }

5.8、分组查询

5.8.1、groupBy

5.8.1.1、方法

1
2
3
4
java复制代码// groupBy("id", "name")--->group by id,name
groupBy ： 分组：GROUP BY 字段, ...
groupBy(R... columns)
groupBy(boolean condition, R... columns)

5.8.1.2、范例

1
2
3
4
5
6
7
8
java复制代码   // 需求： 以部门id进行分组查询，查每个部门员工个数
    @Test
    public void testQuery22(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.groupBy("dept_id");
        wrapper.select("dept_id", "count(id) count");
        employeeMapper.selectMaps(wrapper);
    }

5.8.2、having

5.8.2.1、方法

1
2
3
4
5
java复制代码// having("sum(age) > 10")--->having sum(age) > 10
// having("sum(age) > {0}", 11)--->having sum(age) > 11
having ： HAVING ( sql语句 ) 
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

5.8.2.2、范例

1
2
3
4
5
6
7
8
9
10
java复制代码  // 需求： 以部门id进行分组查询，查每个部门员工个数， 将大于3人的部门过滤出来
    @Test
    public void testQuery23(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.groupBy("dept_id")
                .select("dept_id", "count(id) count")
                //.having("count > {0}", 3)
                .having("count >3");
        employeeMapper.selectMaps(wrapper);
    }

六、通用Service接口

6.1、传统方式

在以前的业务层中，我们需要写接口和实现类，其中有不少的接口都是重复的CRUD，没有任何技术含量。

6.1.1、Service接口

1
2
3
4
5
6
7
java复制代码public interface EmployeeService {
    void save(Employee employee);
    void update(Employee employee);
    void delete(Long id);
    Employee get(Long id);
    List<Employee> list();
}

6.1.2、ServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
java复制代码@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    private EmployeeMapper mapper;

    @Override
    public void save(Employee employee) {
        mapper.insert(employee);
    }

    @Override
    public void update(Employee employee) {
        mapper.updateById(employee);  //必须全量更新
    }

    @Override
    public void delete(Long id) {
        mapper.deleteById(id);
    }

    @Override
    public Employee get(Long id) {
        return mapper.selectById(id);
    }

    @Override
    public List<Employee> list() {
        return mapper.selectList(null);
    }
}

6.2、MyBatis-Plus的通用Service接口

既然需要重复写那么多没有技术含量的代码，那么肯定MyBatis-Plus会帮我们做好，我们只需要简单两部即可使用MyBatis-Plus给我们写好的CRUD方法，他会自动调用mapper接口方法。
  1. 自定义服务接口继承IService接口，其中泛型是实体类对象
1
2
java复制代码public interface IEmployeeService extends IService<Employee> {
}
  1. 服务接口实现类集成IService接口实现类ServiceImpl同时实现自定义接口，泛型一是实体类的mapper接口，泛型二是实体类。
1
2
3
java复制代码@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements IEmployeeService {
}

6.2.1、常用方法

  1. getBaseMapper()：获取引用的XxxxMapper对象。
  2. getOne(wrapper)：指定条件查询单个， 结果数据超过1个报错。
  3. list(wrapper)：指定条件查询多个。

6.2.2、分页

分页所用的方法是：`page(page, wrapper)`，他也可以配合高级查询一起。

6.2.2.1、配置分页插件

我们需要在配置类中配置分页插件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
java复制代码//分页

    @Bean

    public MybatisPlusInterceptor mybatisPlusInterceptor() {

        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);

        paginationInnerInterceptor.setOverflow(true); //合理化

        interceptor.addInnerInterceptor(paginationInnerInterceptor);

        return interceptor;

    }

6.2.2.2、编写分页代码

MyBatis-Plus的分页对象是IPage，分页信息封装对象，里面有各种分页相关信息等价于之前的PageInfo。
1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码//需求：查询第2页员工信息， 每页显示3条， 按id排序
@Test
public void testPage(){
    EmployeeQuery qo = new EmployeeQuery();
    qo.setPageSize(3);
    qo.setCurrentPage(2);
    IPage<Employee> page = employeeService.query(qo);
    System.out.println("当前页：" + page.getCurrent());
    System.out.println("总页数：" + page.getPages());
    System.out.println("每页显示条数：" + page.getSize());
    System.out.println("总记录数：" + page.getTotal());
    System.out.println("当前页显示记录：" + page.getRecords());
}

七、ActiveRecord

7.1、什么是ActiveRecord

ActiveRecord也属于ORM（对象关系映射）层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。


ActiveRecord的主要思想是：
  1. 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段
    在类中都有相应的Field。
  2. ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD。
  3. ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；
ActiveRecord（简称AR）一直广受动态语言（ PHP 、 Ruby 等）的喜爱，而 Java 作为准静态语言，对于ActiveRecord 往往只能感叹其优雅，所以我们也在 AR 道路上进行了一定的探索，喜欢大家能够喜欢。

7.2、开启AR之旅

在MP中，开启AR非常简单，只需要将实体对象继承Model即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
java复制代码@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee extends Model<Employee> {

  @TableId(type = IdType.AUTO)
  private Long id;
  private String username;
  private String name;
  private String password;
  private String email;
  private Integer age;
  private Boolean admin;
  private Long deptId;
  private Boolean status;
}

7.2.1、查询所有

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class Test1 {

  @Autowired
  EmployeeMapper employeeMapper;

  /**
  * 用于测试查询所有
  */
  @Test
  public void test(){
    Employee employee = new Employee();
    List<Employee> employees = employee.selectAll();
    for (Employee employee1 : employees) {
      System.out.println(employee1);
    }
  }
}

7.2.2、根据id查询

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class Test2 {
  /**
   * 用于测试根据id查询
   */
  @Test
  public void test2(){
    Employee employee = new Employee();
    employee.setId(1L);
    System.out.println(employee.selectById());
  }
}

7.2.3、根据条件查询

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码  /**
  * 用于测试根据条件查询
  */
  @Test
  public void test4(){
    Employee employee = new Employee();
    QueryWrapper<Employee> userQueryWrapper = new QueryWrapper<>();
    userQueryWrapper.le("password","123");
    List<Employee> employees = employee.selectList(userQueryWrapper);
    for (Employee employee1 : employees) {
      System.out.println(employee1);
    }
  }

7.2.4、新增数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {

  /**
   * 用于测试新增数据
   */
  @Test
  public void test3(){
    Employee employee = new Employee();
    employee.setId(11L);
    employee.setPassword("123");
    employee.insert();
  }
}

7.2.5、更新数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {
  /**
  * 用于测试更新
  */
  @Test
  public void test5(){
      Employee employee = new Employee();
      employee.setId(1L);
      employee.setPassword("123456789");
      employee.updateById();
  }
}

7.2.6、删除数据

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {
  /**
   * 用于测试删除
   */
  @Test
  public void test6(){
    Employee employee = new Employee();
    employee.setId(1L);
    employee.deleteById();
  }
}

八、插件机制

8.1、插件机制简介

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
  1. Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
  2. ParameterHandler (getParameterObject, setParameters)
  3. ResultSetHandler (handleResultSets, handleOutputParameters)
  4. StatementHandler (prepare, parameterize, batch, update, query)
我们看到了可以拦截Executor接口的部分方法，比如update，query，commit，rollback等方法，还有其他接口的一些方法等。总体概括为：
  1. 拦截执行器的方法。
  2. 拦截参数的处理。
  3. 拦截结果集的处理。
  4. 拦截Sql语法构建的处理。

8.2、执行分析插件

在MP中提供了对SQL执行的分析的插件，可用作阻断全表更新、删除的操作，注意：该插件仅适用于开发环境，不适用于生产环境。我们首先要在启动类上配置：
1
2
3
4
5
6
7
8
9
java复制代码  @Bean
  public SqlExplainInterceptor sqlExplainInterceptor(){
    SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
    List<ISqlParser> sqlParserList = new ArrayList<>();
	// 攻击 SQL 阻断解析器、加入解析链
    sqlParserList.add(new BlockAttackSqlParser());
    sqlExplainInterceptor.setSqlParserList(sqlParserList);
    return sqlExplainInterceptor;
  }

测试类：

1
2
3
4
5
6
7
java复制代码@Test
public void testUpdate(){
Employee employee = new Employee();
employee.setPassword("123456");
int result = this.employeeMapper.update(employee, null);
System.out.println("result = " + result);
}
执行后会发现控制台报错了，当执行全表更新时，会抛出异常，这样有效防止了一些误操作。

image-20210509210703826.png

8.3、乐观锁插件

8.3.1、适用场景

当要更新一条记录的时候，希望这条记录没有被别人更新。


乐观锁的实现方式：
  1. 取出记录时，获取当前version。
  2. 更新时，带上这个version。
  3. 执行更新时， set version = newVersion where version = oldVersion。
  4. 如果version不对，就更新失败。

8.3.2、插件配置

我们需要在spring.xml中进行配置。
1
xml复制代码<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>
然后在singboot的启动类中配置。
1
2
3
4
java复制代码Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
	return new OptimisticLockerInterceptor();
}

8.3.3、注解实体字段

为表添加version字段，并赋初始值为1

1
2
3
mysql复制代码ALTER TABLE `employee`
ADD COLUMN `version` int(10) NULL AFTER `email`;
UPDATE `tb_user` SET `version`='1';

为实体类添加version字段，并且添加@Version注解

1
2
java复制代码@Version
private Integer version;

测试

1
2
3
4
5
6
7
8
9
java复制代码@Test
public void testUpdate(){
	Employee employee = new Employee();
	user.setPassword("456789");
	user.setId(2L);
	user.setVersion(1); //设置version为1
	int result = this.userMapper.updateById(user);
	System.out.println("result = " + result);
}

8.3.4、说明

  1. 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime。
  2. 整数类型下 newVersion = oldVersion + 1。
  3. newVersion 会回写到 entity 中仅支持 updateById(id) 与 update(entity, wrapper) 方法。
  4. 在 update(entity, wrapper) 方法下, wrapper 不能复用。

文末抽奖福利

最后，因为XiaoLin有幸申请到了 [请查收｜你有一次免费申请掘金周边礼物的机会](https://dev.newban.cn/7000643252957216782)活动的名额，具体要求如下👇：


**所有**看到该文章的童鞋都可以在评论区**发表评论**哦！赶快行动起来吧！🤗🤗🤗**截止到 9月10日，如果评论区超过 10 人互动（不含作者本人），作者可以以自己的名义抽奖送出掘金徽章 2 枚（掘金官方承担）。**
  1. 通过评论方式参加。
  2. 评论必须和此文章有关的内容。
  3. 奖品最终会由热评用户获得。
  4. 获奖后我会以评论方式告知你并添加微信留收货地址。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%