龙空技术网

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

编程菌zfn 2260

前言:

目前姐妹们对“phpapachesql2005”大概比较着重,各位老铁们都想要知道一些“phpapachesql2005”的相关文章。那么小编在网络上网罗了一些关于“phpapachesql2005””的相关文章,希望姐妹们能喜欢,同学们一起来了解一下吧!

一、MyBatis回顾1.1、回顾MyBatis1.1.1、建库建表

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、引入依赖
<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
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driverspring.datasource.druid.url=jdbc:mysql:///db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8spring.datasource.druid.username=rootspring.datasource.druid.password=123456
1.1.4、编写Mapper接口
public interface UserMapper {    List<Employee> selectAll();}
1.1.5、编写Mapper.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 的基础上只做增强不做改变,为简化开发、提高效率而生。

2.1、代码以及文档

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

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

<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
og4j.rootLogger=DEBUG,A1log4j.appender.A1=org.apache.log4j.ConsoleAppenderlog4j.appender.A1.layout=org.apache.log4j.PatternLayoutlog4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n
2.3.3、编写实体类
@Data@AllArgsConstructor@NoArgsConstructorpublic class User {  private Integer id;  private String username;  private String password;  private String type;}
2.3.4、编写mapper
// 直接继承Myabtis-Plus的BaseMapper即可,泛型表示实体类public interface UserMapper extends BaseMapper<User> {}
2.3.5、编写启动类
@SpringBootApplication// 设置mapper接口扫描包@MapperScan("cn.linstudy.mapper")public class DemoApplication {  public static void main(String[] args) {    SpringApplication.run(DemoApplication.class, args);  }}
2.3.6、测试
@RunWith(SpringRunner.class)@SpringBootTestpublic 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、架构三、常用注解3.1、@TableName

MyBatis-Plus中默认表名是跟实体类名一致,当我们实体类的类名和表名不一致的时候,MyBatis-Plus就会报错,但是我们实际上又有这种需求的时候,我们就需要使用@TableName这个注解,来指定当前实体类映射哪张数据库表。

@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,所以我们需要设置主键增长的策略。

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

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

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

对象中的属性名和字段名不一致的问题(非驼峰)对象中的属性字段在表中不存在的问题

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

四、通用CRUD

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

4.1、插入操作4.1.1、方法定义

MyBatis-Plus中对于insert的方法定义是:

/*** 插入一条记录** @param entity 实体对象*/int insert(T entity);
4.1.2、测试
package cn.linstudy.testimport 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)@SpringBootTestpublic 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、updateById4.2.1.1、方法定义
/*** 根据 ID 修改** @param entity 实体对象*/int updateById(@Param(Constants.ENTITY) T entity);
4.2.1.2、测试
	// 需求: 将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、update4.2.2.1、方法定义
  /**   * 根据 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、测试
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、使用建议知道id,并且所有更新使用updateById部分字段更新,使用update4.3、删除操作4.3.1、deleteById4.3.1.1、方法定义
/*** 根据 ID 删除** @param id 主键ID*/int deleteById(Serializable id);
4.3.1.2、测试
@Testpublic void testDeleteById() {	//执行删除操作	int result = this.userMapper.deleteById(6L);	System.out.println("result = " + result);}
4.3.2、deleteByMap4.3.2.1、方法定义
/*** 根据 columnMap 条件,删除记录** @param columnMap 表字段 map 对象*/int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
4.3.2.2、测试
@Testpublic 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、delete4.3.3.1、方法定义
/*** 根据 entity 条件,删除记录** @param wrapper 实体对象封装操作类(可以为 null)*/int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
4.3.3.2、测试
@Testpublic 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、deleteBatchIds4.3.4.1、方法定义
/*** 删除(根据ID 批量删除)** @param idList 主键ID列表(不能为 null 以及 empty)*/int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>idList);
4.3.4.2、测试
@Testpublic 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、selectById4.4.1.1、方法定义

/*** 根据 ID 查询** @param id 主键ID*/T selectById(Serializable id);
4.1.1.2、测试
@Testpublic void testSelectById() {	//根据id查询数据	User user = this.userMapper.selectById(2L);	System.out.println("result = " + user);}
4.4.2、selectBatchIds4.4.2.1、方法定义
/*** 查询(根据ID 批量查询)** @param idList 主键ID列表(不能为 null 以及 empty)*/List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>idList);
4.2.2.2、测试
@Testpublic 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、selectOne4.4.3.1、方法定义
/*** 根据 entity 条件,查询一条记录** @param queryWrapper 实体对象封装操作类(可以为 null)*/T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
4.4.3.2、测试
@Testpublic void testSelectOne() {	QueryWrapper<User> wrapper = new QueryWrapper<User>();	wrapper.eq("name", "李四");	//根据条件查询一条数据,如果结果超过一条会报错	User user = this.userMapper.selectOne(wrapper);    System.out.println(user);}
4.4.4、selectCount4.4.4.1、方法定义
/*** 根据 Wrapper 条件,查询总记录数** @param queryWrapper 实体对象封装操作类(可以为 null)*/Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
4.4.4.2、测试
@Testpublic 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、selectList4.4.5.1、方法定义
/*** 根据 entity 条件,查询全部记录** @param queryWrapper 实体对象封装操作类(可以为 null)*/List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
4.4.5.2、测试
@Testpublic 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、selectPage4.4.6.1 方法定义
/*** 根据 entity 条件,查询全部记录(并翻页)** @param page 分页查询条件(可以为 RowBounds.DEFAULT)* @param queryWrapper 实体对象封装操作类(可以为 null)*/IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
4.4.6.2、配置分页插件
@Configuration@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包public class MybatisPlusConfig {/*** 分页插件*/@Beanpublic PaginationInterceptor paginationInterceptor() {    return new PaginationInterceptor();	}}
4.4.6.3、测试
@Testpublic 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是它的实现类,实现关系如下:

在AbstractSqlInjector中,主要是由inspectInject()方法进行注入的:

@Overridepublic 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 methodwas found.");			}			mapperRegistryCache.add(className);		}	}}	

以SelectById为例查看:

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中。

五、条件构造器

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

5.1、继承体系

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

AbstractWrapper: 用于查询条件封装,生成 sql 的 where 条件。QueryWrapper: Entity 对象封装操作类,不是用lambda语法。UpdateWrapper: Update 条件封装,用于Entity对象更新操作。AbstractLambdaWrapper: Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。LambdaQueryWrapper:看名称也能明白就是用于Lambda语法使用的查询Wrapper。LambdaUpdateWrapper: Lambda 更新封装Wrapper。5.2、更新操作5.2.1、普通更新

@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进行更新。他的方法主要是有两个:

set(String column, Object val)set(boolean condition, String column, Object val)

// 需求:将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语句。

	// 需求:将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来进行操作。

   // 需求:将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、普通查询

  // 需求:查询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查询
  // 需求:查询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查询
  //需求:查询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方法进行实现的。他有三个重载方法:

select(String... sqlSelect) :参数是指定查询后返回的列。select(Predicate<TableFieldInfo> predicate):参数是Predicate 函数,满足指定判定逻辑列才返回。select(Class<T> entityClass, Predicate<TableFieldInfo> predicate):参数1是通过实体属性映射表中列,参数2是Predicate 函数, 满足指定判定逻辑列才返回。

  // 需求:查询所有员工, 返回员工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;

orderByAsc: 正序排序。orderByDesc:倒序排序。

  // 需求:查询所有员工信息按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:控制是不是正序。

  // 需求:查询所有员工信息按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、方法
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的。例如:

allEq({id:1,name:"老王",age:null})--->id = 1 and name = '老王' and age is nullallEq({id:1,name:"老王",age:null}, false) ---> id = 1 and name = '老王'5.5.1.2、范例

  // 需求:查询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、方法
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同上,例如:

allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})--->name = '老王' and age is nullallEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)--->name = '老王'5.5.2.2、范例

   // 需求:查询满足条件员工信息, 注意传入的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、方法

eq(R column, Object val)eq(boolean condition, R column, Object val) // 相较于上一个方法,多了一个条件,当前面的条件成立时,才拼接后面语句,常用于判断当某个值不为空的时候进行拼接。
5.5.3.2、范例
  // 需求:查询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 != '老王'。

  // 需求:查询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、方法

gt(R column, Object val)gt(boolean condition, R column, Object val)
5.5.5.2、范例
  // 需求:查询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、方法

ge(R column, Object val)ge(boolean condition, R column, Object val)
5.5.6.2、范例
  // 需求:查询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、方法

lt(R column, Object val)lt(boolean condition, R column, Object val
5.5.7.2、范例
  // 需求:查询age < 12 员工信息    @Test    public void testQuery12(){        QueryWrapper<Employee> wrapper = new QueryWrapper<>();        wrapper.lt("age", "12");        employeeMapper.selectList(wrapper);  }
5.5.8、lt

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

5.5.8、方法

lt(R column, Object val)lt(boolean condition, R column, Object val
5.5.7.2、范例
  // 需求:查询age < 12 员工信息    @Test    public void testQuery12(){        QueryWrapper<Employee> wrapper = new QueryWrapper<>();        wrapper.lt("age", "12");        employeeMapper.selectList(wrapper);  }
5.5.9、le

le表示小于等于。le("age", 18)等价于age <= 18。

le(R column, Object val)le(boolean condition, R column, Object val)
5.5.10、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.10.1、方法

// between : BETWEEN 值1 AND 值2between(R column, Object val1, Object val2)between(boolean condition, R column, Object val1, Object val2)   // notBetween : NOT BETWEEN 值1 AND 值2notBetween(R column, Object val1, Object val2)notBetween(boolean condition, R column, Object val1, Object val2)
5.5.10.2、范例
  // 需求:查询年龄介于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.11、isNull、isNotNull

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

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

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

5.5.11.1、方法

// isNull :  字段 IS NULLisNull(R column)isNull(boolean condition, R column)    // isNotNull :  字段 IS NOT NULLisNotNull(R column)isNotNull(boolean condition, R column)
5.5.11.2、范例
  // 需求: 查询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.12、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.12.1、方法

// 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.12.2、范例
  // 需求: 查询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.13、inSql、notInSql

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

5.5.13.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)

// 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.13.2、范例
  // 需求: 查询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、notLike5.6.1.1、方法
// 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、范例
  // 需求: 查询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、likeRight5.6.2.1、方法
// 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、范例
  // 需求: 查询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、or5.7.1.1、方法
// eq("id",1).or().eq("name","老王")--->id = 1 or name = '老王'or : 拼接 ORor()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、范例

  // 需求: 查询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、and5.7.2.1、方法
// 嵌套and:and(Consumer<Param> consumer)and(boolean condition, Consumer<Param> consumer)
5.7.2.2、范例
  // 需求:查询年龄介于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、groupBy5.8.1.1、方法
// groupBy("id", "name")--->group by id,namegroupBy : 分组:GROUP BY 字段, ...groupBy(R... columns)groupBy(boolean condition, R... columns)
5.8.1.2、范例
   // 需求: 以部门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、having5.8.2.1、方法
// having("sum(age) > 10")--->having sum(age) > 10// having("sum(age) > {0}", 11)--->having sum(age) > 11having : HAVING ( sql语句 ) having(String sqlHaving, Object... params)having(boolean condition, String sqlHaving, Object... params)
5.8.2.2、范例
  // 需求: 以部门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接口

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
@Servicepublic 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接口方法。

自定义服务接口继承IService接口,其中泛型是实体类对象

public interface IEmployeeService extends IService<Employee> {}
服务接口实现类集成IService接口实现类ServiceImpl同时实现自定义接口,泛型一是实体类的mapper接口,泛型二是实体类。
@Servicepublic class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements IEmployeeService {}
6.2.1、常用方法getBaseMapper():获取引用的XxxxMapper对象。getOne(wrapper):指定条件查询单个, 结果数据超过1个报错list(wrapper):指定条件查询多个。6.2.2、分页

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

6.2.2.1、配置分页插件

我们需要在配置类中配置分页插件。

//分页    @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。

//需求:查询第2页员工信息, 每页显示3条, 按id排序@Testpublic 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());}
七、ActiveRecord7.1、什么是ActiveRecord

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

ActiveRecord的主要思想是:

每一个数据库表对应创建一个类,类的每一个对象实例对应于数据库中表的一行记录;通常表的每个字段 在类中都有相应的Field。ActiveRecord同时负责把自己持久化,在ActiveRecord中封装了对数据库的访问,即CURD。ActiveRecord是一种领域模型(Domain Model),封装了部分业务逻辑;

ActiveRecord(简称AR)一直广受动态语言( PHP 、 Ruby 等)的喜爱,而 Java 作为准静态语言,对于ActiveRecord 往往只能感叹其优雅,所以我们也在 AR 道路上进行了一定的探索,喜欢大家能够喜欢。

7.2、开启AR之旅

在MP中,开启AR非常简单,只需要将实体对象继承Model即可。

@Data@AllArgsConstructor@NoArgsConstructorpublic 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、查询所有
@RunWith(SpringRunner.class)@SpringBootTestpublic 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查询
@RunWith(SpringRunner.class)@SpringBootTestpublic class Test2 {  /**   * 用于测试根据id查询   */  @Test  public void test2(){    Employee employee = new Employee();    employee.setId(1L);    System.out.println(employee.selectById());  }}
7.2.3、根据条件查询
  /**  * 用于测试根据条件查询  */  @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、新增数据
@RunWith(SpringRunner.class)@SpringBootTestpublic class TestAR {  /**   * 用于测试新增数据   */  @Test  public void test3(){    Employee employee = new Employee();    employee.setId(11L);    employee.setPassword("123");    employee.insert();  }}
7.2.5、更新数据
@RunWith(SpringRunner.class)@SpringBootTestpublic class TestAR {  /**  * 用于测试更新  */  @Test  public void test5(){      Employee employee = new Employee();      employee.setId(1L);      employee.setPassword("123456789");      employee.updateById();  }}
7.2.6、删除数据
@RunWith(SpringRunner.class)@SpringBootTestpublic class TestAR {  /**   * 用于测试删除   */  @Test  public void test6(){    Employee employee = new Employee();    employee.setId(1L);    employee.deleteById();  }}
八、插件机制8.1、插件机制简介

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下,MyBatis 允许使用插件来拦截的方法调用包括:

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)ParameterHandler (getParameterObject, setParameters)ResultSetHandler (handleResultSets, handleOutputParameters)StatementHandler (prepare, parameterize, batch, update, query)

我们看到了可以拦截Executor接口的部分方法,比如update,query,commit,rollback等方法,还有其他接口的一些方法等。总体概括为:

拦截执行器的方法。拦截参数的处理。拦截结果集的处理。拦截Sql语法构建的处理。8.2、执行分析插件

在MP中提供了对SQL执行的分析的插件,可用作阻断全表更新、删除的操作,注意:该插件仅适用于开发环境,不适用于生产环境。我们首先要在启动类上配置:

  @Bean  public SqlExplainInterceptor sqlExplainInterceptor(){    SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();    List<ISqlParser> sqlParserList = new ArrayList<>();	// 攻击 SQL 阻断解析器、加入解析链    sqlParserList.add(new BlockAttackSqlParser());    sqlExplainInterceptor.setSqlParserList(sqlParserList);    return sqlExplainInterceptor;  }

测试类:

@Testpublic void testUpdate(){Employee employee = new Employee();employee.setPassword("123456");int result = this.employeeMapper.update(employee, null);System.out.println("result = " + result);}

执行后会发现控制台报错了,当执行全表更新时,会抛出异常,这样有效防止了一些误操作。

8.3、乐观锁插件8.3.1、适用场景

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

乐观锁的实现方式:

取出记录时,获取当前version。更新时,带上这个version。执行更新时, set version = newVersion where version = oldVersion。如果version不对,就更新失败。8.3.2、插件配置

我们需要在spring.xml中进行配置。

<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>

然后在singboot的启动类中配置。

Beanpublic OptimisticLockerInterceptor optimisticLockerInterceptor() {	return new OptimisticLockerInterceptor();}
8.3.3、注解实体字段

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

ALTER TABLE `employee`ADD COLUMN `version` int(10) NULL AFTER `email`;UPDATE `tb_user` SET `version`='1';

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

@Versionprivate Integer version;

测试

@Testpublic 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、说明支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime。整数类型下 newVersion = oldVersion + 1。newVersion 会回写到 entity 中仅支持 updateById(id) 与 update(entity, wrapper) 方法。在 update(entity, wrapper) 方法下, wrapper 不能复用。

标签: #phpapachesql2005